Request 5366 (accepted)

Overview

Request 5366 (accepted)

- Update to version 1.16.2
* Bug fixes:
- Mac OS: Program produced random errors when running on OS X
10.11 El Captain or earlier versions
- Linux: ccextractor is now part of OSS package

Created by manfred.h over 3 years ago
In state accepted
Package maintainers: manfred-h and microchip8

Submit MakeMKV

Submit package home:manfred.h / MakeMKV to package Multimedia / MakeMKV

makemkv.changes Changed

makemkv.spec Changed

makemkv-bin-1.16.1.tar.gz/bin/amd64/makemkvcon -> makemkv-bin-1.16.2.tar.gz/bin/amd64/makemkvcon Changed

makemkv-bin-1.16.1.tar.gz/bin/arm64/makemkvcon -> makemkv-bin-1.16.2.tar.gz/bin/arm64/makemkvcon Changed

makemkv-bin-1.16.1.tar.gz/bin/armel/makemkvcon -> makemkv-bin-1.16.2.tar.gz/bin/armel/makemkvcon Changed

makemkv-bin-1.16.1.tar.gz/bin/i386/makemkvcon -> makemkv-bin-1.16.2.tar.gz/bin/i386/makemkvcon Changed

makemkv-bin-1.16.1.tar.gz/src/share/blues.jar -> makemkv-bin-1.16.2.tar.gz/src/share/blues.jar Changed

makemkv-oss-1.16.1.tar.gz/makemkvgui/src/str Deleted

makemkv-oss-1.16.1.tar.gz/makemkvgui/src/str/en_utf16.cpp Deleted

@@ -1,635 +0,0 @@
-/*
-    MakeMKV GUI - Graphics user interface application for MakeMKV
-
-    Copyright (C) 2007-2020 GuinpinSoft inc <makemkvgui@makemkv.com>
-
-    You may use this file in accordance with the end user license
-    agreement provided with the Software. For licensing terms and
-    conditions see License.txt
-
-    This Software is distributed on an "AS IS" basis, WITHOUT WARRANTY
-    OF ANY KIND, either express or implied. See the License.txt for
-    the specific language governing rights and limitations.
-
-*/
-
-static const unsigned short en_po_str[21848]={
-'e','n','g',':','E','n','g','l','i','s','h',0,
-'D','B','G',' ','A','S','S','E','R','T',':',' ','%','1',' ','a','t',' ','%','2',':','%','3',0,
-'L','I','B','M','K','V','_','T','R','A','C','E',':',' ','%','1',0,
-'D','E','B','U','G',':',' ','C','o','d','e',' ','%','1',' ','a','t',' ','%','2',':','%','3',0,
-'D','e','b','u','g',' ','l','o','g','g','i','n','g',' ','e','n','a','b','l','e','d',',',' ','l','o','g',' ','w','i','l','l',' ','b','e',' ','s','a','v','e','d',' ','a','s',' ','%','1',0,
-'%','1',' ','s','t','a','r','t','e','d',0,
-0,
-'M','a','k','e','M','K','V',' ','a','p','p','l','i','c','a','t','i','o','n',' ','d','i','r','e','c','t','o','r','y',' ',0x27,'%','1',0x27,' ','i','s',' ','i','n','v','a','l','i','d',',',' ','t','h','e',' ','p','r','o','g','r','a','m',' ','w','i','l','l',' ','l','i','k','e','l','y',' ','b','e','h','a','v','e',' ','i','n','c','o','r','r','e','c','t','l','y',0,
-'F','a','i','l','e','d',' ','t','o',' ','l','o','a','d',' ','c','o','n','v','e','r','s','i','o','n',' ','p','r','o','f','i','l','e',' ','f','r','o','m',' ','f','i','l','e',' ',0x27,'%','1',0x27,0,
-'P','r','o','f','i','l','e',' ','p','a','r','s','i','n','g',' ','e','r','r','o','r',':',' ','%','1',0,
-'I','n','t','e','r','n','a','l',' ','e','r','r','o','r',':',' ','%','1',0,
-'%','1',0,
-'%','1',' ','%','2',0,
-'F','i','l','e',' ','s','y','s','t','e','m',' ','n','o','t',' ','r','e','c','o','g','n','i','z','e','d',',',' ','d','i','s','c',' ','c','a','n',0x27,'t',' ','b','e',' ','o','p','e','n','e','d',0,
-'E','r','r','o','r',' ',0x27,'%','1',0x27,' ','o','c','c','u','r','r','e','d',' ','w','h','i','l','e',' ','r','e','a','d','i','n','g',' ',0x27,'%','2',0x27,' ','a','t',' ','o','f','f','s','e','t',' ',0x27,'%','3',0x27,0,
-'E','r','r','o','r',' ',0x27,'%','1',0x27,' ','o','c','c','u','r','r','e','d',' ','w','h','i','l','e',' ','i','s','s','u','i','n','g',' ','S','C','S','I',' ','c','o','m','m','a','n','d',' ','%','4',' ','t','o',' ','d','e','v','i','c','e',' ',0x27,'%','2',':','%','3',0x27,0,
-'O','p','e','r','a','t','i','n','g',' ','s','y','s','t','e','m',' ','b','l','o','c','k','e','d',' ','a','c','c','e','s','s',' ','t','o',' ','o','p','t','i','c','a','l',' ','d','r','i','v','e',' ','"','%','1','"','.',' ','P','r','o','g','r','a','m',' ','n','e','e','d','s',' ','t','o',' ','b','e',' ','r','u','n',' ','a','s',' ','a','d','m','i','n','i','s','t','r','a','t','o','r',' ','t','o',' ','a','c','c','e','s','s',' ','t','h','e',' ','d','r','i','v','e','.',0,
-'C','a','n','n','o','t',' ','o','b','t','a','i','n',' ','e','x','c','l','u','s','i','v','e',' ','a','c','c','e','s','s',' ','f','o','r',' ','o','p','t','i','c','a','l',' ','d','r','i','v','e',' ','"','%','1','"',' ','-',' ','d','i','s','c',' ','r','e','a','d','i','n','g',' ','w','i','l','l',' ','l','i','k','e','l','y',' ','f','a','i','l','.',' ','Y','o','u',' ','m','a','y',' ','w','a','n','t',' ','t','o',' ','e','j','e','c','t',' ','a','n','d',' ','r','e','l','o','a','d',' ','t','h','e',' ','d','i','s','c',' ','w','h','i','l','e',' ','m','a','k','e','m','k','v',' ','i','s',' ','r','u','n','n','i','n','g','.',0,
-'P','r','o','g','r','a','m',' ','r','e','a','d','s',' ','d','a','t','a',' ','f','a','s','t','e','r',' ','t','h','a','n',' ','i','t',' ','c','a','n',' ','w','r','i','t','e',' ','t','o',' ','d','i','s','k',',',' ','c','o','n','s','i','d','e','r',' ','u','p','g','r','a','d','i','n','g',' ','y','o','u','r',' ','h','a','r','d',' ','d','r','i','v','e',' ','i','f',' ','y','o','u',' ','s','e','e',' ','m','a','n','y',' ','o','f',' ','t','h','e','s','e',' ','m','e','s','s','a','g','e','s','.',0,
-'F','a','i','l','e','d',' ','t','o',' ','p','a','r','s','e',' ','U','D','F',' ','f','i','l','e',' ','r','e','c','o','r','d',' ','f','o','r',' ','f','i','l','e',' ','"','%','1','"',',',' ','U','D','F',' ','f','i','l','e','s','y','s','t','e','m',' ','o','n',' ','d','i','s','c',' ','s','e','e','m','s',' ','t','o',' ','b','e',' ','c','o','r','r','u','p','t','.',' ','Y','o','u',' ','m','a','y',' ','g','e','t',' ','r','a','n','d','o','m',' ','p','r','o','g','r','a','m',' ','b','e','h','a','v','i','o','r','.',0,
-'O','p','t','i','c','a','l',' ','d','r','i','v','e',' ','"','%','1','"',' ','o','p','e','n','e','d',' ','i','n',' ','O','S',' ','a','c','c','e','s','s',' ','m','o','d','e','.',0,
-'F','a','i','l','e','d',' ','t','o',' ','a','l','l','o','c','a','t','e',' ','m','e','m','o','r','y',' ','f','o','r',' ','r','e','a','d',' ','c','a','c','h','e',',',' ','d','i','s','c',' ','r','e','a','d','i','n','g',' ','w','i','l','l',' ','b','e',' ','s','l','o','w','.',' ','P','l','e','a','s','e',' ','c','h','a','n','g','e',' ','r','e','a','d',' ','b','u','f','f','e','r',' ','s','i','z','e',' ','i','n',' ','p','r','e','f','e','r','e','n','c','e','s',' ','o','r',' ','c','l','o','s','e',' ','o','t','h','e','r',' ','a','p','p','l','i','c','a','t','i','o','n','s','.',0,
-'H','i','t',' ','O','S',' ','X',' ','I','O','S','C','S','I','M','u','l','t','i','m','e','d','i','a','C','o','m','m','a','n','d','s',' ','b','u','g',',',' ','u','s','e','d',' ','t','y','p','e',' ','%','1',' ','w','o','r','k','a','r','o','u','n','d',',',' ','s','e','e',' ','%','2',' ','f','o','r',' ','d','e','t','a','i','l','s','.',0,
-'H','i','t',' ','O','S',' ','X',' ','I','O','S','C','S','I','M','u','l','t','i','m','e','d','i','a','C','o','m','m','a','n','d','s',' ','b','u','g',',',' ','t','y','p','e',' ','%','1',' ','w','o','r','k','a','r','o','u','n','d',' ','f','a','i','l','e','d',',',' ','s','e','e',' ','%','2',' ','f','o','r',' ','d','e','t','a','i','l','s','.',0,
-'O','p','t','i','c','a','l',' ','d','r','i','v','e',' ','"','%','1','"',' ','o','p','e','n','e','d',' ','i','n',' ','D','A','S','P','I',' ','v','%','2','.','%','3',' ','m','o','d','e','.',0,
-'I','t',0x27,'s',' ','h','i','g','h','l','y',' ','r','e','c','o','m','m','e','n','d','e','d',' ','t','o',' ','i','n','s','t','a','l','l',' ','D','A','S','P','I',' ','k','e','r','n','e','l',' ','e','x','t','e','n','s','i','o','n',' ','t','o',' ','i','m','p','r','o','v','e',' ','p','e','r','f','o','r','m','a','n','c','e','.',0,
-'F','a','i','l','e','d',' ','t','o',' ','g','e','t',' ','f','u','l','l',' ','a','c','c','e','s','s',' ','t','o',' ','d','r','i','v','e',' ','"','%','1',' ','%','2','"','.',' ','M','a','k','e',' ','s','u','r','e',' ','t','h','a','t',' ','y','o','u',' ','e','i','t','h','e','r',' ','h','a','v','e',' ','w','r','i','t','e',' ','a','c','c','e','s','s',' ','t','o',' ','d','e','v','i','c','e',' ','"','%','3','"',',',' ','a','r','e',' ','m','e','m','b','e','r',' ','o','f',' ','"','c','d','r','o','m','"',' ','g','r','o','u','p',' ','o','r',' ','h','a','v','e',' ','C','A','P','_','S','Y','S','_','R','A','W','I','O',' ','e','n','a','b','l','e','d','.',0,
-'C','u','r','r','e','n','t','l','y',' ','i','n','s','t','a','l','l','e','d',' ','D','A','S','P','I',' ','v','%','1','.','%','2',' ','k','e','r','n','e','l',' ','e','x','t','e','n','s','i','o','n',' ','i','s',' ','t','o','o',' ','o','l','d',' ','a','n','d',' ','c','a','n',0x27,'t',' ','b','e',' ','u','s','e','d','.',' ','P','l','e','a','s','e',' ','i','n','s','t','a','l','l',' ','t','h','e',' ','l','a','t','e','s','t',' ','v','e','r','s','i','o','n','.',0,
-'E','r','r','o','r',' ',0x27,'%','1',0x27,' ','o','c','c','u','r','r','e','d',' ','w','h','i','l','e',' ','w','r','i','t','i','n','g',' ','d','a','t','a',' ','t','o',' ',0x27,'%','2',0x27,' ','a','t',' ','o','f','f','s','e','t',' ',0x27,'%','3',0x27,0,
-'E','r','r','o','r',' ',0x27,'%','1',0x27,' ','o','c','c','u','r','r','e','d',' ','w','h','i','l','e',' ','c','r','e','a','t','i','n','g',' ',0x27,'%','2',0x27,0,
-'D','e','v','i','c','e',' ',0x27,'%','1',0x27,' ','i','s',' ','p','a','r','t','i','a','l','l','y',' ','i','n','a','c','c','e','s','s','i','b','l','e',' ','d','u','e',' ','t','o',' ','a',' ','b','u','g',' ','i','n',' ','L','i','n','u','x',' ','k','e','r','n','e','l',' ','(','i','t',' ','r','e','p','o','r','t','s',' ','i','n','v','a','l','i','d',' ','b','l','o','c','k',' ','d','e','v','i','c','e',' ','s','i','z','e',')','.',' ','T','h','i','s',' ','c','a','n',' ','b','e',' ','w','o','r','k','e','d',' ','a','r','o','u','n','d',',',' ','b','u','t',' ','r','e','a','d',' ','s','p','e','e','d',' ','m','a','y',' ','b','e',' ','v','e','r','y',' ','s','l','o','w','.',0,
-'U','n','a','b','l','e',' ','t','o',' ','o','p','e','n',' ','f','i','l','e',' ',0x27,'%','1',0x27,' ','i','n',' ','O','S',' ','m','o','d','e',' ','d','u','e',' ','t','o',' ','a',' ','b','u','g',' ','i','n',' ','O','S',' ','K','e','r','n','e','l','.',' ','T','h','i','s',' ','c','a','n',' ','b','e',' ','w','o','r','k','e','d',' ','a','r','o','u','n','d',',',' ','b','u','t',' ','r','e','a','d',' ','s','p','e','e','d',' ','m','a','y',' ','b','e',' ','v','e','r','y',' ','s','l','o','w','.',0,
-'F','a','i','l','e','d',' ','t','o',' ','a','l','l','o','c','a','t','e',' ','m','e','m','o','r','y',' ','f','o','r',' ','w','r','i','t','e',' ','c','a','c','h','e',',',' ','c','a','n',0x27,'t',' ','c','o','n','t','i','n','u','e','.',' ','P','l','e','a','s','e',' ','c','h','a','n','g','e',' ','r','e','a','d',' ','b','u','f','f','e','r',' ','s','i','z','e',' ','i','n',' ','p','r','e','f','e','r','e','n','c','e','s',' ','o','r',' ','c','l','o','s','e',' ','o','t','h','e','r',' ','a','p','p','l','i','c','a','t','i','o','n','s','.',0,
-'E','n','c','o','u','n','t','e','r','e','d',' ','%','1',' ','e','r','r','o','r','s',' ','o','f',' ','t','y','p','e',' ',0x27,'%','2',0x27,' ','-',' ','s','e','e',' ','%','3',0,
-'U','n','k','n','o','w','n',' ','d','e','v','i','c','e',' ','-',' ',0x27,'%','1',0x27,0,
-'U','n','s','p','e','c','i','f','i','e','d',' ','e','r','r','o','r',0,
-'O','p','e','r','a','t','i','o','n',' ','w','a','s',' ','c','a','n','c','e','l','l','e','d',0,
-'I','n','p','u','t',' ','p','a','r','a','m','e','t','e','r',' ','i','s',' ','i','n','c','o','r','r','e','c','t',0,
-'O','p','e','r','a','t','i','o','n',' ','r','e','s','u','l','t',' ','i','s',' ','i','n','c','o','r','r','e','c','t',0,
-'U','n','a','b','l','e',' ','t','o',' ','a','l','l','o','c','a','t','e',' ','r','e','s','o','u','r','c','e','s',0,
-'S','y','n','c','h','r','o','n','i','s','a','t','i','o','n',' ','f','a','i','l','e','d',0,
-'D','e','c','r','y','p','t','i','o','n',' ','e','r','r','o','r',0,
-'A','V',' ','t','r','a','n','s','f','o','r','m',' ','f','a','i','l','e','d',0,
-'U','n','k','n','o','w','n',' ','m','e','d','i','a',' ','s','t','a','t','u','s',0,
-'R','e','q','u','e','s','t',' ','r','e','j','e','c','t','e','d',' ','b','y',' ','O','S',0,
-'P','i','p','e',' ','c','o','m','m','u','n','i','c','a','t','i','o','n',' ','e','r','r','o','r',0,
-'M','2','T','S',' ','h','a','s','h',' ','c','h','e','c','k',' ','f','a','i','l','e','d',0,
-'O','S',' ','e','r','r','o','r',' ','-',' ','%','1',0,
-'P','o','s','i','x',' ','e','r','r','o','r',' ','-',' ','%','1',0,
-'S','c','s','i',' ','e','r','r','o','r',' ','-',' ','%','1',0,
-'S','c','s','i',' ','e','r','r','o','r',' ','-',' ','%','1',':','%','2',0,
-'I','n','t','e','r','n','a','l',' ','e','r','r','o','r',' ','-',' ','%','1',' ','(','%','2',')',0,
-'R','e','a','d',' ','E','r','r','o','r',0,
-'O','S',' ','X',' ','I','P','C',' ','E','r','r','o','r',0,
-'A','A','C','S',' ','A','u','t','h',' ','E','r','r','o','r',0,
-'H','a','s','h','C','h','e','c','k',' ','E','r','r','o','r',0,
-'D','v','d',' ','f','i','l','e','s',' ','a','r','e',' ','c','o','r','r','u','p','t',0,
-'D','v','d',' ','f','i','l','e','s',' ','a','r','e',' ','i','n','c','o','n','s','i','s','t','e','n','t','.',' ','P','r','o','b','a','b','l','y',' ','s','t','r','u','c','t','u','r','e',' ','p','r','o','t','e','c','t','i','o','n',' ','w','a','s',' ','a','p','p','l','i','e','d',' ','o','r',' ','f','i','l','e','s',' ','a','r','e',' ','m','i','s','s','i','n','g',0,
-'C','a','l','c','u','l','a','t','e','d',' ','B','U','P',' ','o','f','f','s','e','t',' ','f','o','r',' ','V','T','S',' ','#','%','1',' ','d','o','e','s',' ','n','o','t',' ','m','a','t','c','h',' ','o','n','e',' ','i','n',' ','I','F','O',' ','h','e','a','d','e','r','.',0,
-'S','i','g','n','a','t','u','r','e',' ','i','s',' ','i','n','v','a','l','i','d',' ','i','n',' ','I','F','O',' ','f','i','l','e',0,
-'T','h','i','s',' ','d','v','d',' ','h','a','s',' ','%','1',' ','t','i','t','l','e','s','e','t','s',' ','w','h','i','c','h',' ','i','s',' ','m','o','r','e',' ','t','h','a','n',' ','9','9',0,
-'T','i','t','l','e','s','e','t',' ','i','d',' ','%','1',' ','i','s',' ','i','n','v','a','l','i','d',0,
-'O','p','e','n','i','n','g',' ','f','i','l','e','s',' ','o','n',' ','h','a','r','d','d','r','i','v','e',' ','a','t',' ','%','1',0,
-'U','s','i','n','g',' ','d','i','r','e','c','t',' ','d','i','s','c',' ','a','c','c','e','s','s',' ','m','o','d','e',0,
-'T','i','t','l','e','s','e','t',' ','s','t','a','r','t',' ','s','e','c','t','o','r',' ','m','i','s','m','a','t','c','h',' ','f','o','r',' ','t','i','t','l','e','s','e','t',' ','%','1',' ',':',' ','%','2',' ','!','=',' ','%','3',0,
-'T','i','t','l','e',' ','w','i','t','h',' ','T','T','N',' ','%','1',' ','i','s',' ','n','o','t',' ','p','r','e','s','e','n','t',' ','i','n',' ','t','i','t','l','e','s','e','t',' ','%','2',0,
-'C','a','n',0x27,'t',' ','l','o','c','a','t','e',' ','a',' ','c','e','l','l',' ','f','o','r',' ','V','T','S',' ','%','1',' ','T','T','N',' ','%','2',' ','P','G','C','N',' ','%','3',' ','P','G','N',' ','%','4',0,
-'A','u','d','i','o',' ','s','t','r','e','a','m',' ','c','o','u','n','t',' ','i','s',' ','%','1',' ','i','n',' ','V','T','S',' ','%','2',0,
-'S','u','b','p','i','c','t','u','r','e',' ','s','t','r','e','a','m',' ','c','o','u','n','t',' ','i','s',' ','%','1',' ','i','n',' ','V','T','S',' ','%','2',0,
-'T','i','t','l','e',' ','#','%','1',' ','w','i','t','h',' ','s','p','e','c','i','a','l',' ','a','t','t','r','i','b','u','t','e','s',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'T','i','t','l','e',' ','#','%','1',' ','i','n',' ','b','r','o','k','e','n',' ','t','i','t','l','e','s','e','t',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'T','i','t','l','e',' ','#','%','1',' ','(','%','2',')',' ','w','a','s',' ','s','k','i','p','p','e','d',' ','d','u','e',' ','t','o',' ','n','a','v','i','g','a','t','i','o','n',' ','e','r','r','o','r',0,
-'T','i','t','l','e',' ','#','%','1',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'T','i','t','l','e',' ','#','%','1',' ','(','%','2',')',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'T','i','t','l','e',' ','%','1',' ','i','n',' ','V','T','S',' ','%','2',' ','i','s',' ','a',' ','M','u','l','t','i','-','P','G','C',' ','t','i','t','l','e',0,
-'C','e','l','l','s',' ','%','1','-','%','2',' ','w','e','r','e',' ','s','k','i','p','p','e','d',' ','d','u','e',' ','t','o',' ','c','e','l','l',' ','c','o','m','m','a','n','d','s',' ','(','s','t','r','u','c','t','u','r','e',' ','p','r','o','t','e','c','t','i','o','n','?',')',0,
-'J','u','m','p','e','d',' ','t','o',' ','c','e','l','l',' ','%','2',' ','f','r','o','m',' ','c','e','l','l',' ','%','1',' ','d','u','e',' ','t','o',' ','c','e','l','l',' ','c','o','m','m','a','n','d','s',' ','(','s','t','r','u','c','t','u','r','e',' ','p','r','o','t','e','c','t','i','o','n','?',')',0,
-'L','o','o','p',' ','d','e','t','e','c','t','e','d','.',' ','P','o','s','s','i','b','l','y',' ','d','u','e',' ','t','o',' ','u','n','k','n','o','w','n',' ','s','t','r','u','c','t','u','r','e',' ','p','r','o','t','e','c','t','i','o','n','.',0,
-'B','r','o','k','e','n',' ','a','n','g','l','e',' ','b','l','o','c','k',' ','a','r','o','u','n','d',' ','c','e','l','l',' ','%','1',0,
-'W','r','o','n','g',' ','A','n','g','l','e','s',' ','c','o','u','n','t',' ','i','n',' ','a','n','g','l','e',' ','b','l','o','c','k',' ','a','r','o','u','n','d',' ','c','e','l','l',' ','%','1',' ',',',' ','%','2',' ','(','t','i','t','l','e',')',' ','!','=',' ','%','3',' ','(','p','g','c',')',0,
-'C','o','m','p','l','e','x',' ','m','u','l','t','i','p','l','e','x',' ','e','n','c','o','u','n','t','e','r','e','d',' ','-',' ','%','1',' ','c','e','l','l','s',' ','a','n','d',' ','%','2',' ','V','O','B','U','s',' ','h','a','v','e',' ','t','o',' ','b','e',' ','s','c','a','n','n','e','d','.',' ','T','h','i','s',' ','m','a','y',' ','t','a','k','e',' ','s','o','m','e',' ','t','i','m','e',',',' ','p','l','e','a','s','e',' ','b','e',' ','p','a','t','i','e','n','t',' ','-',' ','i','t',' ','c','a','n',0x27,'t',' ','b','e',' ','a','v','o','i','d','e','d','.',0,
-'T','i','t','l','e',' ','#','%','1',' ','h','a','s',' ','l','e','n','g','t','h',' ','o','f',' ','%','2',' ','s','e','c','o','n','d','s',' ','w','h','i','c','h',' ','i','s',' ','l','e','s','s',' ','t','h','a','n',' ','m','i','n','i','m','u','m',' ','t','i','t','l','e',' ','l','e','n','g','t','h',' ','o','f',' ','%','3',' ','s','e','c','o','n','d','s',' ','a','n','d',' ','w','a','s',' ','t','h','e','r','e','f','o','r','e',' ','s','k','i','p','p','e','d',0,
-'T','i','t','l','e',' ','#','%','1',' ','d','e','c','l','a','r','e','d',' ','l','e','n','g','t','h',' ','i','s',' ','%','2',' ','w','h','i','l','e',' ','i','t','s',' ','r','e','a','l',' ','l','e','n','g','t','h',' ','i','s',' ','%','3',' ','-',' ','a','s','s','u','m','i','n','g',' ','f','a','k','e',' ','t','i','t','l','e',0,
-'T','i','t','l','e',' ','%','3',' ','i','n',' ','V','T','S',' ','%','1',' ','i','s',' ','e','q','u','a','l',' ','t','o',' ','t','i','t','l','e',' ','%','2',' ','a','n','d',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'T','i','t','l','e',' ','#','%','1',' ','w','a','s',' ','a','d','d','e','d',' ','(','%','2',' ','c','e','l','l','(','s',')',',',' ','%','3',')',0,
-'A','u','d','i','o',' ','s','t','r','e','a','m',' ','#','%','1',' ','i','s',' ','i','d','e','n','t','i','c','a','l',' ','t','o',' ','s','t','r','e','a','m',' ','#','%','2',' ','a','n','d',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'S','u','b','t','i','t','l','e',' ','s','t','r','e','a','m',' ','#','%','1',' ','i','s',' ','i','d','e','n','t','i','c','a','l',' ','t','o',' ','s','t','r','e','a','m',' ','#','%','2',' ','a','n','d',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'D','r','i','v','e',' ','%','1',' ','h','a','s',' ','R','P','C',' ','p','r','o','t','e','c','t','i','o','n',' ','t','h','a','t',' ','c','a','n',' ','n','o','t',' ','b','e',' ','b','y','p','a','s','s','e','d','.',' ','C','h','a','n','g','e',' ','d','r','i','v','e',' ','r','e','g','i','o','n',' ','o','r',' ','u','p','d','a','t','e',' ','d','r','i','v','e',' ','f','i','r','m','w','a','r','e',' ','f','r','o','m',' ','h','t','t','p',':','/','/','t','d','b','.','r','p','c','1','.','o','r','g','.',' ','E','r','r','o','r','s',' ','l','i','k','e','l','y',' ','t','o',' ','f','o','l','l','o','w','.',0,
-'R','e','g','i','o','n',' ','s','e','t','t','i','n','g',' ','o','f',' ','d','r','i','v','e',' ','%','1',':','%','2',' ','d','o','e','s',' ','n','o','t',' ','m','a','t','c','h',' ','t','h','e',' ','r','e','g','i','o','n',' ','o','f',' ','c','u','r','r','e','n','t','l','y',' ','i','n','s','e','r','t','e','d',' ','d','i','s','c',',',' ','t','r','y','i','n','g',' ','t','o',' ','w','o','r','k',' ','a','r','o','u','n','d','.','.','.',0,
-'C','e','l','l',' ','%','1',' ','w','a','s',' ','d','i','s','c','a','r','d','e','d',' ','(','s','t','r','u','c','t','u','r','e',' ','p','r','o','t','e','c','t','i','o','n','?',')',0,
-'A','u','d','i','o',' ','s','t','r','e','a','m',' ','#','%','1',' ','l','o','o','k','s',' ','e','m','p','t','y',' ','a','n','d',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'C','e','l','l','W','a','l','k',' ','a','l','g','o','r','i','t','h','m',' ','f','a','i','l','e','d',' ','(','s','t','r','u','c','t','u','r','e',' ','p','r','o','t','e','c','t','i','o','n',' ','i','s',' ','t','o','o',' ','t','o','u','g','h','?',')',',',' ','t','r','y','i','n','g',' ','C','e','l','l','T','r','i','m',' ','a','l','g','o','r','i','t','h','m',0,
-'C','e','l','l','T','r','i','m',' ','a','l','g','o','r','i','t','h','m',' ','f','a','i','l','e','d',' ','s','i','n','c','e',' ','t','i','t','l','e',' ','h','a','s',' ','o','n','l','y',' ','%','1',' ','c','h','a','p','t','e','r','s',0,
-'C','e','l','l','s',' ','1','-','%','1',' ','w','e','r','e',' ','r','e','m','o','v','e','d',' ','f','r','o','m',' ','t','i','t','l','e',' ','s','t','a','r','t',0,
-'C','e','l','l','s',' ','%','1','-','%','2',' ','w','e','r','e',' ','r','e','m','o','v','e','d',' ','f','r','o','m',' ','t','i','t','l','e',' ','e','n','d',0,
-'F','a','k','e',' ','c','e','l','l','s',' ','o','c','c','u','p','y',' ','%','1','%','%',' ','o','f',' ','t','h','e',' ','t','i','t','l','e',' ','-',' ','a','s','s','u','m','i','n','g',' ','f','a','k','e',' ','t','i','t','l','e',0,
-'A','n','g','l','e',' ','#','%','1',' ','w','a','s',' ','a','d','d','e','d',' ','f','o','r',' ','t','i','t','l','e',' ','#','%','2',0,
-'F','a','i','l','e','d',' ','t','o',' ','a','d','d',' ','a','n','g','l','e',' ','#','%','1',' ','f','o','r',' ','t','i','t','l','e',' ','#','%','2',0,
-'I','F','O',' ','f','i','l','e',' ','f','o','r',' ','V','T','S',' ','#','%','1',' ','i','s',' ','c','o','r','r','u','p','t',',',' ','V','O','B',' ','f','i','l','e',' ','m','u','s','t',' ','b','e',' ','s','c','a','n','n','e','d','.',' ','T','h','i','s',' ','m','a','y',' ','t','a','k','e',' ','v','e','r','y',' ','l','o','n','g',' ','t','i','m','e',',',' ','p','l','e','a','s','e',' ','b','e',' ','p','a','t','i','e','n','t','.',0,
-'N','a','v','i','g','a','t','i','o','n',' ','i','n','f','o','r','m','a','t','i','o','n',' ','i','s',' ','i','n','v','a','l','i','d',' ','a','r','o','u','n','d',' ','%','1',' ','-',' ','c','h','e','c','k',' ','o','u','t','p','u','t',' ','f','i','l','e',' ','f','o','r',' ','A','V',' ','s','y','n','c',' ','e','r','r','o','r','s',0,
-'O','p','e','n','i','n','g',' ','D','V','D',' ','d','i','s','c',0,
-'O','p','e','n','i','n','g',' ','D','V','D',' ','f','i','l','e','s',' ','o','n',' ','a',' ','h','a','r','d','d','r','i','v','e',0,
-'P','r','o','c','e','s','s','i','n','g',' ','t','i','t','l','e',' ','s','e','t','s',0,
-'P','r','o','c','e','s','s','i','n','g',' ','t','i','t','l','e','s',0,
-'D','e','c','r','y','p','t','i','n','g',' ','d','a','t','a',0,
-'S','o','u','r','c','e',0,
-'P','a','r','s','i','n','g',' ','f','i','l','e',0,
-'T','i','t','l','e',' ','i','d',0,
-'C','u','r','r','e','n','t',' ','c','e','l','l',0,
-'C','u','r','r','e','n','t',' ','V','O','B','U',0,
-'T','i','t','l','e','s','e','t',' ','i','d',0,
-'C','S','S',' ','s','e','c','t','o','r','s',' ','s','c','a','n','n','e','d',0,
-'P','r','o','c','e','s','s','i','n','g',' ','a','d','v','a','n','c','e','d',' ','t','i','t','l','e','s','e','t',0,
-'L','o','a','d','i','n','g',' ','p','l','a','y','l','i','s','t','s',0,
-'D','e','c','r','y','p','t','i','n','g',0,
-'P','r','o','c','e','s','s','i','n','g',' ','t','i','t','l','e','s',0,
-'O','p','e','n','i','n','g',' ','M','K','V',' ','f','i','l','e',0,
-'T','r','a','c','k',' ','#','%','1',' ','o','f',' ','t','y','p','e',' ','%','2',' ','i','n',' ','%','3',' ','f','i','l','e',' ','i','s',' ','n','o','t',' ','r','e','c','o','g','n','i','z','e','d',' ','a','n','d',' ','w','a','s',' ','s','k','i','p','p','e','d','.',0,
-'M','K','V',' ','f','i','l','e',' ','h','a','s',' ','n','o',' ','v','i','d','e','o',' ','t','r','a','c','k','s',' ','a','n','d',' ','c','a','n',0x27,'t',' ','b','e',' ','o','p','e','n','e','d','.',0,
-'S','k','i','p','p','i','n','g',' ','A','V',' ','c','l','i','p',' ','%','1',' ','s','i','n','c','e',' ','i','t',' ','i','s',' ','n','o','t',' ','a',' ','v','i','d','e','o',' ','a','p','p','l','i','c','a','t','i','o','n',0,
-'A','A','C','S','-','p','r','o','t','e','c','t','e','d',' ','d','i','s','c','s',' ','t','h','a','t',' ','u','s','e',' ','S','K','B',' ','a','r','e',' ','n','o','t',' ','s','u','p','p','o','r','t','e','d',0,
-'S','t','r','e','a','m',' ','#','%','1',' ','o','f',' ','t','y','p','e',' ',0x27,'%','2',0x27,' ','i','n',' ','f','i','l','e',' ','%','3',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'T','h','e',' ','v','o','l','u','m','e',' ','k','e','y',' ','i','s',' ','u','n','k','n','o','w','n',' ','f','o','r',' ','t','h','i','s',' ','d','i','s','c',' ','-',' ','v','i','d','e','o',' ','c','a','n',0x27,'t',' ','b','e',' ','d','e','c','r','y','p','t','e','d',0,
-'A','V','C','H','D',' ','m','e','t','a','d','a','t','a',' ','f','o','u','n','d',0,
-'A','A','C','S',' ','d','i','r','e','c','t','o','r','y',' ','n','o','t',' ','p','r','e','s','e','n','t',',',' ','a','s','s','u','m','i','n','g',' ','u','n','e','n','c','r','y','p','t','e','d',' ','d','i','s','c',0,
-'C','a','n',0x27,'t',' ','r','e','a','d',' ','A','A','C','S',' ','V','I','D',' ','f','r','o','m',' ','d','i','s','c',' ','-',' ','m','o','s','t',' ','l','i','k','e','l','y',' ','c','u','r','r','e','n','t',' ','A','A','C','S',' ','h','o','s','t',' ','c','e','r','t','i','f','i','c','a','t','e',' ','i','s',' ','r','e','v','o','k','e','d',' ','b','y',' ','y','o','u','r',' ','d','r','i','v','e',0,
-'F','i','l','e',' ','%','1',' ','w','a','s',' ','a','d','d','e','d',' ','a','s',' ','t','i','t','l','e',' ','#','%','2',0,
-'F','i','l','e',' ','%','1',' ','(','a','n','g','l','e',' ','%','3',')',' ','w','a','s',' ','a','d','d','e','d',' ','a','s',' ','t','i','t','l','e',' ','#','%','2',0,
-'T','i','t','l','e',' ','%','1',' ','i','s',' ','e','q','u','a','l',' ','t','o',' ','t','i','t','l','e',' ','%','2',' ','a','n','d',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'T','h','i','s',' ','d','i','s','c',' ','u','s','e','s',' ','n','e','w','e','r',' ','v','e','r','s','i','o','n',' ','o','f',' ','A','A','C','S',' ','p','r','o','t','e','c','t','i','o','n','.',' ','P','l','e','a','s','e',' ','l','e','t',' ','u','s',' ','k','n','o','w',' ','a','b','o','u','t',' ','i','t',' ','b','y',' ','v','i','s','i','t','i','n','g',' ','%','1',0,
-'T','h','e',' ','v','o','l','u','m','e',' ','I','d',' ','i','s',' ','u','n','k','n','o','w','n',' ','f','o','r',' ','t','h','i','s',' ','d','i','s','c',' ','-',' ','B','D','+',' ','c','o','d','e',' ','w','i','l','l',' ','l','i','k','e','l','y',' ','f','a','i','l',0,
-'F','a','i','l','e','d',' ','t','o',' ','g','e','t',' ','B','D',' ','d','i','s','c',' ','i','n','f','o','r','m','a','t','i','o','n',',',' ','r','e','p','o','r','t','i','n','g',' ','d','o','u','b','l','e','-','l','a','y','e','r',' ','B','D','-','R','O','M',' ','t','o',' ','B','D','+',' ','c','o','d','e',0,
-'D','i','r','e','c','t','o','r','y',' ','w','h','e','r','e',' ','t','o',' ','l','o','o','k',' ','f','o','r',' ','B','D','+',' ','S','V','Q',' ','f','i','l','e','s',' ','i','s',' ','n','o','t',' ','s','e','t',' ','i','n',' ','p','r','e','f','e','r','e','n','c','e','s',0,
-'D','i','r','e','c','t','o','r','y',' ','%','1',' ','d','o','e','s',' ','n','o','t',' ','e','x','i','s','t',' ','o','r',' ','i','s',' ','n','o','t',' ','a','c','c','e','s','s','i','b','l','e',0,
-'S','V','Q',' ','f','i','l','e',' ','%','1',' ','i','s',' ','i','n','v','a','l','i','d',0,
-'S','V','Q',' ','f','i','l','e',' ','%','1',' ','i','s',' ','c','o','r','r','u','p','t',0,
-'L','o','a','d','e','d',' ','%','1',' ','S','V','Q',' ','f','i','l','e','(','s',')',0,
-'N','o',' ','S','V','Q',' ','f','i','l','e','s',' ','w','e','r','e',' ','f','o','u','n','d',',',' ','B','D','+',' ','c','o','d','e',' ','c','a','n',0x27,'t',' ','b','e',' ','p','r','o','c','e','s','s','e','d',0,
-'N','o',' ','m','a','t','c','h','i','n','g',' ','S','V','Q',' ','f','i','l','e','s',' ','w','e','r','e',' ','f','o','u','n','d',',',' ','B','D','+',' ','c','o','d','e',' ','c','a','n',0x27,'t',' ','b','e',' ','p','r','o','c','e','s','s','e','d',0,
-'D','i','s','c',' ','c','o','n','t','a','i','n','s',' ','B','D','+',' ','w','i','t','h','o','u','t',' ','A','A','C','S',',',' ','B','D','+',' ','c','o','d','e',' ','c','a','n',0x27,'t',' ','b','e',' ','p','r','o','c','e','s','s','e','d',0,
-'F','a','i','l','e','d',' ','t','o',' ','p','r','o','c','e','s','s',' ','B','D','+',' ','c','o','d','e',',',' ','p','l','e','a','s','e',' ','c','h','e','c','k',' ','%','1',' ','f','o','r',' ','u','p','d','a','t','e','d',' ','p','r','o','g','r','a','m',' ','a','n','d',' ','S','V','Q',' ','f','i','l','e','s',0,
-'P','r','o','c','e','s','s','i','n','g',' ','B','D','+',' ','c','o','d','e',' ','u','s','i','n','g',' ','d','i','s','c','-','s','p','e','c','i','f','i','c',' ','S','V','Q',' ','f','r','o','m',' ','%','1',0,
-'F','a','i','l','e','d',' ','t','o',' ','p','r','o','c','e','s','s',' ','B','D','+',' ','c','o','d','e',' ','u','s','i','n','g',' ','d','i','s','c','-','s','p','e','c','i','f','i','c',' ','S','V','Q',' ','f','r','o','m',' ','%','1',0,
-'P','r','o','c','e','s','s','i','n','g',' ','B','D','+',' ','c','o','d','e',' ','u','s','i','n','g',' ','g','e','n','e','r','i','c',' ','S','V','Q',' ','f','r','o','m',' ','%','1',0,
-'F','a','i','l','e','d',' ','t','o',' ','p','r','o','c','e','s','s',' ','B','D','+',' ','c','o','d','e',' ','u','s','i','n','g',' ','g','e','n','e','r','i','c',' ','S','V','Q',' ','f','r','o','m',' ','%','1',0,
-'P','r','o','c','e','s','s','i','n','g',' ','B','D','+',' ','c','o','d','e',',',' ','p','l','e','a','s','e',' ','b','e',' ','p','a','t','i','e','n','t',' ','-',' ','t','h','i','s',' ','m','a','y',' ','t','a','k','e',' ','u','p',' ','t','o',' ','f','e','w',' ','m','i','n','u','t','e','s',0,
-'B','D','+',' ','c','o','d','e',' ','p','r','o','c','e','s','s','e','d',' ','b','u','t',' ','n','o',' ','F','U','T','s',' ','w','e','r','e',' ','o','b','t','a','i','n','e','d',',',' ','e','r','r','o','r','s',' ','m','a','y',' ','f','o','l','l','o','w',0,
-'B','D','+',' ','c','o','d','e',' ','p','r','o','c','e','s','s','e','d',',',' ','g','o','t',' ','%','1',' ','F','U','T','(','s',')',' ','f','o','r',' ','%','2',' ','c','l','i','p','(','s',')',0,
-'S','V','Q',' ','i','n',' ','%','1',' ','c','a','n',0x27,'t',' ','b','e',' ','p','r','o','c','e','s','s','e','d',' ','b','y',' ','t','h','i','s',' ','v','e','r','s','i','o','n',',',' ','p','l','e','a','s','e',' ','d','o','w','n','l','o','a','d',' ','l','a','t','e','s','t',' ','p','r','o','g','r','a','m',' ','v','e','r','s','i','o','n',' ','f','r','o','m',' ','%','2',0,
-'B','D','+',' ','d','u','m','p',' ','d','i','r','e','c','t','o','r','y',' ','i','s',' ','n','o','t',' ','a','c','c','e','s','s','i','b','l','e',',',' ','B','D','+',' ','d','u','m','p',' ','n','o','t',' ','s','a','v','e','d',0,
-'F','a','i','l','e','d',' ','t','o',' ','c','r','e','a','t','e',' ','%','1',' ','d','u','m','p',' ','f','i','l','e',' ','%','2',0,
-'S','a','v','e','d',' ','%','1',' ','d','u','m','p',' ','f','i','l','e',' ','a','s',' ','%','2',0,
-'B','D','+',' ','d','u','m','p',' ','d','i','r','e','c','t','o','r','y',' ','i','s',' ','n','o','t',' ','s','e','t',' ','i','n',' ','p','r','e','f','e','r','e','n','c','e','s',',',' ','B','D','+',' ','d','u','m','p',' ','n','o','t',' ','s','a','v','e','d',0,
-'I','t',' ','a','p','p','e','a','r','s',' ','t','h','a','t',' ','y','o','u',' ','h','a','v','e',' ','o','n','-','t','h','e','-','f','l','y',' ','d','e','c','r','y','p','t','i','o','n',' ','s','o','f','t','w','a','r','e',' ','e','n','a','b','l','e','d','.',' ','M','a','k','e','M','K','V',' ','s','h','o','u','l','d',' ','p','r','o','c','e','s','s',' ','d','i','s','c','s',' ','w','i','t','h',' ','m','o','s','t',' ','s','o','p','h','i','s','t','i','c','a','t','e','d',' ','p','r','o','t','e','c','t','i','o','n','s',' ','w','i','t','h','o','u','t',' ','h','e','l','p',' ','o','f',' ','a','n','y',' ','3','r','d',' ','p','a','r','t','y',' ','d','e','c','r','y','p','t','i','o','n',' ','s','o','f','t','w','a','r','e','.',' ','I','n',' ','a','d','d','i','t','i','o','n',' ','M','a','k','e','M','K','V',' ','w','o','r','k','s',' ','f','a','s','t','e','r',' ','a','n','d',' ','m','o','r','e',' ','r','e','l','i','a','b','l','y',' ','w','h','e','n',' ','i','t',' ','d','e','c','r','y','p','t','s',' ','d','a','t','a',' ','b','y',' ','i','t','s','e','l','f','.',' ','I','t',' ','i','s',' ','h','i','g','h','l','y',' ','r','e','c','o','m','m','e','n','d','e','d',' ','t','o',' ','d','i','s','a','b','l','e',' ','s','u','c','h',' ','s','o','f','t','w','a','r','e',' ','a','n','d',' ','r','e','s','t','a','r','t',' ','t','h','e',' ','a','p','p','l','i','c','a','t','i','o','n','.',' ',0xa,0xa,'D','o',' ','y','o','u',' ','w','a','n','t',' ','t','o',' ','c','o','n','t','i','n','u','e',' ','a','n','y','w','a','y',' ','(','e','r','r','o','r','s',' ','m','a','y',' ','f','o','l','l','o','w',')',' ','?',0,
-'I','t',' ','a','p','p','e','a','r','s',' ','t','h','a','t',' ','y','o','u',' ','h','a','v','e',' ','A','n','y','D','V','D',' ','e','n','a','b','l','e','d','.',' ','M','a','k','e','M','K','V',' ','s','h','o','u','l','d',' ','p','r','o','c','e','s','s',' ','d','i','s','c','s',' ','w','i','t','h',' ','m','o','s','t',' ','s','o','p','h','i','s','t','i','c','a','t','e','d',' ','p','r','o','t','e','c','t','i','o','n','s',' ','w','i','t','h','o','u','t',' ','h','e','l','p',' ','o','f',' ','a','n','y',' ','3','r','d',' ','p','a','r','t','y',' ','d','e','c','r','y','p','t','i','o','n',' ','s','o','f','t','w','a','r','e','.',' ','I','n',' ','a','d','d','i','t','i','o','n',' ','M','a','k','e','M','K','V',' ','w','o','r','k','s',' ','f','a','s','t','e','r',' ','a','n','d',' ','m','o','r','e',' ','r','e','l','i','a','b','l','y',' ','w','h','e','n',' ','i','t',' ','d','e','c','r','y','p','t','s',' ','d','a','t','a',' ','b','y',' ','i','t','s','e','l','f','.',' ','I','t',' ','i','s',' ','h','i','g','h','l','y',' ','r','e','c','o','m','m','e','n','d','e','d',' ','t','o',' ','d','i','s','a','b','l','e',' ','A','n','y','D','V','D',' ','a','n','d',' ','r','e','s','t','a','r','t',' ','t','h','e',' ','a','p','p','l','i','c','a','t','i','o','n','.',' ',0xa,0xa,'D','o',' ','y','o','u',' ','w','a','n','t',' ','t','o',' ','c','o','n','t','i','n','u','e',' ','a','n','y','w','a','y',' ','(','e','r','r','o','r','s',' ','m','a','y',' ','f','o','l','l','o','w',')',' ','?',0,
-'I','t',' ','a','p','p','e','a','r','s',' ','t','h','a','t',' ','y','o','u',' ','a','r','e',' ','o','p','e','n','i','n','g',' ','t','h','e',' ','d','i','s','c',' ','p','r','o','c','e','s','s','e','d',' ','b','y',' ','D','v','d','F','a','b','.',' ','D','v','d','F','a','b',' ','i','s',' ','k','n','o','w','n',' ','t','o',' ','d','e','s','t','r','o','y',' ','D','V','D','-','T','E','X','T',' ','m','e','t','a','d','a','t','a',',',' ','s','u','c','h',' ','a','s',' ','d','i','s','c',' ','a','n','d',' ','t','i','t','l','e',' ','n','a','m','e','s',',',' ','i','n',' ','i','f','o',' ','f','i','l','e','s','.',' ','M','a','k','e','M','K','V',' ','s','h','o','u','l','d',' ','p','r','o','c','e','s','s',' ','d','i','s','c','s',' ','w','i','t','h',' ','m','o','s','t',' ','s','o','p','h','i','s','t','i','c','a','t','e','d',' ','p','r','o','t','e','c','t','i','o','n','s',' ','w','i','t','h','o','u','t',' ','h','e','l','p',' ','o','f',' ','a','n','y',' ','3','r','d',' ','p','a','r','t','y',' ','d','e','c','r','y','p','t','i','o','n',' ','s','o','f','t','w','a','r','e','.',' ','I','n',' ','a','d','d','i','t','i','o','n',' ','M','a','k','e','M','K','V',' ','w','o','r','k','s',' ','f','a','s','t','e','r',' ','a','n','d',' ','m','o','r','e',' ','r','e','l','i','a','b','l','y',' ','w','h','e','n',' ','i','t',' ','d','e','c','r','y','p','t','s',' ','d','a','t','a',' ','b','y',' ','i','t','s','e','l','f','.',' ',0xa,0xa,'P','l','e','a','s','e',' ','p','r','e','s','s',' ','O','K',' ','t','o',' ','c','o','n','t','i','n','u','e','.',0,
-'F','a','i','l','e','d',' ','t','o',' ','p','a','r','s','e',' ','A','V','C','H','D',' ','m','e','t','a','d','a','t','a',' ','e','m','b','e','d','d','e','d',' ','b','y',' ','y','o','u','r',' ','c','a','m','e','r','a',',',' ','p','l','e','a','s','e',' ','r','e','p','o','r','t',' ','i','t',' ','o','n',' ','%','1',0,
-'D','o','w','n','l','o','a','d','i','n','g',' ','l','a','t','e','s','t',' ','%','1',' ','t','o',' ','%','2',' ','.','.','.',0,
-'A','u','t','o','m','a','t','i','c',' ','%','1',' ','d','o','w','n','l','o','a','d','i','n','g',' ','i','s',' ','d','i','s','a','b','l','e','d',' ','o','r',' ','f','a','i','l','e','d','.',0,
-'D','r','i','v','e',' ',0x27,'%','1',' ','%','2',' ','%','3',0x27,' ','r','e','q','u','i','r','e','s',' ','A','A','C','S',' ','b','u','s',' ','e','n','c','r','y','p','t','i','o','n',',',' ','d','i','s','c',' ','d','e','c','r','y','p','t','i','o','n',' ','m','a','y',' ','f','a','i','l','.',0,
-'H','i','g','h','e','s','t',' ','A','A','C','S',' ','v','e','r','s','i','o','n',' ','i','s',' ','v','%','1',' ',',',' ','M','K','B',' ','s','a','v','e','d',' ','a','s',' ','%','2',0,
-'I','t',' ','a','p','p','e','a','r','s',' ','t','h','a','t',' ','y','o','u',' ','a','r','e',' ','o','p','e','n','i','n','g',' ','t','h','e',' ','d','i','s','c',' ','p','r','o','c','e','s','s','e','d',' ','b','y',' ','D','v','d','F','a','b','/','M','a','c','T','h','e','R','i','p','p','e','r',' ','w','h','i','c','h',' ','i','s',' ','k','n','o','w','n',' ','t','o',' ','p','r','o','d','u','c','e',' ','d','a','m','a','g','e','d',' ','V','O','B',' ','f','i','l','e','s','.',' ','E','r','r','o','r','s',' ','m','a','y',' ','f','o','l','l','o','w',' ','-',' ','p','l','e','a','s','e',' ','u','s','e',' ','o','r','i','g','i','n','a','l',' ','d','i','s','c',' ','i','n','s','t','e','a','d','.',0,
-'B','o','t','h',' ','d','i','s','c',' ','a','n','d',' ','d','r','i','v','e',' ','r','e','q','u','i','r','e',' ','b','u','s',' ','e','n','c','r','y','p','t','i','o','n',',',' ','b','u','t',' ','t','h','e',' ','b','u','s',' ','k','e','y',' ','i','s',' ','n','o','t',' ','k','n','o','w','n','.',0,
-'U','s','i','n','g',' ','J','a','v','a',' ','r','u','n','t','i','m','e',' ','f','r','o','m',' ','%','1',0,
-'T','h','i','s',' ','d','i','s','c',' ','r','e','q','u','i','r','e','s',' ','J','a','v','a',' ','r','u','n','t','i','m','e',' ','(','J','R','E',')',',',' ','b','u','t',' ','n','o','n','e',' ','w','a','s',' ','f','o','u','n','d','.',' ','C','e','r','t','a','i','n',' ','f','u','n','c','t','i','o','n','s',' ','w','i','l','l',' ','f','a','i','l',',',' ','p','l','e','a','s','e',' ','i','n','s','t','a','l','l',' ','J','a','v','a','.',' ','S','e','e',' ','%','1',' ','f','o','r',' ','d','e','t','a','i','l','s','.',0,
-'L','i','b','r','e','D','r','i','v','e',' ','c','o','m','p','a','t','i','b','l','e',' ','d','r','i','v','e',' ','i','s',' ','r','e','q','u','i','r','e','d',' ','t','o',' ','o','p','e','n',' ','t','h','i','s',' ','d','i','s','c',' ','-',' ','v','i','d','e','o',' ','c','a','n',0x27,'t',' ','b','e',' ','d','e','c','r','y','p','t','e','d','.',0,
-'P','l','e','a','s','e',' ','s','e','n','d',' ','t','h','e',' ','f','i','l','e',' ','"','%','1','"',' ','t','o',' ','%','2',0,
-'P','r','o','c','e','s','s','i','n','g',' ','A','V',' ','c','l','i','p','s',0,
-'P','r','o','c','e','s','s','i','n','g',' ','m','o','v','i','e',' ','p','l','a','y','l','i','s','t','s',0,
-'D','e','c','r','y','p','t','i','n','g',0,
-'P','r','o','c','e','s','s','i','n','g',' ','t','i','t','l','e','s',0,
-'O','p','e','n','i','n','g',' ','B','l','u','-','r','a','y',' ','d','i','s','c',0,
-'A','V',' ','c','l','i','p',0,
-'P','r','o','c','e','s','s','i','n','g',' ','B','D','+',' ','c','o','d','e',0,
-'B','D','+',' ','V','M',' ','s','t','a','t','e',0,
-'F','o','r','c','e','d',' ','s','u','b','t','i','t','l','e','s',' ','t','r','a','c','k',' ','#','%','1',' ','t','u','r','n','e','d',' ','o','u','t',' ','t','o',' ','b','e',' ','e','m','p','t','y',' ','a','n','d',' ','w','a','s',' ','r','e','m','o','v','e','d',' ','f','r','o','m',' ','o','u','t','p','u','t',' ','f','i','l','e',0,
-'T','r','a','c','k',' ','#','%','1',' ','t','u','r','n','e','d',' ','o','u','t',' ','t','o',' ','b','e',' ','e','m','p','t','y',' ','a','n','d',' ','w','a','s',' ','r','e','m','o','v','e','d',' ','f','r','o','m',' ','o','u','t','p','u','t',' ','f','i','l','e',0,
-'T','h','e',' ','s','o','u','r','c','e',' ','f','i','l','e',' ','i','s',' ','c','o','r','r','u','p','t',' ','o','r',' ','i','n','v','a','l','i','d',',',' ','a','t','t','e','m','p','t','i','n','g',' ','t','o',' ','w','o','r','k',' ','a','r','o','u','n','d',0,
-'T','h','e',' ','s','o','u','r','c','e',' ','f','i','l','e',' ',0x27,'%','1',0x27,' ','i','s',' ','c','o','r','r','u','p','t',' ','o','r',' ','i','n','v','a','l','i','d',' ','a','t',' ','o','f','f','s','e','t',' ','%','2',',',' ','a','t','t','e','m','p','t','i','n','g',' ','t','o',' ','w','o','r','k',' ','a','r','o','u','n','d',0,
-'A','V',' ','s','y','n','c','h','r','o','n','i','z','a','t','i','o','n',' ','i','s','s','u','e','s',' ','w','e','r','e',' ','f','o','u','n','d',' ','i','n',' ','f','i','l','e',' ',0x27,'%','1',0x27,' ','(','t','i','t','l','e',' ','#','%','2',')',0,
-'A','V',' ','s','y','n','c',' ','i','s','s','u','e',' ','i','n',' ','s','t','r','e','a','m',' ','%','1',' ','a','t',' ','%','2',' ','w','i','t','h',' ','d','u','r','a','t','i','o','n',' ','o','f',' ','%','3',' ',':',' ','%','4',0,
-'T','o','o',' ','m','a','n','y',' ','A','V',' ','s','y','n','c','h','r','o','n','i','z','a','t','i','o','n',' ','i','s','s','u','e','s',' ','i','n',' ','f','i','l','e',' ',0x27,'%','1',0x27,' ','(','t','i','t','l','e',' ','#','%','2',')',' ',',',' ','f','u','t','u','r','e',' ','m','e','s','s','a','g','e','s',' ','w','i','l','l',' ','b','e',' ','p','r','i','n','t','e','d',' ','o','n','l','y',' ','t','o',' ','l','o','g',' ','f','i','l','e',0,
-'%','1',' ','e','a','r','l','y',' ','f','r','a','m','e','(','s',')',' ','d','r','o','p','p','e','d',' ','a','t',' ','s','t','a','r','t',0,
-'%','1',' ','o','v','e','r','l','a','p','p','i','n','g',' ','f','r','a','m','e','(','s',')',' ','d','r','o','p','p','e','d',' ','a','t',' ','s','e','g','m','e','n','t',' ','b','o','u','n','d','a','r','y',0,
-'a','u','d','i','o',' ','g','a','p',' ','-',' ','%','1',' ','m','i','s','s','i','n','g',' ','f','r','a','m','e','(','s',')',0,
-'a','u','d','i','o',' ','g','a','p',' ','w','a','s',' ','f','i','l','l','e','d',' ','w','i','t','h',' ','%','1',' ','d','u','p','l','i','c','a','t','e',' ','f','r','a','m','e','s',',',' ','a','u','d','i','o',' ','s','k','e','w',' ','i','s',' ','%','2',0,
-'a','u','d','i','o',' ','g','a','p',' ','w','a','s',' ','f','i','l','l','e','d',' ','w','i','t','h',' ','s','i','l','e','n','c','e',0,
-'s','h','o','r','t',' ','a','u','d','i','o',' ','g','a','p',' ','w','a','s',' ','r','e','m','o','v','e','d',',',' ','a','u','d','i','o',' ','s','k','e','w',' ','i','s',' ','%','1',0,
-'%','1',' ','f','r','a','m','e','(','s',')',' ','d','r','o','p','p','e','d',' ','t','o',' ','r','e','d','u','c','e',' ','a','u','d','i','o',' ','s','k','e','w',' ','t','o',' ','%','2',0,
-'e','n','c','o','u','n','t','e','r','e','d',' ','o','v','e','r','l','a','p','p','i','n','g',' ','f','r','a','m','e',',',' ','a','u','d','i','o',' ','s','k','e','w',' ','i','s',' ','%','1',0,
-'b','r','o','k','e','n',' ','t','i','m','e','c','o','d','e',',',' ','a','p','p','a','r','e','n','t',' ','a','u','d','i','o',' ','s','k','e','w',' ','i','s',' ','%','1',0,
-'U','n','a','b','l','e',' ','t','o',' ','e','x','e','c','u','t','e',' ','e','x','t','e','r','n','a','l',' ','p','r','o','g','r','a','m',' ',0x27,'%','1',0x27,' ','a','s',' ','i','t','s',' ','p','a','t','h',' ','i','s',' ','n','o','t',' ','s','e','t',' ','i','n',' ','p','r','e','f','e','r','e','n','c','e','s',0,
-'F','a','i','l','e','d',' ','t','o',' ','e','x','e','c','u','t','e',' ','e','x','t','e','r','n','a','l',' ','p','r','o','g','r','a','m',' ',0x27,'%','1',0x27,' ','f','r','o','m',' ','l','o','c','a','t','i','o','n',' ',0x27,'%','2',0x27,0,
-'F','a','i','l','e','d',' ','t','o',' ','l','o','a','d',' ','e','x','t','e','r','n','a','l',' ','D','L','L',' ',0x27,'%','1',0x27,' ','f','r','o','m',' ','l','o','c','a','t','i','o','n',' ',0x27,'%','2',0x27,0,
-'E','x','t','e','r','n','a','l',' ','D','L','L',' ',0x27,'%','1',0x27,' ','f','r','o','m',' ','l','o','c','a','t','i','o','n',' ',0x27,'%','2',0x27,' ','i','s',' ','u','n','k','n','o','w','n',' ','-',' ','e','i','t','h','e','r',' ','t','o','o',' ','o','l','d',',',' ','t','o','o',' ','n','e','w',' ','o','r',' ','b','e','i','n','g',' ','t','a','m','p','e','r','e','d',' ','w','i','t','h',0,
-'E','x','t','e','r','n','a','l',' ','D','L','L',' ',0x27,'%','1',0x27,' ','(','%','3',')',' ','f','r','o','m',' ','l','o','c','a','t','i','o','n',' ',0x27,'%','2',0x27,' ','i','s',' ','t','o','o',' ','o','l','d',' ','a','n','d',' ','c','a','n',0x27,'t',' ','b','e',' ','u','s','e','d',0,
-'F','a','i','l','e','d',' ','t','o',' ','l','o','a','d',' ','e','x','t','e','r','n','a','l',' ','D','L','L',' ',0x27,'%','1',0x27,' ','a','s',' ','i','t','s',' ','p','a','t','h',' ','i','s',' ','n','o','t',' ','s','e','t',' ','i','n',' ','p','r','e','f','e','r','e','n','c','e','s',',',' ','p','l','e','a','s','e',' ','s','e','e',' ','%','2',' ','f','o','r',' ','d','e','t','a','i','l','s',0,
-'i','g','n','o','r','i','n','g',' ','D','R','C',' ','g','a','i','n',' ','c','h','a','n','g','e',' ','f','r','o','m',' ','%','1','d','B',' ','t','o',' ','%','2','d','B',0,
-'A','V',' ','s','y','n','c',' ','i','s','s','u','e',' ','i','n',' ','s','t','r','e','a','m',' ','%','1',' ','a','t',' ','%','2',' ',':',' ','%','3',0,
-'v','i','d','e','o',' ','f','r','a','m','e',' ','t','i','m','e','c','o','d','e',' ','d','i','f','f','e','r','s',' ','b','y',' ','%','1',0,
-'s','e','c','o','n','d','a','r','y',' ','s','t','r','e','a','m',' ','v','i','d','e','o',' ','f','r','a','m','e',' ','t','i','m','e','c','o','d','e',' ','d','i','f','f','e','r','s',' ','b','y',' ','%','1',0,
-'t','o','o',' ','m','a','n','y',' ','v','i','d','e','o',' ','f','r','a','m','e','s',' ','w','i','t','h',' ','i','n','v','a','l','i','d',' ','t','i','m','e','c','o','d','e','s',',',' ','f','u','t','u','r','e',' ','m','e','s','s','a','g','e','s',' ','w','i','l','l',' ','b','e',' ','s','u','p','p','r','e','s','s','e','d',0,
-'v','i','d','e','o',' ','s','t','r','e','a','m',' ','h','a','s',' ','%','1',' ','f','r','a','m','e','s',' ','w','i','t','h',' ','i','n','v','a','l','i','d',' ','t','i','m','e','c','o','d','e','s',0,
-'c','o','n','v','e','r','t','i','n','g',' ','a','u','d','i','o',' ','f','r','o','m',' ','%','1',' ','t','o',' ','%','2',0,
-'a','u','d','i','o',' ','c','h','a','n','g','e','s',' ','f','r','o','m',' ','%','1',' ','t','o',' ','%','2',',',' ','y','o','u',' ','w','o','n',0x27,'t',' ','b','e',' ','a','b','l','e',' ','t','o',' ','c','o','n','v','e','r','t',' ','t','h','i','s',' ','t','r','a','c','k',' ','t','o',' ','a','n','y',' ','o','t','h','e','r',' ','f','o','r','m','a','t',' ','l','a','t','e','r',',',' ','p','l','e','a','s','e',' ','u','s','e',' ','a',' ','c','o','n','v','e','r','s','i','o','n',' ','p','r','o','f','i','l','e',' ','w','i','t','h',' ','a','u','d','i','o',' ','t','r','a','n','s','c','o','d','i','n','g',0,
-'F','F','M','P','E','G','_','E','R','R','O','R',':',' ','%','1',0,
-'C','l','i','p',' ','b','o','u','n','d','a','r','y',' ','n','o','t',' ','a','l','i','g','n','e','d',',',' ','m','o','v','i','n','g',' ','t','o',' ','t','h','e',' ','c','l','o','s','e','s','t',' ','a','l','i','g','n','e','d',' ','v','a','l','u','e',0,
-'S','t','r','e','a','m','s',' ','w','i','t','h',' ','w','i','d','e',' ','l','e','f','t','/','r','i','g','h','t',' ','c','h','a','n','n','e','l','s',' ','a','r','e',' ','n','o','t',' ','s','u','p','p','o','r','t','e','d','.',0,
-'S','t','r','e','a','m','s',' ','w','i','t','h',' ','s','i','d','e',' ','h','i','g','h',' ','l','e','f','t','/','r','i','g','h','t',' ','c','h','a','n','n','e','l','s',' ','a','r','e',' ','n','o','t',' ','s','u','p','p','o','r','t','e','d','.',0,
-'T','h','i','s',' ','s','t','r','e','a','m',' ','c','a','n',0x27,'t',' ','b','e',' ','p','r','o','p','e','r','l','y',' ','d','e','c','o','d','e','d',' ','b','y',' ','t','h','i','s',' ','D','L','L',',',' ','p','l','e','a','s','e',' ','u','s','e',' ','d','t','s','d','e','c','o','d','e','r','d','l','l',' ','v','1','.','1','.','0','.','5',' ','o','r',' ','l','a','t','e','r','.',0,
-'O','u','t','p','u','t',' ','f','o','l','d','e','r',' ','i','s',' ','n','o','t',' ','s','e','t',0,
-'F','i','l','e',' ','%','1',' ','a','l','r','e','a','d','y',' ','e','x','i','s','t','.',' ','D','o',' ','y','o','u',' ','w','a','n','t',' ','t','o',' ','o','v','e','r','w','r','i','t','e',' ','i','t','?',0,
-'T','i','t','l','e',' ','%','1',' ','s','k','i','p','p','e','d',0,
-'F','a','i','l','e','d',' ','t','o',' ','s','a','v','e',' ','t','i','t','l','e',' ','%','1',' ','t','o',' ','f','i','l','e',' ','%','2',0,
-'%','1',' ','t','i','t','l','e','s',' ','s','a','v','e','d',',',' ','%','2',' ','f','a','i','l','e','d',0,
-'%','1',' ','t','i','t','l','e','s',' ','s','a','v','e','d',0,
-'F','i','l','e',' ','%','1',' ','d','o','e','s',' ','n','o','t',' ','e','x','i','s','t',0,
-'F','a','i','l','e','d',' ','t','o',' ','o','p','e','n',' ','f','i','l','e',' ','%','1',0,
-'T','h','e','r','e',' ','a','r','e',' ','n','o',' ','(','a','c','c','e','s','s','i','b','l','e',')',' ','t','i','t','l','e','s',' ','o','n',' ','d','i','s','c',0,
-'A','p','p','l','i','c','a','t','i','o','n',' ','f','a','i','l','e','d',' ','t','o',' ','i','n','i','t','i','a','l','i','z','e',0,
-'F','a','i','l','e','d',' ','t','o',' ','o','p','e','n',' ','d','i','s','c',0,
-'O','p','e','r','a','t','i','o','n',' ','s','u','c','c','e','s','s','f','u','l','l','y',' ','c','o','m','p','l','e','t','e','d',0,
-'N','o',' ','t','i','t','l','e','s',' ','a','r','e',' ','s','e','l','e','c','t','e','d','.',' ','N','o','t','h','i','n','g',' ','t','o',' ','d','o','.',0,
-'D','i','r','e','c','t','o','r','y',' ','%','1',' ','d','o','e','s',' ','n','o','t',' ','e','x','i','s','t','.',' ','D','o',' ','y','o','u',' ','w','a','n','t',' ','t','o',' ','c','r','e','a','t','e',' ','i','t','?',0,
-'S','a','v','i','n','g',' ','%','1',' ','t','i','t','l','e','s',' ','i','n','t','o',' ','d','i','r','e','c','t','o','r','y',' ','%','2',0,
-'S','a','v','i','n','g',' ','%','1',' ','t','i','t','l','e','s',' ','i','n','t','o',' ','d','i','r','e','c','t','o','r','y',' ','%','2',' ','u','s','i','n','g',' ','p','r','o','f','i','l','e',' ',0x27,'%','3',0x27,' ','f','r','o','m',' ','f','i','l','e',' ',0x27,'%','4',0x27,0,
-'D','i','r','e','c','t','o','r','y',' ','%','1',' ','i','s',' ','i','n','v','a','l','i','d',0,
-'S','a','v','i','n','g',' ','t','o',' ','M','K','V',' ','f','i','l','e',0,
-'S','c','a','n','n','i','n','g',' ','C','D','-','R','O','M',' ','d','e','v','i','c','e','s',0,
-'R','e','a','d','i','n','g',' ','D','i','s','c',' ','i','n','f','o','r','m','a','t','i','o','n',0,
-'T','h','e',' ','s','t','o','r','e','d',' ','a','c','t','i','v','a','t','i','o','n',' ','k','e','y',' ','i','s',' ','i','n','v','a','l','i','d','.',' ','I',' ','g','u','e','s','s',' ','s','o','m','e','o','n','e',' ','t','a','m','p','e','r','e','d',' ','w','i','t','h',' ','s','e','t','t','i','n','g','s','.','.','.',' ','P','l','e','a','s','e',' ','p','u','r','c','h','a','s','e',' ','a','n',' ','a','c','t','i','v','a','t','i','o','n',' ','k','e','y',' ','i','f',' ','y','o','u',0x27,'v','e',' ','f','o','u','n','d',' ','t','h','i','s',' ','a','p','p','l','i','c','a','t','i','o','n',' ','u','s','e','f','u','l','.',0,
-'T','h','i','s',' ','a','p','p','l','i','c','a','t','i','o','n',' ','v','e','r','s','i','o','n',' ','i','s',' ','t','o','o',' ','o','l','d','.',' ',' ','P','l','e','a','s','e',' ','d','o','w','n','l','o','a','d',' ','t','h','e',' ','l','a','t','e','s','t',' ','v','e','r','s','i','o','n',' ','a','t',' ','%','1',' ','o','r',' ','e','n','t','e','r',' ','a',' ','r','e','g','i','s','t','r','a','t','i','o','n',' ','k','e','y',' ','t','o',' ','c','o','n','t','i','n','u','e',' ','u','s','i','n','g',' ','t','h','e',' ','c','u','r','r','e','n','t',' ','v','e','r','s','i','o','n','.',0,
-'F','a','i','l','e','d',' ','t','o',' ','v','a','l','i','d','a','t','e',' ','a','c','t','i','v','a','t','i','o','n',' ','k','e','y','.',' ','A','r','e',' ','y','o','u',' ','r','e','a','l','l','y',' ','t','r','y','i','n','g',' ','t','o',' ','h','a','c','k',' ','t','h','i','s',' ','a','p','p','l','i','c','a','t','i','o','n','?',0,
-'S','a','v','i','n','g',' ','a','l','l',' ','t','i','t','l','e','s',' ','t','o',' ','M','K','V',' ','f','i','l','e','s',0,
-'S','c','a','n','n','i','n','g',' ','d','e','v','i','c','e',0,
-'S','o','u','r','c','e',0,
-'S','o','u','r','c','e',' ','f','i','l','e',0,
-'S','o','u','r','c','e',' ','s','i','z','e',0,
-'R','e','a','d',' ','r','a','t','e',0,
-'O','u','t','p','u','t',' ','f','i','l','e',0,
-'O','u','t','p','u','t',' ','s','i','z','e',0,
-'F','r','e','e',' ','s','p','a','c','e',0,
-'C','o','p','y',' ','c','o','m','p','l','e','t','e','.',' ','%','1',' ','t','i','t','l','e','s',' ','s','a','v','e','d','.',0,
-'C','o','p','y',' ','c','o','m','p','l','e','t','e','.',' ','%','1',' ','t','i','t','l','e','s',' ','s','a','v','e','d',',',' ','%','2',' ','f','a','i','l','e','d','.',0,
-'T','h','e',' ','t','o','t','a','l',' ','s','i','z','e',' ','o','f',' ','a','l','l',' ','o','u','t','p','u','t',' ','f','i','l','e','s',' ','m','a','y',' ','r','e','a','c','h',' ','a','s',' ','m','u','c','h',' ','a','s',' ','%','1',' ','m','e','g','a','b','y','t','e','s',' ','w','h','i','l','e',' ','t','h','e','r','e',' ','a','r','e',' ','o','n','l','y',' ','%','2',' ','m','e','g','a','b','y','t','e','s',' ','f','r','e','e',' ','o','n',' ','t','h','e',' ','d','e','s','t','i','n','a','t','i','o','n',' ','d','r','i','v','e','.',' ','D','o',' ','y','o','u',' ','s','t','i','l','l',' ','w','a','n','t',' ','t','o',' ','c','o','n','t','i','n','u','e','?',0,
-'T','h','e',' ','s','i','z','e',' ','o','f',' ','o','u','t','p','u','t',' ','f','i','l','e',' ',0x27,'%','1',0x27,' ','m','a','y',' ','r','e','a','c','h',' ','a','s',' ','m','u','c','h',' ','a','s',' ','%','2',' ','m','e','g','a','b','y','t','e','s',' ','w','h','i','l','e',' ','t','a','r','g','e','t',' ','f','i','l','e','s','y','s','t','e','m',' ','h','a','s',' ','a',' ','f','i','l','e',' ','s','i','z','e',' ','l','i','m','i','t',' ','o','f',' ','%','3',' ','m','e','g','a','b','y','t','e','s','.',' ','D','o',' ','y','o','u',' ','s','t','i','l','l',' ','w','a','n','t',' ','t','o',' ','c','o','n','t','i','n','u','e',' ','(','t','i','t','l','e',' ','w','i','l','l',' ','b','e',' ','s','k','i','p','p','e','d',')','?',0,
-'T','h','e',' ','f','o','l','d','e','r',' ','"','%','1','"',' ','a','p','p','e','a','r','s',' ','t','o',' ','b','e',' ','a',' ','r','o','o','t',' ','f','o','l','d','e','r',' ','o','n',' ','d','r','i','v','e',' ','"','%','3','"','.',' ','V','i','d','e','o',' ','d','i','s','c','s',' ','s','h','o','u','l','d',' ','b','e',' ','o','p','e','n','e','d',' ','u','s','i','n','g',' ','"','O','p','e','n',' ','d','i','s','c','"',' ','c','o','m','m','a','n','d',',',' ','n','o','t',' ','a','s',' ','i','n','d','i','v','i','d','u','a','l',' ','f','i','l','e','s',' ','-',' ','m','o','s','t',' ','l','i','k','e','l','y',' ','f','i','l','e','s',' ','w','i','l','l',' ','f','a','i','l',' ','t','o',' ','o','p','e','n','.',' ','D','o',' ','y','o','u',' ','w','a','n','t',' ','t','o',' ','o','p','e','n',' ','c','o','r','r','e','s','p','o','n','d','i','n','g',' ','d','i','s','c',' ','i','n','s','t','e','a','d','?',0,
-'T','h','e',' ','f','o','l','d','e','r',' ','"','%','1','"',' ','a','p','p','e','a','r','s',' ','t','o',' ','b','e',' ','a',' ','r','o','o','t',' ','f','o','l','d','e','r',' ','o','n',' ','o','p','t','i','c','a','l',' ','d','r','i','v','e',',',' ','h','o','w','e','v','e','r',' ','d','r','i','v','e',' ','c','a','n',0x27,'t',' ','b','e',' ','a','c','c','e','s','s','e','d',' ','b','y',' ','t','h','e',' ','p','r','o','g','r','a','m','.',' ','T','h','e',' ','o','p','e','r','a','t','i','o','n',' ','w','i','l','l',' ','m','o','s','t',' ','l','i','k','e','l','y',' ','f','a','i','l','.',0,
-'T','h','e',' ','p','r','o','g','r','a','m',' ','c','a','n',0x27,'t',' ','f','i','n','d',' ','a','n','y',' ','u','s','a','b','l','e',' ','o','p','t','i','c','a','l',' ','d','r','i','v','e','s','.',0,
-'F','a','i','l','e','d',' ','t','o',' ','d','e','c','o','d','e',' ','a','u','d','i','o','/','v','i','d','e','o',' ','d','a','t','a',' ','f','o','r',' ','t','i','t','l','e',' ','#','%','1',' ','-',' ','i','n','v','a','l','i','d',' ','m','u','x',' ','o','r',' ','i','n','t','e','r','n','a','l',' ','e','r','r','o','r',',',' ','t','i','t','l','e',' ','s','k','i','p','p','e','d','.',0,
-'B','u','f','f','e','r',' ','s','t','a','t','e',0,
-'F','i','l','e',' ','p','o','s','i','t','i','o','n',0,
-'C','o','p','y','i','n','g',' ','f','i','l','e',0,
-'C','o','p','y','i','n','g',' ','a','l','l',' ','f','i','l','e','s',0,
-'S','c','a','n','n','i','n','g',' ','f','i','l','e','s',0,
-'C','l','i','e','n','t',0,
-'E','v','a','l','u','a','t','i','o','n',' ','v','e','r','s','i','o','n',',',' ','%','1',' ','d','a','y','(','s',')',' ','o','u','t',' ','o','f',' ','%','2',' ','r','e','m','a','i','n','i','n','g',0,
-'E','v','a','l','u','a','t','i','o','n',' ','p','e','r','i','o','d',' ','h','a','s',' ','e','x','p','i','r','e','d','.',' ','P','l','e','a','s','e',' ','p','u','r','c','h','a','s','e',' ','a','n',' ','a','c','t','i','v','a','t','i','o','n',' ','k','e','y',' ','i','f',' ','y','o','u',0x27,'v','e',' ','f','o','u','n','d',' ','t','h','i','s',' ','a','p','p','l','i','c','a','t','i','o','n',' ','u','s','e','f','u','l','.',' ','Y','o','u',' ','m','a','y',' ','s','t','i','l','l',' ','u','s','e',' ','a','l','l',' ','f','u','n','c','t','i','o','n','a','l','i','t','y',' ','f','o','r',' ','a',' ','f','e','w',' ','d','a','y','s','.',0,
-'E','v','a','l','u','a','t','i','o','n',' ','p','e','r','i','o','d',' ','h','a','s',' ','e','x','p','i','r','e','d','.',' ','P','l','e','a','s','e',' ','p','u','r','c','h','a','s','e',' ','a','n',' ','a','c','t','i','v','a','t','i','o','n',' ','k','e','y',' ','i','f',' ','y','o','u',0x27,'v','e',' ','f','o','u','n','d',' ','t','h','i','s',' ','a','p','p','l','i','c','a','t','i','o','n',' ','u','s','e','f','u','l','.',' ','Y','o','u',' ','m','a','y',' ','s','t','i','l','l',' ','u','s','e',' ','a','l','l',' ','f','r','e','e',' ','f','u','n','c','t','i','o','n','a','l','i','t','y',' ','w','i','t','h','o','u','t',' ','a','n','y',' ','r','e','s','t','r','i','c','t','i','o','n','s','.',0,
-'T','h','i','s',' ','f','u','n','c','t','i','o','n','a','l','i','t','y',' ','i','s',' ','s','h','a','r','e','w','a','r','e','.',' ','Y','o','u',' ','m','a','y',' ','e','v','a','l','u','a','t','e',' ','i','t',' ','f','o','r',' ','%','1',' ','d','a','y','s',' ','a','f','t','e','r',' ','w','h','a','t',' ','y','o','u',' ','w','o','u','l','d',' ','n','e','e','d',' ','t','o',' ','p','u','r','c','h','a','s','e',' ','a','n',' ','a','c','t','i','v','a','t','i','o','n',' ','k','e','y',' ','i','f',' ','y','o','u',' ','l','i','k','e',' ','t','h','e',' ','f','u','n','c','t','i','o','n','a','l','i','t','y','.',' ','D','o',' ','y','o','u',' ','w','a','n','t',' ','t','o',' ','s','t','a','r','t',' ','e','v','a','l','u','a','t','i','o','n',' ','p','e','r','i','o','d',' ','n','o','w','?',0,
-'E','v','a','l','u','a','t','i','o','n',' ','v','e','r','s','i','o','n',',',' ','e','v','a','l','u','a','t','i','o','n',' ','p','e','r','i','o','d',' ','e','x','p','i','r','e','d',' ','%','1',' ','d','a','y','(','s',')',' ','a','g','o',0,
-'E','v','a','l','u','a','t','i','o','n',' ','p','e','r','i','o','d',' ','h','a','s',' ','e','x','p','i','r','e','d',',',' ','s','h','a','r','e','w','a','r','e',' ','f','u','n','c','t','i','o','n','a','l','i','t','y',' ','u','n','a','v','a','i','l','a','b','l','e','.',0,
-'E','v','a','l','u','a','t','i','o','n',' ','p','e','r','i','o','d',' ','n','o','t',' ','s','t','a','r','t','e','d',',',' ','s','h','a','r','e','w','a','r','e',' ','f','u','n','c','t','i','o','n','a','l','i','t','y',' ','u','n','a','v','a','i','l','a','b','l','e','.',0,
-'A','n','a','l','y','z','i','n','g',' ','s','e','a','m','l','e','s','s',' ','s','e','g','m','e','n','t','s',0,
-'Y','o','u',' ','a','r','e',' ','t','r','y','i','n','g',' ','t','o',' ','s','t','a','r','t',' ','M','a','k','e','M','K','V',' ','e','v','a','l','u','a','t','i','o','n',' ','f','r','o','m',' ','a',' ','t','h','i','r','d','-','p','a','r','t','y',' ','a','p','p','l','i','c','a','t','i','o','n','.',' ','P','l','e','a','s','e',' ','l','a','u','n','c','h',' ','M','a','k','e','M','K','V',' ','i','f',' ','y','o','u',' ','w','o','u','l','d',' ','l','i','k','e',' ','t','o',' ','s','t','a','r','t',' ','t','h','e',' ','e','v','a','l','u','a','t','i','o','n',' ','p','e','r','i','o','d','.',0,
-'F','r','e','e','w','a','r','e',0,
-'T','i','m','e','-','l','i','m','i','t','e','d',0,
-'R','e','g','i','s','t','e','r','e','d',0,
-'N','o','t',' ','s','t','a','r','t','e','d',0,
-'E','n','d','e','d',0,
-'S','t','a','r','t','e','d',0,
-'%','1',' ','[','%','2',' ','d','a','y','(','s',')',']',0,
-'N','e','v','e','r',0,
-'F','o','l','d','e','r',' ','%','1',' ','a','l','r','e','a','d','y',' ','c','o','n','t','a','i','n','s',' ','a',' ','b','a','c','k','u','p',',',' ','p','l','e','a','s','e',' ','c','h','o','o','s','e',' ','a','n','o','t','h','e','r',' ','f','o','l','d','e','r',0,
-'B','a','c','k','u','p',' ','f','a','i','l','e','d',0,
-'B','a','c','k','u','p',' ','d','o','n','e',0,
-'T','h','e',' ','s','o','u','r','c','e',' ','d','i','s','c',' ','c','o','n','t','a','i','n','s',' ','f','i','l','e','s',' ','a','s',' ','b','i','g',' ','a','s',' ','%','1',' ','m','e','g','a','b','y','t','e','s',' ','w','h','i','l','e',' ','t','a','r','g','e','t',' ','f','i','l','e','s','y','s','t','e','m',' ','h','a','s',' ','a',' ','f','i','l','e',' ','s','i','z','e',' ','l','i','m','i','t',' ','o','f',' ','%','2',' ','m','e','g','a','b','y','t','e','s','.',' ','D','o',' ','y','o','u',' ','s','t','i','l','l',' ','w','a','n','t',' ','t','o',' ','c','o','n','t','i','n','u','e',' ','(','o','p','e','r','a','t','i','o','n',' ','w','i','l','l',' ','l','i','k','e','l','y',' ','f','a','i','l',')','?',0,
-'B','a','c','k','i','n','g',' ','u','p',' ','d','i','s','c',' ','i','n','t','o',' ','f','o','l','d','e','r',' ','"','%','1','"',0,
-'Y','o','u','r',' ','t','e','m','p','o','r','a','r','y',' ','k','e','y',' ','h','a','s',' ','e','x','p','i','r','e','d',' ','a','n','d',' ','w','a','s',' ','r','e','m','o','v','e','d','.',' ','P','l','e','a','s','e',' ','r','e','s','t','a','r','t',' ','t','h','e',' ','a','p','p','l','i','c','a','t','i','o','n','.',0,
-'A','u','t','o','m','a','t','i','c',' ','c','h','e','c','k','i','n','g',' ','f','o','r',' ','u','p','d','a','t','e','s',' ','i','s',' ','e','n','a','b','l','e','d',',',' ','y','o','u',' ','m','a','y',' ','d','i','s','a','b','l','e',' ','i','t',' ','i','n',' ','p','r','e','f','e','r','e','n','c','e','s',' ','i','f',' ','y','o','u',' ','d','o','n',0x27,'t',' ','w','a','n','t',' ','M','a','k','e','M','K','V',' ','t','o',' ','c','o','n','t','a','c','t',' ','w','e','b',' ','s','e','r','v','e','r','.',0,
-'T','h','e',' ','n','e','w',' ','v','e','r','s','i','o','n',' ','%','1',' ','i','s',' ','a','v','a','i','l','a','b','l','e',' ','f','o','r',' ','d','o','w','n','l','o','a','d',' ','a','t',' ','%','2',0,
-'H','a','s','h',' ','c','h','e','c','k',' ','f','a','i','l','e','d',' ','f','o','r',' ','f','i','l','e',' ','%','1',' ','a','t',' ','o','f','f','s','e','t',' ','%','2',',',' ','f','i','l','e',' ','i','s',' ','c','o','r','r','u','p','t','.',0,
-'T','o','o',' ','m','a','n','y',' ','h','a','s','h',' ','c','h','e','c','k',' ','e','r','r','o','r','s',' ','i','n',' ','f','i','l','e',' ','%','1','.',0,
-'H','a','s','h',' ','c','h','e','c','k',' ','f','o','r',' ','%','1',' ',':',' ','%','2','%','%',' ','c','o','r','r','u','p','t',',',' ','%','3','%','%',' ','c','o','r','r','e','c','t',',',' ','%','4','%','%',' ','c','h','e','c','k','e','d','.',0,
-'B','a','c','k','u','p',' ','d','o','n','e',' ','b','u','t',' ','%','1',' ','f','i','l','e','s',' ','f','a','i','l','e','d',' ','h','a','s','h',' ','c','h','e','c','k',0,
-'B','a','c','k','u','p',' ','f','a','i','l','e','d','.',0,
-'B','a','c','k','u','p',' ','d','o','n','e','.',0,
-'B','a','c','k','u','p',' ','d','o','n','e',' ','b','u','t',' ','%','1',' ','f','i','l','e','s',' ','f','a','i','l','e','d',' ','h','a','s','h',' ','c','h','e','c','k','.',0,
-'C','o','n','t','e','n','t',' ','h','a','s','h',' ','t','a','b','l','e',' ','m','i','s','s','i','n','g',',',' ','u','n','a','b','l','e',' ','t','o',' ','v','e','r','i','f','y',' ','i','n','t','e','g','r','i','t','y',' ','o','f',' ','M','2','T','S',' ','f','i','l','e','s','.',0,
-'F','a','i','l','e','d',' ','t','o',' ','l','o','a','d',' ','c','o','n','t','e','n','t',' ','h','a','s','h',' ','t','a','b','l','e',',',' ','u','n','a','b','l','e',' ','t','o',' ','v','e','r','i','f','y',' ','i','n','t','e','g','r','i','t','y',' ','o','f',' ','M','2','T','S',' ','f','i','l','e','s','.',0,
-'L','o','a','d','e','d',' ','c','o','n','t','e','n','t',' ','h','a','s','h',' ','t','a','b','l','e',',',' ','w','i','l','l',' ','v','e','r','i','f','y',' ','i','n','t','e','g','r','i','t','y',' ','o','f',' ','M','2','T','S',' ','f','i','l','e','s','.',0,
-'D','e','f','a','u','l','t',0,
-'(',' ','L','o','s','s','y',' ','c','o','n','v','e','r','s','i','o','n',' ',')',0,
-'(',' ','L','o','s','s','l','e','s','s',' ','c','o','n','v','e','r','s','i','o','n',' ',')',0,
-'C','h','a','p','t','e','r',' ','%','1',0,
-'M','o','n','o',0,
-'S','t','e','r','e','o',0,
-'S','u','r','r','o','u','n','d',0,
-'M','a','k','e','M','K','V',' ','w','e','b','s','i','t','e',' ','a','d','d','r','e','s','s',' ','i','s',' ','%','1',0,
-'F','i','l','e',' ','"','%','1','"',' ','w','a','s',' ','s','k','i','p','p','e','d',0,
-'P','r','i','m','a','r','y',' ','t','i','t','l','e',0,
-'Y','o','u',' ','a','r','e',' ','a','b','o','u','t',' ','t','o',' ','u','s','e',' ','f','e','a','t','u','r','e',' ',0x27,'%','1',0x27,' ','w','h','i','c','h',' ','i','s',' ','m','a','r','k','e','d',' ','o','b','s','o','l','e','t','t','e',' ','a','n','d',' ','w','i','l','l',' ','b','e',' ','r','e','m','o','v','e','d',' ','i','n',' ','f','u','t','u','r','e',' ','v','e','r','s','i','o','n','s','.',' ','P','l','e','a','s','e',' ','s','e','e',' ','%','2',' ','f','o','r',' ','d','e','t','a','i','l','s','.',0,
-'T','y','p','e',0,
-'N','a','m','e',0,
-'L','a','n','g','u','a','g','e',0,
-'L','a','n','g','u','a','g','e',0,
-'C','o','d','e','c',0,
-'C','h','a','p','t','e','r','s',' ','c','o','u','n','t',0,
-'D','u','r','a','t','i','o','n',0,
-'S','i','z','e',0,
-'C','h','a','n','n','e','l','s',0,
-'A','n','g','l','e',0,
-'S','o','u','r','c','e',' ','f','i','l','e',' ','n','a','m','e',0,
-'S','a','m','p','l','e',' ','r','a','t','e',0,
-'B','i','t','s',' ','p','e','r',' ','s','a','m','p','l','e',0,
-'R','e','s','o','l','u','t','i','o','n',0,
-'A','s','p','e','c','t',' ','r','a','t','i','o',0,
-'F','r','a','m','e',' ','r','a','t','e',0,
-'F','l','a','g','s',0,
-'T','i','m','e','s','t','a','m','p',0,
-'S','o','u','r','c','e',' ','t','i','t','l','e',' ','I','D',0,
-'S','e','g','m','e','n','t',' ','c','o','u','n','t',0,
-'S','e','g','m','e','n','t',' ','m','a','p',0,
-'F','i','l','e',' ','n','a','m','e',0,
-'M','e','t','a','d','a','t','a',' ','l','a','n','g','u','a','g','e',0,
-'O','r','d','e','r',' ','w','e','i','g','h','t',0,
-'O','u','t','p','u','t',' ','f','o','r','m','a','t',0,
-'O','u','t','p','u','t',' ','d','e','s','c','r','i','p','t','i','o','n',0,
-'M','K','V',' ','F','l','a','g','s',0,
-'M','K','V',' ','F','l','a','g','s',0,
-'C','h','a','n','n','e','l',' ','l','a','y','o','u','t',0,
-'A','u','d','i','o',' ','m','i','x',0,
-'C','o','m','m','e','n','t',0,
-'3','D',' ','p','l','a','n','e',0,
-'C','o','p','y',' ','a','s',' ','i','s',0,
-'R','a','w',' ','L','P','C','M',' ','a','u','d','i','o',' ','w','i','t','h','o','u','t',' ','c','h','a','n','n','e','l',' ','c','o','n','f','i','g','u','r','a','t','i','o','n',' ','m','e','t','a','d','a','t','a',0,
-'L','P','C','M',' ','a','u','d','i','o',' ','i','n',' ','W','A','V',' ','c','o','n','t','a','i','n','e','r',' ','w','i','t','h',' ','c','h','a','n','n','e','l',' ','c','o','n','f','i','g','u','r','a','t','i','o','n',' ','m','e','t','a','d','a','t','a',0,
-'F','L','A','C',' ','a','u','d','i','o',0,
-'V','O','B','S','U','B',' ','s','u','b','t','i','t','l','e','s',0,
-'A','C','3',' ','a','u','d','i','o',0,
-'A','A','C',' ','a','u','d','i','o',0,
-'T','e','x','t',' ','s','u','b','t','i','t','l','e','s',0,
-'D','e','f','a','u','l','t',0,
-'F','o','r','c','e','d',0,
-'M','a','k','e','M','K','V',' ','B','E','T','A',0,
-'M','a','k','e','M','K','V',' ','B','E','T','A',' ','p','o','p','u','p',0,
-'A','b','o','u','t',' ','M','a','k','e','M','K','V',' ','B','E','T','A',0,
-'S','e','l','e','c','t',' ','e','x','i','s','t','i','n','g',' ','v','i','d','e','o',' ','s','o','u','r','c','e',' ','f','i','l','e',0,
-'S','e','l','e','c','t',' ','o','u','t','p','u','t',' ','f','o','l','d','e','r',0,
-'O','u','t','p','u','t',' ','f','o','l','d','e','r',0,
-'A','l','l',' ','v','i','d','e','o',' ','f','i','l','e','s',' ','(','%','1',')',';',';','D','v','d','-','v','i','d','e','o',' ','f','i','l','e','s',' ','(','%','2',')',';',';','B','l','u','-','r','a','y',' ','f','i','l','e','s',' ','(','%','3',')',';',';','H','d','-','d','v','d',' ','f','i','l','e','s',' ','(','%','4',')',0,
-'%','1',' ','f','i','l','e','s',' ','(','%','2',')',0,
-'&','O','p','e','n',' ','f','i','l','e','s',0,
-'C','t','r','l','+','O',0,
-'O','p','e','n','s',' ','v','i','d','e','o',' ','f','i','l','e','s',' ','(','d','i','s','c',' ','i','m','a','g','e',' ','o','n',' ','h','a','r','d','d','r','i','v','e',')',0,
-'&','C','l','o','s','e',0,
-'C','l','o','s','e',' ','o','p','e','n','e','d',' ','v','i','d','e','o',' ','f','i','l','e','s',0,
-'S','e','t',' ','o','u','t','p','u','t',' ','f','o','l','d','e','r',0,
-'S','e','t',' ','f','o','l','d','e','r',' ','w','h','e','r','e',' ','o','u','t','p','u','t',' ','f','i','l','e','s',' ','w','o','u','l','d',' ','b','e',' ','w','r','i','t','t','e','n',0,
-'S','a','v','e',' ','s','e','l','e','c','t','e','d',' ','t','i','t','l','e','s',0,
-'S','a','v','e',' ','s','e','l','e','c','t','e','d',' ','t','i','t','l','e','s',0,
-'&','Q','u','i','t',0,
-'C','t','r','l','+','Q',0,
-'Q','u','i','t',' ','a','p','p','l','i','c','a','t','i','o','n',0,
-'&','A','b','o','u','t',0,
-'S','h','o','w',' ','t','h','e',' ','a','p','p','l','i','c','a','t','i','o','n',0x27,'s',' ','A','b','o','u','t',' ','b','o','x',0,
-'O','p','e','n',' ','D','V','D',' ','f','i','l','e','s',' ','m','a','n','u','a','l','l','y',0,
-'O','p','e','n','s',' ','D','V','D',' ','f','i','l','e','s',' ','(','d','i','s','c',' ','i','m','a','g','e',' ','o','n',' ','h','a','r','d','d','r','i','v','e',')',' ','i','n',' ','m','a','n','u','a','l',' ','m','o','d','e',0,
-'&','F','i','l','e',0,
-'&','V','i','e','w',0,
-'&','H','e','l','p',0,
-'T','o','o','l','b','a','r',0,
-'O','p','e','n',' ','d','i','s','c',0,
-'&','C','a','n','c','e','l',0,
-'C','a','n','c','e','l',' ','c','u','r','r','e','n','t',' ','o','p','e','r','a','t','i','o','n',0,
-'I','n','f','o','r','m','a','t','i','o','n',0,
-'E','l','a','p','s','e','d',':',' ','%','1',0,
-'E','l','a','p','s','e','d',':',' ','%','1',' ','/',' ','R','e','m','a','i','n','i','n','g',' ',':',' ','%','2',0,
-'A','r','e',' ','y','o','u',' ','s','u','r','e',' ','y','o','u',' ','w','a','n','t',' ','t','o',' ','c','a','n','c','e','l',' ','t','h','e',' ','c','u','r','r','e','n','t',' ','o','p','e','r','a','t','i','o','n','?',0,
-'&','P','r','e','f','e','r','e','n','c','e','s',0,
-'S','h','o','w',' ','t','h','e',' ','p','r','e','f','e','r','e','n','c','e','s',' ','d','i','a','l','o','g',0,
-'&','P','r','e','f','e','r','e','n','c','e','s',0,
-'O','n','l','i','n','e',' ','&','H','e','l','p',0,
-'O','p','e','n',' ','O','n','l','i','n','e',' ','h','e','l','p',' ','p','a','g','e',0,
-'&','R','e','g','i','s','t','e','r',0,
-'E','n','t','e','r',' ','r','e','g','i','s','t','r','a','t','i','o','n',' ','c','o','d','e',0,
-'F','a','t','a','l',' ','e','r','r','o','r',' ','o','c','c','u','r','r','e','d',',',' ','p','r','o','g','r','a','m',' ','w','i','l','l',' ','n','o','w',' ','e','x','i','t','.',0,
-'F','a','t','a','l',' ','e','r','r','o','r',' ','-',' ','t','h','e','r','e',' ','i','s',' ','n','o','t',' ','e','n','o','u','g','h',' ','m','e','m','o','r','y',' ','f','o','r',' ','a','p','p','l','i','c','a','t','i','o','n',' ','t','o',' ','c','o','n','t','i','n','u','e',',',' ','p','r','o','g','r','a','m',' ','w','i','l','l',' ','n','o','w',' ','e','x','i','t','.',0,
-'&','E','j','e','c','t',' ','d','i','s','c',0,
-'O','p','e','n',' ','d','r','i','v','e',' ','t','r','a','y',0,
-'G','U','I',' ','v','e','r','s','i','o','n',':',' ','%','1',0,
-'L','i','c','e','n','s','e',' ','t','y','p','e',' ',':',0,
-'E','v','a','l','u','a','t','i','o','n',' ',':',0,
-'E','v','a','l','u','a','t','i','o','n',' ','e','x','p','i','r','e','s',' ',':',0,
-'V','i','d','e','o',0,
-'M','o','v','i','e','s',0,
-'V','i','d','e','o','s',0,
-'U','N','N','A','M','E','D',' ','D','I','S','C',0,
-'O','p','e','n',' ','D','V','D',' ','d','i','s','c',0,
-'O','p','e','n',' ','H','D','-','D','V','D',' ','d','i','s','c',0,
-'O','p','e','n',' ','B','l','u','-','r','a','y',' ','d','i','s','c',0,
-'D','i','s','c',' ','i','s',' ','l','o','a','d','i','n','g',0,
-'&','T','o','g','g','l','e',' ','i','t','e','m',0,
-'&','S','e','l','e','c','t',' ','a','l','l',0,
-'&','U','n','s','e','l','e','c','t',' ','a','l','l',0,
-'I','n','f','o',0,
-'M','a','k','e',' ','M','K','V',0,
-'S','o','u','r','c','e',0,
-'T','y','p','e',' ',':',0,
-'L','a','b','e','l',' ',':',0,
-'P','r','o','t','e','c','t','i','o','n',' ',':',0,
-'I','n','f','o',0,
-'E','n','t','e','r',' ','r','e','g','i','s','t','r','a','t','i','o','n',' ','c','o','d','e',0,
-'R','e','g','i','s','t','a','r','t','i','o','n',' ','c','o','d','e',' ','i','s',' ','i','n','c','o','r','r','e','c','t',0,
-'F','a','i','l','e','d',' ','t','o',' ','s','t','o','r','e',' ','r','e','g','i','s','t','r','a','t','i','o','n',' ','c','o','d','e',' ','i','n',' ','s','e','t','t','i','n','g','s',' ','d','a','t','a','b','a','s','e',0,
-'T','h','a','n','k',' ','y','o','u','.',' ','P','l','e','a','s','e',' ','r','e','s','t','a','r','t',' ','t','h','e',' ','a','p','p','l','i','c','a','t','i','o','n',' ','f','o','r',' ','c','h','a','n','g','e','s',' ','t','o',' ','t','a','k','e',' ','e','f','f','e','c','t','.',0,
-'O','p','t','i','o','n','s',0,
-'A','u','t','o',0,
-'R','e','a','d',' ','r','e','t','r','y',' ','c','o','u','n','t',' ',':',0,
-'R','e','a','d',' ','b','u','f','f','e','r',' ','s','i','z','e',' ','(','M','B',')',' ',':',0,
-'O','p','e','n',' ','D','V','D',' ','m','a','n','u','a','l','l','y',' ',':',0,
-'A','u','t','o',0,
-'M','i','n','i','m','u','m',' ','t','i','t','l','e',' ','l','e','n','g','t','h',' ','(','s','e','c','o','n','d','s',')',' ',':',0,
-'D','V','D',' ','s','t','r','u','c','t','u','r','e',' ','p','r','o','t','e','c','t','i','o','n',' ','r','e','m','o','v','a','l',' ','m','e','t','h','o','d',' ',':',0,
-'K','e','y',' ','f','i','l','e','s',' ','d','i','r','e','c','t','o','r','y',0,
-'N','o','n','e',0,
-'A','u','t','o',0,
-'S','e','m','i','A','u','t','o',0,
-'C','u','s','t','o','m',0,
-'D','e','f','a','u','l','t',' ','d','e','s','t','i','n','a','t','i','o','n',0,
-'M','i','s','c','e','l','l','a','n','e','o','u','s',0,
-'L','o','g',' ','d','e','b','u','g',' ','m','e','s','s','a','g','e','s',' ',':',0,
-'G','e','n','e','r','a','l',0,
-'F','a','i','l','e','d',' ','t','o',' ','s','a','v','e',' ','s','e','t','t','i','n','g','s',0,
-'S','o','m','e',' ','s','e','t','t','i','n','g','s',' ','w','i','l','l',' ','a','p','p','l','y',' ','n','e','x','t',' ','t','i','m','e',' ','y','o','u',' ','s','t','a','r','t',' ','t','h','e',' ','a','p','p','l','i','c','a','t','i','o','n','.',0,
-'D','i','s','c',' ','c','a','n',0x27,'t',' ','b','e',' ','o','p','e','n','e','d',0,
-'L','o','a','d','i','n','g','.','.','.',0,
-'P','l','e','a','s','e',' ','w','a','i','t',0,
-'N','o',' ','d','i','s','c',0,
-'D','a','t','a',0,
-'N','o',' ','i','n','f','o','r','m','a','t','i','o','n',' ','a','v','a','i','l','a','b','l','e',0,
-'R','e','v','e','r','t',0,
-'R','e','v','e','r','t',' ','t','o',' ','o','r','i','g','i','n','a','l',' ','v','a','l','u','e',0,
-'N','e','w',' ','M','a','k','e','M','K','V',' ','i','n','s','t','a','n','c','e',0,
-'S','t','a','r','t',' ','s','e','c','o','n','d',' ','c','o','p','y',' ','o','f',' ','M','a','k','e','M','K','V',' ','a','p','p','l','i','c','a','t','i','o','n',0,
-'N','o',' ','d','i','s','c',' ','i','n','s','e','r','t','e','d',0,
-'&','C','l','e','a','r',' ','l','o','g',0,
-'C','l','e','a','r',' ','l','o','g',' ','w','i','n','d','o','w',0,
-'U','n','m','o','u','n','t','i','n','g','.','.','.',0,
-'<','b','>','S','o','u','r','c','e',' ','i','n','f','o','r','m','a','t','i','o','n','<','/','b','>','<','b','r','>',0,
-'<','b','>','T','i','t','l','e',' ','i','n','f','o','r','m','a','t','i','o','n','<','/','b','>','<','b','r','>',0,
-'<','b','>','T','r','a','c','k',' ','i','n','f','o','r','m','a','t','i','o','n','<','/','b','>','<','b','r','>',0,
-'<','b','>','A','t','t','a','c','h','m','e','n','t',' ','i','n','f','o','r','m','a','t','i','o','n','<','/','b','>','<','b','r','>',0,
-'<','b','>','C','h','a','p','t','e','r',' ','i','n','f','o','r','m','a','t','i','o','n','<','/','b','>','<','b','r','>',0,
-'<','b','>','C','h','a','p','t','e','r','s',' ','i','n','f','o','r','m','a','t','i','o','n','<','/','b','>','<','b','r','>',0,
-'D','i','r','e','c','t','o','r',0x27,'s',' ','c','o','m','m','e','n','t','s',0,
-'A','l','t','e','r','n','a','t','e',' ','d','i','r','e','c','t','o','r',0x27,'s',' ','c','o','m','m','e','n','t','s',0,
-'S','e','c','o','n','d','a','r','y',' ','l','o','w','-','b','i','t','r','a','t','e',' ','a','u','d','i','o',0,
-'F','o','r',' ','v','i','s','u','a','l','l','y',' ','i','m','p','a','i','r','e','d',0,
-'M','i','s','c','e','l','l','a','n','e','o','u','s',0,
-'A','l','w','a','y','s',' ','c','r','e','a','t','e',' ','B','D','+',' ','d','u','m','p','s',' ',':',0,
-'S','&','t','r','e','a','m',0,
-'S','t','a','r','t',' ','s','t','r','e','a','m','i','n','g',' ','s','e','r','v','e','r',0,
-'&','B','a','c','k','u','p','.','.','.',0,
-'B','a','c','k','u','p',' ','d','i','s','c',0,
-'M','a','k','e','M','K','V',' ','p','r','e','f','e','r','e','n','c','e','s',0,
-'M','a','k','e','M','K','V',' ','d','i','s','c',' ','b','a','c','k','u','p',0,
-'I','n','f','o','r','m','a','t','i','o','n',0,
-'M','a','k','e','M','K','V',' ','c','a','n',' ','b','a','c','k',' ','u','p',' ','y','o','u','r',' ','d','i','s','c',' ','t','o',' ','a',' ','d','i','r','e','c','t','o','r','y',' ','o','n',' ','a',' ','h','a','r','d',' ','d','r','i','v','e','.',' ',0xa,'Y','o','u',' ','m','a','y',' ','c','h','o','o','s','e',' ','t','o',' ','s','a','v','e',' ','a','l','l',' ','d','a','t','a',' ','f','r','o','m',' ','d','i','s','c',' ','a','s',' ','i','s',',',' ','w','i','t','h','o','u','t',' ','d','e','c','r','y','p','t','i','n','g',' ','o','r',' ','c','h','a','n','g','i','n','g',' ','a','n','y',' ','f','i','l','e','s',';',' ','o','r',' ','d','e','c','r','y','p','t',' ','A','V',' ','f','i','l','e','s',' ','a','n','d',' ','c','h','a','n','g','e',' ','r','e','l','a','t','e','d',' ','m','e','t','a','d','a','t','a','.',' ',0xa,'I','n',' ','a','l','l',' ','c','a','s','e','s',' ','p','r','o','d','u','c','e','d',' ','b','a','c','k','u','p',' ','m','a','y',' ','b','e',' ','l','a','t','e','r',' ','o','p','e','n','e','d',' ','b','y',' ','M','a','k','e','M','K','V','.',0,
-'P','l','e','a','s','e',' ','s','p','e','c','i','f','y',' ','o','u','t','p','u','t',' ','d','i','r','e','c','t','o','r','y',0,
-'T','h','i','s',' ','v','e','r','s','i','o','n',' ','e','x','p','i','r','e','s',' ',':',0,
-'C','o','r','e',' ','a','u','d','i','o',0,
-'F','o','r','c','e','d',' ','s','u','b','t','i','t','l','e','s',0,
-'&','P','u','r','c','h','a','s','e',0,
-'O','p','e','n',' ','p','u','r','c','h','a','s','e',' ','o','r','d','e','r',' ','p','a','g','e',0,
-'O','p','t','i','o','n','s',0,
-'D','e','c','r','y','p','t',' ','v','i','d','e','o',' ','f','i','l','e','s',0,
-'D','i','s','a','b','l','e',' ','d','i','r','e','c','t',' ','a','c','c','e','s','s',' ',':',0,
-'M','a','c',' ','O','S',' ','X',' ','*','_','K','E','Y','_','V','2',' ','b','u','g',' ','w','o','r','k','a','r','o','u','n','d',' ','t','y','p','e',' ',':',0,
-'L','a','n','g','u','a','g','e',0,
-'I','n','t','e','r','f','a','c','e',' ','l','a','n','g','u','a','g','e',' ',':',0,
-'P','r','e','f','e','r','r','e','d',' ','l','a','n','g','u','a','g','e',' ',':',0,
-'A','u','t','o',0,
-'N','o','n','e',0,
-'L','a','t','e','s','t',' ','a','v','a','i','l','a','b','l','e',' ','v','e','r','s','i','o','n',':',0,
-'W','e','b','s','i','t','e',' ','U','R','L',':',0,
-'I','O',0,
-'S','t','r','e','a','m','i','n','g',0,
-'P','r','o','t','e','c','t','i','o','n',0,
-'M','a','k','e','M','K','V',' ','d','a','t','a',' ','d','i','r','e','c','t','o','r','y',0,
-'A','s','k',' ','f','o','r',' ','s','i','n','g','l','e',' ','d','r','i','v','e',' ','m','o','d','e',' ',':',0,
-'E','x','p','e','r','t',' ','m','o','d','e',' ',':',0,
-'S','h','o','w',' ','A','V',' ','s','y','n','c','h','r','o','n','i','z','a','t','i','o','n',' ','m','e','s','s','a','g','e','s',' ',':',0,
-'P','r','o','f','i','l','e','-','d','e','f','i','n','e','d',' ','s','e','c','o','n','d','a','r','y',' ','s','t','r','e','a','m',0,
-'A','d','v','a','n','c','e','d',0,
-'D','e','f','a','u','l','t',' ','p','r','o','f','i','l','e',' ',':',0,
-'D','e','f','a','u','l','t',' ','s','e','l','e','c','t','i','o','n',' ','r','u','l','e',' ',':',0,
-'%','1',' ','e','x','e','c','u','t','a','b','l','e',' ','l','o','c','a','t','i','o','n',0,
-'C','u','s','t','o','m',' ','J','a','v','a',' ','e','x','e','c','u','t','a','b','l','e',' ','l','o','c','a','t','i','o','n',0,
-'O','u','t','p','u','t',' ','f','i','l','e',' ','n','a','m','e',' ','t','e','m','p','l','a','t','e',' ',':',0,
-'P','r','o','f','i','l','e',0,
-'P','r','o','p','e','r','t','i','e','s',0,
-'E','n','a','b','l','e',' ','I','n','t','e','r','n','e','t',' ','a','c','c','e','s','s',' ',':',0,
-'O','n','l','i','n','e',' ','u','p','d','a','t','e','s',0,
-'P','r','o','x','y',' ','s','e','r','v','e','r',' ',':',0,
-'I','n','t','e','g','r','a','t','i','o','n',0,
-'M','a','k','e','M','K','V',' ','c','a','n',' ','a','c','t',' ','a','s',' ','d','e','c','r','y','p','t','i','o','n',' ','e','n','g','i','n','e',' ','f','o','r',' ','m','a','n','y',' ','3','r','d','-','p','a','r','t','y',' ','a','p','p','l','i','c','a','t','i','o','n','s',',',' ','e','n','a','b','l','i','n','g',' ','d','i','r','e','c','t',' ','p','l','a','y','b','a','c','k',' ','o','f',' ','p','r','o','t','e','c','t','e','d',' ','d','i','s','c','s','.','<','b','r','/','>','Y','o','u',' ','c','a','n',' ','e','n','a','b','l','e',' ','M','a','k','e','M','K','V',' ','d','e','c','r','y','p','t','i','o','n',' ','e','n','g','i','n','e',' ','(','l','i','b','m','m','b','d',')',' ','g','l','o','b','a','l','l','y',',',' ','o','r',' ','p','e','r',' ','a','p','p','l','i','c','a','t','i','o','n','.','<','b','r','/','>','P','l','e','a','s','e',' ','s','e','e',' ','%','1',' ','f','o','r',' ','d','e','t','a','i','l','s','.',0,
-'P','a','t','h',0,
-'T','i','t','l','e',0,
-'V','i','d','e','o',0,
-'A','u','d','i','o',0,
-'S','u','b','t','i','t','l','e','s',0,
-'T','y','p','e',0,
-'D','e','s','c','r','i','p','t','i','o','n',0,
-'D','V','D',' ','d','i','s','c',0,
-'%','1',' ','c','h','a','p','t','e','r','(','s',')',0,
-'B','l','u','-','r','a','y',' ','d','i','s','c',0,
-'(','a','n','g','l','e',' ','%','1',')',0,
-' ','(','f','o','r','c','e','d',' ','o','n','l','y',')',0,
-'H','D','-','D','V','D',' ','d','i','s','c',0,
-'M','K','V',' ','f','i','l','e',0,
-'A','t','t','a','c','h','m','e','n','t',0,
-'C','h','a','p','t','e','r','s',0,
-'C','h','a','p','t','e','r',0,
-'O','p','e','n',' ','D','V','D',' ','i','n',' ','m','a','n','u','a','l',' ','m','o','d','e',0,
-'T','i','t','l','e','s',' ','c','o','u','n','t',0,
-'%','1',' ','c','e','l','l','(','s',')',0,
-'%','1',' ','P','G','C','(','s',')',0,
-'b','r','o','k','e','n',' ','e','n','t','r','y',0,
-'Y','o','u',' ','a','r','e',' ','o','p','e','n','i','n','g',' ','t','h','i','s',' ','D','V','D',' ','d','i','s','c',' ','i','n',' ','m','a','n','u','a','l',' ','m','o','d','e','.',0xa,'T','h','i','s',' ','m','o','d','e',' ','r','e','q','u','i','r','e','s',' ','a','d','v','a','n','c','e','d',' ','k','n','o','w','l','e','d','g','e',' ','a','b','o','u','t',' ','D','V','D',' ','l','a','y','o','u','t',',',0xa,'b','u','t',' ','a','l','l','o','w','s',' ','p','r','e','c','i','e','s','e',' ','s','e','l','e','c','t','i','o','n',' ','f','o','r',' ','v','i','d','e','o',' ','d','a','t','a','.',0xa,'Y','o','u',' ','c','a','n',' ','s','p','e','c','i','f','y',' ','e','x','a','c','t',' ','t','i','t','l','e',' ','o','r','d','e','r',',',' ','s','p','l','i','t',' ','t','i','t','l','e','s',' ','b','y',' ','c','h','a','p','t','e','r','s','/','c','e','l','l','s',',',' ','a','n','d',0xa,'f','o','r','c','e',' ','a','n','y',' ','t','i','t','l','e',' ','t','o',' ','b','e',' ','r','e','t','a','i','n','e','d','.',0xa,0xa,'E','n','t','e','r',' ','t','h','e',' ','s','t','r','i','n','g',' ','d','e','s','c','r','i','b','i','n','g',' ','t','i','t','l','e','s',' ','a','n','d','/','o','r',' ','c','h','a','p','t','e','r','s','(','c','e','l','l','s',')',' ','y','o','u',' ','w','o','u','l','d',' ','l','i','k','e',' ','t','o',' ','o','p','e','n','.',0xa,'P','l','e','a','s','e',' ','s','e','e',' ','%','1',' ','f','o','r',' ','d','e','t','a','i','l','e','d',' ','s','y','n','t','a','x','.',0,
-'S','i','n','g','l','e',' ','d','r','i','v','e',' ','m','o','d','e',0,
-'Y','o','u',' ','h','a','v','e',' ','m','o','r','e',' ','t','h','a','n',' ','o','n','e',' ','o','p','t','i','c','a','l',' ','d','r','i','v','e','.',' ','W','h','i','c','h',' ','d','r','i','v','e',' ','d','o',' ','y','o','u',' ','w','a','n','t',' ','t','h','i','s',' ','i','n','s','t','a','n','c','e',' ','o','f',' ','M','a','k','e','M','K','V',' ','t','o',' ','w','o','r','k',' ','w','i','t','h','?',0,
-'A','l','l',' ','d','r','i','v','e','s',0,
-'S','e','l','e','c','t',' ','t','h','e',' ','d','r','i','v','e',0,
-'<','b','>','D','r','i','v','e',' ','I','n','f','o','r','m','a','t','i','o','n','<','/','b','>','<','b','r','>',0,
-'C','u','r','r','e','n','t',' ','p','r','o','f','i','l','e',':',' ',0,
-'M','a','n','u','f','a','c','t','u','r','e','r',':',' ',0,
-'P','r','o','d','u','c','t',':',' ',0,
-'R','e','v','i','s','i','o','n',':',' ',0,
-'S','e','r','i','a','l',' ','n','u','m','b','e','r',':',' ',0,
-'F','i','r','m','w','a','r','e',' ','d','e','t','a','i','l','s',':',' ',0,
-'F','i','r','m','w','a','r','e',' ','d','a','t','e',':',' ',0,
-'B','u','s',' ','e','n','c','r','y','p','t','i','o','n',' ','f','l','a','g','s',':',' ',0,
-'H','i','g','h','e','s','t',' ','A','A','C','S',' ','v','e','r','s','i','o','n',':',' ',0,
-'<','b','r','>','<','b','>','D','i','s','c',' ','I','n','f','o','r','m','a','t','i','o','n','<','/','b','>','<','b','r','>',0,
-'<','b','r','>','<','b','>','N','o',' ','d','i','s','c',' ','i','n','s','e','r','t','e','d','<','/','b','>','<','b','r','>',0,
-'D','i','s','c',' ','i','s',' ','b','e','i','n','g',' ','l','o','a','d','e','d','<','b','r','>',0,
-'D','a','t','a',' ','c','a','p','a','c','i','t','y',':',' ',0,
-'D','i','s','c',' ','t','y','p','e',':',' ',0,
-'D','i','s','c',' ','s','i','z','e',':',' ',0,
-'M','a','x','i','m','u','m',' ','r','e','a','d',' ','r','a','t','e',':',' ',0,
-'N','u','m','b','e','r',' ','o','f',' ','l','a','y','e','r','s',':',' ',0,
-'C','h','a','n','n','e','l',' ','b','i','t',' ','l','e','n','g','t','h',':',' ',0,
-'7','4',',','5',' ','n','m',' ','(','2','5','.','0',' ','G','B',' ','m','a','x','.',' ','p','e','r',' ','l','a','y','e','r',')',0,
-'6','9',',','0',' ','n','m',' ','(','2','7','.','0',' ','G','B',' ','m','a','x','.',' ','p','e','r',' ','l','a','y','e','r',')',0,
-'O','S',' ','d','e','v','i','c','e',' ','n','a','m','e',':',' ',0,
-0};
-
-static const unsigned int en_po_off[1113]={
-1000,0,1001,12,1002,36,1003,53,1004,77,1005,124,1006,135,1007,136,1008,226,1009,275,1010,301,
-1011,320,1012,323,2001,329,2003,378,2004,432,2006,500,2007,617,2008,772,2009,895,2010,1023,2011,1068,
-2012,1212,2013,1296,2014,1382,2015,1430,2016,1512,2017,1675,2018,1790,2019,1852,2020,1892,2021,2059,2022,2182,
-2023,2316,2024,2360,2200,2382,2201,2400,2202,2424,2203,2453,2204,2483,2205,2512,2206,2535,2207,2552,2208,2572,
-2209,2593,2210,2616,2211,2641,2300,2664,2301,2678,2302,2695,2303,2711,2304,2730,2400,2755,2401,2766,2402,2781,
-2404,2797,3000,2813,3001,2835,3002,2926,3003,2994,3004,3027,3005,3075,3006,3101,3007,3134,3008,3164,3009,3222,
-3010,3270,3011,3323,3012,3358,3013,3398,3014,3444,3015,3485,3016,3536,3017,3558,3018,3585,3019,3625,3020,3695,
-3021,3771,3022,3832,3023,3866,3024,3940,3025,4080,3026,4195,3027,4277,3028,4333,3029,4370,3030,4430,3031,4493,
-3032,4643,3033,4752,3034,4798,3035,4843,3036,4933,3037,4992,3038,5033,3039,5073,3040,5131,3041,5165,3042,5203,
-3043,5311,3100,5394,3101,5411,3102,5444,3103,5466,3104,5484,3105,5500,3106,5507,3107,5520,3108,5529,3109,5542,
-3110,5555,3111,5567,3200,5587,3201,5616,3202,5634,3203,5645,3210,5663,3220,5680,3221,5747,3300,5797,3301,5853,
-3302,5905,3303,5952,3304,6019,3305,6040,3306,6094,3307,6193,3308,6224,3309,6266,3310,6312,3311,6404,3312,6471,
-3313,6548,3314,6616,3315,6665,3316,6688,3317,6711,3318,6733,3319,6786,3320,6848,3321,6908,3322,6986,3323,7038,
-3324,7097,3325,7143,3326,7196,3327,7269,3328,7333,3329,7382,3330,7475,3331,7532,3332,7565,3333,7590,3334,7655,
-3335,8054,3336,8422,3337,8805,3338,8884,3339,8916,3340,8964,3341,9037,3342,9083,3343,9256,3344,9330,3345,9357,
-3346,9486,3347,9572,3400,9604,3401,9624,3402,9651,3403,9662,3404,9680,3405,9701,3406,9709,3407,9729,4001,9742,
-4002,9825,4003,9891,4004,9956,4007,10039,4008,10101,4009,10159,4020,10270,4021,10305,4022,10357,4023,10389,4024,10453,
-4025,10487,4026,10533,4027,10580,4028,10628,4040,10671,4041,10749,4042,10808,4043,10860,4044,10957,4045,11028,4046,11126,
-4047,11169,4048,11207,4049,11242,4050,11294,4051,11375,4052,11425,4053,11456,4054,11607,4055,11624,4060,11687,4061,11744,
-4062,11806,5000,11901,5001,11926,5002,11978,5003,11995,5004,12030,5005,12057,5006,12073,5007,12096,5008,12119,5009,12160,
-5010,12193,5011,12213,5012,12246,5013,12285,5014,12340,5015,12375,5016,12444,5017,12468,5018,12487,5019,12511,5020,12536,
-5021,12691,5022,12837,5024,12920,5025,12951,5026,12967,5027,12974,5028,12986,5029,12998,5030,13008,5031,13020,5033,13032,
-5036,13043,5037,13075,5038,13118,5039,13283,5040,13464,5041,13690,5042,13837,5043,13887,5044,13983,5045,13996,5046,14010,
-5047,14023,5048,14041,5049,14056,5050,14063,5051,14113,5052,14271,5053,14444,5054,14640,5055,14700,5056,14768,5057,14836,
-5058,14864,5060,15011,5061,15020,5062,15033,5063,15044,5064,15056,5065,15062,5066,15070,5067,15085,5068,15091,5069,15157,
-5070,15171,5071,15183,5072,15360,5073,15393,5074,15473,5075,15599,5076,15650,5077,15711,5078,15750,5079,15812,5080,15855,
-5081,15870,5082,15883,5083,15927,5084,15997,5085,16074,5086,16138,5087,16146,5088,16167,5089,16191,5090,16202,5091,16207,
-5092,16214,5093,16223,5094,16253,5100,16275,5101,16289,5201,16416,5202,16421,5203,16426,5204,16435,5207,16444,5208,16450,
-5209,16465,5210,16474,5214,16479,5215,16488,5216,16494,5217,16511,5218,16523,5219,16539,5220,16550,5221,16563,5222,16574,
-5223,16580,5224,16590,5225,16606,5226,16620,5227,16632,5228,16642,5233,16660,5234,16673,5235,16687,5238,16706,5239,16716,
-5240,16726,5248,16741,5249,16751,5250,16759,5301,16768,5302,16779,5303,16833,5304,16897,5305,16908,5306,16925,5307,16935,
-5308,16945,5380,16960,5381,16968,6000,16975,6001,16988,6002,17007,6003,17026,6005,17060,6006,17081,6007,17095,6008,17177,
-6010,17191,6011,17203,6012,17210,6013,17254,6014,17261,6015,17286,6016,17304,6017,17351,6018,17372,6019,17393,6020,17399,
-6021,17406,6022,17423,6023,17430,6024,17463,6026,17487,6030,17544,6031,17550,6032,17556,6034,17562,6035,17570,6036,17580,
-6037,17588,6038,17613,6039,17625,6040,17637,6041,17666,6042,17721,6043,17734,6044,17762,6045,17775,6046,17788,6047,17810,
-6048,17820,6050,17844,6051,17889,6052,17982,6053,17994,6054,18010,6055,18026,6056,18041,6057,18054,6058,18075,6059,18081,
-6060,18088,6061,18095,6062,18108,6063,18122,6064,18139,6065,18157,6066,18173,6067,18186,6068,18198,6069,18212,6070,18217,
-6071,18226,6072,18233,6073,18240,6074,18248,6075,18261,6076,18266,6077,18290,6078,18321,6079,18376,6080,18446,6081,18454,
-6082,18459,6083,18478,6084,18502,6085,18522,6086,18527,6087,18560,6088,18602,6089,18622,6090,18627,6091,18632,6092,18641,
-6093,18648,6094,18668,6095,18682,6096,18703,6097,18711,6098,18735,6099,18797,6100,18818,6101,18829,6102,18841,6103,18849,
-6104,18854,6105,18879,6106,18886,6107,18911,6108,18932,6109,18973,6110,18990,6111,19001,6112,19018,6119,19032,6120,19062,
-6121,19091,6122,19120,6123,19154,6124,19185,6125,19217,6126,19237,6127,19267,6128,19295,6129,19317,6130,19331,6131,19357,
-6132,19365,6133,19388,6134,19399,6135,19411,6136,19431,6137,19451,6138,19463,6139,19728,6142,19760,6143,19783,6144,19794,
-6145,19811,6146,19821,6147,19846,6148,19854,6150,19874,6151,19898,6152,19938,6153,19947,6154,19968,6156,19989,6157,19994,
-6158,19999,6159,20025,6164,20038,6165,20041,6166,20051,6167,20062,6168,20085,6169,20113,6170,20127,6171,20162,6172,20195,
-6173,20204,6174,20222,6175,20247,6177,20270,6178,20302,6180,20330,6181,20338,6187,20349,6188,20374,6189,20389,6190,20404,
-6191,20416,6192,20647,6200,20652,6201,20658,6202,20664,6203,20670,6204,20680,6205,20685,6206,20697,6207,20706,6209,20720,
-6210,20733,6211,20744,6212,20759,6213,20771,6214,20780,6215,20791,6216,20800,6220,20808,6221,20832,6222,20845,6223,20856,
-6224,20866,6225,20879,6226,21248,6227,21266,6228,21367,6229,21378,6300,21395,6301,21424,6302,21442,6303,21457,6304,21467,
-6305,21478,6306,21494,6307,21513,6308,21529,6309,21552,6320,21575,6321,21607,6322,21639,6323,21664,6324,21680,6325,21692,
-6326,21704,6327,21724,6329,21743,6330,21764,6331,21797,6332,21830,0};
-
-extern "C" const unsigned short * en_po_getstr_utf16(unsigned int code)
-{
-  for (const unsigned int *p = en_po_off;*p!=0;p+=2) {
-    if (*p==code) { return (en_po_str+p[1]); };
-  };
-  return 0;
-};
-

makemkv-oss-1.16.1.tar.gz/Makefile.in -> makemkv-oss-1.16.2.tar.gz/Makefile.in Changed

@@ -1,4 +1,5 @@
 include makefile.common
+include mmccextr/mmccextr.mak
 
 GCC=@CC@
 GXX=@CXX@
@@ -41,14 +42,15 @@
 
 LIBABI_OBJ := $(patsubst %,tmp/%.o,$(LIBABI_SRC))
 LIBFFABI_OBJ := $(patsubst %,tmp/%.o,$(LIBFFABI_SRC))
+MMCCX_SRC := $(patsubst %,mmccextr/%,$(MMCCEXTR_SRC))
 
-all: out/libdriveio.so.0 out/libmakemkv.so.1 $(OUT_GUI) out/libmmbd.so.0
+all: out/libdriveio.so.0 out/libmakemkv.so.1 $(OUT_GUI) out/libmmbd.so.0 out/mmccextr
 	@echo "type \"sudo make install\" to install"
 
 clean:
 	-rm -rf out tmp
 
-install: out/libdriveio.so.0 out/libmakemkv.so.1 $(OUT_GUI) out/libmmbd.so.0
+install: out/libdriveio.so.0 out/libmakemkv.so.1 $(OUT_GUI) out/libmmbd.so.0 out/mmccextr
 	$(INSTALL) -D -m 644 out/libdriveio.so.0 $(DESTDIR)$(libdir)/libdriveio.so.0
 	$(INSTALL) -D -m 644 out/libmakemkv.so.1 $(DESTDIR)$(libdir)/libmakemkv.so.1
 	$(INSTALL) -D -m 644 out/libmmbd.so.0 $(DESTDIR)$(libdir)/libmmbd.so.0
@@ -65,6 +67,7 @@
 	$(INSTALL) -D -m 644 makemkvgui/share/icons/128x128/makemkv.png $(DESTDIR)$(datadir)/icons/hicolor/128x128/apps/makemkv.png
 	$(INSTALL) -D -m 644 makemkvgui/share/icons/256x256/makemkv.png $(DESTDIR)$(datadir)/icons/hicolor/256x256/apps/makemkv.png
 endif
+	$(INSTALL) -D -m 755 out/mmccextr $(DESTDIR)$(bindir)/mmccextr
 
 out/%: out/%.full
 	$(OBJCOPY) $(STRIP_FLAGS) $< $@
@@ -107,6 +110,11 @@
 	$(QT_INC) -lc -lstdc++ \
 	$(QT_LIB) -lpthread -lz -lrt
 
+out/mmccextr.full: $(MMCCX_SRC) tmp/gen_buildinfo.h
+	mkdir -p out
+	$(GCC) $(CFLAGS) $(MMCCEXTR_DEF) -DHAVE_BUILDINFO_H -Itmp -D_GNU_SOURCE -o$@ $(MMCCX_SRC) -lc \
+	-ffunction-sections -Wl,--gc-sections -Wl,-z,defs
+
 tmp/gen_buildinfo.h:
 	mkdir -p tmp
 	echo "#define BUILDINFO_ARCH_NAME \"$(BUILDINFO_ARCH_NAME)\"" >> $@

makemkv-oss-1.16.2.tar.gz/libmmbd/src/dstring.h Added

@@ -0,0 +1,60 @@
+/*
+    MakeMKV GUI - Graphics user interface application for MakeMKV
+
+    Copyright (C) 2007-2020 GuinpinSoft inc <makemkvgui@makemkv.com>
+
+    You may use this file in accordance with the end user license
+    agreement provided with the Software. For licensing terms and
+    conditions see License.txt
+
+    This Software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+    OF ANY KIND, either express or implied. See the License.txt for
+    the specific language governing rights and limitations.
+
+*/
+#include <lgpl/aproxy.h>
+
+static const utf8_t* str_default_utf8(unsigned int code)
+{
+    switch (code)
+    {
+    case 1001: return "DBG ASSERT: %1 at %2:%3";
+    case 1002: return "LIBMKV_TRACE: %1";
+    case 1003: return "DEBUG: Code %1 at %2:%3";
+    case 1006: return "";
+    case 1011: return "%1";
+    case 1012: return "%1 %2";
+    case 5009: return "Application failed to initialize";
+    case 6001: return "MakeMKV";
+    default: break;
+    }
+    return "---error---";
+}
+
+static const utf16_t msg_1001[] = { 'D', 'B', 'G', ' ', 'A', 'S', 'S', 'E', 'R', 'T', ':', ' ', '%', '1', ' ', 'a', 't', ' ', '%', '2', ':', '%', '3', 0 };
+static const utf16_t msg_1002[] = { 'L', 'I', 'B', 'M', 'K', 'V', '_', 'T', 'R', 'A', 'C', 'E', ':', ' ', '%', '1', 0 };
+static const utf16_t msg_1003[] = { 'D', 'E', 'B', 'U', 'G', ':', ' ', 'C', 'o', 'd', 'e', ' ', '%', '1', ' ', 'a', 't', ' ', '%', '2', ':', '%', '3', 0 };
+static const utf16_t msg_1006[] = { 0 };
+static const utf16_t msg_1011[] = { '%', '1', 0 };
+static const utf16_t msg_1012[] = { '%', '1', ' ', '%', '2', 0 };
+static const utf16_t msg_5009[] = { 'A','p','p','l','i','c','a','t','i','o','n',' ','f','a','i','l','e','d',' ','t','o',' ','i','n','i','t','i','a','l','i','z','e',0 };
+static const utf16_t msg_6001[] = { 'M', 'a', 'k', 'e', 'M', 'K', 'V', 0, };
+static const utf16_t msg_errr[] = { '-','-','-',' ','e','r','r','o','r',' ','-','-','-',0 };
+
+static const utf16_t* str_default_utf16(unsigned int code)
+{
+    switch (code)
+    {
+    case 1001: return msg_1001;
+    case 1002: return msg_1002;
+    case 1003: return msg_1003;
+    case 1006: return msg_1006;
+    case 1011: return msg_1011;
+    case 1012: return msg_1012;
+    case 5009: return msg_5009;
+    case 6001: return msg_6001;
+    default: break;
+    }
+    return msg_errr;
+}
+

makemkv-oss-1.16.1.tar.gz/libmmbd/src/nstring.cpp -> makemkv-oss-1.16.2.tar.gz/libmmbd/src/nstring.cpp Changed

makemkv-oss-1.16.1.tar.gz/makefile.common -> makemkv-oss-1.16.2.tar.gz/makefile.common Changed

@@ -51,7 +51,7 @@
   makemkvgui/src/logic.cpp makemkvgui/src/logtext.cpp makemkvgui/src/main.cpp \
   makemkvgui/src/mainwnd.cpp makemkvgui/src/marshall.cpp makemkvgui/src/progress.cpp makemkvgui/src/scsiinfo.cpp \
   makemkvgui/src/settingdlg.cpp makemkvgui/src/uisync.cpp makemkvgui/src/viteminfo.cpp makemkvgui/src/margui.cpp \
-  makemkvgui/src/backupdlg.cpp makemkvgui/src/lstring.cpp makemkvgui/src/notify.cpp makemkvgui/src/str/en_utf16.cpp \
+  makemkvgui/src/backupdlg.cpp makemkvgui/src/lstring.cpp makemkvgui/src/notify.cpp \
   makemkvgui/src/image.cpp makemkvgui/src/abutton.cpp makemkvgui/src/lineeditk.cpp makemkvgui/src/dvdbox.cpp \
   makemkvgui/src/drivebox.cpp makemkvgui/src/toolbuttonp.cpp
 
@@ -60,7 +60,7 @@
   tmp/moc_backupdlg.cpp tmp/moc_lineeditk.cpp tmp/moc_dvdbox.cpp tmp/moc_drivebox.cpp tmp/moc_toolbuttonp.cpp
 
 MAKEMKVGUI_SRC_LINUX=makemkvgui/src/api_posix.cpp makemkvgui/src/api_linux.cpp makemkvgui/src/sem_posix.cpp \
-  makemkvgui/src/spawn_posix.cpp makemkvgui/src/logic_posix.cpp libabi/src/sys_linux.cpp \
+  makemkvgui/src/spawn_posix.cpp makemkvgui/src/logic_posix.cpp libabi/src/sys_linux.cpp makemkvgui/src/api_posix_shm.cpp \
   makemkvgui/src/notify_linux.cpp makemkvgui/src/image_linux.cpp \
   tmp/image_data.o

makemkv-oss-1.16.1.tar.gz/makemkvgui/inc/lgpl/aproxy.h -> makemkv-oss-1.16.2.tar.gz/makemkvgui/inc/lgpl/aproxy.h Changed

makemkv-oss-1.16.1.tar.gz/makemkvgui/inc/ver_num.h -> makemkv-oss-1.16.2.tar.gz/makemkvgui/inc/ver_num.h Changed

makemkv-oss-1.16.1.tar.gz/makemkvgui/src/api_posix.cpp -> makemkv-oss-1.16.2.tar.gz/makemkvgui/src/api_posix.cpp Changed

@@ -13,21 +13,16 @@
 
 */
 #include <lgpl/aproxy.h>
-#include <lgpl/smem.h>
 #include <stdint.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/stat.h>
-#include <sys/mman.h>
-#include <semaphore.h>
 #include <sys/time.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <lgpl/sysabi.h>
-#include <sys/types.h>
-#include <sys/stat.h>
 #include <poll.h>
 
 const char* const* ApGetAppLocations();
@@ -154,33 +149,6 @@
     return err;
 }
 
-void* ApOpenShmem(const char *Name)
-{
-    int fd;
-    void* pmap;
-    struct stat st;
-
-    fd=shm_open(Name,O_RDWR,0);
-    if (fd<0)
-    {
-        return NULL;
-    }
-    shm_unlink(Name);
-
-    if (fstat(fd,&st))
-    {
-        return NULL;
-    }
-
-    pmap=mmap(NULL,st.st_size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
-    if (MAP_FAILED==pmap)
-    {
-        return NULL;
-    }
-
-    return pmap;
-}
-
 uintptr_t ApDebugOpen(const char* name)
 {
     int fd = open(name,O_WRONLY|O_CREAT|O_TRUNC|O_SYNC,S_IRUSR|S_IWUSR|S_IRGRP|S_IROTH);
@@ -225,18 +193,12 @@
     err = read((int)handle,buffer,size);
     if (err<=0) return -1;
 
-#ifdef DBG_DUMP_PIPE
-    ApDebugDump("crp", buffer, err);
-#endif
 
     return err;
 }
 
 int ApWritePipe(uint64_t handle, const void* buffer, unsigned int size)
 {
-#ifdef DBG_DUMP_PIPE
-    ApDebugDump("cwp", buffer, size);
-#endif
 
     return write((int)handle,buffer,size);
 }

makemkv-oss-1.16.2.tar.gz/makemkvgui/src/api_posix_shm.cpp Added

@@ -0,0 +1,47 @@
+/*
+    MakeMKV GUI - Graphics user interface application for MakeMKV
+
+    Copyright (C) 2007-2020 GuinpinSoft inc <makemkvgui@makemkv.com>
+
+    You may use this file in accordance with the end user license
+    agreement provided with the Software. For licensing terms and
+    conditions see License.txt
+
+    This Software is distributed on an "AS IS" basis, WITHOUT WARRANTY
+    OF ANY KIND, either express or implied. See the License.txt for
+    the specific language governing rights and limitations.
+
+*/
+#include <lgpl/aproxy.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <fcntl.h>
+
+void* ApOpenShmem(const char *Name)
+{
+    int fd;
+    void* pmap;
+    struct stat st;
+
+    fd=shm_open(Name,O_RDWR,0);
+    if (fd<0)
+    {
+        return NULL;
+    }
+    shm_unlink(Name);
+
+    if (fstat(fd,&st))
+    {
+        return NULL;
+    }
+
+    pmap=mmap(NULL,st.st_size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
+    if (MAP_FAILED==pmap)
+    {
+        return NULL;
+    }
+
+    return pmap;
+}
+

makemkv-oss-1.16.1.tar.gz/makemkvgui/src/client.cpp -> makemkv-oss-1.16.2.tar.gz/makemkvgui/src/client.cpp Changed

makemkv-oss-1.16.1.tar.gz/makemkvgui/src/clt_pipe.cpp -> makemkv-oss-1.16.2.tar.gz/makemkvgui/src/clt_pipe.cpp Changed

makemkv-oss-1.16.2.tar.gz/makemkvgui/src/dstring.h Added

makemkv-oss-1.16.1.tar.gz/makemkvgui/src/lstring.cpp -> makemkv-oss-1.16.2.tar.gz/makemkvgui/src/lstring.cpp Changed

@@ -16,11 +16,12 @@
 #include <zlib.h>
 #include <algorithm>
 
-static uint32_t*    stringData=NULL;
+#include "dstring.h"
 
-extern "C" const unsigned short * en_po_getstr_utf16(unsigned int code);
+static uint32_t*    stringData=NULL;
+static utf8_t**     stringDataUtf8=NULL;
 
-extern const utf16_t* AppGetString(unsigned int code)
+static const utf16_t* GetStringFromData(unsigned int code, unsigned int* p_ndx)
 {
     const utf16_t* string;
     uint32_t count;
@@ -28,7 +29,7 @@
 
     if (!stringData)
     {
-        return en_po_getstr_utf16(code);
+        return NULL;
     }
 
     string = NULL;
@@ -38,17 +39,61 @@
     if (*item==code)
     {
         string = (const utf16_t*)(stringData + item[count]);
+        if (p_ndx)
+        {
+            *p_ndx = (unsigned int)(item - (stringData + 1));
+        }
     }
 
+    return string;
+}
+
+extern const utf16_t* AppGetString(unsigned int code)
+{
+    const utf16_t* string = GetStringFromData(code, NULL);
+
     if (!string)
     {
-        string = en_po_getstr_utf16(code);
+        string = str_default_utf16(code);
     }
 
     return string;
 }
 
+const utf8_t* AppGetStringUtf8(unsigned int code)
+{
+    unsigned int count,ndx;
 
+    const utf16_t* str16 = GetStringFromData(code, &ndx);
+    utf8_t* str8;
+
+    if (!str16)
+    {
+        return str_default_utf8(code);
+    }
+
+    count = stringData[0];
+
+    if (!stringDataUtf8)
+    {
+        stringDataUtf8 = new utf8_t*[count];
+        memset(stringDataUtf8, 0, count * sizeof(utf8_t*));
+    }
+
+    if (stringDataUtf8[ndx])
+    {
+        return stringDataUtf8[ndx];
+    }
+
+    size_t len = utf16toutf8len(str16);
+
+    stringDataUtf8[ndx] = str8 = new utf8_t[len+1];
+
+    utf16toutf8(str8, len, str16, utf16len(str16));
+    str8[len] = 0;
+
+    return str8;
+}
 
 extern bool AppGetInterfaceLanguageData(CGUIApClient* app)
 {
@@ -58,7 +103,9 @@
     uLongf          zlibDataSize;
 
     delete[] stringData;
+    delete[] stringDataUtf8;
     stringData = NULL;
+    stringDataUtf8 = NULL;
 
     if (NULL==app->GetAppString(AP_vastr_InterfaceLanguage,AP_APP_LOC_MAX,0)) return false;
 
@@ -79,3 +126,4 @@
 
     return true;
 }
+

makemkv-oss-1.16.2.tar.gz/mmccextr Added

makemkv-oss-1.16.2.tar.gz/mmccextr/License.txt Added

@@ -0,0 +1,339 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.

makemkv-oss-1.16.2.tar.gz/mmccextr/ccextractor.c Added

@@ -0,0 +1,558 @@
+
+/* CCExtractor, originally by carlos at ccextractor.org, now a lot of people.
+Credits: See AUTHORS.TXT
+License: GPL 2.0
+*/
+#include "ccextractor.h"
+#include <stdio.h>
+#include <locale.h>
+
+volatile int terminate_asap = 0;
+
+void sigusr1_handler(int sig)
+{
+    mprint("Caught SIGUSR1. Filename Change Requested\n");
+    change_filename_requested = 1;
+}
+
+
+void sigterm_handler(int sig)
+{
+    printf("Received SIGTERM, terminating as soon as possible.\n");
+    terminate_asap = 1;
+}
+
+
+void sigint_handler(int sig)
+{
+    if (ccx_options.print_file_reports)
+        print_file_report(signal_ctx);
+
+    exit(EXIT_SUCCESS);
+}
+
+
+void print_end_msg(void)
+{
+    mprint("Issues? Open a ticket here\n");
+    mprint("https://github.com/CCExtractor/ccextractor/issues\n");
+}
+
+
+int api_start(struct ccx_s_options api_options)
+{
+    struct lib_ccx_ctx *ctx;
+    struct lib_cc_decode *dec_ctx = NULL;
+    int ret = 0, tmp;
+    enum ccx_stream_mode_enum stream_mode;
+
+#if defined(ENABLE_OCR) && defined(_WIN32)
+    setMsgSeverity(LEPT_MSG_SEVERITY);
+#endif
+#ifdef ENABLE_HARDSUBX
+    if(api_options.hardsubx)
+	{
+		// Perform burned in subtitle extraction
+		hardsubx(&api_options);
+		return 0;
+	}
+#endif
+
+    // Initialize CCExtractor libraries
+    ctx = init_libraries(&api_options);
+#ifdef ENABLE_PYTHON
+    int i=0;
+
+    while(i<api_options.python_param_count)
+    {
+        free(api_options.python_params[i]);
+        i++;
+    }
+#endif
+    if (!ctx && errno == ENOMEM)
+        fatal (EXIT_NOT_ENOUGH_MEMORY, "Not enough memory, could not initialize libraries\n");
+    else if (!ctx && errno == EINVAL)
+        fatal (CCX_COMMON_EXIT_BUG_BUG, "Invalid option to CCextractor Library\n");
+    else if (!ctx && errno == EPERM)
+        fatal (CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Unable to create output file: Operation not permitted.\n");
+    else if (!ctx && errno == EACCES)
+        fatal (CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Unable to create output file: Permission denied\n");
+    else if (!ctx)
+        fatal (EXIT_NOT_CLASSIFIED, "Unable to create Library Context %d\n",errno);
+
+#ifdef WITH_LIBCURL
+    curl_global_init(CURL_GLOBAL_ALL);
+
+  	/* get a curl handle */
+  	curl = curl_easy_init();
+	if (!curl)
+	{
+		curl_global_cleanup(); // Must be done even on init fail
+		fatal (EXIT_NOT_CLASSIFIED, "Unable to init curl.");
+	}
+#endif
+
+    int show_myth_banner = 0;
+
+#ifndef MMCCXTR
+    params_dump(ctx);
+#endif
+
+#ifndef MMCCXTR
+    // default teletext page
+    if (tlt_config.page > 0) {
+        // dec to BCD, magazine pages numbers are in BCD (ETSI 300 706)
+        tlt_config.page = ((tlt_config.page / 100) << 8) | (((tlt_config.page / 10) % 10) << 4) | (tlt_config.page % 10);
+    }
+#endif
+
+#ifndef MMCCXTR
+    if (api_options.transcript_settings.xds)
+    {
+        if (api_options.write_format != CCX_OF_TRANSCRIPT)
+        {
+            api_options.transcript_settings.xds = 0;
+            mprint ("Warning: -xds ignored, XDS can only be exported to transcripts at this time.\n");
+        }
+    }
+#endif
+
+
+    time_t start, final;
+    time(&start);
+
+    if (api_options.binary_concat)
+    {
+        ctx->total_inputsize=get_total_file_size(ctx);
+        if (ctx->total_inputsize < 0)
+        {
+            switch (ctx->total_inputsize)
+            {
+                case -1*ENOENT:
+                    fatal(EXIT_NO_INPUT_FILES, "Failed to open one of the input file(s): File does not exist.");
+                case -1*EACCES:
+                    fatal(EXIT_READ_ERROR, "Failed to open input file: Unable to access");
+                case -1*EINVAL:
+                    fatal(EXIT_READ_ERROR, "Failed to open input file: Invalid opening flag.");
+                case -1*EMFILE:
+                    fatal(EXIT_TOO_MANY_INPUT_FILES, "Failed to open input file: Too many files are open.");
+                default:
+                    fatal(EXIT_READ_ERROR, "Failed to open input file: Reason unknown");
+            }
+        }
+    }
+
+#ifndef _WIN32
+    signal_ctx = ctx;
+    m_signal(SIGINT, sigint_handler);
+    m_signal(SIGTERM, sigterm_handler);
+    m_signal(SIGUSR1, sigusr1_handler);
+#endif
+    terminate_asap = 0;
+
+#ifdef ENABLE_SHARING
+    if (api_options.translate_enabled && ctx->num_input_files > 1)
+	{
+		mprint("[share] WARNING: simultaneous translation of several input files is not supported yet\n");
+		api_options.translate_enabled = 0;
+	    api_options.sharing_enabled = 0;
+	}
+	if (api_options.translate_enabled)
+	{
+		mprint("[share] launching translate service\n");
+		ccx_share_launch_translator(api_options.translate_langs, api_options.translate_key);
+	}
+#endif //ENABLE_SHARING
+    ret = 0;
+    while (switch_to_next_file(ctx, 0))
+    {
+        prepare_for_new_file(ctx);
+#ifdef ENABLE_SHARING
+        if (api_options.sharing_enabled)
+			ccx_share_start(ctx->basefilename);
+#endif //ENABLE_SHARING
+
+        stream_mode = ctx->demux_ctx->get_stream_mode(ctx->demux_ctx);
+        // Disable sync check for raw formats - they have the right timeline.
+        // Also true for bin formats, but -nosync might have created a
+        // broken timeline for debug purposes.
+        // Disable too in MP4, specs doesn't say that there can't be a jump
+        switch (stream_mode)
+        {
+#ifndef MMCCXTR
+            case CCX_SM_MCPOODLESRAW:
+#endif
+            case CCX_SM_RCWT:
+#ifndef MMCCXTR
+            case CCX_SM_MP4:
+#endif
+#ifdef WTV_DEBUG
+                case CCX_SM_HEX_DUMP:
+#endif
+                ccx_common_timing_settings.disable_sync_check = 1;
+                break;
+            default:
+                break;
+        }
+        /* -----------------------------------------------------------------
+        MAIN LOOP
+        ----------------------------------------------------------------- */
+        switch (stream_mode)
+        {
+#ifndef MMCCXTR
+            case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
+                if (!api_options.use_gop_as_pts) // If !0 then the user selected something
+                    api_options.use_gop_as_pts = 1; // Force GOP timing for ES
+                ccx_common_timing_settings.is_elementary_stream = 1;
+            case CCX_SM_TRANSPORT:
+            case CCX_SM_PROGRAM:
+            case CCX_SM_ASF:
+            case CCX_SM_WTV:
+            case CCX_SM_GXF:
+            case CCX_SM_MXF:
+#ifdef ENABLE_FFMPEG
+                case CCX_SM_FFMPEG:
+#endif
+                if (!api_options.use_gop_as_pts) // If !0 then the user selected something
+                    api_options.use_gop_as_pts = 0;
+                if (api_options.ignore_pts_jumps)
+                    ccx_common_timing_settings.disable_sync_check = 1;
+                mprint ("\rAnalyzing data in general mode\n");
+                tmp = general_loop(ctx);
+                if (!ret) ret = tmp;
+                break;
+            case CCX_SM_MCPOODLESRAW:
+                mprint ("\rAnalyzing data in McPoodle raw mode\n");
+                tmp = raw_loop(ctx);
+                if (!ret) ret = tmp;
+                break;
+#endif
+            case CCX_SM_RCWT:
+                mprint ("\rAnalyzing data in CCExtractor's binary format\n");
+                tmp = rcwt_loop(ctx);
+                if (!ret) ret = tmp;
+                break;
+#ifndef MMCCXTR
+            case CCX_SM_MYTH:
+                mprint ("\rAnalyzing data in MythTV mode\n");
+                show_myth_banner = 1;
+                tmp = myth_loop(ctx);
+                if (!ret) ret = tmp;
+                break;
+            case CCX_SM_MP4:
+                mprint ("\rAnalyzing data with GPAC (MP4 library)\n");
+                close_input_file(ctx); // No need to have it open. GPAC will do it for us
+                if (ctx->current_file == -1) // We don't have a file to open, must be stdin, and GPAC is incompatible with stdin
+                {
+                    fatal (EXIT_INCOMPATIBLE_PARAMETERS, "MP4 requires an actual file, it's not possible to read from a stream, including stdin.\n");
+                }
+                if(api_options.extract_chapters)
+                {
+                    tmp = dumpchapters(ctx, &ctx->mp4_cfg, ctx->inputfile[ctx->current_file]);
+                }
+                else
+                {
+                    tmp = processmp4(ctx, &ctx->mp4_cfg, ctx->inputfile[ctx->current_file]);
+                }
+                if (api_options.print_file_reports)
+                    print_file_report(ctx);
+                if (!ret) ret = tmp;
+                break;
+            case CCX_SM_MKV:
+                mprint ("\rAnalyzing data in Matroska mode\n");
+                tmp = matroska_loop(ctx);
+                if (!ret) ret = tmp;
+                break;
+#else
+            default:
+#endif
+#ifdef WTV_DEBUG
+            case CCX_SM_HEX_DUMP:
+				close_input_file(ctx); // process_hex will open it in text mode
+				process_hex (ctx, ctx->inputfile[0]);
+				break;
+#endif
+            case CCX_SM_AUTODETECT:
+                fatal(CCX_COMMON_EXIT_BUG_BUG, "Cannot be reached!");
+                break;
+        }
+        list_for_each_entry(dec_ctx, &ctx->dec_ctx_head, list, struct lib_cc_decode)
+        {
+            mprint("\n");
+            dbg_print(CCX_DMT_DECODER_608, "\nTime stamps after last caption block was written:\n");
+            dbg_print(CCX_DMT_DECODER_608, "GOP: %s	  \n", print_mstime_static(gop_time.ms) );
+
+            dbg_print(CCX_DMT_DECODER_608, "GOP: %s (%+3dms incl.)\n",
+                      print_mstime_static((LLONG)(gop_time.ms
+                          -first_gop_time.ms
+                          +get_fts_max(dec_ctx->timing)-fts_at_gop_start)),
+                      (int)(get_fts_max(dec_ctx->timing)-fts_at_gop_start));
+            // When padding is active the CC block time should be within
+            // 1000/29.97 us of the differences.
+            dbg_print(CCX_DMT_DECODER_608, "Max. FTS:	   %s  (without caption blocks since then)\n",
+                      print_mstime_static(get_fts_max(dec_ctx->timing)));
+
+            if (dec_ctx->codec == CCX_CODEC_ATSC_CC)
+            {
+                mprint ("\nTotal frames time:	  %s  (%u frames at %.2ffps)\n",
+                        print_mstime_static( (LLONG)(total_frames_count*1000/current_fps) ),
+                        total_frames_count, current_fps);
+            }
+
+            if (dec_ctx->stat_hdtv)
+            {
+                mprint ("\rCC type 0: %d (%s)\n", dec_ctx->cc_stats[0], cc_types[0]);
+                mprint ("CC type 1: %d (%s)\n", dec_ctx->cc_stats[1], cc_types[1]);
+                mprint ("CC type 2: %d (%s)\n", dec_ctx->cc_stats[2], cc_types[2]);
+                mprint ("CC type 3: %d (%s)\n", dec_ctx->cc_stats[3], cc_types[3]);
+            }
+            // Add one frame as fts_max marks the beginning of the last frame,
+            // but we need the end.
+            dec_ctx->timing->fts_global += dec_ctx->timing->fts_max + (LLONG) (1000.0/current_fps);
+            // CFS: At least in Hauppage mode, cb_field can be responsible for ALL the
+            // timing (cb_fields having a huge number and fts_now and fts_global being 0 all
+            // the time), so we need to take that into account in fts_global before resetting
+            // counters.
+            if (cb_field1!=0)
+                dec_ctx->timing->fts_global += cb_field1*1001/3;
+            else if (cb_field2!=0)
+                dec_ctx->timing->fts_global += cb_field2*1001/3;
+            else
+                dec_ctx->timing->fts_global += cb_708*1001/3;
+            // Reset counters - This is needed if some captions are still buffered
+            // and need to be written after the last file is processed.
+            cb_field1 = 0; cb_field2 = 0; cb_708 = 0;
+            dec_ctx->timing->fts_now = 0;
+            dec_ctx->timing->fts_max = 0;
+
+#ifdef ENABLE_SHARING
+            if (api_options.sharing_enabled)
+			{
+				ccx_share_stream_done(ctx->basefilename);
+				ccx_share_stop();
+			}
+#endif //ENABLE_SHARING
+
+            if (dec_ctx->total_pulldownframes)
+                mprint ("incl. pulldown frames:  %s  (%u frames at %.2ffps)\n",
+                        print_mstime_static( (LLONG)(dec_ctx->total_pulldownframes*1000/current_fps) ),
+                        dec_ctx->total_pulldownframes, current_fps);
+            if (dec_ctx->timing->pts_set >= 1 && dec_ctx->timing->min_pts != 0x01FFFFFFFFLL)
+            {
+                LLONG postsyncms = (LLONG) (dec_ctx->frames_since_last_gop*1000/current_fps);
+                mprint ("\nMin PTS:				%s\n",
+                        print_mstime_static( dec_ctx->timing->min_pts/(MPEG_CLOCK_FREQ/1000) - dec_ctx->timing->fts_offset));
+                if (pts_big_change)
+                    mprint ("(Reference clock was reset at some point, Min PTS is approximated)\n");
+                mprint ("Max PTS:				%s\n",
+                        print_mstime_static( dec_ctx->timing->sync_pts/(MPEG_CLOCK_FREQ/1000) + postsyncms));
+
+                mprint ("Length:				 %s\n",
+                        print_mstime_static( dec_ctx->timing->sync_pts/(MPEG_CLOCK_FREQ/1000) + postsyncms
+                                                 - dec_ctx->timing->min_pts/(MPEG_CLOCK_FREQ/1000) + dec_ctx->timing->fts_offset ));
+            }
+
+
+            // dvr-ms files have invalid GOPs
+#ifndef MMCCXTR
+            if (gop_time.inited && first_gop_time.inited && stream_mode != CCX_SM_ASF)
+            {
+                mprint ("\nInitial GOP time:	   %s\n",
+                        print_mstime_static(first_gop_time.ms));
+                mprint ("Final GOP time:		 %s%+3dF\n",
+                        print_mstime_static(gop_time.ms),
+                        dec_ctx->frames_since_last_gop);
+                mprint ("Diff. GOP length:	   %s%+3dF",
+                        print_mstime_static(gop_time.ms - first_gop_time.ms),
+                        dec_ctx->frames_since_last_gop);
+                mprint ("	(%s)\n\n",
+                        print_mstime_static(gop_time.ms - first_gop_time.ms
+                                                +(LLONG) ((dec_ctx->frames_since_last_gop)*1000/29.97)) );
+            }
+#endif
+
+            if (dec_ctx->false_pict_header)
+                mprint ("Number of likely false picture headers (discarded): %d\n",dec_ctx->false_pict_header);
+            if (dec_ctx->num_key_frames)
+                mprint("Number of key frames: %d\n", dec_ctx->num_key_frames);
+
+            if (dec_ctx->stat_numuserheaders)
+                mprint("Total user data fields: %d\n", dec_ctx->stat_numuserheaders);
+            if (dec_ctx->stat_dvdccheaders)
+                mprint("DVD-type user data fields: %d\n", dec_ctx->stat_dvdccheaders);
+            if (dec_ctx->stat_scte20ccheaders)
+                mprint("SCTE-20 type user data fields: %d\n", dec_ctx->stat_scte20ccheaders);
+            if (dec_ctx->stat_replay4000headers)
+                mprint("ReplayTV 4000 user data fields: %d\n", dec_ctx->stat_replay4000headers);
+            if (dec_ctx->stat_replay5000headers)
+                mprint("ReplayTV 5000 user data fields: %d\n", dec_ctx->stat_replay5000headers);
+            if (dec_ctx->stat_hdtv)
+                mprint("HDTV type user data fields: %d\n", dec_ctx->stat_hdtv);
+            if (dec_ctx->stat_dishheaders)
+                mprint("Dish Network user data fields: %d\n", dec_ctx->stat_dishheaders);
+            if (dec_ctx->stat_divicom)
+            {
+                mprint("CEA608/Divicom user data fields: %d\n", dec_ctx->stat_divicom);
+
+                mprint("\n\nNOTE! The CEA 608 / Divicom standard encoding for closed\n");
+                mprint("caption is not well understood!\n\n");
+                mprint("Please submit samples to the developers.\n\n\n");
+            }
+
+        }
+
+        if(is_decoder_processed_enough(ctx) == CCX_TRUE)
+            break;
+    } // file loop
+    close_input_file(ctx);
+    free((void *) ctx->extension);
+
+    prepare_for_new_file (ctx); // To reset counters used by handle_end_of_data()
+
+
+    time (&final);
+
+    long proc_time=(long) (final-start);
+    mprint ("\rDone, processing time = %ld seconds\n", proc_time);
+#if 0
+    if (proc_time>0)
+	{
+		LLONG ratio=(get_fts_max()/10)/proc_time;
+		unsigned s1=(unsigned) (ratio/100);
+		unsigned s2=(unsigned) (ratio%100);
+		mprint ("Performance (real length/process time) = %u.%02u\n",
+			s1, s2);
+	}
+#endif
+
+    if (is_decoder_processed_enough(ctx) == CCX_TRUE)
+    {
+        mprint ("\rNote: Processing was canceled before all data was processed because\n");
+        mprint ("\rone or more user-defined limits were reached.\n");
+    }
+
+#ifdef CURL
+    if (curl)
+		curl_easy_cleanup(curl);
+  	curl_global_cleanup();
+#endif
+    dinit_libraries(&ctx);
+
+    if (!ret)
+        mprint("\nNo captions were found in input.\n");
+
+    print_end_msg();
+
+    if (show_myth_banner)
+    {
+        mprint("NOTICE: Due to the major rework in 0.49, we needed to change part of the timing\n");
+        mprint("code in the MythTV's branch. Please report results to the address above. If\n");
+        mprint("something is broken it will be fixed. Thanks\n");
+    }
+    return ret ? EXIT_OK : EXIT_NO_CAPTIONS;
+}
+
+struct ccx_s_options* api_init_options()
+{
+    init_options(&ccx_options);
+    return &ccx_options;
+}
+
+#ifndef MMCCXTR
+void check_configuration_file(struct ccx_s_options api_options)
+{
+    parse_configuration(&api_options);
+}
+#endif
+
+#ifdef PYTHON_API
+int compile_params(struct ccx_s_options *api_options,int argc)
+{
+    //adding the parameter ./ccextractor to the list of python_params for further parsing
+    api_options->python_params = realloc(api_options->python_params, (api_options->python_param_count+1) * sizeof *api_options->python_params);
+    api_options->python_params[api_options->python_param_count] = malloc(strlen("./ccextractor")+1);
+    strcpy(api_options->python_params[api_options->python_param_count], "./ccextractor");
+    api_options->python_param_count++;
+
+    char* temp = api_options->python_params[api_options->python_param_count-1];
+    for (int i = api_options->python_param_count-1; i > 0; i--)
+        api_options->python_params[i] = api_options->python_params[i-1];
+    api_options->python_params[0] = temp;
+
+    int ret = parse_parameters (api_options, api_options->python_param_count, api_options->python_params);
+    api_options->messages_target = CCX_MESSAGES_QUIET;
+
+    return ret;
+}
+
+void api_add_param(struct ccx_s_options* api_options,char* arg)
+{
+    api_options->python_params = realloc(api_options->python_params, (api_options->python_param_count+1) * sizeof *api_options->python_params);
+    api_options->python_params[api_options->python_param_count] = malloc(strlen(arg)+1);
+    strcpy(api_options->python_params[api_options->python_param_count], arg);
+    api_options->python_param_count++;
+}
+
+void py_callback(char *line, int encoding)
+{
+       assert ( PyFunction_Check(py_callback_func) );
+       PyObject* args = Py_BuildValue("(si)",line,encoding);
+       PyObject_CallObject((PyObject*)py_callback_func, args);
+}
+
+/*
+ * Helper function to print the i-th param submitted by the user.
+ * Helpful for debugging
+ */
+char * api_param(struct ccx_s_options* api_options, int count)
+{
+    return api_options->python_params[count];
+}
+
+/*
+ * Helper function to get the total number of params provided by the user.
+ * Helpful for debugging
+ */
+int api_param_count(struct ccx_s_options* api_options)
+{
+    return api_options->python_param_count;
+}
+#endif // PYTHON_API
+
+
+
+int main(int argc, char* argv[])
+{
+    setlocale(LC_ALL, "");
+    struct ccx_s_options* api_options = api_init_options();
+#ifndef MMCCXTR
+    check_configuration_file(*api_options);
+#endif
+#ifdef PYTHON_API
+    for(int i = 1; i < argc; i++)
+        api_add_param(api_options,argv[i]);
+#endif
+
+#ifdef PYTHON_API
+    int compile_ret = compile_params(api_options,argc);
+#else
+    int compile_ret = parse_parameters (api_options, argc, argv);
+#endif
+
+    if (compile_ret == EXIT_NO_INPUT_FILES)
+    {
+        print_usage ();
+        fatal (EXIT_NO_INPUT_FILES, "(This help screen was shown because there were no input files)\n");
+    }
+    else if (compile_ret == EXIT_WITH_HELP)
+    {
+        return EXIT_OK;
+    }
+    else if (compile_ret != EXIT_OK)
+    {
+        exit(compile_ret);
+    }
+
+    int start_ret = api_start(*api_options);
+    return start_ret;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/ccextractor.h Added

@@ -0,0 +1,63 @@
+#ifndef CCEXTRACTOR_H
+#define CCEXTRACTOR_H
+
+// Needed to avoid warning implicit declaration of function ‘asprintf’ on Linux
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE 1
+#endif
+
+#ifdef ENABLE_OCR
+#include <allheaders.h>
+#endif
+
+#include <stdio.h>
+#include "lib_ccx/lib_ccx.h"
+#ifndef MMCCXTR
+#include "lib_ccx/configuration.h"
+#endif
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include "lib_ccx/ccx_common_option.h"
+#ifndef MMCCXTR
+#include "lib_ccx/ccx_mp4.h"
+#include "lib_ccx/hardsubx.h"
+#include "lib_ccx/ccx_share.h"
+#endif
+#ifdef WITH_LIBCURL
+CURL *curl;
+CURLcode res;
+#endif
+#if defined(ENABLE_OCR) && defined(_WIN32)
+#define LEPT_MSG_SEVERITY L_SEVERITY_NONE
+#endif
+
+#ifdef PYTHON_API
+#include "Python.h"
+#include "funcobject.h"
+
+PyObject* py_callback_func;
+void api_add_param(struct ccx_s_options* api_options,char* arg);
+int compile_params(struct ccx_s_options *api_options,int argc);
+void py_callback(char *line, int encoding);
+int api_param_count(struct ccx_s_options* api_options);
+char * api_param(struct ccx_s_options* api_options, int count);
+#endif
+
+
+struct ccx_s_options ccx_options;
+struct lib_ccx_ctx *signal_ctx;
+//volatile int terminate_asap = 0;
+
+struct ccx_s_options* api_init_options();
+void check_configuration_file(struct ccx_s_options api_options);
+int api_start(struct ccx_s_options api_options);
+
+
+void sigterm_handler(int sig);
+void sigint_handler(int sig);
+void print_end_msg(void);
+
+int main(int argc, char *argv[]);
+
+#endif //CCEXTRACTOR_H

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx Added

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/activity.c Added

@@ -0,0 +1,143 @@
+/* This file contains functions that report the user of the GUI of
+relevant events. */
+
+#include "lib_ccx.h"
+#include "ccx_common_option.h"
+
+static int credits_shown=0;
+unsigned long net_activity_gui=0;
+
+/* Print current progress. For percentage, -1 -> streaming mode */
+void activity_progress (int percentage, int cur_min, int cur_sec)
+{
+	if (!ccx_options.no_progress_bar)
+	{
+		if (percentage==-1)
+			mprint ("\rStreaming |  %02d:%02d", cur_min, cur_sec);
+		else
+			mprint ("\r%3d%%  |  %02d:%02d",percentage, cur_min, cur_sec);
+		if (ccx_options.pes_header_to_stdout || ccx_options.debug_mask&CCX_DMT_DVB) //For PES Header dumping and DVB debug traces
+		{
+			mprint("\n");
+		}
+	}
+	fflush (stdout);
+	if (ccx_options.gui_mode_reports)
+	{
+		fprintf (stderr, "###PROGRESS#%d#%d#%d\n", percentage, cur_min, cur_sec);
+		fflush (stderr);
+	}
+}
+
+void activity_input_file_open (const char *filename)
+{
+	if (ccx_options.gui_mode_reports)
+	{
+		fprintf (stderr, "###INPUTFILEOPEN#%s\n", filename);
+		fflush (stderr);
+	}
+}
+
+void activity_library_process(enum ccx_common_logging_gui message_type, ...)
+{
+	if (ccx_options.gui_mode_reports){
+		va_list args;
+		va_start(args, message_type);
+		switch (message_type)
+		{
+			case CCX_COMMON_LOGGING_GUI_XDS_CALL_LETTERS:
+				vfprintf(stderr, "###XDSNETWORKCALLLETTERS#%s\n",args);
+				break;
+			case CCX_COMMON_LOGGING_GUI_XDS_PROGRAM_DESCRIPTION:
+				vfprintf(stderr, "###XDSPROGRAMDESC#%d#%s\n", args);
+				break;
+			case CCX_COMMON_LOGGING_GUI_XDS_PROGRAM_ID_NR:
+				vfprintf(stderr, "###XDSPROGRAMIDENTIFICATIONNUMBER#%u#%u#%u#%u\n", args);
+				break;
+			case CCX_COMMON_LOGGING_GUI_XDS_PROGRAM_NAME:
+				vfprintf(stderr, "###XDSPROGRAMNAME#%s\n", args);
+				break;
+			default:
+				break;
+		}
+		fflush(stderr);
+		va_end(args);
+	}
+}
+
+void  activity_video_info (int hor_size,int vert_size,
+		const char *aspect_ratio, const char *framerate)
+{
+	if (ccx_options.gui_mode_reports)
+	{
+		fprintf (stderr, "###VIDEOINFO#%u#%u#%s#%s\n",
+				hor_size,vert_size, aspect_ratio, framerate);
+		fflush (stderr);
+	}
+}
+
+
+void activity_message (const char *fmt, ...)
+{
+	if (ccx_options.gui_mode_reports)
+	{
+		va_list args;
+		fprintf (stderr, "###MESSAGE#");
+		va_start(args, fmt);
+		fprintf(stderr, fmt, args);
+		fprintf(stderr, "\n");
+		va_end(args);
+		fflush (stderr);
+	}
+}
+
+void activity_input_file_closed (void)
+{
+	if (ccx_options.gui_mode_reports)
+	{
+		fprintf (stderr, "###INPUTFILECLOSED\n");
+		fflush (stderr);
+	}
+}
+
+void activity_program_number (unsigned program_number)
+{
+	if (ccx_options.gui_mode_reports)
+	{
+		fprintf (stderr, "###TSPROGRAMNUMBER#%u\n", program_number);
+		fflush (stderr);
+	}
+}
+
+void activity_report_version (void)
+{
+	if (ccx_options.gui_mode_reports)
+	{
+		fprintf (stderr, "###VERSION#CCExtractor#%s\n", VERSION);
+		fflush (stderr);
+	}
+}
+
+void activity_report_data_read (void)
+{
+	if (ccx_options.gui_mode_reports)
+	{
+		fprintf (stderr, "###DATAREAD#%lu\n", net_activity_gui/1000);
+		fflush (stderr);
+	}
+}
+
+
+void activity_header (void)
+{
+	if (!credits_shown)
+	{
+		credits_shown = 1;
+		mprint ("CCExtractor %s, Carlos Fernandez Sanz, Volker Quetschke.\n", VERSION);
+		mprint ("Teletext portions taken from Petr Kutalek's telxcc\n");
+#ifdef MMCCXTR
+		mprint("This is a reduced-functionality version optimised for DVD closed captions transcoding.\n");
+#endif
+		mprint ("--------------------------------------------------------------------------\n");
+	}
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/activity.h Added

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/bitstream.h Added

@@ -0,0 +1,66 @@
+#ifndef _BITSTREAM_
+#define _BITSTREAM_
+
+
+// The structure holds the current position in the bitstream.
+// pos points to the current byte position and bpos counts the
+// bits left unread at the current byte pos. No bit read means
+// bpos = 8.
+// end is used to check that nothing is read at "end" or after it.
+struct bitstream
+{
+	unsigned char *pos;
+	int bpos;
+	unsigned char *end;
+	// Indicate how many bits are left in the stream after the previous
+	// read call.  A negative number indicates that a read after the
+	// end of the stream was attempted.
+	int64_t bitsleft;
+	// Indicate an error occured while parsing the bitstream.
+	// This is meant to store high level syntax errors, i.e a function
+	// using the bitstream functions found a syntax error.
+	int error;
+	// Internal (private) variable - used to store the the bitstream
+	// position until it is decided if the bitstream pointer will be
+	// increased by the calling function, or not.
+	unsigned char *_i_pos;
+	int _i_bpos;
+};
+
+#define read_u8(bstream) (uint8_t)bitstream_get_num(bstream,1,1)
+#define read_u16(bstream) (uint16_t)bitstream_get_num(bstream,2,1)
+#define read_u32(bstream) (uint32_t)bitstream_get_num(bstream,4,1)
+#define read_u64(bstream) (uint64_t)bitstream_get_num(bstream,8,1)
+#define read_i8(bstream) (int8_t)bitstream_get_num(bstream,1,1)
+#define read_i16(bstream) (int16_t)bitstream_get_num(bstream,2,1)
+#define read_i32(bstream) (int32_t)bitstream_get_num(bstream,4,1)
+#define read_i64(bstream) (int64_t)bitstream_get_num(bstream,8,1)
+
+#define skip_u32(bstream) (void)bitstream_get_num(bstream,4,1)
+
+#define next_u8(bstream) (uint8_t)bitstream_get_num(bstream,1,0)
+#define next_u16(bstream) (uint16_t)bitstream_get_num(bstream,2,0)
+#define next_u32(bstream) (uint32_t)bitstream_get_num(bstream,4,0)
+#define next_u64(bstream) (uint64_t)bitstream_get_num(bstream,8,0)
+#define next_i8(bstream) (int8_t)bitstream_get_num(bstream,1,0)
+#define next_i16(bstream) (int16_t)bitstream_get_num(bstream,2,0)
+#define next_i32(bstream) (int32_t)bitstream_get_num(bstream,4,0)
+#define next_i64(bstream) (int64_t)bitstream_get_num(bstream,8,0)
+
+
+int init_bitstream(struct bitstream *bstr, unsigned char *start, unsigned char *end);
+uint64_t next_bits(struct bitstream *bstr, unsigned bnum);
+uint64_t read_bits(struct bitstream *bstr, unsigned bnum);
+int skip_bits(struct bitstream *bstr, unsigned bnum);
+int is_byte_aligned(struct bitstream *bstr);
+void make_byte_aligned(struct bitstream *bstr);
+unsigned char *next_bytes(struct bitstream *bstr, unsigned bynum);
+unsigned char *read_bytes(struct bitstream *bstr, unsigned bynum);
+uint64_t bitstream_get_num(struct bitstream *bstr, unsigned bytes, int advance);
+uint64_t read_exp_golomb_unsigned(struct bitstream *bstr);
+int64_t read_exp_golomb(struct bitstream *bstr);
+uint64_t read_int_unsigned(struct bitstream *bstr, unsigned bnum);
+int64_t read_int(struct bitstream *bstr, unsigned bnum);
+uint8_t reverse8(uint8_t data);
+
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_char_encoding.c Added

@@ -0,0 +1,840 @@
+#include <ctype.h>
+
+void get_char_in_latin_1 (unsigned char *buffer, unsigned char c)
+{
+	unsigned char c1='?';
+	if (c<0x80)
+	{
+		// Regular line-21 character set, mostly ASCII except these exceptions
+		switch (c)
+		{
+			case 0x2a: // lowercase a, acute accent
+				c1=0xe1;
+				break;
+			case 0x5c: // lowercase e, acute accent
+				c1=0xe9;
+				break;
+			case 0x5e: // lowercase i, acute accent
+				c1=0xed;
+				break;
+			case 0x5f: // lowercase o, acute accent
+				c1=0xf3;
+				break;
+			case 0x60: // lowercase u, acute accent
+				c1=0xfa;
+				break;
+			case 0x7b: // lowercase c with cedilla
+				c1=0xe7;
+				break;
+			case 0x7c: // division symbol
+				c1=0xf7;
+				break;
+			case 0x7d: // uppercase N tilde
+				c1=0xd1;
+				break;
+			case 0x7e: // lowercase n tilde
+				c1=0xf1;
+				break;
+			default:
+				c1=c;
+				break;
+		}
+		*buffer=c1;
+		return;
+	}
+	switch (c)
+	{
+		// THIS BLOCK INCLUDES THE 16 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
+		// THAT COME FROM HI BYTE=0x11 AND LOW BETWEEN 0x30 AND 0x3F
+		case 0x80: // Registered symbol (R)
+			c1=0xae;
+			break;
+		case 0x81: // degree sign
+			c1=0xb0;
+			break;
+		case 0x82: // 1/2 symbol
+			c1=0xbd;
+			break;
+		case 0x83: // Inverted (open) question mark
+			c1=0xbf;
+			break;
+		case 0x84: // Trademark symbol (TM) - Does not exist in Latin 1
+			break;
+		case 0x85: // Cents symbol
+			c1=0xa2;
+			break;
+		case 0x86: // Pounds sterling
+			c1=0xa3;
+			break;
+		case 0x87: // Music note - Not in latin 1, so we use 'pilcrow'
+			c1=0xb6;
+			break;
+		case 0x88: // lowercase a, grave accent
+			c1=0xe0;
+			break;
+		case 0x89: // transparent space, we make it regular
+			c1=0x20;
+			break;
+		case 0x8a: // lowercase e, grave accent
+			c1=0xe8;
+			break;
+		case 0x8b: // lowercase a, circumflex accent
+			c1=0xe2;
+			break;
+		case 0x8c: // lowercase e, circumflex accent
+			c1=0xea;
+			break;
+		case 0x8d: // lowercase i, circumflex accent
+			c1=0xee;
+			break;
+		case 0x8e: // lowercase o, circumflex accent
+			c1=0xf4;
+			break;
+		case 0x8f: // lowercase u, circumflex accent
+			c1=0xfb;
+			break;
+			// THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
+			// THAT COME FROM HI BYTE=0x12 AND LOW BETWEEN 0x20 AND 0x3F
+		case 0x90: // capital letter A with acute
+			c1=0xc1;
+			break;
+		case 0x91: // capital letter E with acute
+			c1=0xc9;
+			break;
+		case 0x92: // capital letter O with acute
+			c1=0xd3;
+			break;
+		case 0x93: // capital letter U with acute
+			c1=0xda;
+			break;
+		case 0x94: // capital letter U with diaeresis
+			c1=0xdc;
+			break;
+		case 0x95: // lowercase letter U with diaeresis
+			c1=0xfc;
+			break;
+		case 0x96: // apostrophe
+			c1=0x27;
+			break;
+		case 0x97: // inverted exclamation mark
+			c1=0xa1;
+			break;
+		case 0x98: // asterisk
+			c1=0x2a;
+			break;
+		case 0x99: // apostrophe (yes, duped). See CCADI source code.
+			c1=0x27;
+			break;
+		case 0x9a: // em dash
+			c1=0x2d;
+			break;
+		case 0x9b: // copyright sign
+			c1=0xa9;
+			break;
+		case 0x9c: // Service Mark - not available in latin 1
+			break;
+		case 0x9d: // Full stop (.)
+			c1=0x2e;
+			break;
+		case 0x9e: // Quotation mark
+			c1=0x22;
+			break;
+		case 0x9f: // Quotation mark
+			c1=0x22;
+			break;
+		case 0xa0: // uppercase A, grave accent
+			c1=0xc0;
+			break;
+		case 0xa1: // uppercase A, circumflex
+			c1=0xc2;
+			break;
+		case 0xa2: // uppercase C with cedilla
+			c1=0xc7;
+			break;
+		case 0xa3: // uppercase E, grave accent
+			c1=0xc8;
+			break;
+		case 0xa4: // uppercase E, circumflex
+			c1=0xca;
+			break;
+		case 0xa5: // capital letter E with diaeresis
+			c1=0xcb;
+			break;
+		case 0xa6: // lowercase letter e with diaeresis
+			c1=0xeb;
+			break;
+		case 0xa7: // uppercase I, circumflex
+			c1=0xce;
+			break;
+		case 0xa8: // uppercase I, with diaeresis
+			c1=0xcf;
+			break;
+		case 0xa9: // lowercase i, with diaeresis
+			c1=0xef;
+			break;
+		case 0xaa: // uppercase O, circumflex
+			c1=0xd4;
+			break;
+		case 0xab: // uppercase U, grave accent
+			c1=0xd9;
+			break;
+		case 0xac: // lowercase u, grave accent
+			c1=0xf9;
+			break;
+		case 0xad: // uppercase U, circumflex
+			c1=0xdb;
+			break;
+		case 0xae: // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+			c1=0xab;
+			break;
+		case 0xaf: // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+			c1=0xbb;
+			break;
+			// THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
+			// THAT COME FROM HI BYTE=0x13 AND LOW BETWEEN 0x20 AND 0x3F
+		case 0xb0: // Uppercase A, tilde
+			c1=0xc3;
+			break;
+		case 0xb1: // Lowercase a, tilde
+			c1=0xe3;
+			break;
+		case 0xb2: // Uppercase I, acute accent
+			c1=0xcd;
+			break;
+		case 0xb3: // Uppercase I, grave accent
+			c1=0xcc;
+			break;
+		case 0xb4: // Lowercase i, grave accent
+			c1=0xec;
+			break;
+		case 0xb5: // Uppercase O, grave accent
+			c1=0xd2;
+			break;
+		case 0xb6: // Lowercase o, grave accent
+			c1=0xf2;
+			break;
+		case 0xb7: // Uppercase O, tilde
+			c1=0xd5;
+			break;
+		case 0xb8: // Lowercase o, tilde
+			c1=0xf5;
+			break;
+		case 0xb9: // Open curly brace
+			c1=0x7b;
+			break;
+		case 0xba: // Closing curly brace
+			c1=0x7d;
+			break;
+		case 0xbb: // Backslash
+			c1=0x5c;
+			break;
+		case 0xbc: // Caret
+			c1=0x5e;
+			break;
+		case 0xbd: // Underscore
+			c1=0x5f;
+			break;
+		case 0xbe: // Pipe (broken bar)
+			c1=0xa6;
+			break;
+		case 0xbf: // Tilde
+			c1=0x7e;
+			break;
+		case 0xc0: // Uppercase A, umlaut
+			c1=0xc4;
+			break;
+		case 0xc1: // Lowercase A, umlaut
+			c1=0xe3;
+			break;
+		case 0xc2: // Uppercase O, umlaut
+			c1=0xd6;
+			break;
+		case 0xc3: // Lowercase o, umlaut
+			c1=0xf6;
+			break;
+		case 0xc4: // Eszett (sharp S)
+			c1=0xdf;
+			break;
+		case 0xc5: // Yen symbol
+			c1=0xa5;
+			break;
+		case 0xc6: // Currency symbol
+			c1=0xa4;
+			break;
+		case 0xc7: // Vertical bar
+			c1=0x7c;
+			break;
+		case 0xc8: // Uppercase A, ring
+			c1=0xc5;
+			break;
+		case 0xc9: // Lowercase A, ring
+			c1=0xe5;
+			break;
+		case 0xca: // Uppercase O, slash
+			c1=0xd8;
+			break;
+		case 0xcb: // Lowercase o, slash
+			c1=0xf8;
+			break;
+		case 0xcc: // Upper left corner
+		case 0xcd: // Upper right corner
+		case 0xce: // Lower left corner
+		case 0xcf: // Lower right corner
+		default: // For those that don't have representation
+			*buffer='?'; // I'll do it eventually, I promise
+			break; // This are weird chars anyway
+	}
+	*buffer=c1;
+}
+
+void get_char_in_unicode (unsigned char *buffer, unsigned char c)
+{
+	unsigned char c1,c2;
+	switch (c)
+	{
+		case 0x84: // Trademark symbol (TM)
+			c2=0x21;
+			c1=0x22;
+			break;
+		case 0x87: // Music note
+			c2=0x26;
+			c1=0x6a;
+			break;
+		case 0x9c: // Service Mark
+			c2=0x21;
+			c1=0x20;
+			break;
+		case 0xcc: // Upper left corner
+			c2=0x23;
+			c1=0x1c;
+			break;
+		case 0xcd: // Upper right corner
+			c2=0x23;
+			c1=0x1d;
+			break;
+		case 0xce: // Lower left corner
+			c2=0x23;
+			c1=0x1e;
+			break;
+		case 0xcf: // Lower right corner
+			c2=0x23;
+			c1=0x1f;
+			break;
+		default: // Everything else, same as latin-1 followed by 00
+			get_char_in_latin_1 (&c1,c);
+			c2=0;
+			break;
+	}
+	*buffer=c1;
+	*(buffer+1)=c2;
+}
+
+int get_char_in_utf_8 (unsigned char *buffer, unsigned char c) // Returns number of bytes used
+{
+	if (c<0x80) // Regular line-21 character set, mostly ASCII except these exceptions
+	{
+		switch (c)
+		{
+			case 0x2a: // lowercase a, acute accent
+				*buffer=0xc3;
+				*(buffer+1)=0xa1;
+				return 2;
+			case 0x5c: // lowercase e, acute accent
+				*buffer=0xc3;
+				*(buffer+1)=0xa9;
+				return 2;
+			case 0x5e: // lowercase i, acute accent
+				*buffer=0xc3;
+				*(buffer+1)=0xad;
+				return 2;
+			case 0x5f: // lowercase o, acute accent
+				*buffer=0xc3;
+				*(buffer+1)=0xb3;
+				return 2;
+			case 0x60: // lowercase u, acute accent
+				*buffer=0xc3;
+				*(buffer+1)=0xba;
+				return 2;
+			case 0x7b: // lowercase c with cedilla
+				*buffer=0xc3;
+				*(buffer+1)=0xa7;
+				return 2;
+			case 0x7c: // division symbol
+				*buffer=0xc3;
+				*(buffer+1)=0xb7;
+				return 2;
+			case 0x7d: // uppercase N tilde
+				*buffer=0xc3;
+				*(buffer+1)=0x91;
+				return 2;
+			case 0x7e: // lowercase n tilde
+				*buffer=0xc3;
+				*(buffer+1)=0xb1;
+				return 2;
+			case 0x7f: // Solid block
+				*buffer=0xe2;
+				*(buffer+1)=0x96;
+				*(buffer+2)=0xa0;
+				return 3;
+			default:
+				*buffer=c;
+				return 1;
+		}
+	}
+	switch (c)
+	{
+		// THIS BLOCK INCLUDES THE 16 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
+		// THAT COME FROM HI BYTE=0x11 AND LOW BETWEEN 0x30 AND 0x3F
+		case 0x80: // Registered symbol (R)
+			*buffer=0xc2;
+			*(buffer+1)=0xae;
+			return 2;
+		case 0x81: // degree sign
+			*buffer=0xc2;
+			*(buffer+1)=0xb0;
+			return 2;
+		case 0x82: // 1/2 symbol
+			*buffer=0xc2;
+			*(buffer+1)=0xbd;
+			return 2;
+		case 0x83: // Inverted (open) question mark
+			*buffer=0xc2;
+			*(buffer+1)=0xbf;
+			return 2;
+		case 0x84: // Trademark symbol (TM)
+			*buffer=0xe2;
+			*(buffer+1)=0x84;
+			*(buffer+2)=0xa2;
+			return 3;
+		case 0x85: // Cents symbol
+			*buffer=0xc2;
+			*(buffer+1)=0xa2;
+			return 2;
+		case 0x86: // Pounds sterling
+			*buffer=0xc2;
+			*(buffer+1)=0xa3;
+			return 2;
+		case 0x87: // Music note
+			*buffer=0xe2;
+			*(buffer+1)=0x99;
+			*(buffer+2)=0xaa;
+			return 3;
+		case 0x88: // lowercase a, grave accent
+			*buffer=0xc3;
+			*(buffer+1)=0xa0;
+			return 2;
+		case 0x89: // transparent space, we make it regular
+			*buffer=0x20;
+			return 1;
+		case 0x8a: // lowercase e, grave accent
+			*buffer=0xc3;
+			*(buffer+1)=0xa8;
+			return 2;
+		case 0x8b: // lowercase a, circumflex accent
+			*buffer=0xc3;
+			*(buffer+1)=0xa2;
+			return 2;
+		case 0x8c: // lowercase e, circumflex accent
+			*buffer=0xc3;
+			*(buffer+1)=0xaa;
+			return 2;
+		case 0x8d: // lowercase i, circumflex accent
+			*buffer=0xc3;
+			*(buffer+1)=0xae;
+			return 2;
+		case 0x8e: // lowercase o, circumflex accent
+			*buffer=0xc3;
+			*(buffer+1)=0xb4;
+			return 2;
+		case 0x8f: // lowercase u, circumflex accent
+			*buffer=0xc3;
+			*(buffer+1)=0xbb;
+			return 2;
+			// THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
+			// THAT COME FROM HI BYTE=0x12 AND LOW BETWEEN 0x20 AND 0x3F
+		case 0x90: // capital letter A with acute
+			*buffer=0xc3;
+			*(buffer+1)=0x81;
+			return 2;
+		case 0x91: // capital letter E with acute
+			*buffer=0xc3;
+			*(buffer+1)=0x89;
+			return 2;
+		case 0x92: // capital letter O with acute
+			*buffer=0xc3;
+			*(buffer+1)=0x93;
+			return 2;
+		case 0x93: // capital letter U with acute
+			*buffer=0xc3;
+			*(buffer+1)=0x9a;
+			return 2;
+		case 0x94: // capital letter U with diaeresis
+			*buffer=0xc3;
+			*(buffer+1)=0x9c;
+			return 2;
+		case 0x95: // lowercase letter U with diaeresis
+			*buffer=0xc3;
+			*(buffer+1)=0xbc;
+			return 2;
+		case 0x96: // apostrophe
+			*buffer=0x27;
+			return 1;
+		case 0x97: // inverted exclamation mark
+			*buffer=0xc2;
+			*(buffer+1)=0xa1;
+			return 2;
+		case 0x98: // asterisk
+			*buffer=0x2a;
+			return 1;
+		case 0x99: // Plain single quote
+			*buffer=0x27;
+			return 1;
+		case 0x9a: // em dash
+			*buffer=0xe2;
+			*(buffer+1)=0x80;
+			*(buffer+2)=0x94;
+			return 3;
+		case 0x9b: // copyright sign
+			*buffer=0xc2;
+			*(buffer+1)=0xa9;
+			return 2;
+		case 0x9c: // Service mark
+			*buffer=0xe2;
+			*(buffer+1)=0x84;
+			*(buffer+2)=0xa0;
+			return 3;
+		case 0x9d: // Round bullet
+			*buffer=0xe2;
+			*(buffer+1)=0x80;
+			*(buffer+2)=0xa2;
+			return 3;
+		case 0x9e: // Opening double quotes
+			*buffer=0xe2;
+			*(buffer+1)=0x80;
+			*(buffer+2)=0x9c;
+			return 3;
+		case 0x9f: // Closing double quotes
+			*buffer=0xe2;
+			*(buffer+1)=0x80;
+			*(buffer+2)=0x9d;
+			return 3;
+		case 0xa0: // uppercase A, grave accent
+			*buffer=0xc3;
+			*(buffer+1)=0x80;
+			return 2;
+		case 0xa1: // uppercase A, circumflex
+			*buffer=0xc3;
+			*(buffer+1)=0x82;
+			return 2;
+		case 0xa2: // uppercase C with cedilla
+			*buffer=0xc3;
+			*(buffer+1)=0x87;
+			return 2;
+		case 0xa3: // uppercase E, grave accent
+			*buffer=0xc3;
+			*(buffer+1)=0x88;
+			return 2;
+		case 0xa4: // uppercase E, circumflex
+			*buffer=0xc3;
+			*(buffer+1)=0x8a;
+			return 2;
+		case 0xa5: // capital letter E with diaeresis
+			*buffer=0xc3;
+			*(buffer+1)=0x8b;
+			return 2;
+		case 0xa6: // lowercase letter e with diaeresis
+			*buffer=0xc3;
+			*(buffer+1)=0xab;
+			return 2;
+		case 0xa7: // uppercase I, circumflex
+			*buffer=0xc3;
+			*(buffer+1)=0x8e;
+			return 2;
+		case 0xa8: // uppercase I, with diaeresis
+			*buffer=0xc3;
+			*(buffer+1)=0x8f;
+			return 2;
+		case 0xa9: // lowercase i, with diaeresis
+			*buffer=0xc3;
+			*(buffer+1)=0xaf;
+			return 2;
+		case 0xaa: // uppercase O, circumflex
+			*buffer=0xc3;
+			*(buffer+1)=0x94;
+			return 2;
+		case 0xab: // uppercase U, grave accent
+			*buffer=0xc3;
+			*(buffer+1)=0x99;
+			return 2;
+		case 0xac: // lowercase u, grave accent
+			*buffer=0xc3;
+			*(buffer+1)=0xb9;
+			return 2;
+		case 0xad: // uppercase U, circumflex
+			*buffer=0xc3;
+			*(buffer+1)=0x9b;
+			return 2;
+		case 0xae: // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
+			*buffer=0xc2;
+			*(buffer+1)=0xab;
+			return 2;
+		case 0xaf: // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
+			*buffer=0xc2;
+			*(buffer+1)=0xbb;
+			return 2;
+			// THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
+			// THAT COME FROM HI BYTE=0x13 AND LOW BETWEEN 0x20 AND 0x3F
+		case 0xb0: // Uppercase A, tilde
+			*buffer=0xc3;
+			*(buffer+1)=0x83;
+			return 2;
+		case 0xb1: // Lowercase a, tilde
+			*buffer=0xc3;
+			*(buffer+1)=0xa3;
+			return 2;
+		case 0xb2: // Uppercase I, acute accent
+			*buffer=0xc3;
+			*(buffer+1)=0x8d;
+			return 2;
+		case 0xb3: // Uppercase I, grave accent
+			*buffer=0xc3;
+			*(buffer+1)=0x8c;
+			return 2;
+		case 0xb4: // Lowercase i, grave accent
+			*buffer=0xc3;
+			*(buffer+1)=0xac;
+			return 2;
+		case 0xb5: // Uppercase O, grave accent
+			*buffer=0xc3;
+			*(buffer+1)=0x92;
+			return 2;
+		case 0xb6: // Lowercase o, grave accent
+			*buffer=0xc3;
+			*(buffer+1)=0xb2;
+			return 2;
+		case 0xb7: // Uppercase O, tilde
+			*buffer=0xc3;
+			*(buffer+1)=0x95;
+			return 2;
+		case 0xb8: // Lowercase o, tilde
+			*buffer=0xc3;
+			*(buffer+1)=0xb5;
+			return 2;
+		case 0xb9: // Open curly brace
+			*buffer=0x7b;
+			return 1;
+		case 0xba: // Closing curly brace
+			*buffer=0x7d;
+			return 1;
+		case 0xbb: // Backslash
+			*buffer=0x5c;
+			return 1;
+		case 0xbc: // Caret
+			*buffer=0x5e;
+			return 1;
+		case 0xbd: // Underscore
+			*buffer=0x5f;
+			return 1;
+		case 0xbe: // Pipe (broken bar)
+			*buffer=0xc2;
+			*(buffer+1)=0xa6;
+			return 2;
+		case 0xbf: // Tilde
+			*buffer=0x7e; // Not sure
+			return 1;
+		case 0xc0: // Uppercase A, umlaut
+			*buffer=0xc3;
+			*(buffer+1)=0x84;
+			return 2;
+		case 0xc1: // Lowercase A, umlaut
+			*buffer=0xc3;
+			*(buffer+1)=0xa4;
+			return 2;
+		case 0xc2: // Uppercase O, umlaut
+			*buffer=0xc3;
+			*(buffer+1)=0x96;
+			return 2;
+		case 0xc3: // Lowercase o, umlaut
+			*buffer=0xc3;
+			*(buffer+1)=0xb6;
+			return 2;
+		case 0xc4: // Esszett (sharp S)
+			*buffer=0xc3;
+			*(buffer+1)=0x9f;
+			return 2;
+		case 0xc5: // Yen symbol
+			*buffer=0xc2;
+			*(buffer+1)=0xa5;
+			return 2;
+		case 0xc6: // Currency symbol
+			*buffer=0xc2;
+			*(buffer+1)=0xa4;
+			return 2;
+		case 0xc7: // Vertical bar
+			*buffer=0x7c;
+			return 1;
+		case 0xc8: // Uppercase A, ring
+			*buffer=0xc3;
+			*(buffer+1)=0x85;
+			return 2;
+		case 0xc9: // Lowercase A, ring
+			*buffer=0xc3;
+			*(buffer+1)=0xa5;
+			return 2;
+		case 0xca: // Uppercase O, slash
+			*buffer=0xc3;
+			*(buffer+1)=0x98;
+			return 2;
+		case 0xcb: // Lowercase o, slash
+			*buffer=0xc3;
+			*(buffer+1)=0xb8;
+			return 2;
+		case 0xcc: // Top left corner
+			*buffer=0xe2;
+			*(buffer+1)=0x8c;
+			*(buffer+2)=0x9c;
+			return 3;
+		case 0xcd: // Top right corner
+			*buffer=0xe2;
+			*(buffer+1)=0x8c;
+			*(buffer+2)=0x9d;
+			return 3;
+		case 0xce: // Bottom left corner
+			*buffer=0xe2;
+			*(buffer+1)=0x8c;
+			*(buffer+2)=0x9e;
+			return 3;
+		case 0xcf: // Bottom right corner
+			*buffer=0xe2;
+			*(buffer+1)=0x8c;
+			*(buffer+2)=0x9f;
+			return 3;
+		default: //
+			*buffer='?'; // I'll do it eventually, I promise
+			return 1; // This are weird chars anyway
+	}
+}
+
+unsigned char cctolower (unsigned char c)
+{
+	if (c>='A' && c<='Z')
+		return tolower(c);
+	switch (c)
+	{
+		case 0x7d: // uppercase N tilde
+			return 0x7e;
+		case 0x90: // capital letter A with acute
+			return 0x2a;
+		case 0x91: // capital letter E with acute
+			return 0x5c;
+		case 0x92: // capital letter O with acute
+			return 0x5f;
+		case 0x93: // capital letter U with acute
+			return 0x60;
+		case 0xa2: // uppercase C with cedilla
+			return 0x7b;
+		case 0xa0: // uppercase A, grave accent
+			return 0x88;
+		case 0xa3: // uppercase E, grave accent
+			return 0x8a;
+		case 0xa1: // uppercase A, circumflex
+			return 0x8b;
+		case 0xa4: // uppercase E, circumflex
+			return 0x8c;
+		case 0xa7: // uppercase I, circumflex
+			return 0x8d;
+		case 0xaa: // uppercase O, circumflex
+			return 0x8e;
+		case 0xad: // uppercase U, circumflex
+			return 0x8f;
+		case 0x94: // capital letter U with diaeresis
+			return 0x95;
+		case 0xa5: // capital letter E with diaeresis
+			return 0xa6;
+		case 0xa8: // uppercase I, with diaeresis
+			return 0xa9;
+		case 0xab: // uppercase U, grave accent
+			return 0xac;
+		case 0xb0: // Uppercase A, tilde
+			return 0xb1;
+		case 0xb2: // Uppercase I, acute accent
+			return 0x5e;
+		case 0xb3: // Uppercase I, grave accent
+			return 0xb4;
+		case 0xb5: // Uppercase O, grave accent
+			return 0xb6;
+		case 0xb7: // Uppercase O, tilde
+			return 0xb8;
+		case 0xc0: // Uppercase A, umlaut
+			return 0xc1;
+		case 0xc2: // Uppercase O, umlaut
+			return 0xc3;
+		case 0xc8: // Uppercase A, ring
+			return 0xc9;
+		case 0xca: // Uppercase O, slash
+			return 0xcb;
+	}
+	return c;
+}
+
+unsigned char cctoupper (unsigned char c)
+{
+	if (c>='a' && c<='z')
+		return toupper(c);
+	switch (c)
+	{
+		case 0x7e: // lowercase n tilde
+			return 0x7d;
+		case 0x2a: // lowercase a, acute accent
+			return 0x90;
+		case 0x5c: // lowercase e, acute accent
+			return 0x91;
+		case 0x5e: // lowercase i, acute accent
+			return 0xb2;
+		case 0x5f: // lowercase o, acute accent
+			return 0x92;
+		case 0x60: // lowercase u, acute accent
+			return 0x93;
+		case 0x7b: // lowercase c with cedilla
+			return 0xa2;
+		case 0x88: // lowercase a, grave accent
+			return 0xa0;
+		case 0x8a: // lowercase e, grave accent
+			return 0xa3;
+		case 0x8b: // lowercase a, circumflex accent
+			return 0xa1;
+		case 0x8c: // lowercase e, circumflex accent
+			return 0xa4;
+		case 0x8d: // lowercase i, circumflex accent
+			return 0xa7;
+		case 0x8e: // lowercase o, circumflex accent
+			return 0xaa;
+		case 0x8f: // lowercase u, circumflex accent
+			return 0xad;
+		case 0x95: // lowercase letter U with diaeresis
+			return 0x94;
+		case 0xa6: // lowercase letter e with diaeresis
+			return 0xa5;
+		case 0xa9: // lowercase i, with diaeresis
+			return 0xa8;
+		case 0xac: // lowercase u, grave accent
+			return 0xab;
+		case 0xb1: // Lowercase a, tilde
+			return 0xb0;
+		case 0xb4: // Lowercase i, grave accent
+			return 0xb3;
+		case 0xb6: // Lowercase o, grave accent
+			return 0xb5;
+		case 0xb8: // Lowercase o, tilde
+			return 0xb7;
+		case 0xc1: // Lowercase A, umlaut
+			return 0xc0;
+		case 0xc3: // Lowercase o, umlaut
+			return 0xc2;
+		case 0xc9: // Lowercase A, ring
+			return 0xc8;
+		case 0xcb: // Lowercase o, slash
+			return 0xca;
+	}
+	return c;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_char_encoding.h Added

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_common.c Added

@@ -0,0 +1,133 @@
+#include "ccx_common_common.h"
+
+int cc608_parity_table[256];
+
+#ifndef MMCCXTR
+/* printf() for fd instead of FILE*, since dprintf is not portable */
+void fdprintf(int fd, const char *fmt, ...)
+{
+	/* Guess we need no more than 100 bytes. */
+	int n, size = 100;
+	char *p, *np;
+	va_list ap;
+
+	if (fd < 0)
+		return;
+	if ((p = (char *)malloc(size)) == NULL)
+		return;
+
+	while (1)
+	{
+		/* Try to print in the allocated space. */
+		va_start(ap, fmt);
+		n = vsnprintf(p, size, fmt, ap);
+		va_end(ap);
+		/* If that worked, return the string. */
+		if (n > -1 && n < size)
+		{
+			write(fd, p, n);
+			free(p);
+			return;
+		}
+		/* Else try again with more space. */
+		if (n > -1)    /* glibc 2.1 */
+			size = n + 1; /* precisely what is needed */
+		else           /* glibc 2.0 */
+			size *= 2;  /* twice the old size */
+		if ((np = (char *)realloc(p, size)) == NULL)
+		{
+			free(p);
+			return;
+		}
+		else
+		{
+			p = np;
+		}
+	}
+}
+#endif
+/* Converts the given milli to separate hours,minutes,seconds and ms variables */
+void millis_to_time(LLONG milli, unsigned *hours, unsigned *minutes,
+	unsigned *seconds, unsigned *ms)
+{
+	// LLONG milli = (LLONG) ((ccblock*1000)/29.97);
+	*ms = (unsigned)(milli % 1000); // milliseconds
+	milli = (milli - *ms) / 1000;  // Remainder, in seconds
+	*seconds = (int)(milli % 60);
+	milli = (milli - *seconds) / 60; // Remainder, in minutes
+	*minutes = (int)(milli % 60);
+	milli = (milli - *minutes) / 60; // Remainder, in hours
+	*hours = (int)milli;
+}
+/* Frees the given pointer */
+void freep(void *arg)
+{
+	void **ptr = (void **)arg;
+	if (*ptr)
+		free(*ptr);
+	*ptr = NULL;
+
+}
+
+int add_cc_sub_text(struct cc_subtitle *sub, char *str, LLONG start_time,
+		LLONG end_time, char *info, char *mode, enum ccx_encoding_type e_type)
+{
+	if (str == NULL || strlen(str) == 0)
+		return 0;
+	if (sub->nb_data)
+	{
+		for(;sub->next;sub = sub->next);
+		sub->next = malloc(sizeof(struct cc_subtitle));
+		if(!sub->next)
+			return -1;
+		sub->next->prev = sub;
+		sub = sub->next;
+	}
+
+	sub->type = CC_TEXT;
+	sub->enc_type = e_type;
+	sub->data = strdup(str);
+	sub->datatype = CC_DATATYPE_GENERIC;
+	sub->nb_data = str? strlen(str): 0;
+	sub->start_time = start_time;
+	sub->end_time = end_time;
+	if(info)
+		strncpy(sub->info, info, 4);
+	if(mode)
+		strncpy(sub->mode, mode, 4);
+	sub->got_output = 1;
+	sub->next = NULL;
+
+	return 0;
+}
+
+int cc608_parity(unsigned int byte)
+{
+	int ones = 0;
+
+	for (int i = 0; i < 7; i++)
+	{
+		if (byte & (1 << i))
+			ones++;
+	}
+
+	return ones & 1;
+}
+
+void cc608_build_parity_table(int *parity_table)
+{
+	unsigned int byte;
+	int parity_v;
+	for (byte = 0; byte <= 127; byte++)
+	{
+		parity_v = cc608_parity(byte);
+		/* CC uses odd parity (i.e., # of 1's in byte is odd.) */
+		parity_table[byte] = parity_v;
+		parity_table[byte | 0x80] = !parity_v;
+	}
+}
+
+void build_parity_table (void)
+{
+	cc608_build_parity_table(cc608_parity_table);
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_common.h Added

@@ -0,0 +1,52 @@
+#ifndef _CC_COMMON_COMMON
+#define _CC_COMMON_COMMON
+
+#include "ccx_common_platform.h"
+#include "ccx_common_structs.h"
+
+// Define possible exit codes that will be passed on to the fatal function
+/* Exit codes. Take this seriously as the GUI depends on them.
+   0 means OK as usual,
+   <100 means display whatever was output to stderr as a warning
+   >=100 means display whatever was output to stdout as an error
+*/
+#define EXIT_OK                                 0
+#define EXIT_NO_INPUT_FILES                     2
+#define EXIT_TOO_MANY_INPUT_FILES               3
+#define EXIT_INCOMPATIBLE_PARAMETERS            4
+#define EXIT_UNABLE_TO_DETERMINE_FILE_SIZE      6
+#define EXIT_MALFORMED_PARAMETER                7
+#define EXIT_READ_ERROR                         8
+#define EXIT_WITH_HELP                          9
+#define EXIT_NO_CAPTIONS                        10
+#define EXIT_NOT_CLASSIFIED                     300
+#define EXIT_ERROR_IN_CAPITALIZATION_FILE       501
+#define EXIT_BUFFER_FULL                        502
+#define EXIT_MISSING_ASF_HEADER                 1001
+#define EXIT_MISSING_RCWT_HEADER                1002
+
+#define CCX_COMMON_EXIT_FILE_CREATION_FAILED   5
+#define CCX_COMMON_EXIT_UNSUPPORTED            9
+#define EXIT_NOT_ENOUGH_MEMORY                 500
+#define CCX_COMMON_EXIT_BUG_BUG                1000
+
+#define CCX_OK       0
+#define CCX_FALSE    0
+#define CCX_TRUE     1
+#define CCX_EAGAIN  -100
+#define CCX_EOF     -101
+#define CCX_EINVAL  -102
+#define CCX_ENOSUPP -103
+#define CCX_ENOMEM  -104
+
+// Declarations
+void fdprintf(int fd, const char *fmt, ...);
+void millis_to_time(LLONG milli, unsigned *hours, unsigned *minutes,unsigned *seconds, unsigned *ms);
+void freep(void *arg);
+void dbg_print(LLONG mask, const char *fmt, ...);
+unsigned char *debug_608_to_ASC(unsigned char *ccdata, int channel);
+int add_cc_sub_text(struct cc_subtitle *sub, char *str, LLONG start_time,
+		LLONG end_time, char *info, char *mode, enum ccx_encoding_type);
+
+extern int cc608_parity_table[256]; // From myth
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_constants.c Added

@@ -0,0 +1,233 @@
+#include "ccx_common_constants.h"
+
+// RCWT header (11 bytes):
+//byte(s)   value   description (All values below are hex numbers, not
+//                  actual numbers or values
+//0-2       CCCCED  magic number, for Closed Caption CC Extractor Data
+//3         CC      Creating program.  Legal values: CC = CC Extractor
+//4-5       0050    Program version number
+//6-7       0001    File format version
+//8-10      000000  Padding, required  :-)
+unsigned char rcwt_header[11]={0xCC, 0xCC, 0xED, 0xCC, 0x00, 0x50, 0, 1, 0, 0, 0};
+
+const unsigned char BROADCAST_HEADER[]={0xff, 0xff, 0xff, 0xff};
+const unsigned char LITTLE_ENDIAN_BOM[]={0xff, 0xfe};
+const unsigned char UTF8_BOM[]={0xef, 0xbb,0xbf};
+
+const unsigned char DVD_HEADER[8]={0x00,0x00,0x01,0xb2,0x43,0x43,0x01,0xf8};
+const unsigned char lc1[1]={0x8a};
+const unsigned char lc2[1]={0x8f};
+const unsigned char lc3[2]={0x16,0xfe};
+const unsigned char lc4[2]={0x1e,0xfe};
+const unsigned char lc5[1]={0xff};
+const unsigned char lc6[1]={0xfe};
+
+const double framerates_values[16]=
+{
+	0,
+	24000.0/1001, /* 23.976 */
+	24.0,
+	25.0,
+	30000.0/1001, /* 29.97 */
+	30.0,
+	50.0,
+	60000.0/1001, /* 59.94 */
+	60.0,
+	0,
+	0,
+	0,
+	0,
+	0
+};
+
+const char *framerates_types[16]=
+{
+	"00 - forbidden",
+	"01 - 23.976",
+	"02 - 24",
+	"03 - 25",
+	"04 - 29.97",
+	"05 - 30",
+	"06 - 50",
+	"07 - 59.94",
+	"08 - 60",
+	"09 - reserved",
+	"10 - reserved",
+	"11 - reserved",
+	"12 - reserved",
+	"13 - reserved",
+	"14 - reserved",
+	"15 - reserved"
+};
+
+const char *aspect_ratio_types[16]=
+{
+	"00 - forbidden",
+	"01 - 1:1",
+	"02 - 4:3",
+	"03 - 16:9",
+	"04 - 2.21:1",
+	"05 - reserved",
+	"06 - reserved",
+	"07 - reserved",
+	"08 - reserved",
+	"09 - reserved",
+	"10 - reserved",
+	"11 - reserved",
+	"12 - reserved",
+	"13 - reserved",
+	"14 - reserved",
+	"15 - reserved"
+};
+
+
+const char *pict_types[8]=
+{
+	"00 - illegal (0)",
+	"01 - I",
+	"02 - P",
+	"03 - B",
+	"04 - illegal (D)",
+	"05 - illegal (5)",
+	"06 - illegal (6)",
+	"07 - illegal (7)"
+};
+
+
+const char *slice_types[10]=
+{
+	"0 - P",
+	"1 - B",
+	"2 - I",
+	"3 - SP",
+	"4 - SI",
+	"5 - P",
+	"6 - B",
+	"7 - I",
+	"8 - SP",
+	"9 - SI"
+};
+
+const char *cc_types[4] =
+{
+	"NTSC line 21 field 1 closed captions",
+	"NTSC line 21 field 2 closed captions",
+	"DTVCC Channel Packet Data",
+	"DTVCC Channel Packet Start"
+};
+
+enum
+{
+	NTSC_CC_f1         = 0,
+	NTSC_CC_f2         = 1,
+	DTVCC_PACKET_DATA  = 2,
+	DTVCC_PACKET_START = 3,
+};
+
+/**
+ * After Adding a new language here, don't forget
+ * to increase NB_LANGUAGE define ccx_common_constants.h
+ */
+const char *language[NB_LANGUAGE] =
+{
+	/*0*/"und", //Undefined
+	/*1*/"eng",
+	/*2*/"afr",
+	/*3*/"amh",
+	/*4*/"ara",
+	/*5*/"asm",
+	/*6*/"aze",
+	/*7*/"bel",
+	/*8*/"ben",
+	/*9*/"bod",
+	/*10*/"bos",
+	/*11*/"bul",
+	/*12*/"cat",
+	/*13*/"ceb",
+	/*14*/"ces",
+	/*15*/"chs",
+	/*16*/"chi",
+	/*17*/"chr",
+	/*18*/"cym",
+	/*19*/"dan",
+	/*20*/"deu",
+	/*21*/"dzo",
+	/*22*/"ell",
+	/*23*/"enm",
+	/*24*/"epo",
+	/*25*/"equ",
+	/*26*/"est",
+	/*27*/"eus",
+	/*28*/"fas",
+	/*29*/"fin",
+	/*30*/"fra",
+	/*31*/"frk",
+	/*32*/"frm",
+	/*33*/"gle",
+	/*34*/"glg",
+	/*35*/"grc",
+	/*36*/"guj",
+	/*37*/"hat",
+	/*38*/"heb",
+	/*39*/"hin",
+	/*40*/"hrv",
+	/*41*/"hun",
+	/*42*/"iku",
+	/*43*/"ind",
+	/*44*/"isl",
+	/*45*/"ita",
+	/*46*/"jav",
+	/*47*/"jpn",
+	/*48*/"kan",
+	/*49*/"kat",
+	/*50*/"kaz",
+	/*51*/"khm",
+	/*52*/"kir",
+	/*53*/"kor",
+	/*54*/"kur",
+	/*55*/"lao",
+	/*56*/"lat",
+	/*57*/"lav",
+	/*58*/"lit",
+	/*59*/"mal",
+	/*60*/"mar",
+	/*61*/"mkd",
+	/*62*/"mlt",
+	/*63*/"msa",
+	/*64*/"mya",
+	/*65*/"nep",
+	/*66*/"nld",
+	/*67*/"nor",
+	/*68*/"ori",
+	/*69*/"osd",
+	/*70*/"pan",
+	/*71*/"pol",
+	/*72*/"por",
+	/*73*/"pus",
+	/*74*/"ron",
+	/*75*/"rus",
+	/*76*/"san",
+	/*77*/"sin",
+	/*78*/"slk",
+	/*79*/"slv",
+	/*80*/"spa",
+	/*81*/"sqi",
+	/*82*/"srp",
+	/*83*/"swa",
+	/*84*/"swe",
+	/*85*/"syr",
+	/*86*/"tam",
+	/*87*/"tel",
+	/*88*/"tgk",
+	/*89*/"tgl",
+	/*90*/"tha",
+	/*91*/"tir",
+	/*92*/"tur",
+	/*93*/"uig",
+	/*94*/"ukr",
+	/*95*/"urd",
+	/*96*/"uzb",
+	/*97*/"vie",
+	/*98*/"yid",
+	NULL
+};

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_constants.h Added

@@ -0,0 +1,321 @@
+#ifndef CCX_CONSTANTS_H
+#define CCX_CONSTANTS_H
+
+#include "stdio.h"
+
+#ifndef __cplusplus
+#define false 0
+#define true 1
+#endif
+
+extern const char *framerates_types[16];
+extern const double framerates_values[16];
+
+extern const char *aspect_ratio_types[16];
+extern const char *pict_types[8];
+extern const char *slice_types[10];
+extern const char *cc_types[4];
+
+extern const unsigned char BROADCAST_HEADER[4];
+extern const unsigned char LITTLE_ENDIAN_BOM[2];
+extern const unsigned char UTF8_BOM[3];
+extern const unsigned char DVD_HEADER[8];
+extern const unsigned char lc1[1];
+extern const unsigned char lc2[1];
+extern const unsigned char lc3[2];
+extern const unsigned char lc4[2];
+extern const unsigned char lc5[1];
+extern const unsigned char lc6[1];
+
+extern unsigned char rcwt_header[11];
+
+#define ONEPASS 120                          /* Bytes we can always look ahead without going out of limits */
+#define BUFSIZE (2048*1024+ONEPASS)          /* 2 Mb plus the safety pass */
+#define MAX_CLOSED_CAPTION_DATA_PER_PICTURE 32
+#define EIA_708_BUFFER_LENGTH   2048         // TODO: Find out what the real limit is
+#define TS_PACKET_PAYLOAD_LENGTH     184     // From specs
+#define SUBLINESIZE 2048                     // Max. length of a .srt line - TODO: Get rid of this
+#define STARTBYTESLENGTH	(1024*1024)
+#define UTF8_MAX_BYTES 6
+#define XMLRPC_CHUNK_SIZE (64*1024)          // 64 Kb per chunk, to avoid too many realloc()
+
+enum ccx_debug_message_types
+{
+	/* Each debug message now belongs to one of these types. Use bitmaps in case
+	   we want one message to belong to more than one type. */
+	CCX_DMT_PARSE = 1,               // Show information related to parsing the container
+	CCX_DMT_VIDES = 2,               // Show video stream related information
+	CCX_DMT_TIME = 4,                // Show GOP and PTS timing information
+	CCX_DMT_VERBOSE = 8,             // Show lots of debugging output
+	CCX_DMT_DECODER_608 = 0x10,      // Show CC-608 decoder debug?
+	CCX_DMT_708 = 0x20,              // Show CC-708 decoder debug?
+	CCX_DMT_DECODER_XDS = 0x40,      // Show XDS decoder debug?
+	CCX_DMT_CBRAW = 0x80,            // Caption blocks with FTS timing
+	CCX_DMT_GENERIC_NOTICES = 0x100, // Generic, always displayed even if no debug is selected
+	CCX_DMT_TELETEXT = 0x200,        // Show teletext debug?
+	CCX_DMT_PAT = 0x400,             // Program Allocation Table dump
+	CCX_DMT_PMT = 0x800,             // Program Map Table dump
+	CCX_DMT_LEVENSHTEIN = 0x1000,    // Levenshtein distance calculations
+	CCX_DMT_DVB = 0x2000,			 // DVB 
+#ifdef ENABLE_SHARING
+	CCX_DMT_SHARE = 0x2000,        // Extracted captions sharing service
+#endif //ENABLE_SHARING
+	CCX_DMT_DUMPDEF=0x4000,        // Dump defective TS packets
+};
+
+// AVC NAL types
+enum ccx_avc_nal_types
+{
+	CCX_NAL_TYPE_UNSPECIFIED_0 = 0,
+	CCX_NAL_TYPE_CODED_SLICE_NON_IDR_PICTURE_1 = 1,
+	CCX_NAL_TYPE_CODED_SLICE_PARTITION_A = 2,
+	CCX_NAL_TYPE_CODED_SLICE_PARTITION_B = 3,
+	CCX_NAL_TYPE_CODED_SLICE_PARTITION_C = 4,
+	CCX_NAL_TYPE_CODED_SLICE_IDR_PICTURE = 5,
+	CCX_NAL_TYPE_SEI = 6,
+	CCX_NAL_TYPE_SEQUENCE_PARAMETER_SET_7 = 7,
+	CCX_NAL_TYPE_PICTURE_PARAMETER_SET = 8,
+	CCX_NAL_TYPE_ACCESS_UNIT_DELIMITER_9 = 9,
+	CCX_NAL_TYPE_END_OF_SEQUENCE = 10,
+	CCX_NAL_TYPE_END_OF_STREAM = 11,
+	CCX_NAL_TYPE_FILLER_DATA = 12,
+	CCX_NAL_TYPE_SEQUENCE_PARAMETER_SET_EXTENSION = 13,
+	CCX_NAL_TYPE_PREFIX_NAL_UNIT = 14,
+	CCX_NAL_TYPE_SUBSET_SEQUENCE_PARAMETER_SET = 15,
+	CCX_NAL_TYPE_RESERVED_16 = 16,
+	CCX_NAL_TYPE_RESERVED_17 = 18,
+	CCX_NAL_TYPE_RESERVED_18 = 18,
+	CCX_NAL_TYPE_CODED_SLICE_AUXILIARY_PICTURE = 19,
+	CCX_NAL_TYPE_CODED_SLICE_EXTENSION = 20,
+	CCX_NAL_TYPE_RESERVED_21 = 21,
+	CCX_NAL_TYPE_RESERVED_22 = 22,
+	CCX_NAL_TYPE_RESERVED_23 = 23,
+	CCX_NAL_TYPE_UNSPECIFIED_24 = 24,
+	CCX_NAL_TYPE_UNSPECIFIED_25 = 25,
+	CCX_NAL_TYPE_UNSPECIFIED_26 = 26,
+	CCX_NAL_TYPE_UNSPECIFIED_27 = 27,
+	CCX_NAL_TYPE_UNSPECIFIED_28 = 28,
+	CCX_NAL_TYPE_UNSPECIFIED_29 = 29,
+	CCX_NAL_TYPE_UNSPECIFIED_30 = 30,
+	CCX_NAL_TYPE_UNSPECIFIED_31 = 31
+};
+
+// MPEG-2 TS stream types
+enum ccx_stream_type
+{
+	CCX_STREAM_TYPE_UNKNOWNSTREAM = 0,
+	CCX_STREAM_TYPE_VIDEO_MPEG1 = 0x01,
+	CCX_STREAM_TYPE_VIDEO_MPEG2 = 0x02,
+	CCX_STREAM_TYPE_AUDIO_MPEG1 = 0x03,
+	CCX_STREAM_TYPE_AUDIO_MPEG2 = 0x04,
+	CCX_STREAM_TYPE_PRIVATE_TABLE_MPEG2 = 0x05,
+	CCX_STREAM_TYPE_PRIVATE_MPEG2 = 0x06,
+	CCX_STREAM_TYPE_MHEG_PACKETS = 0x07,
+	CCX_STREAM_TYPE_MPEG2_ANNEX_A_DSM_CC = 0x08,
+	CCX_STREAM_TYPE_ITU_T_H222_1 = 0x09,
+	CCX_STREAM_TYPE_ISO_IEC_13818_6_TYPE_A = 0x0A,
+	CCX_STREAM_TYPE_ISO_IEC_13818_6_TYPE_B = 0x0B,
+	CCX_STREAM_TYPE_ISO_IEC_13818_6_TYPE_C = 0x0C,
+	CCX_STREAM_TYPE_ISO_IEC_13818_6_TYPE_D = 0x0D,
+	CCX_STREAM_TYPE_AUDIO_AAC   = 0x0f,
+	CCX_STREAM_TYPE_VIDEO_MPEG4 = 0x10,
+	CCX_STREAM_TYPE_VIDEO_H264  = 0x1b,
+	CCX_STREAM_TYPE_PRIVATE_USER_MPEG2=0x80,
+	CCX_STREAM_TYPE_AUDIO_AC3   = 0x81,
+	CCX_STREAM_TYPE_AUDIO_HDMV_DTS = 0x82,
+	CCX_STREAM_TYPE_AUDIO_DTS   = 0x8a,
+};
+
+enum ccx_mpeg_descriptor
+{
+	CCX_MPEG_DSC_REGISTRATION = 0x05,
+	CCX_MPEG_DSC_DATA_STREAM_ALIGNMENT = 0x06,
+	CCX_MPEG_DSC_ISO639_LANGUAGE = 0x0A,
+	CCX_MPEG_DSC_VBI_DATA_DESCRIPTOR = 0x45,
+	CCX_MPEG_DSC_VBI_TELETEXT_DESCRIPTOR = 0x46,
+	CCX_MPEG_DSC_TELETEXT_DESCRIPTOR = 0x56,
+	CCX_MPEG_DSC_DVB_SUBTITLE = 0x59,
+	CCX_MPEG_DSC_CAPTION_SERVICE = 0x86,
+	CCX_MPEG_DESC_DATA_COMP = 0xfd,
+};
+
+
+enum
+{
+	CCX_MESSAGES_QUIET = 0,
+	CCX_MESSAGES_STDOUT =1,
+	CCX_MESSAGES_STDERR =2
+};
+
+enum ccx_datasource
+{
+	CCX_DS_FILE=0,
+	CCX_DS_STDIN=1,
+	CCX_DS_NETWORK=2,
+	CCX_DS_TCP=3
+};
+
+enum ccx_output_format
+{
+	CCX_OF_RAW	= 0,
+	CCX_OF_SRT	= 1,
+#ifndef MMCCXTR
+	CCX_OF_SAMI = 2,
+	CCX_OF_TRANSCRIPT = 3,
+	CCX_OF_RCWT = 4,
+#endif
+	CCX_OF_NULL = 5,
+#ifndef MMCCXTR
+	CCX_OF_SMPTETT = 6,
+	CCX_OF_SPUPNG = 7,
+	CCX_OF_DVDRAW = 8, // See -d at http://www.theneitherworld.com/mcpoodle/SCC_TOOLS/DOCS/SCC_TOOLS.HTML#CCExtract
+	CCX_OF_WEBVTT = 9,
+	CCX_OF_SIMPLE_XML = 10,
+	CCX_OF_G608 = 11,
+#endif
+	CCX_OF_CURL = 12,
+#ifndef MMCCXTR
+	CCX_OF_SSA = 13,
+#endif
+};
+
+enum ccx_output_date_format
+{
+	ODF_NONE = 0,
+	ODF_HHMMSS = 1,
+	ODF_SECONDS = 2,
+	ODF_DATE =3,
+	ODF_HHMMSSMS = 4,    // HH:MM:SS,MILIS (.srt style)
+};
+
+enum ccx_stream_mode_enum
+{
+	CCX_SM_ELEMENTARY_OR_NOT_FOUND=0,
+#ifndef MMCCXTR
+	CCX_SM_TRANSPORT=1,
+	CCX_SM_PROGRAM=2,
+	CCX_SM_ASF=3,
+	CCX_SM_MCPOODLESRAW = 4,
+#endif
+	CCX_SM_RCWT = 5,     // Raw Captions With Time, not used yet.
+#ifndef MMCCXTR
+	CCX_SM_MYTH = 6,     // Use the myth loop
+	CCX_SM_MP4 = 7,      // MP4, ISO-
+#ifdef WTV_DEBUG
+	CCX_SM_HEX_DUMP = 8, // Hexadecimal dump generated by wtvccdump
+#endif
+	CCX_SM_WTV = 9,
+#ifdef ENABLE_FFMPEG
+	CCX_SM_FFMPEG = 10,
+#endif
+	CCX_SM_GXF = 11,
+	CCX_SM_MKV = 12,
+	CCX_SM_MXF = 13,
+#endif
+
+	CCX_SM_AUTODETECT = 16
+};
+
+enum ccx_encoding_type
+{
+	CCX_ENC_UNICODE = 0,
+	CCX_ENC_LATIN_1 = 1,
+	CCX_ENC_UTF_8 = 2,
+	CCX_ENC_ASCII = 3
+};
+
+enum ccx_bufferdata_type
+{
+	CCX_UNKNOWN = 0,
+	CCX_PES = 1,
+	CCX_RAW = 2,
+	CCX_H264 = 3,
+	CCX_HAUPPAGE = 4,
+	CCX_TELETEXT = 5,
+	CCX_PRIVATE_MPEG2_CC = 6,
+	CCX_DVB_SUBTITLE = 7,
+	CCX_ISDB_SUBTITLE = 8,
+	/* BUffer where cc data contain 3 byte cc_valid ccdata 1 ccdata 2 */
+	CCX_RAW_TYPE = 9,
+	CCX_DVD_SUBTITLE =10,
+};
+
+enum ccx_frame_type
+{
+	CCX_FRAME_TYPE_RESET_OR_UNKNOWN = 0,
+	CCX_FRAME_TYPE_I_FRAME = 1,
+	CCX_FRAME_TYPE_P_FRAME = 2,
+	CCX_FRAME_TYPE_B_FRAME = 3,
+	CCX_FRAME_TYPE_D_FRAME = 4
+};
+
+typedef enum {
+	YES = 1,
+	NO = 0,
+	UNDEFINED = 0xff
+} bool_t;
+
+enum ccx_code_type
+{
+	CCX_CODEC_ANY,
+	CCX_CODEC_TELETEXT,
+	CCX_CODEC_DVB,
+	CCX_CODEC_ISDB_CC,
+	CCX_CODEC_ATSC_CC,
+	CCX_CODEC_NONE,
+};
+
+enum cdp_section_type
+{
+	CDP_SECTION_DATA = 0x72,
+	CDP_SECTION_SVC_INFO = 0x73,
+	CDP_SECTION_FOOTER = 0x74
+};
+
+/*
+ * This Macro check whether descriptor tag is valid for teletext
+ * codec or not.
+ *
+ * @param desc descriptor tag given for each stream
+ *
+ * @return if descriptor tag is valid then it return 1 otherwise 0
+ *
+ */
+
+#define IS_VALID_TELETEXT_DESC(desc) ( ((desc) == CCX_MPEG_DSC_VBI_DATA_DESCRIPTOR )|| \
+		( (desc) == CCX_MPEG_DSC_VBI_TELETEXT_DESCRIPTOR ) || \
+		( (desc) == CCX_MPEG_DSC_TELETEXT_DESCRIPTOR ) )
+
+/*
+ * This  macro to be used when you want to find out whether you
+ * should parse f_sel subtitle codec type or not
+ *
+ * @param u_sel pass the codec selected by user to be searched in
+ *  all elementary stream, we ignore the not to be selected stream
+ *  if we find stream this is selected stream. since setting
+ *  selected stream and not selected to same codec does not
+ *  make ay sense.
+ *
+ * @param u_nsel pass the codec selected by user not to be parsed
+ *               we give false value if f_sel is equal to n_sel
+ *               and vice versa true if ...
+ *
+ * @param f_sel pass the codec name whom you are testing to be feasible
+ *              to parse.
+ */
+#define IS_FEASIBLE(u_sel,u_nsel,f_sel) ( ( (u_sel) == CCX_CODEC_ANY && (u_nsel) != (f_sel) ) || (u_sel) == (f_sel) )
+#define CCX_TXT_FORBIDDEN		0 // Ignore teletext packets
+#define CCX_TXT_AUTO_NOT_YET_FOUND	1
+#define CCX_TXT_IN_USE			2 // Positive auto-detected, or forced, etc
+
+#define NB_LANGUAGE 100
+extern const char *language[NB_LANGUAGE];
+
+#define DEF_VAL_STARTCREDITSNOTBEFORE 	"0"
+// To catch the theme after the teaser in TV shows
+#define DEF_VAL_STARTCREDITSNOTAFTER	"5:00"
+#define DEF_VAL_STARTCREDITSFORATLEAST	"2"
+#define DEF_VAL_STARTCREDITSFORATMOST	"5"
+#define DEF_VAL_ENDCREDITSFORATLEAST	"2"
+#define DEF_VAL_ENDCREDITSFORATMOST	"5"
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_option.c Added

@@ -0,0 +1,184 @@
+#include "ccx_common_option.h"
+#include "ccx_encoders_common.h"
+#include "ccx_decoders_708.h"
+#include "utility.h"
+
+extern ccx_encoders_transcript_format ccx_encoders_default_transcript_settings;
+/* Parameters */
+void init_options (struct ccx_s_options *options)
+{
+#ifdef _WIN32
+	options->buffer_input = 1; // In Windows buffering seems to help
+#else
+	options->buffer_input = 0; // In Linux, not so much.
+#endif
+	options->nofontcolor=0; // 1 = don't put <font color> tags
+	options->notypesetting=0; // 1 = Don't put <i>, <u>, etc typesetting tags
+	options->no_rollup = 0;
+	options->noscte20 = 0;
+
+
+	options->settings_608.direct_rollup = 0;
+	options->settings_608.no_rollup = 0;
+	options->settings_608.force_rollup = 0;
+	options->settings_608.screens_to_process = -1;
+	options->settings_608.default_color = COL_TRANSPARENT; // Defaults to transparent/no-color.
+
+	options->extract = 1; // Extract 1st field only (primary language)
+	options->cc_channel = 1; // Channel we want to dump in srt mode
+	options->binary_concat=1; // Disabled by -ve or --videoedited
+	options->use_gop_as_pts = 0; // Use GOP instead of PTS timing (0=do as needed, 1=always, -1=never)
+	options->fix_padding = 0; // Replace 0000 with 8080 in HDTV (needed for some cards)
+	options->gui_mode_reports=0; // If 1, output in stderr progress updates so the GUI can grab them
+	options->no_progress_bar=0; // If 1, suppress the output of the progress to stdout
+	options->enc_cfg.sentence_cap =0 ; // FIX CASE? = Fix case?
+	options->enc_cfg.splitbysentence = 0; // Split text into complete sentences and prorate time?
+	options->enc_cfg.nospupngocr = 0;
+	options->sentence_cap_file=NULL; // Extra words file?
+	options->live_stream=0; // 0 -> A regular file
+	options->messages_target=1; // 1=stdout
+	options->print_file_reports=0;
+	/* Levenshtein's parameters, for string comparison */
+	options->dolevdist = 1; // By default attempt to correct typos
+	options->levdistmincnt=2; // Means 2 fails or less is "the same"...
+	options->levdistmaxpct=10; // ...10% or less is also "the same"
+	options->investigate_packets = 0; // Look for captions in all packets when everything else fails
+	options->fullbin=0; // Disable pruning of padding cc blocks
+	options->nosync=0; // Disable syncing
+	options->hauppauge_mode=0; // If 1, use PID=1003, process specially and so on
+	options->wtvconvertfix = 0; // Fix broken Windows 7 conversion
+	options->wtvmpeg2 = 0;
+	options->auto_myth = 2; // 2=auto
+	/* MP4 related stuff */
+	options->mp4vidtrack=0; // Process the video track even if a CC dedicated track exists.
+	options->extract_chapters=0; // By default don't extract chapters.
+	/* General stuff */
+	options->usepicorder = 0; // Force the use of pic_order_cnt_lsb in AVC/H.264 data streams
+	options->xmltv=0; // 1 = full output. 2 = live output. 3 = both
+	options->xmltvliveinterval=10; // interval in seconds between writing xmltv output files in live mode
+	options->xmltvoutputinterval=0; // interval in seconds between writing xmltv full file output
+	options->xmltvonlycurrent=0; // 0 off 1 on
+	options->keep_output_closed = 0; // By default just keep the file open.
+	options->force_flush = 0; // Don't flush whenever content is written.
+	options->append_mode = 0; //By default, files are overwritten.
+	options->ucla = 0; // By default, -UCLA not used
+	options->tickertext = 0; // By default, do not assume ticker style text
+	options->hardsubx = 0; // By default, don't try to extract hard subtitles
+	options->dvblang = NULL; // By default, autodetect DVB language
+	options->ocrlang = NULL; // By default, autodetect .traineddata file
+	options->ocr_oem = 0; // By default, set Tesseract OEM mode OEM_TESSERACT_ONLY (0)
+	options->ocr_quantmode = 1; // CCExtractor's internal
+	options->mkvlang = NULL; // By default, all the languages are extracted 
+	options->ignore_pts_jumps = 1;
+	options->analyze_video_stream = 0;
+
+	/*HardsubX related stuff*/
+	options->hardsubx_ocr_mode = 0;
+	options->hardsubx_subcolor = 0;
+	options->hardsubx_min_sub_duration = 0.5;
+	options->hardsubx_detect_italics = 0;
+	options->hardsubx_conf_thresh = 0.0;
+	options->hardsubx_hue = 0.0;
+	options->hardsubx_lum_thresh = 95.0;
+
+#ifndef MMCCXTR
+	options->transcript_settings = ccx_encoders_default_transcript_settings;
+#endif
+	options->millis_separator=',';
+
+	options->write_format=CCX_OF_SRT; // 0=Raw, 1=srt, 2=SMI
+	options->date_format=ODF_NONE;
+	options->output_filename = NULL;
+	options->debug_mask=CCX_DMT_GENERIC_NOTICES; // dbg_print will use this mask to print or ignore different types
+	options->debug_mask_on_debug=CCX_DMT_VERBOSE; // If we're using temp_debug to enable/disable debug "live", this is the mask when temp_debug=1
+	/* Networking */
+	options->udpsrc = NULL;
+	options->udpaddr = NULL;
+	options->udpport=0; // Non-zero => Listen for UDP packets on this port, no files.
+	options->send_to_srv = 0;
+	options->tcpport = NULL;
+	options->tcp_password = NULL;
+	options->tcp_desc = NULL;
+	options->srv_addr = NULL;
+	options->srv_port = NULL;
+	options->noautotimeref=0; // Do NOT set time automatically?
+	options->input_source=CCX_DS_FILE; // Files, stdin or network
+	options->multiprogram = 0;
+	options->out_interval = -1;
+	options->segment_on_key_frames_only = 0;
+
+	options->subs_delay = 0;
+
+	/* Select subtitle codec */
+	options->demux_cfg.codec = CCX_CODEC_ANY;
+	options->demux_cfg.nocodec = CCX_CODEC_NONE;
+
+	options->demux_cfg.auto_stream = CCX_SM_AUTODETECT;
+	options->demux_cfg.m2ts = 0;
+	options->demux_cfg.out_elementarystream_filename=NULL;
+#ifndef MMCCXTR
+	options->demux_cfg.ts_autoprogram =0; // Try to find a stream with captions automatically (no -pn needed)
+	options->demux_cfg.ts_cappids[0] = 0; // PID for stream that holds caption information
+	options->demux_cfg.nb_ts_cappid = 0;
+	options->demux_cfg.ts_forced_program = -1; // Specific program to process in TS files, if ts_forced_program_selected==1
+	options->demux_cfg.ts_forced_program_selected=0;
+	options->demux_cfg.ts_datastreamtype = CCX_STREAM_TYPE_UNKNOWNSTREAM; // User WANTED stream type (i.e. use the stream that has this type)
+	options->demux_cfg.ts_forced_streamtype=CCX_STREAM_TYPE_UNKNOWNSTREAM; // User selected (forced) stream type
+#endif
+
+	options->enc_cfg.autodash=0; // Add dashes (-) before each speaker automatically?
+	options->enc_cfg.trim_subs=0; // "	Remove spaces at sides?	"
+	options->enc_cfg.in_format = 1;
+	options->enc_cfg.line_terminator_lf=0; // 0 = CRLF
+	options->enc_cfg.start_credits_text=NULL;
+	options->enc_cfg.end_credits_text=NULL;
+	options->enc_cfg.encoding = CCX_ENC_UTF_8;
+	options->enc_cfg.no_bom = 0; // Use BOM by default.
+	options->enc_cfg.services_charsets = NULL;
+	options->enc_cfg.all_services_charset = NULL;
+	options->enc_cfg.with_semaphore = 0;
+
+	options->settings_dtvcc.enabled = 0;
+	options->settings_dtvcc.active_services_count = 0;
+	options->settings_dtvcc.print_file_reports = 1;
+	options->settings_dtvcc.no_rollup = 0;
+	options->settings_dtvcc.report = NULL;
+	memset(options->settings_dtvcc.services_enabled, 0, CCX_DTVCC_MAX_SERVICES);
+
+#ifdef ENABLE_SHARING
+	options->sharing_enabled = 0;
+	options->sharing_url = NULL;
+	options->translate_enabled = 0;
+	options->translate_key = NULL;
+	options->translate_langs = NULL;
+#endif //ENABLE_SHARING
+#ifdef WITH_LIBCURL
+	options->curlposturl = NULL;
+#endif
+
+	// Prepare time structures
+	init_boundary_time (&options->extraction_start);
+	init_boundary_time (&options->extraction_end);
+
+	/* Credit stuff */
+	init_boundary_time (&options->enc_cfg.startcreditsnotbefore);
+	init_boundary_time (&options->enc_cfg.startcreditsnotafter);
+	init_boundary_time (&options->enc_cfg.startcreditsforatleast);
+	init_boundary_time (&options->enc_cfg.startcreditsforatmost);
+	init_boundary_time (&options->enc_cfg.endcreditsforatleast);
+	init_boundary_time (&options->enc_cfg.endcreditsforatmost);
+
+
+	// Sensible default values for credits
+	stringztoms (DEF_VAL_STARTCREDITSNOTBEFORE, &options->enc_cfg.startcreditsnotbefore);
+	stringztoms (DEF_VAL_STARTCREDITSNOTAFTER, &options->enc_cfg.startcreditsnotafter);
+	stringztoms (DEF_VAL_STARTCREDITSFORATLEAST, &options->enc_cfg.startcreditsforatleast);
+	stringztoms (DEF_VAL_STARTCREDITSFORATMOST, &options->enc_cfg.startcreditsforatmost);
+	stringztoms (DEF_VAL_ENDCREDITSFORATLEAST, &options->enc_cfg.endcreditsforatleast);
+	stringztoms (DEF_VAL_ENDCREDITSFORATMOST, &options->enc_cfg.endcreditsforatmost);
+
+#ifdef PYTHON_API
+    options->python_param_count = 0;
+    options->python_params = malloc(options->python_param_count * sizeof *options->python_params);
+#endif
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_option.h Added

@@ -0,0 +1,212 @@
+#ifndef CCX_COMMON_OPTION_H
+#define CCX_COMMON_OPTION_H
+
+#include "ccx_common_timing.h"
+#include "ccx_decoders_608.h"
+#include "ccx_encoders_structs.h"
+#include "list.h"
+
+struct demuxer_cfg
+{
+	int m2ts; // Regular TS or M2TS
+	enum ccx_stream_mode_enum auto_stream;
+	char *out_elementarystream_filename;
+
+	/* subtitle codec type */
+	enum ccx_code_type codec;
+	enum ccx_code_type nocodec;
+
+#ifndef MMCCXTR
+	unsigned ts_autoprogram;       // Try to find a stream with captions automatically (no -pn needed)
+	unsigned ts_allprogram;
+	unsigned ts_cappids[128];      // PID for stream that holds caption information
+	int nb_ts_cappid;
+	unsigned ts_forced_cappid ;    // If 1, never mess with the selected PID
+	int ts_forced_program;         // Specific program to process in TS files, if ts_forced_program_selected==1
+	unsigned ts_forced_program_selected;
+	int ts_datastreamtype ;        // User WANTED stream type (i.e. use the stream that has this type)
+	unsigned ts_forced_streamtype; // User selected (forced) stream type
+#endif
+};
+
+struct encoder_cfg
+{
+	int extract;                         // Extract 1st, 2nd or both fields
+	int dtvcc_extract;                   // 1 or 0
+	int gui_mode_reports;                // If 1, output in stderr progress updates so the GUI can grab them
+	char *output_filename;
+	enum ccx_output_format write_format; // 0=Raw, 1=srt, 2=SMI
+	int keep_output_closed;
+	int force_flush;                     // Force flush on content write
+	int append_mode;                     // Append mode for output files
+	int ucla;                            // 1 if -UCLA used, 0 if not
+
+	enum ccx_encoding_type encoding;
+	enum ccx_output_date_format date_format;
+	char millis_separator;
+	int autodash;        // Add dashes (-) before each speaker automatically?
+	int trim_subs;       // "    Remove spaces at sides?    "
+	int sentence_cap ;   // FIX CASE? = Fix case?
+	int splitbysentence; // Split text into complete sentences and prorate time?
+#ifdef WITH_LIBCURL
+	char *curlposturl;   // If out=curl, where do we send the data to?
+#endif
+
+	int with_semaphore; // Write a .sem file on file open and delete it on close?
+	/* Credit stuff */
+	char *start_credits_text;
+	char *end_credits_text;
+	struct ccx_boundary_time startcreditsnotbefore, startcreditsnotafter;   // Where to insert start credits, if possible
+	struct ccx_boundary_time startcreditsforatleast, startcreditsforatmost; // How long to display them?
+	struct ccx_boundary_time endcreditsforatleast, endcreditsforatmost;
+
+	ccx_encoders_transcript_format transcript_settings; // Keeps the settings for generating transcript output files.
+	unsigned int send_to_srv;
+	int no_bom;                                         // Set to 1 when no BOM (Byte Order Mark) should be used for files. Note, this might make files unreadable in windows!
+	char *first_input_file;
+	int multiple_files;
+	int no_font_color;
+	int no_type_setting;
+	int cc_to_stdout;                                   // If this is set to 1, the stdout will be flushed when data was written to the screen during a process_608 call.
+	int line_terminator_lf;                             // 0 = CRLF, 1=LF
+	LLONG subs_delay;                                   // ms to delay (or advance) subs
+	int program_number;
+	unsigned char in_format;
+	int nospupngocr;				                    // 1 if we don't want to OCR bitmaps to add the text as comments in the XML file in spupng
+	
+	// text -> png (text render)
+	char *render_font;                                  // The font used to render text if needed (e.g. teletext->spupng)
+
+	//CEA-708
+	int services_enabled[CCX_DTVCC_MAX_SERVICES];
+	char** services_charsets;
+	char* all_services_charset;
+};
+
+struct ccx_s_options // Options from user parameters
+{
+	int extract;                                               // Extract 1st, 2nd or both fields
+	int no_rollup;
+	int noscte20;
+	int webvtt_create_css;
+	int cc_channel;                                            // Channel we want to dump in srt mode
+	int buffer_input;
+	int nofontcolor;
+	int nohtmlescape;
+	int notypesetting;
+	struct ccx_boundary_time extraction_start, extraction_end; // Segment we actually process
+	int print_file_reports;
+
+	ccx_decoder_608_settings settings_608;                     // Contains the settings for the 608 decoder.
+	ccx_decoder_dtvcc_settings settings_dtvcc;                 // Same for 708 decoder
+
+	char millis_separator;
+	int binary_concat;                // Disabled by -ve or --videoedited
+	int use_gop_as_pts;               // Use GOP instead of PTS timing (0=do as needed, 1=always, -1=never)
+	int fix_padding;                  // Replace 0000 with 8080 in HDTV (needed for some cards)
+	int gui_mode_reports;             // If 1, output in stderr progress updates so the GUI can grab them
+	int no_progress_bar;              // If 1, suppress the output of the progress to stdout
+	char *sentence_cap_file;          // Extra words file?
+	int live_stream;                  /* -1 -> Not a complete file but a live stream, without timeout
+                                          0 -> A regular file
+                                         >0 -> Live stream with a timeout of this value in seconds */
+	int messages_target;              // 0 = nowhere (quiet), 1=stdout, 2=stderr
+	/* Levenshtein's parameters, for string comparison */
+	int dolevdist;					  // 0 => don't attempt to correct typos with this algorithm
+	int levdistmincnt, levdistmaxpct; // Means 2 fails or less is "the same", 10% or less is also "the same"
+	int investigate_packets;          // Look for captions in all packets when everything else fails
+	int fullbin;                      // Disable pruning of padding cc blocks
+	int nosync;                       // Disable syncing
+	unsigned int hauppauge_mode;      // If 1, use PID=1003, process specially and so on
+	int wtvconvertfix;                // Fix broken Windows 7 conversion
+	int wtvmpeg2;
+	int auto_myth;                    // Use myth-tv mpeg code? 0=no, 1=yes, 2=auto
+	/* MP4 related stuff */
+	unsigned mp4vidtrack;             // Process the video track even if a CC dedicated track exists.
+	int extract_chapters;		  // If 1, extracts chapters (if present), from MP4 files.
+	/* General settings */
+	int usepicorder;                  // Force the use of pic_order_cnt_lsb in AVC/H.264 data streams
+	int xmltv;                        // 1 = full output. 2 = live output. 3 = both
+	int xmltvliveinterval;            // interval in seconds between writing xmltv output files in live mode
+	int xmltvoutputinterval;          // interval in seconds between writing xmltv full file output
+	int xmltvonlycurrent;             // 0 off 1 on
+	int keep_output_closed;
+	int force_flush;                  // Force flush on content write
+	int append_mode;                  // Append mode for output files
+	int ucla;                         // 1 if UCLA used, 0 if not
+	int tickertext;                   // 1 if ticker text style burned in subs, 0 if not
+	int hardsubx;                     // 1 if burned-in subtitles to be extracted
+	char *dvblang;                    // The name of the language stream for DVB
+	char *ocrlang;                    // The name of the .traineddata file to be loaded with tesseract
+	int ocr_oem;                      // The Tesseract OEM mode, could be 0 (default), 1 or 2
+	int ocr_quantmode;				  // How to quantize the bitmap before passing to to tesseract (0=no quantization at all, 1=CCExtractor's internal)
+	char *mkvlang;                    // The name of the language stream for MKV
+	int analyze_video_stream;         // If 1, the video stream will be processed even if we're using a different one for subtitles.
+
+	/*HardsubX related stuff*/
+	int hardsubx_ocr_mode;
+	int hardsubx_subcolor;
+	float hardsubx_min_sub_duration;
+	int hardsubx_detect_italics;
+	float hardsubx_conf_thresh;
+	float hardsubx_hue;
+	float hardsubx_lum_thresh;
+
+	ccx_encoders_transcript_format transcript_settings; // Keeps the settings for generating transcript output files.
+	enum ccx_output_date_format date_format;
+	unsigned send_to_srv;
+	enum ccx_output_format write_format;                // 0=Raw, 1=srt, 2=SMI
+	int write_format_rewritten;
+	int use_ass_instead_of_ssa;
+	int use_webvtt_styling;
+	LLONG debug_mask;                                   // dbg_print will use this mask to print or ignore different types
+	LLONG debug_mask_on_debug;                          // If we're using temp_debug to enable/disable debug "live", this is the mask when temp_debug=1
+	/* Networking */
+	char *udpsrc;
+	char *udpaddr;
+	unsigned udpport;                                   // Non-zero => Listen for UDP packets on this port, no files.
+	char *tcpport;
+	char *tcp_password;
+	char *tcp_desc;
+	char *srv_addr;
+	char *srv_port;
+	int noautotimeref;                                  // Do NOT set time automatically?
+	enum ccx_datasource input_source;                   // Files, stdin or network
+
+	char *output_filename;
+
+	char **inputfile;                                   // List of files to process
+	int num_input_files;                                // How many?
+	struct demuxer_cfg demux_cfg;
+	struct encoder_cfg enc_cfg;
+	LLONG subs_delay;                                   // ms to delay (or advance) subs
+	int cc_to_stdout;                                   // If this is set to 1, the stdout will be flushed when data was written to the screen during a process_608 call.
+	int pes_header_to_stdout;                           // If this is set to 1, the PES Header will be printed to console (debugging purposes)
+	int ignore_pts_jumps;                               // If 1, the program will ignore PTS jumps. Sometimes this parameter is required for DVB subs with > 30s pause time
+	int multiprogram;
+	int out_interval;
+	int segment_on_key_frames_only;
+#ifdef WITH_LIBCURL
+	char *curlposturl;
+#endif
+
+
+#ifdef ENABLE_SHARING
+	//CC sharing
+	int sharing_enabled;
+	char *sharing_url;
+	//Translating
+	int translate_enabled;
+	char *translate_langs;
+	char *translate_key;
+#endif
+
+#ifdef PYTHON_API
+    char** python_params;                                 // An array of strings to store the params supplied in the python processing
+    int python_param_count;                                 // Count of the total number of params passed via python bindings
+#endif
+};
+
+extern struct ccx_s_options ccx_options;
+void init_options (struct ccx_s_options *options);
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_platform.h Added

@@ -0,0 +1,136 @@
+#ifndef CCX_PLATFORM_H
+	#define CCX_PLATFORM_H
+
+	// Default includes (cross-platform)
+	#include <stdio.h>
+	#include <stdlib.h>
+	#include <string.h>
+	#include <ctype.h>
+	#include <time.h>
+	#include <fcntl.h>
+	#include <stdarg.h>
+	#include <errno.h>
+
+#ifdef MMCCXTR
+	#include <stdint.h>
+	#define __STDC_LIMIT_MACROS
+	#include <inttypes.h>
+	#ifndef PRIu8
+	#define PRIu8 "%u"
+	#endif
+	#ifndef PRIu16
+	#define PRIu16 "%u"
+	#endif
+#endif
+
+	#define __STDC_FORMAT_MACROS
+
+	#ifdef _WIN32
+		#define inline _inline
+		#define typeof decltype
+		#include <io.h>
+		#include <ws2tcpip.h>
+		#include <windows.h>
+		#define STDIN_FILENO 0
+		#define STDOUT_FILENO 1
+		#define STDERR_FILENO 2
+#ifndef MMCCXTR
+		#include "inttypes.h"
+		#define UINT64_MAX   _UI64_MAX
+		typedef int socklen_t;
+		typedef int ssize_t;
+		typedef uint32_t in_addr_t;
+		#ifndef IN_CLASSD
+			#define IN_CLASSD(i)       (((INT32)(i) & 0xf0000000) == 0xe0000000)
+			#define IN_MULTICAST(i)    IN_CLASSD(i)
+		#endif
+		#include <direct.h>
+		#define mkdir(path, mode) _mkdir(path)
+#endif
+		#ifndef snprintf
+			// Added ifndef because VS2013 warns for macro redefinition.
+			#define snprintf(buf, len, fmt, ...) _snprintf(buf, len, fmt, __VA_ARGS__)
+		#endif
+		#define sleep(sec) Sleep((sec) * 1000)
+
+		#include <fcntl.h>
+	#else // _WIN32
+		#include <unistd.h>
+		#define __STDC_LIMIT_MACROS
+		#include <inttypes.h>
+		#include <stdint.h>
+		#include <sys/socket.h>
+		#include <netinet/in.h>
+		#include <arpa/inet.h>
+		#include <netdb.h>
+		#include <sys/stat.h>
+		#include <sys/types.h>
+                #define __cdecl
+	#endif // _WIN32
+
+#ifndef MMCCXTR
+	#include "disable_warnings.h"
+
+	#ifdef _MSC_VER
+		#include "stdintmsc.h"
+		// Don't bug me with strcpy() deprecation warnings
+		#pragma warning(disable : 4996)
+	#else
+		#include <stdint.h>
+	#endif
+#endif
+
+	#ifdef __OpenBSD__
+		#define FOPEN64 fopen
+		#define OPEN open
+		#define FSEEK fseek
+		#define FTELL ftell
+		#define LSEEK lseek
+		#define FSTAT fstat
+	#else
+		#ifdef _WIN32
+			#define OPEN _open
+			// 64 bit file functions
+			#if defined(_MSC_VER)
+				#define FSEEK _fseeki64
+				#define FTELL _ftelli64
+			#else
+				// For MinGW
+				#define FSEEK fseeko64
+				#define FTELL ftello64
+			#endif
+			#define TELL _telli64
+			#define LSEEK _lseeki64
+			typedef struct _stati64 FSTATSTRUCT;
+		#else
+			// Linux internally maps these functions to 64bit usage,
+			// if _FILE_OFFSET_BITS macro is set to 64
+			#define FOPEN64 fopen
+			#define OPEN open
+			#define LSEEK lseek
+			#define FSEEK fseek
+			#define FTELL ftell
+			#define FSTAT fstat
+			#define TELL tell
+			#include <stdint.h>
+			#endif
+	#endif
+
+	#ifndef int64_t_C
+		#define int64_t_C(c)     (c ## LL)
+		#define uint64_t_C(c)    (c ## ULL)
+	#endif
+
+	#ifndef O_BINARY
+		#define O_BINARY 0  // Not present in Linux because it's always binary
+	#endif
+
+	#ifndef max
+		#define max(a,b) (((a) > (b)) ? (a) : (b))
+	#endif
+
+	typedef int64_t LLONG;
+	typedef uint64_t ULLONG;
+	typedef uint8_t UBYTE;
+
+#endif // CCX_PLATFORM_H

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_structs.h Added

@@ -0,0 +1,81 @@
+#ifndef _CC_COMMON_STRUCTS
+#define _CC_COMMON_STRUCTS
+
+#include "ccx_common_constants.h"
+
+enum ccx_common_logging_gui {
+	CCX_COMMON_LOGGING_GUI_XDS_PROGRAM_NAME,        // Called with xds_program_name
+	CCX_COMMON_LOGGING_GUI_XDS_PROGRAM_ID_NR,       // Called with current_xds_min, current_xds_hour, current_xds_date, current_xds_month
+	CCX_COMMON_LOGGING_GUI_XDS_PROGRAM_DESCRIPTION, // Called with line_num, xds_desc
+	CCX_COMMON_LOGGING_GUI_XDS_CALL_LETTERS         // Called with current_xds_call_letters
+};
+
+struct ccx_common_logging_t {
+	LLONG debug_mask;                                              // The debug mask that is used to determine if things should be printed or not.
+	void(*fatal_ftn) (int exit_code, const char *fmt, ...);        // Used when an unrecoverable error happens. This should log output/save the error and then exit the program.
+	void(*debug_ftn) (LLONG mask, const char *fmt, ...);           // Used to process debug output. Mask can be ignored (custom set by debug_mask).
+	void(*log_ftn)(const char *fmt, ...);                          // Used to print things. Replacement of standard printf, to allow more control.
+	void(*gui_ftn)(enum ccx_common_logging_gui message_type, ...); // Used to display things in a gui (if appropriate). Is called with the message_type and appropriate variables (described in enum)
+};
+extern struct ccx_common_logging_t ccx_common_logging;
+
+enum subdatatype
+{
+	CC_DATATYPE_GENERIC=0,
+	CC_DATATYPE_DVB=1
+};
+
+enum subtype
+{
+	CC_BITMAP,
+	CC_608,
+	CC_708,
+	CC_TEXT,
+	CC_RAW,
+};
+
+/**
+* Raw Subtitle struct used as output of decoder (cc608)
+* and input for encoder (sami, srt, transcript or smptett etc)
+*
+* if subtype CC_BITMAP then data contain nb_data numbers of rectangle
+* which have to be displayed at same time.
+*/
+struct cc_subtitle
+{
+	/**
+	* A generic data which contain data according to decoder
+	* @warn decoder cant output multiple types of data
+	*/
+	void *data;
+	enum subdatatype datatype;
+
+	/** number of data */
+	unsigned int nb_data;
+
+	/**  type of subtitle */
+	enum subtype type;
+
+	/** Encoding type of Text, must be ignored in case of subtype as bitmap or cc_screen*/
+	enum ccx_encoding_type  enc_type;
+
+	/* set only when all the data is to be displayed at same time */
+	LLONG start_time;
+	LLONG end_time;
+
+	/* flags */
+	int flags;
+
+	/* index of language table */
+	int lang_index;
+
+	/** flag to tell that decoder has given output */
+	int got_output;
+	
+	char mode[5];
+	char info[4];
+
+	struct cc_subtitle *next;
+	struct cc_subtitle *prev;
+};
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_timing.c Added

@@ -0,0 +1,379 @@
+#include "ccx_common_timing.h"
+#include "ccx_common_constants.h"
+#include "ccx_common_structs.h"
+#include "ccx_common_common.h"
+
+/* Provide the current time since the file (or the first file) started
+ * in ms using PTS time information.
+ * Requires: frames_since_ref_time, current_tref
+ */
+
+// Count 608 (per field) and 708 blocks since last set_fts() call
+int cb_field1, cb_field2, cb_708;
+
+int MPEG_CLOCK_FREQ = 90000; // This "constant" is part of the standard
+
+int max_dif = 5;
+unsigned pts_big_change;
+
+// PTS timing related stuff
+
+double current_fps = (double) 30000.0 / 1001; /* 29.97 */ // TODO: Get from framerates_values[] instead
+
+int frames_since_ref_time = 0;
+unsigned total_frames_count;
+
+struct gop_time_code gop_time, first_gop_time, printed_gop;
+LLONG fts_at_gop_start = 0;
+int gop_rollover = 0;
+
+struct ccx_common_timing_settings_t ccx_common_timing_settings;
+
+void ccx_common_timing_init(LLONG *file_position,int no_sync)
+{
+	ccx_common_timing_settings.disable_sync_check = 0;
+	ccx_common_timing_settings.is_elementary_stream = 0;
+	ccx_common_timing_settings.file_position = file_position;
+	ccx_common_timing_settings.no_sync = no_sync;
+}
+
+void dinit_timing_ctx(struct ccx_common_timing_ctx **arg)
+{
+	freep(arg);
+}
+struct ccx_common_timing_ctx *init_timing_ctx(struct ccx_common_timing_settings_t *cfg)
+{
+	struct ccx_common_timing_ctx *ctx = malloc(sizeof(struct ccx_common_timing_ctx));
+	if(!ctx)
+		return NULL;
+
+	ctx->pts_set = 0;
+	ctx->current_tref = 0;
+	ctx->current_pts = 0;
+	ctx->current_picture_coding_type = CCX_FRAME_TYPE_RESET_OR_UNKNOWN;
+	ctx->min_pts_adjusted = 0;
+	ctx->min_pts = 0x01FFFFFFFFLL; // 33 bit
+	ctx->max_pts = 0;
+	ctx->sync_pts = 0;
+	ctx->minimum_fts = 0;
+	ctx->sync_pts2fts_set = 0;
+	ctx->sync_pts2fts_fts = 0;
+	ctx->sync_pts2fts_pts = 0;
+
+	ctx->fts_now = 0; // Time stamp of current file (w/ fts_offset, w/o fts_global)
+	ctx->fts_offset = 0; // Time before first sync_pts
+	ctx->fts_fc_offset = 0; // Time before first GOP
+	ctx->fts_max = 0; // Remember the maximum fts that we saw in current file
+	ctx->fts_global = 0; // Duration of previous files (-ve mode), see c1global
+
+	return ctx;
+}
+
+void add_current_pts(struct ccx_common_timing_ctx *ctx, LLONG pts)
+{
+	set_current_pts(ctx, ctx->current_pts + pts);
+}
+
+void set_current_pts(struct ccx_common_timing_ctx *ctx, LLONG pts)
+{
+	ctx->current_pts = pts;
+	if(ctx->pts_set == 0)
+		ctx->pts_set = 1;
+	dbg_print(CCX_DMT_VIDES, "PTS: %s (%8u)", print_mstime_static(ctx->current_pts/(MPEG_CLOCK_FREQ/1000)),
+				(unsigned) (ctx->current_pts));
+	dbg_print(CCX_DMT_VIDES, "  FTS: %s \n",print_mstime_static(ctx->fts_now));
+}
+
+int set_fts(struct ccx_common_timing_ctx *ctx)
+{
+	int pts_jump = 0;
+
+	// ES don't have PTS unless GOP timing is used
+	if (!ctx->pts_set && ccx_common_timing_settings.is_elementary_stream)
+		return CCX_OK;
+
+	// First check for timeline jump (only when min_pts was set (implies sync_pts)).
+	int dif = 0;
+	if (ctx->pts_set == 2)
+	{
+		dif=(int) (ctx->current_pts - ctx->sync_pts)/MPEG_CLOCK_FREQ;
+
+		if (ccx_common_timing_settings.disable_sync_check){
+			// Disables sync check. Used for several input formats.
+			dif = 0;
+		}
+
+		if (dif < -0.2 || dif >= max_dif )
+		{
+			// ATSC specs: More than 3501 ms means missing component
+			ccx_common_logging.log_ftn ("\nWarning: Reference clock has changed abruptly (%d seconds filepos=%lld), attempting to synchronize\n", (int) dif, *ccx_common_timing_settings.file_position);
+			ccx_common_logging.log_ftn ("Last sync PTS value: %lld\n",ctx->sync_pts);
+			ccx_common_logging.log_ftn ("Current PTS value: %lld\n",ctx->current_pts);
+			ccx_common_logging.log_ftn("Note: You can disable this behavior by adding -ignoreptsjumps to the parameters.\n");
+			pts_jump = 1;
+			pts_big_change = 1;
+
+			// Discard the gap if it is not on an I-frame or temporal reference zero.
+			if(ctx->current_tref != 0 && ctx->current_picture_coding_type != CCX_FRAME_TYPE_I_FRAME)
+			{
+				ctx->fts_now = ctx->fts_max;
+				ccx_common_logging.log_ftn ("Change did not occur on first frame - probably a broken GOP\n");
+				return CCX_OK;
+			}
+		}
+	}
+
+	// If min_pts was set just before a rollover we compensate by "roll-oving" it too
+	if (ctx->pts_set == 2 && !ctx->min_pts_adjusted) // min_pts set
+	{
+		// We want to be aware of the upcoming rollover, not after it happened, so we don't take
+		// the 3 most significant bits but the 3 next ones
+		uint64_t min_pts_big_bits = (ctx->min_pts >> 30) & 7; 
+		uint64_t cur_pts_big_bits = (ctx->current_pts >> 30) & 7;
+		if (cur_pts_big_bits == 7 && !min_pts_big_bits)
+		{
+			// Huge difference possibly means the first min_pts was actually just over the boundary
+			// Take the current_pts (smaller, accounting for the rollover) instead
+			ctx->min_pts = ctx->current_pts;
+			ctx->min_pts_adjusted = 1;
+		}
+		else if (cur_pts_big_bits>=1 && cur_pts_big_bits<=6) // Far enough from the boundary
+		{
+			// Prevent the eventual difference with min_pts to make a bad adjustment
+			ctx->min_pts_adjusted = 1;
+		}
+	}
+	// Set min_pts, fts_offset
+	if (ctx->pts_set != 0)
+	{
+		ctx->pts_set = 2;
+
+		// Use this part only the first time min_pts is set. Later treat
+		// it as a reference clock change
+		if (ctx->current_pts < ctx->min_pts && !pts_jump)
+		{
+			// If this is the first GOP, and seq 0 was not encountered yet
+			// we might reset min_pts/fts_offset again
+
+			ctx->min_pts = ctx->current_pts;
+
+			// Avoid next async test
+			ctx->sync_pts = (LLONG)(ctx->current_pts
+					-ctx->current_tref*1000.0/current_fps
+					*(MPEG_CLOCK_FREQ/1000));
+
+			if(ctx->current_tref == 0)
+			{   // Earliest time in GOP.
+				ctx->fts_offset = 0;
+			}
+			else if ( total_frames_count-frames_since_ref_time == 0 )
+			{   // If this is the first frame (PES) there cannot be an offset.
+				// This part is also reached for dvr-ms/NTSC (RAW) as
+				// total_frames_count = frames_since_ref_time = 0 when
+				// this is called for the first time.
+				ctx->fts_offset = 0;
+			}
+			else
+			{   // It needs to be "+1" because the current frame is
+				// not yet counted.
+				ctx->fts_offset = (LLONG)((total_frames_count
+							-frames_since_ref_time+1)
+						*1000.0/current_fps);
+			}
+			ccx_common_logging.debug_ftn(CCX_DMT_TIME, "\nFirst sync time    PTS: %s %+lldms (time before this PTS)\n",
+					print_mstime_static(ctx->min_pts/(MPEG_CLOCK_FREQ/1000)),
+					ctx->fts_offset );
+			ccx_common_logging.debug_ftn(CCX_DMT_TIME, "Total_frames_count %u frames_since_ref_time %u\n",
+					total_frames_count, frames_since_ref_time);
+		}
+
+		// -nosync disables syncing
+		if (pts_jump && !ccx_common_timing_settings.no_sync)
+		{
+			// The current time in the old time base is calculated using
+			// sync_pts (set at the beginning of the last GOP) plus the
+			// time of the frames since then.
+			ctx->fts_offset = ctx->fts_offset
+				+ (ctx->sync_pts - ctx->min_pts)/(MPEG_CLOCK_FREQ/1000)
+				+ (LLONG) (frames_since_ref_time*1000/current_fps);
+			ctx->fts_max = ctx->fts_offset;
+
+			// Start counting again from here
+			ctx->pts_set = 1; // Force min to be set again
+			ctx->sync_pts2fts_set = 0; // Make note of the new conversion values
+
+			// Avoid next async test - the gap might have occured on
+			// current_tref != 0.
+			ctx->sync_pts = (LLONG) (ctx->current_pts
+					-ctx->current_tref*1000.0/current_fps
+					*(MPEG_CLOCK_FREQ/1000));
+			// Set min_pts = sync_pts as this is used for fts_now
+			ctx->min_pts = ctx->sync_pts;
+
+			ccx_common_logging.debug_ftn(CCX_DMT_TIME, "\nNew min PTS time: %s %+lldms (time before this PTS)\n",
+					print_mstime_static(ctx->min_pts/(MPEG_CLOCK_FREQ/1000)),
+					ctx->fts_offset );
+		}
+	}
+
+	// Set sync_pts, fts_offset
+	if(ctx->current_tref == 0)
+		ctx->sync_pts = ctx->current_pts;
+
+	// Reset counters
+	cb_field1 = 0;
+	cb_field2 = 0;
+	cb_708 = 0;
+
+	// Avoid wrong "Calc. difference" and "Asynchronous by" numbers
+	// for uninitialized min_pts
+	if (1) // CFS: Remove or think decent condition
+	{
+		if ( ctx->pts_set )
+		{
+			// If pts_set is TRUE we have min_pts
+			ctx->fts_now = (LLONG)((ctx->current_pts - ctx->min_pts)/(MPEG_CLOCK_FREQ/1000)
+					+ ctx->fts_offset);
+			if (!ctx->sync_pts2fts_set)
+			{
+				ctx->sync_pts2fts_pts = ctx->current_pts;
+				ctx->sync_pts2fts_fts = ctx->fts_now;
+				ctx->sync_pts2fts_set = 1;
+			}
+		}
+		else
+		{
+			// No PTS info at all!!
+			ccx_common_logging.log_ftn("Set PTS called without any global timestamp set\n");
+			return CCX_EINVAL;
+		}
+	}
+	if ( ctx->fts_now > ctx->fts_max )
+	{
+		ctx->fts_max = ctx->fts_now;
+	}
+	return CCX_OK;
+}
+
+
+LLONG get_fts(struct ccx_common_timing_ctx *ctx, int current_field)
+{
+	LLONG fts;
+
+	switch (current_field)
+	{
+		case 1:
+			fts = ctx->fts_now + ctx->fts_global + cb_field1*1001/30;
+			break;
+		case 2:
+			fts = ctx->fts_now + ctx->fts_global + cb_field2*1001/30;
+			break;
+		case 3:
+			fts = ctx->fts_now + ctx->fts_global + cb_708*1001/30;
+			break;
+		default:
+			ccx_common_logging.fatal_ftn(CCX_COMMON_EXIT_BUG_BUG, "get_fts: unhandled branch");
+	}
+//	ccx_common_logging.debug_ftn(CCX_DMT_TIME, "[FTS] "
+//			"fts: %llu, fts_now: %llu, fts_global: %llu, current_field: %llu, cb_708: %llu\n",
+//								 fts, fts_now, fts_global, current_field, cb_708);
+	return fts;
+}
+
+LLONG get_fts_max(struct ccx_common_timing_ctx *ctx)
+{
+	// This returns the maximum FTS that belonged to a frame.  Caption block
+	// counters are not applicable.
+	return ctx->fts_max + ctx->fts_global;
+}
+
+/**
+ * Fill buffer with a time string using specified format
+ * @param fmt has to contain 4 format specifiers for h, m, s and ms respectively
+ */
+size_t print_mstime_buff(LLONG mstime, char* fmt, char* buf){
+	unsigned hh, mm, ss, ms;
+	int signoffset = (mstime < 0 ? 1 : 0);
+
+	if (mstime < 0) // Avoid loss of data warning with abs()
+		mstime = -mstime;
+
+	hh = (unsigned) (mstime / 1000 / 60 / 60);
+	mm = (unsigned) (mstime / 1000 / 60 - 60 * hh);
+	ss = (unsigned) (mstime / 1000 - 60 * (mm + 60 * hh));
+	ms = (unsigned) (mstime - 1000 * (ss + 60 * (mm + 60 * hh)));
+
+	buf[0] = '-';
+
+	return (size_t) sprintf(buf + signoffset, fmt, hh, mm, ss, ms);
+}
+
+/* Fill a static buffer with a time string (hh:mm:ss:ms) corresponding
+   to the microsecond value in mstime. */
+char *print_mstime_static( LLONG mstime )
+{
+	static char buf[15]; // 14 should be long enough
+	print_mstime_buff(mstime, "%02u:%02u:%02u:%03u", buf);
+	return buf;
+}
+
+/* Helper function for to display debug timing info. */
+void print_debug_timing(struct ccx_common_timing_ctx *ctx)
+{
+	// Avoid wrong "Calc. difference" and "Asynchronous by" numbers
+	// for uninitialized min_pts
+	LLONG tempmin_pts = (ctx->min_pts==0x01FFFFFFFFLL ? ctx->sync_pts : ctx->min_pts);
+
+	ccx_common_logging.log_ftn("Sync time stamps:  PTS: %s                ",
+			print_mstime_static((ctx->sync_pts)/(MPEG_CLOCK_FREQ/1000)) );
+	ccx_common_logging.log_ftn("GOP: %s      \n", print_mstime_static(gop_time.ms));
+
+	// Length first GOP to last GOP
+	LLONG goplenms = (LLONG) (gop_time.ms - first_gop_time.ms);
+	// Length at last sync point
+	LLONG ptslenms = (unsigned)((ctx->sync_pts-tempmin_pts)/(MPEG_CLOCK_FREQ/1000)
+			+ ctx->fts_offset);
+
+	ccx_common_logging.log_ftn("Last               FTS: %s",
+			print_mstime_static(get_fts_max(ctx)));
+	ccx_common_logging.log_ftn("      GOP start FTS: %s\n",
+			print_mstime_static(fts_at_gop_start));
+
+	// Times are based on last GOP and/or sync time
+	ccx_common_logging.log_ftn("Max FTS diff. to   PTS:       %6lldms              GOP:       %6lldms\n\n",
+			get_fts_max(ctx)+(LLONG)(1000.0/current_fps)-ptslenms,
+			get_fts_max(ctx)+(LLONG)(1000.0/current_fps)-goplenms);
+}
+
+void calculate_ms_gop_time (struct gop_time_code *g)
+{
+	int seconds=(g->time_code_hours*3600)+(g->time_code_minutes*60)+g->time_code_seconds;
+	g->ms = (LLONG)( 1000*(seconds + g->time_code_pictures/current_fps) );
+	if (gop_rollover)
+		g->ms += 24*60*60*1000;
+}
+
+int gop_accepted(struct gop_time_code* g )
+{
+	if (! ((g->time_code_hours <= 23)
+				&& (g->time_code_minutes <= 59)
+				&& (g->time_code_seconds <= 59)
+				&& (g->time_code_pictures <= 59)))
+		return 0;
+
+	if (gop_time.time_code_hours==23 && gop_time.time_code_minutes==59 &&
+			g->time_code_hours==0 && g->time_code_minutes==0)
+	{
+		gop_rollover = 1;
+		return 1;
+	}
+	if (gop_time.inited)
+	{
+		if (gop_time.ms > g->ms)
+		{
+			// We are going back in time but it's not a complete day rollover
+			return 0;
+		}
+	}
+	return 1;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_common_timing.h Added

@@ -0,0 +1,88 @@
+#ifndef __Timing_H__
+#define __Timing_H__
+
+#include "ccx_common_platform.h"
+#include "ccx_common_constants.h"
+struct gop_time_code
+{
+	int drop_frame_flag;
+	int time_code_hours;
+	int time_code_minutes;
+	int marker_bit;
+	int time_code_seconds;
+	int time_code_pictures;
+	int inited;
+	LLONG ms;
+};
+
+struct ccx_common_timing_settings_t
+{
+	int disable_sync_check;   // If 1, timeline jumps will be ignored. This is important in several input formats that are assumed to have correct timing, no matter what.
+	int no_sync;              // If 1, there will be no sync at all. Mostly useful for debugging.
+	int is_elementary_stream; // Needs to be set, as it's used in set_fts.
+	LLONG *file_position;     // The position of the file
+};
+extern struct ccx_common_timing_settings_t ccx_common_timing_settings;
+
+struct ccx_boundary_time
+{
+	int hh,mm,ss;
+	LLONG time_in_ms;
+	int set;
+};
+
+struct ccx_common_timing_ctx
+{
+	int pts_set;          // 0 = No, 1 = received, 2 = min_pts set
+	int min_pts_adjusted; // 0 = No, 1=Yes (don't adjust again)
+	LLONG current_pts;
+	enum ccx_frame_type current_picture_coding_type;
+	int current_tref;     // Store temporal reference of current frame
+	LLONG min_pts;
+	LLONG max_pts;
+	LLONG sync_pts;
+	LLONG minimum_fts;    // No screen should start before this FTS
+	LLONG fts_now;        // Time stamp of current file (w/ fts_offset, w/o fts_global)
+	LLONG fts_offset;     // Time before first sync_pts
+	LLONG fts_fc_offset;  // Time before first GOP
+	LLONG fts_max;        // Remember the maximum fts that we saw in current file
+	LLONG fts_global;     // Duration of previous files (-ve mode)
+	int sync_pts2fts_set; // 0 = No, 1 = Yes
+	LLONG sync_pts2fts_fts;
+	LLONG sync_pts2fts_pts;
+};
+// Count 608 (per field) and 708 blocks since last set_fts() call
+extern int cb_field1, cb_field2, cb_708;
+
+extern int MPEG_CLOCK_FREQ; // This is part of the standard
+
+extern int max_dif;
+extern unsigned pts_big_change;
+
+
+extern enum ccx_frame_type current_picture_coding_type;
+extern double current_fps;
+extern int frames_since_ref_time;
+extern unsigned total_frames_count;
+
+extern struct gop_time_code gop_time, first_gop_time, printed_gop;
+extern LLONG fts_at_gop_start;
+extern int gop_rollover;
+
+void ccx_common_timing_init(LLONG *file_position, int no_sync);
+
+void dinit_timing_ctx(struct ccx_common_timing_ctx **arg);
+struct ccx_common_timing_ctx *init_timing_ctx(struct ccx_common_timing_settings_t *cfg);
+
+void set_current_pts(struct ccx_common_timing_ctx *ctx, LLONG pts);
+void add_current_pts(struct ccx_common_timing_ctx *ctx, LLONG pts);
+int set_fts(struct ccx_common_timing_ctx *ctx);
+LLONG get_fts(struct ccx_common_timing_ctx *ctx, int current_field);
+LLONG get_fts_max(struct ccx_common_timing_ctx *ctx);
+char *print_mstime_static(LLONG mstime);
+size_t print_mstime_buff(LLONG mstime, char *fmt, char *buf);
+void print_debug_timing(struct ccx_common_timing_ctx *ctx);
+int gop_accepted(struct gop_time_code* g);
+void calculate_ms_gop_time(struct gop_time_code *g);
+
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_decoders_608.c Added

@@ -0,0 +1,1291 @@
+#include "ccx_decoders_608.h"
+#include "ccx_common_common.h"
+#include "ccx_common_structs.h"
+#include "ccx_common_constants.h"
+#include "ccx_common_timing.h"
+#include "ccx_decoders_structs.h"
+#ifndef MMCCXTR
+#include "ccx_decoders_xds.h"
+#endif
+#include "ccx_decoders_common.h"
+
+static const int rowdata[] = {11,-1,1,2,3,4,12,13,14,15,5,6,7,8,9,10};
+// Relationship between the first PAC byte and the row number
+
+#ifndef MMCCXTR
+int in_xds_mode=0;
+#endif
+
+//unsigned char str[2048]; // Another generic general purpose buffer
+
+const unsigned char pac2_attribs[][3] = // Color, font, ident
+{
+	{ COL_WHITE, FONT_REGULAR, 0 },  // 0x40 || 0x60
+	{ COL_WHITE, FONT_UNDERLINED, 0 },  // 0x41 || 0x61
+	{ COL_GREEN, FONT_REGULAR, 0 },  // 0x42 || 0x62
+	{ COL_GREEN, FONT_UNDERLINED, 0 },  // 0x43 || 0x63
+	{ COL_BLUE, FONT_REGULAR, 0 },  // 0x44 || 0x64
+	{ COL_BLUE, FONT_UNDERLINED, 0 },  // 0x45 || 0x65
+	{ COL_CYAN, FONT_REGULAR, 0 },  // 0x46 || 0x66
+	{ COL_CYAN, FONT_UNDERLINED, 0 },  // 0x47 || 0x67
+	{ COL_RED, FONT_REGULAR, 0 },  // 0x48 || 0x68
+	{ COL_RED, FONT_UNDERLINED, 0 },  // 0x49 || 0x69
+	{ COL_YELLOW, FONT_REGULAR, 0 },  // 0x4a || 0x6a
+	{ COL_YELLOW, FONT_UNDERLINED, 0 },  // 0x4b || 0x6b
+	{ COL_MAGENTA, FONT_REGULAR, 0 },  // 0x4c || 0x6c
+	{ COL_MAGENTA, FONT_UNDERLINED, 0 },  // 0x4d || 0x6d
+	{ COL_WHITE, FONT_ITALICS, 0 },  // 0x4e || 0x6e
+	{ COL_WHITE, FONT_UNDERLINED_ITALICS, 0 },  // 0x4f || 0x6f
+	{ COL_WHITE, FONT_REGULAR, 0 },  // 0x50 || 0x70
+	{ COL_WHITE, FONT_UNDERLINED, 0 },  // 0x51 || 0x71
+	{ COL_WHITE, FONT_REGULAR, 4 },  // 0x52 || 0x72
+	{ COL_WHITE, FONT_UNDERLINED, 4 },  // 0x53 || 0x73
+	{ COL_WHITE, FONT_REGULAR, 8 },  // 0x54 || 0x74
+	{ COL_WHITE, FONT_UNDERLINED, 8 },  // 0x55 || 0x75
+	{ COL_WHITE, FONT_REGULAR, 12 }, // 0x56 || 0x76
+	{ COL_WHITE, FONT_UNDERLINED, 12 }, // 0x57 || 0x77
+	{ COL_WHITE, FONT_REGULAR, 16 }, // 0x58 || 0x78
+	{ COL_WHITE, FONT_UNDERLINED, 16 }, // 0x59 || 0x79
+	{ COL_WHITE, FONT_REGULAR, 20 }, // 0x5a || 0x7a
+	{ COL_WHITE, FONT_UNDERLINED, 20 }, // 0x5b || 0x7b
+	{ COL_WHITE, FONT_REGULAR, 24 }, // 0x5c || 0x7c
+	{ COL_WHITE, FONT_UNDERLINED, 24 }, // 0x5d || 0x7d
+	{ COL_WHITE, FONT_REGULAR, 28 }, // 0x5e || 0x7e
+	{ COL_WHITE, FONT_UNDERLINED, 28 }  // 0x5f || 0x7f
+};
+
+
+static const char *command_type[] =
+{
+	"Unknown",
+	"EDM - EraseDisplayedMemory",
+	"RCL - ResumeCaptionLoading",
+	"EOC - End Of Caption",
+	"TO1 - Tab Offset, 1 column",
+	"TO2 - Tab Offset, 2 column",
+	"TO3 - Tab Offset, 3 column",
+	"RU2 - Roll up 2 rows",
+	"RU3 - Roll up 3 rows",
+	"RU4 - Roll up 4 rows",
+	"CR  - Carriage Return",
+	"ENM - Erase non-displayed memory",
+	"BS  - Backspace",
+	"RTD - Resume Text Display",
+	"AOF - Not Used (Alarm Off)",
+	"AON - Not Used (Alarm On)",
+	"DER - Delete to End of Row",
+	"RDC - Resume Direct Captioning",
+	"RU1 - Fake Roll up 1 rows"
+};
+
+static const char *font_text[]=
+{
+	"regular",
+	"italics",
+	"underlined",
+	"underlined italics"
+};
+
+#if 0
+static const char *cc_modes_text[]=
+{
+	"Pop-Up captions"
+};
+#endif
+
+const char *color_text[MAX_COLOR][2]=
+{
+	{"white",""},
+	{"green","<font color=\"#00ff00\">"},
+	{"blue","<font color=\"#0000ff\">"},
+	{"cyan","<font color=\"#00ffff\">"},
+	{"red","<font color=\"#ff0000\">"},
+	{"yellow","<font color=\"#ffff00\">"},
+	{"magenta","<font color=\"#ff00ff\">"},
+	{"userdefined","<font color=\""},
+	{"black",""},
+	{"transparent",""}
+};
+
+
+void clear_eia608_cc_buffer(ccx_decoder_608_context *context, struct eia608_screen *data)
+{
+	for (int i=0;i<15;i++)
+	{
+		memset(data->characters[i], ' ', CCX_DECODER_608_SCREEN_WIDTH);
+		data->characters[i][CCX_DECODER_608_SCREEN_WIDTH] = 0;
+		memset(data->colors[i], context->settings->default_color, CCX_DECODER_608_SCREEN_WIDTH + 1);
+		memset(data->fonts[i], FONT_REGULAR, CCX_DECODER_608_SCREEN_WIDTH + 1);
+		data->row_used[i]=0;
+	}
+	data->empty=1;
+}
+
+void ccx_decoder_608_dinit_library(void **ctx)
+{
+	freep(ctx);
+}
+ccx_decoder_608_context* ccx_decoder_608_init_library(struct ccx_decoder_608_settings *settings, int channel,
+		int field, int *halt,
+		int cc_to_stdout,
+		enum ccx_output_format output_format, struct ccx_common_timing_ctx *timing)
+{
+	ccx_decoder_608_context *data = NULL;
+
+	data = malloc(sizeof(ccx_decoder_608_context));
+
+	data->cursor_column=0;
+	data->cursor_row=0;
+	data->visible_buffer=1;
+	data->last_c1=0;
+	data->last_c2=0;
+	data->mode=MODE_POPON;
+	// data->current_visible_start_cc=0;
+	data->current_visible_start_ms=0;
+	data->screenfuls_counter=0;
+	data->channel=1;
+	data->font=FONT_REGULAR;
+	data->rollup_base_row=14;
+	data->ts_start_of_current_line=-1;
+	data->ts_last_char_received=-1;
+	data->new_channel=1;
+	data->bytes_processed_608 = 0;
+	data->my_field = field;
+	data->my_channel = channel;
+	data->have_cursor_position = 0;
+	data->output_format = output_format;
+	data->cc_to_stdout = cc_to_stdout;
+	data->textprinted = 0;
+	data->ts_start_of_current_line = 0;
+
+	data->halt = halt;
+
+	data->settings = settings;
+	data->current_color = data->settings->default_color;
+	data->report = settings->report;
+	data->timing = timing;
+
+	clear_eia608_cc_buffer(data, &data->buffer1);
+	clear_eia608_cc_buffer(data, &data->buffer2);
+
+	return data;
+}
+
+struct eia608_screen *get_writing_buffer(ccx_decoder_608_context *context)
+{
+	struct eia608_screen *use_buffer=NULL;
+	switch (context->mode)
+	{
+		case MODE_POPON: // Write on the non-visible buffer
+			if (context->visible_buffer == 1)
+				use_buffer = &context->buffer2;
+			else
+				use_buffer = &context->buffer1;
+			break;
+		case MODE_FAKE_ROLLUP_1: // Write directly to screen
+		case MODE_ROLLUP_2:
+		case MODE_ROLLUP_3:
+		case MODE_ROLLUP_4:
+		case MODE_PAINTON:
+		case MODE_TEXT:
+			// TODO: Fix this. Text uses a different buffer, and contains non-program information.
+			if (context->visible_buffer == 1)
+				use_buffer = &context->buffer1;
+			else
+				use_buffer = &context->buffer2;
+			break;
+		default:
+			ccx_common_logging.fatal_ftn(CCX_COMMON_EXIT_BUG_BUG, "Caption mode has an illegal value at get_writing_buffer(), this is a bug.\n");
+	}
+	return use_buffer;
+}
+
+void delete_to_end_of_row(ccx_decoder_608_context *context)
+{
+	if (context->mode != MODE_TEXT)
+	{
+		struct eia608_screen *use_buffer = get_writing_buffer(context);
+		for (int i = context->cursor_column; i <= CCX_DECODER_608_SCREEN_WIDTH-1; i++)
+		{
+			// TODO: This can change the 'used' situation of a column, so we'd
+			// need to check and correct.
+			use_buffer->characters[context->cursor_row][i] = ' ';
+			use_buffer->colors[context->cursor_row][i] = context->settings->default_color;
+			use_buffer->fonts[context->cursor_row][i] = context->font;
+		}
+	}
+}
+
+void write_char(const unsigned char c, ccx_decoder_608_context *context)
+{
+	if (context->mode != MODE_TEXT)
+	{
+		struct eia608_screen *use_buffer = get_writing_buffer(context);
+		/* printf ("\rWriting char [%c] at %s:%d:%d\n",c,
+		use_buffer == &wb->data608->buffer1?"B1":"B2",
+		wb->data608->cursor_row,wb->data608->cursor_column); */
+		use_buffer->characters[context->cursor_row][context->cursor_column] = c;
+		use_buffer->colors[context->cursor_row][context->cursor_column] = context->current_color;
+		use_buffer->fonts[context->cursor_row][context->cursor_column] = context->font;
+		use_buffer->row_used[context->cursor_row] = 1;
+
+		if (use_buffer->empty)
+		{
+			if (MODE_POPON != context->mode)
+				context->current_visible_start_ms = get_visible_start(context->timing, context->my_field);
+		}
+		use_buffer->empty=0;
+
+		if (context->cursor_column<CCX_DECODER_608_SCREEN_WIDTH - 1)
+			context->cursor_column++;
+		if (context->ts_start_of_current_line == -1)
+			context->ts_start_of_current_line = get_fts(context->timing, context->my_field);
+		context->ts_last_char_received = get_fts(context->timing, context->my_field);
+	}
+}
+
+/* Handle MID-ROW CODES. */
+void handle_text_attr(const unsigned char c1, const unsigned char c2, ccx_decoder_608_context *context)
+{
+	// Handle channel change
+	context->channel = context->new_channel;
+	if (context->channel != context->my_channel)
+		return;
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\r608: text_attr: %02X %02X", c1, c2);
+	if ( ((c1!=0x11 && c1!=0x19) ||
+		(c2<0x20 || c2>0x2f)))
+	{
+		ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rThis is not a text attribute!\n");
+	}
+	else
+	{
+		int i = c2-0x20;
+		context->current_color = pac2_attribs[i][0];
+		context->font = pac2_attribs[i][1];
+		ccx_common_logging.debug_ftn(
+			CCX_DMT_DECODER_608,
+			"  --  Color: %s,  font: %s\n",
+			color_text[context->current_color][0],
+			font_text[context->font]);
+		// Mid-row codes should put a non-transparent space at the current position
+		// and advance the cursor
+		//so use write_char
+		write_char(0x20, context);
+	}
+}
+
+struct eia608_screen *get_current_visible_buffer(ccx_decoder_608_context *context)
+{
+	struct eia608_screen *data;
+	if (context->visible_buffer == 1)
+		data = &context->buffer1;
+	else
+		data = &context->buffer2;
+	return data;
+}
+
+int write_cc_buffer(ccx_decoder_608_context *context, struct cc_subtitle *sub)
+{
+	struct eia608_screen *data;
+	int wrote_something=0;
+	LLONG start_time;
+	LLONG end_time;
+
+
+	if (context->settings->screens_to_process != -1 &&
+		context->screenfuls_counter >= context->settings->screens_to_process)
+	{
+		// We are done.
+		*context->halt=1;
+		return 0;
+	}
+
+	data = get_current_visible_buffer(context);
+
+	if (context->mode == MODE_FAKE_ROLLUP_1 && // Use the actual start of data instead of last buffer change
+		context->ts_start_of_current_line != -1)
+		context->current_visible_start_ms = context->ts_start_of_current_line;
+
+	start_time = context->current_visible_start_ms;
+	end_time = get_visible_end(context->timing, context->my_field);
+	sub->type = CC_608;
+	data->format = SFORMAT_CC_SCREEN;
+	data->start_time = 0;
+	data->end_time = 0;
+	data->mode = context->mode;
+	data->channel = context->channel;
+	data->my_field = context->my_field;
+
+	if (!data->empty && context->output_format != CCX_OF_NULL)
+	{
+		sub->data = (struct eia608_screen *) realloc(sub->data,( sub->nb_data + 1 ) * sizeof(*data));
+		if (!sub->data)
+		{
+			ccx_common_logging.log_ftn("No Memory left");
+			return 0;
+		}
+		sub->datatype = CC_DATATYPE_GENERIC;
+		memcpy(((struct eia608_screen *)sub->data) + sub->nb_data, data, sizeof(*data));
+		sub->nb_data++;
+		wrote_something = 1;
+		if(start_time < end_time)
+		{
+			int i = 0;
+			int nb_data = sub->nb_data;
+			data = (struct eia608_screen *)sub->data;
+			for(i = 0;(unsigned) i < sub->nb_data; i++)
+			{
+				if(!data->start_time)
+					break;
+				nb_data--;
+				data++;
+			}
+			for(i = 0; i < nb_data; i++)
+			{
+				data->start_time = start_time + ( ( (end_time - start_time)/nb_data ) * i );
+				data->end_time = start_time + ( ( (end_time - start_time)/nb_data ) * (i + 1) );
+				data++;
+			}
+			sub->got_output = 1;
+		}
+
+
+	}
+	return wrote_something;
+}
+int write_cc_line(ccx_decoder_608_context *context, struct cc_subtitle *sub)
+{
+	struct eia608_screen *data;
+	LLONG start_time;
+	LLONG end_time;
+	int i = 0;
+	int wrote_something=0;
+	data = get_current_visible_buffer(context);
+
+	start_time = context->ts_start_of_current_line;
+	end_time = get_fts(context->timing, context->my_field);
+	sub->type = CC_608;
+	data->format = SFORMAT_CC_LINE;
+	data->start_time = 0;
+	data->end_time = 0;
+	data->mode = context->mode;
+	data->channel = context->channel;
+	data->my_field = context->my_field;
+
+	if (!data->empty)
+	{
+		sub->data = (struct eia608_screen *) realloc(sub->data,(sub->nb_data +1) * sizeof(*data));
+		if (!sub->data)
+		{
+			ccx_common_logging.log_ftn("No Memory left");
+			return 0;
+		}
+		memcpy(((struct eia608_screen *)sub->data) + sub->nb_data, data, sizeof(*data));
+		data = (struct eia608_screen *)sub->data + sub->nb_data;
+		sub->datatype = CC_DATATYPE_GENERIC;
+		sub->nb_data++;
+
+		for(i = 0; i < 15; i++)
+		{
+			if(i == context->cursor_row)
+				data->row_used[i] = 1;
+			else
+				data->row_used[i] = 0;
+		}
+		wrote_something = 1;
+		if(start_time < end_time)
+		{
+			int nb_data = sub->nb_data;
+			data = (struct eia608_screen *)sub->data;
+			for(i = 0;(unsigned) i < sub->nb_data; i++)
+			{
+				if(!data->start_time)
+					break;
+				nb_data--;
+				data++;
+			}
+			for(i = 0;(int) i < nb_data; i++)
+			{
+				data->start_time = start_time + ( ( (end_time - start_time)/nb_data ) * i );
+				data->end_time = start_time + ( ( (end_time - start_time)/nb_data ) * (i + 1) );
+				data++;
+			}
+			sub->got_output = 1;
+		}
+	}
+	return wrote_something;
+
+}
+
+// Check if a rollup would cause a line to go off the visible area
+int check_roll_up(ccx_decoder_608_context *context)
+{
+	int keep_lines=0;
+	int firstrow=-1, lastrow=-1;
+	struct eia608_screen *use_buffer;
+	if (context->visible_buffer == 1)
+		use_buffer = &context->buffer1;
+	else
+		use_buffer = &context->buffer2;
+
+	switch (context->mode)
+	{
+		case MODE_FAKE_ROLLUP_1:
+			keep_lines=1;
+			break;
+		case MODE_ROLLUP_2:
+			keep_lines=2;
+			break;
+		case MODE_ROLLUP_3:
+			keep_lines=3;
+			break;
+		case MODE_ROLLUP_4:
+			keep_lines=4;
+			break;
+		case MODE_TEXT:
+			keep_lines=7; // CFS: can be 7 to 15 according to the handbook. No idea how this is selected.
+			break;
+		default: // Shouldn't happen
+			return 0;
+			break;
+	}
+	if (use_buffer->row_used[0]) // If top line is used it will go off the screen no matter what
+		return 1;
+	int rows_orig=0; // Number of rows in use right now
+	for (int i=0;i<15;i++)
+	{
+		if (use_buffer->row_used[i])
+		{
+			rows_orig++;
+			if (firstrow==-1)
+				firstrow=i;
+			lastrow=i;
+		}
+	}
+	if (lastrow==-1) // Empty screen, nothing to rollup
+		return 0;
+	if ((lastrow-firstrow+1)>=keep_lines)
+		return 1; // We have the roll-up area full, so yes
+
+	if ((firstrow - 1) <= context->cursor_row - keep_lines) // Roll up will delete those lines.
+		return 1;
+	return 0;
+}
+
+// Roll-up: Returns true if a line was rolled over the visible area (it disappears from screen), false
+// if the rollup didn't delete any line.
+int roll_up(ccx_decoder_608_context *context)
+{
+	struct eia608_screen *use_buffer;
+	if (context->visible_buffer == 1)
+		use_buffer = &context->buffer1;
+	else
+		use_buffer = &context->buffer2;
+	int keep_lines;
+	switch (context->mode)
+	{
+		case MODE_FAKE_ROLLUP_1:
+			keep_lines=1;
+			break;
+		case MODE_ROLLUP_2:
+			keep_lines=2;
+			break;
+		case MODE_ROLLUP_3:
+			keep_lines=3;
+			break;
+		case MODE_ROLLUP_4:
+			keep_lines=4;
+			break;
+		case MODE_TEXT:
+			keep_lines=7; // CFS: can be 7 to 15 according to the handbook. No idea how this is selected.
+			break;
+		default: // Shouldn't happen
+			keep_lines=0;
+			break;
+	}
+	int firstrow=-1, lastrow=-1;
+	// Look for the last line used
+	int rows_orig=0; // Number of rows in use right now
+	for (int i=0;i<15;i++)
+	{
+		if (use_buffer->row_used[i])
+		{
+			rows_orig++;
+			if (firstrow==-1)
+				firstrow=i;
+			lastrow=i;
+		}
+	}
+
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rIn roll-up: %d lines used, first: %d, last: %d\n", rows_orig, firstrow, lastrow);
+
+	if (lastrow==-1) // Empty screen, nothing to rollup
+		return 0;
+
+	for (int j=lastrow-keep_lines+1;j<lastrow; j++)
+	{
+		if (j>=0)
+		{
+			memcpy(use_buffer->characters[j], use_buffer->characters[j + 1], CCX_DECODER_608_SCREEN_WIDTH + 1);
+			memcpy(use_buffer->colors[j], use_buffer->colors[j + 1], CCX_DECODER_608_SCREEN_WIDTH + 1);
+			memcpy(use_buffer->fonts[j], use_buffer->fonts[j + 1], CCX_DECODER_608_SCREEN_WIDTH + 1);
+			use_buffer->row_used[j]=use_buffer->row_used[j+1];
+		}
+	}
+	for (int j = 0; j<(1 + context->cursor_row - keep_lines); j++)
+	{
+		memset(use_buffer->characters[j], ' ', CCX_DECODER_608_SCREEN_WIDTH);
+		memset(use_buffer->colors[j], context->settings->default_color, CCX_DECODER_608_SCREEN_WIDTH);
+		memset(use_buffer->fonts[j], FONT_REGULAR, CCX_DECODER_608_SCREEN_WIDTH);
+		use_buffer->characters[j][CCX_DECODER_608_SCREEN_WIDTH] = 0;
+		use_buffer->row_used[j]=0;
+	}
+	memset(use_buffer->characters[lastrow], ' ', CCX_DECODER_608_SCREEN_WIDTH);
+	memset(use_buffer->colors[lastrow], context->settings->default_color, CCX_DECODER_608_SCREEN_WIDTH);
+	memset(use_buffer->fonts[lastrow], FONT_REGULAR, CCX_DECODER_608_SCREEN_WIDTH);
+
+	use_buffer->characters[lastrow][CCX_DECODER_608_SCREEN_WIDTH] = 0;
+	use_buffer->row_used[lastrow]=0;
+
+	// Sanity check
+	int rows_now=0;
+	for (int i=0;i<15;i++)
+		if (use_buffer->row_used[i])
+			rows_now++;
+	if (rows_now>keep_lines)
+		ccx_common_logging.log_ftn("Bug in roll_up, should have %d lines but I have %d.\n",
+			keep_lines, rows_now);
+
+	// If the buffer is now empty, let's set the flag
+	// This will allow write_char to set visible start time appropriately
+	if (0 == rows_now)
+		use_buffer->empty = 1;
+
+	return (rows_now != rows_orig);
+}
+
+void erase_memory(ccx_decoder_608_context *context, int displayed)
+{
+	struct eia608_screen *buf;
+	if (displayed)
+	{
+		if (context->visible_buffer == 1)
+			buf = &context->buffer1;
+		else
+			buf = &context->buffer2;
+	}
+	else
+	{
+		if (context->visible_buffer == 1)
+			buf = &context->buffer2;
+		else
+			buf = &context->buffer1;
+	}
+	clear_eia608_cc_buffer (context,buf);
+}
+
+int is_current_row_empty(ccx_decoder_608_context *context)
+{
+	struct eia608_screen *use_buffer;
+	if (context->visible_buffer == 1)
+		use_buffer = &context->buffer1;
+	else
+		use_buffer = &context->buffer2;
+	for (int i = 0; i<CCX_DECODER_608_SCREEN_WIDTH; i++)
+	{
+		if (use_buffer->characters[context->rollup_base_row][i] != ' ')
+			return 0;
+	}
+	return 1;
+}
+
+/* Process GLOBAL CODES */
+void handle_command(unsigned char c1, const unsigned char c2, ccx_decoder_608_context *context, struct cc_subtitle *sub)
+{
+	int changes=0;
+
+	// Handle channel change
+	context->channel = context->new_channel;
+	if (context->channel != context->my_channel)
+		return;
+
+	enum command_code command = COM_UNKNOWN;
+	if (c1==0x15)
+		c1=0x14;
+	if ((c1==0x14 || c1==0x1C) && c2==0x2C)
+		command = COM_ERASEDISPLAYEDMEMORY;
+	if ((c1==0x14 || c1==0x1C) && c2==0x20)
+		command = COM_RESUMECAPTIONLOADING;
+	if ((c1==0x14 || c1==0x1C) && c2==0x2F)
+		command = COM_ENDOFCAPTION;
+	if ((c1==0x14 || c1==0x1C) && c2==0x22)
+		command = COM_ALARMOFF;
+	if ((c1==0x14 || c1==0x1C) && c2==0x23)
+		command = COM_ALARMON;
+	if ((c1==0x14 || c1==0x1C) && c2==0x24)
+		command = COM_DELETETOENDOFROW;
+	if ((c1==0x17 || c1==0x1F) && c2==0x21)
+		command = COM_TABOFFSET1;
+	if ((c1==0x17 || c1==0x1F) && c2==0x22)
+		command = COM_TABOFFSET2;
+	if ((c1==0x17 || c1==0x1F) && c2==0x23)
+		command = COM_TABOFFSET3;
+	if ((c1==0x14 || c1==0x1C) && c2==0x25)
+		command = COM_ROLLUP2;
+	if ((c1==0x14 || c1==0x1C) && c2==0x26)
+		command = COM_ROLLUP3;
+	if ((c1==0x14 || c1==0x1C) && c2==0x27)
+		command = COM_ROLLUP4;
+	if ((c1==0x14 || c1==0x1C) && c2==0x29)
+		command = COM_RESUMEDIRECTCAPTIONING;
+	if ((c1==0x14 || c1==0x1C) && c2==0x2D)
+		command = COM_CARRIAGERETURN;
+	if ((c1==0x14 || c1==0x1C) && c2==0x2E)
+		command = COM_ERASENONDISPLAYEDMEMORY;
+	if ((c1==0x14 || c1==0x1C) && c2==0x21)
+		command = COM_BACKSPACE;
+	if ((c1==0x14 || c1==0x1C) && c2==0x2b)
+		command = COM_RESUMETEXTDISPLAY;
+
+	if ((command == COM_ROLLUP2 || command == COM_ROLLUP3 || command == COM_ROLLUP4) && context->settings->force_rollup == 1)
+		command=COM_FAKE_RULLUP1;
+
+	if ((command == COM_ROLLUP3 || command == COM_ROLLUP4) && context->settings->force_rollup == 2)
+		command=COM_ROLLUP2;
+	else if (command == COM_ROLLUP4 && context->settings->force_rollup == 3)
+		command=COM_ROLLUP3;
+
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rCommand begin: %02X %02X (%s)\n", c1, c2, command_type[command]);
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rCurrent mode: %d  Position: %d,%d  VisBuf: %d\n", context->mode,
+		context->cursor_row, context->cursor_column, context->visible_buffer);
+
+	switch (command)
+	{
+		case COM_BACKSPACE:
+			if (context->cursor_column>0)
+			{
+				context->cursor_column--;
+				get_writing_buffer(context)->characters[context->cursor_row][context->cursor_column] = ' ';
+			}
+			break;
+		case COM_TABOFFSET1:
+			if (context->cursor_column<CCX_DECODER_608_SCREEN_WIDTH - 1)
+				context->cursor_column++;
+			break;
+		case COM_TABOFFSET2:
+			context->cursor_column += 2;
+			if (context->cursor_column>CCX_DECODER_608_SCREEN_WIDTH - 1)
+				context->cursor_column = CCX_DECODER_608_SCREEN_WIDTH - 1;
+			break;
+		case COM_TABOFFSET3:
+			context->cursor_column += 3;
+			if (context->cursor_column>CCX_DECODER_608_SCREEN_WIDTH - 1)
+				context->cursor_column = CCX_DECODER_608_SCREEN_WIDTH - 1;
+			break;
+		case COM_RESUMECAPTIONLOADING:
+			context->mode = MODE_POPON;
+			break;
+		case COM_RESUMETEXTDISPLAY:
+			context->mode = MODE_TEXT;
+			break;
+		case COM_FAKE_RULLUP1:
+		case COM_ROLLUP2:
+		case COM_ROLLUP3:
+		case COM_ROLLUP4:
+			if (context->mode == MODE_POPON || context->mode == MODE_PAINTON)
+			{
+				/* CEA-608 C.10 Style Switching (regulatory)
+				[...]if pop-up or paint-on captioning is already present in
+				either memory it shall be erased[...] */
+				if (write_cc_buffer(context, sub))
+					context->screenfuls_counter++;
+				erase_memory(context, true);
+			}
+			erase_memory(context, false);
+
+			// If the reception of data for a row is interrupted by data for the alternate
+			// data channel or for text mode, the display of caption text will resume from the same
+			// cursor position if a roll-up caption command is received and no PAC is given [...]
+			if (context->mode != MODE_TEXT && context->have_cursor_position == 0)
+			{
+				// If no Preamble Address Code  is received, the base row shall default to row 15
+				context->cursor_row = 14; // Default if the previous mode wasn't roll up already.
+				context->cursor_column = 0;
+				context->have_cursor_position = 1;
+			}
+
+			switch (command)
+			{
+				case COM_FAKE_RULLUP1:
+					context->mode = MODE_FAKE_ROLLUP_1;
+					break;
+				case COM_ROLLUP2:
+					context->mode = MODE_ROLLUP_2;
+					break;
+				case COM_ROLLUP3:
+					context->mode = MODE_ROLLUP_3;
+					break;
+				case COM_ROLLUP4:
+					context->mode = MODE_ROLLUP_4;
+					break;
+				default: // Impossible, but remove compiler warnings
+					break;
+			}
+			break;
+		case COM_CARRIAGERETURN:
+			if (context->mode == MODE_PAINTON) // CR has no effect on painton mode according to zvbis' code
+				break;
+			if (context->mode == MODE_POPON) // CFS: Not sure about this. Is there a valid reason for CR in popup?
+			{
+				context->cursor_column = 0;
+				if (context->cursor_row<15)
+					context->cursor_row++;
+				break;
+			}
+#ifndef MMCCXTR
+			if (context->output_format == CCX_OF_TRANSCRIPT)
+			{
+				write_cc_line(context,sub);
+			}
+#endif
+
+			// In transcript mode, CR doesn't write the whole screen, to avoid
+			// repeated lines.
+			changes = check_roll_up(context);
+			if (changes)
+			{
+				// Only if the roll up would actually cause a line to disappear we write the buffer
+#ifndef MMCCXTR
+				if (context->output_format != CCX_OF_TRANSCRIPT)
+#endif
+				{
+					if (write_cc_buffer(context, sub))
+						context->screenfuls_counter++;
+					if (context->settings->no_rollup)
+						erase_memory(context, true); // Make sure the lines we just wrote aren't written again
+				}
+			}
+			roll_up(context); // The roll must be done anyway of course.
+			context->ts_start_of_current_line = -1; // Unknown.
+			if (changes)
+				context->current_visible_start_ms = get_visible_start(context->timing, context->my_field);
+			context->cursor_column = 0;
+			break;
+		case COM_ERASENONDISPLAYEDMEMORY:
+			erase_memory(context, false);
+			break;
+		case COM_ERASEDISPLAYEDMEMORY:
+			// Write it to disk before doing this, and make a note of the new
+			// time it became clear.
+#ifndef MMCCXTR
+			if (context->output_format == CCX_OF_TRANSCRIPT &&
+				(context->mode == MODE_FAKE_ROLLUP_1 ||
+				context->mode == MODE_ROLLUP_2 ||
+				context->mode == MODE_ROLLUP_3 ||
+				context->mode == MODE_ROLLUP_4))
+			{
+				// In transcript mode we just write the cursor line. The previous lines
+				// should have been written already, so writing everything produces
+				// duplicate lines.
+				write_cc_line(context, sub);
+			}
+			else
+#endif
+			{
+#ifndef MMCCXTR
+				if (context->output_format == CCX_OF_TRANSCRIPT)
+					context->ts_start_of_current_line = context->current_visible_start_ms;
+#endif
+				if (write_cc_buffer(context, sub))
+					context->screenfuls_counter++;
+			}
+			erase_memory(context, true);
+			context->current_visible_start_ms = get_visible_start(context->timing, context->my_field);
+			break;
+		case COM_ENDOFCAPTION: // Switch buffers
+			// The currently *visible* buffer is leaving, so now we know its ending
+			// time. Time to actually write it to file.
+			if (write_cc_buffer(context, sub))
+				context->screenfuls_counter++;
+			context->visible_buffer = (context->visible_buffer == 1) ? 2 : 1;
+			context->current_visible_start_ms = get_visible_start(context->timing, context->my_field);
+			context->cursor_column = 0;
+			context->cursor_row = 0;
+			context->current_color = context->settings->default_color;
+			context->font = FONT_REGULAR;
+			context->mode = MODE_POPON;
+			break;
+		case COM_DELETETOENDOFROW:
+			delete_to_end_of_row(context);
+			break;
+		case COM_ALARMOFF:
+		case COM_ALARMON:
+			// These two are unused according to Robson's, and we wouldn't be able to do anything useful anyway
+			break;
+		case COM_RESUMEDIRECTCAPTIONING:
+			context->mode = MODE_PAINTON;
+			//ccx_common_logging.log_ftn ("\nWarning: Received ResumeDirectCaptioning, this mode is almost impossible.\n");
+			//ccx_common_logging.log_ftn ("to transcribe to a text file.\n");
+			break;
+		default:
+			ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rNot yet implemented.\n");
+			break;
+	}
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rCurrent mode: %d  Position: %d,%d	VisBuf: %d\n", context->mode,
+		context->cursor_row, context->cursor_column, context->visible_buffer);
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rCommand end: %02X %02X (%s)\n", c1, c2, command_type[command]);
+
+}
+
+void flush_608_context(ccx_decoder_608_context *context, struct cc_subtitle *sub)
+{
+	// We issue a EraseDisplayedMemory here so if there's any captions pending
+	// they get written to Subtitle.
+	handle_command (0x14, 0x2c, context, sub); // EDM
+}
+
+// CEA-608, Anex F 1.1.1. - Character Set Table / Special Characters
+void handle_double(const unsigned char c1, const unsigned char c2, ccx_decoder_608_context *context)
+{
+	unsigned char c;
+	if (context->channel != context->my_channel)
+		return;
+	if (c2>=0x30 && c2<=0x3f)
+	{
+		c=c2 + 0x50; // So if c>=0x80 && c<=0x8f, it comes from here
+		ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rDouble: %02X %02X  -->  %c\n", c1, c2, c);
+		write_char(c, context);
+	}
+}
+
+/* Process EXTENDED CHARACTERS */
+unsigned char handle_extended(unsigned char hi, unsigned char lo, ccx_decoder_608_context *context)
+{
+	// Handle channel change
+	if (context->new_channel > 2)
+	{
+		context->new_channel -= 2;
+		ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\nChannel correction, now %d\n", context->new_channel);
+	}
+	context->channel = context->new_channel;
+	if (context->channel != context->my_channel)
+		return 0;
+
+	// For lo values between 0x20-0x3f
+	unsigned char c=0;
+
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rExtended: %02X %02X\n", hi, lo);
+	if (lo>=0x20 && lo<=0x3f && (hi==0x12 || hi==0x13))
+	{
+		switch (hi)
+		{
+			case 0x12:
+				c=lo+0x70; // So if c>=0x90 && c<=0xaf it comes from here
+				break;
+			case 0x13:
+				c=lo+0x90; // So if c>=0xb0 && c<=0xcf it comes from here
+				break;
+		}
+		// This column change is because extended characters replace
+		// the previous character (which is sent for basic decoders
+		// to show something similar to the real char)
+		if (context->cursor_column>0)
+			context->cursor_column--;
+
+		write_char(c, context);
+	}
+	return 1;
+}
+
+/* Process PREAMBLE ACCESS CODES (PAC) */
+void handle_pac(unsigned char c1, unsigned char c2, ccx_decoder_608_context *context)
+{
+	// Handle channel change
+	if (context->new_channel > 2)
+	{
+		context->new_channel -= 2;
+		ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\nChannel correction, now %d\n", context->new_channel);
+	}
+	context->channel = context->new_channel;
+	if (context->channel != context->my_channel)
+		return;
+
+	int row=rowdata[((c1<<1)&14)|((c2>>5)&1)];
+
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rPAC: %02X %02X", c1, c2);
+
+	if (c2>=0x40 && c2<=0x5f)
+	{
+		c2=c2-0x40;
+	}
+	else
+	{
+		if (c2>=0x60 && c2<=0x7f)
+		{
+			c2=c2-0x60;
+		}
+		else
+		{
+			ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\rThis is not a PAC!!!!!\n");
+			return;
+		}
+	}
+	context->current_color = pac2_attribs[c2][0];
+	context->font = pac2_attribs[c2][1];
+	int indent=pac2_attribs[c2][2];
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "  --  Position: %d:%d, color: %s,  font: %s\n", row,
+		indent, color_text[context->current_color][0], font_text[context->font]);
+	if (context->settings->default_color == COL_USERDEFINED && (context->current_color == COL_WHITE || context->current_color == COL_TRANSPARENT))
+		context->current_color = COL_USERDEFINED;
+	if (context->mode != MODE_TEXT)
+	{
+		// According to Robson, row info is discarded in text mode
+		// but column is accepted
+		context->cursor_row = row - 1; // Since the array is 0 based
+	}
+	context->rollup_base_row = row - 1;
+	context->cursor_column = indent;
+	context->have_cursor_position = 1;
+	if (context->mode == MODE_FAKE_ROLLUP_1 || context->mode == MODE_ROLLUP_2 ||
+		context->mode == MODE_ROLLUP_3 || context->mode == MODE_ROLLUP_4)
+	{
+		/* In roll-up, delete lines BELOW the PAC. Not sure (CFS) this is correct (possibly we may have to move the
+		   buffer around instead) but it's better than leaving old characters in the buffer */
+		struct eia608_screen *use_buffer = get_writing_buffer(context); // &wb->data608->buffer1;
+
+		for (int j=row;j<15;j++)
+		{
+			if (use_buffer->row_used[j])
+			{
+				memset(use_buffer->characters[j], ' ', CCX_DECODER_608_SCREEN_WIDTH);
+				memset(use_buffer->colors[j], context->settings->default_color, CCX_DECODER_608_SCREEN_WIDTH);
+				memset(use_buffer->fonts[j], FONT_REGULAR, CCX_DECODER_608_SCREEN_WIDTH);
+				use_buffer->characters[j][CCX_DECODER_608_SCREEN_WIDTH] = 0;
+				use_buffer->row_used[j] = 0;
+			}
+		}
+	}
+
+}
+
+
+void handle_single(const unsigned char c1, ccx_decoder_608_context *context)
+{
+	if (c1<0x20 || context->channel != context->my_channel)
+		return; // We don't allow special stuff here
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "%c", c1);
+
+	write_char (c1,context);
+}
+
+void erase_both_memories(ccx_decoder_608_context *context, struct cc_subtitle *sub)
+{
+	erase_memory(context, false);
+	// For the visible memory, we write the contents to disk
+			// The currently *visible* buffer is leaving, so now we know its ending
+			// time. Time to actually write it to file.
+	if (write_cc_buffer(context, sub))
+		context->screenfuls_counter++;
+	context->current_visible_start_ms = get_visible_start(context->timing, context->my_field);
+	context->cursor_column = 0;
+	context->cursor_row = 0;
+	context->current_color = context->settings->default_color;
+	context->font = FONT_REGULAR;
+
+	erase_memory(context, true);
+}
+
+int check_channel(unsigned char c1, ccx_decoder_608_context *context)
+{
+	int newchan = context->channel;
+	if (c1>=0x10 && c1<=0x17)
+		newchan=1;
+	else if (c1>=0x18 && c1<=0x1e)
+		newchan=2;
+	if (newchan != context->channel)
+	{
+		ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\nChannel change, now %d\n", newchan);
+		if (context->channel != 3) // Don't delete memories if returning from XDS.
+		{
+			// erase_both_memories (wb); // 47cfr15.119.pdf, page 859, part f
+			// CFS: Removed this because the specs say memories should be deleted if THE USER
+			// changes the channel.
+		}
+	}
+	return newchan;
+}
+
+/* Handle Command, special char or attribute and also check for
+* channel changes.
+* Returns 1 if something was written to screen, 0 otherwise */
+int disCommand(unsigned char hi, unsigned char lo, ccx_decoder_608_context *context, struct cc_subtitle *sub)
+{
+	int wrote_to_screen=0;
+
+	/* Full channel changes are only allowed for "GLOBAL CODES",
+	* "OTHER POSITIONING CODES", "BACKGROUND COLOR CODES",
+	* "MID-ROW CODES".
+	* "PREAMBLE ACCESS CODES", "BACKGROUND COLOR CODES" and
+	* SPECIAL/SPECIAL CHARACTERS allow only switching
+	* between 1&3 or 2&4. */
+	context->new_channel = check_channel(hi, context);
+	//if (wb->data608->channel!=cc_channel)
+	//	continue;
+
+	if (hi>=0x18 && hi<=0x1f)
+		hi=hi-8;
+
+	switch (hi)
+	{
+		case 0x10:
+			if (lo>=0x40 && lo<=0x5f)
+				handle_pac(hi, lo, context);
+			break;
+		case 0x11:
+			if (lo>=0x20 && lo<=0x2f)
+				handle_text_attr(hi, lo, context);
+			if (lo>=0x30 && lo<=0x3f)
+			{
+				wrote_to_screen=1;
+				handle_double(hi, lo, context);
+			}
+			if (lo>=0x40 && lo<=0x7f)
+				handle_pac(hi, lo, context);
+			break;
+		case 0x12:
+		case 0x13:
+			if (lo>=0x20 && lo<=0x3f)
+			{
+				wrote_to_screen = handle_extended(hi, lo, context);
+			}
+			if (lo>=0x40 && lo<=0x7f)
+				handle_pac(hi, lo, context);
+			break;
+		case 0x14:
+		case 0x15:
+			if (lo>=0x20 && lo<=0x2f)
+				handle_command(hi, lo, context, sub);
+			if (lo>=0x40 && lo<=0x7f)
+				handle_pac(hi, lo, context);
+			break;
+		case 0x16:
+			if (lo>=0x40 && lo<=0x7f)
+				handle_pac(hi, lo, context);
+			break;
+		case 0x17:
+			if (lo>=0x21 && lo<=0x23)
+				handle_command(hi, lo, context, sub);
+			if (lo>=0x2e && lo<=0x2f)
+				handle_text_attr(hi, lo, context);
+			if (lo>=0x40 && lo<=0x7f)
+				handle_pac(hi, lo, context);
+			break;
+	}
+	return wrote_to_screen;
+}
+
+/* If private data is NULL, then only XDS will be processed */
+int process608(const unsigned char *data, int length, void *private_data, struct cc_subtitle *sub)
+{
+	struct ccx_decoder_608_report  *report = NULL;
+	struct lib_cc_decode *dec_ctx = private_data;
+	struct ccx_decoder_608_context *context;
+	int i;
+
+	if(dec_ctx->current_field == 1)
+	{
+		context = dec_ctx->context_cc608_field_1;
+	}
+	else if (dec_ctx->current_field == 2 && dec_ctx->extract == 1)
+	{
+		context = NULL;
+	}
+	else
+	{
+		context = dec_ctx->context_cc608_field_2;
+	}
+	if (context)
+	{
+		report = context->report;
+		context->bytes_processed_608 += length;
+	}
+	if (!data)
+	{
+		return -1;
+	}
+	for (i=0; i < length; i=i+2)
+	{
+		unsigned char hi, lo;
+		int wrote_to_screen=0;
+
+		hi = data[i] & 0x7F; // Get rid of parity bit
+		lo = data[i+1] & 0x7F; // Get rid of parity bit
+
+		if (hi==0 && lo==0) // Just padding
+			continue;
+
+		// printf ("\r[%02X:%02X]\n",hi,lo);
+
+		if (hi>=0x10 && hi<=0x1e) {
+			int ch = (hi<=0x17)? 1 : 2;
+			if (context == NULL || context->my_field == 2) // Originally: current_field from sequencing.c. Seems to be just to change channel, so context->my_field seems good.
+				ch+=2;
+
+			if(report)
+				report->cc_channels[ch - 1] = 1;
+		}
+
+#ifndef MMCCXTR
+		if (hi >= 0x01 && hi <= 0x0E && (context == NULL || context->my_field == 2)) // XDS can only exist in field 2.
+		{
+			if (context)
+				context->channel = 3;
+			if (!in_xds_mode)
+			{
+				ts_start_of_xds = get_fts(dec_ctx->timing, dec_ctx->current_field);
+				in_xds_mode = 1;
+			}
+			if(report)
+				report->xds = 1;
+		}
+		if (hi == 0x0F && in_xds_mode && (context == NULL || context->my_field == 2)) // End of XDS block
+		{
+			in_xds_mode=0;
+			do_end_of_xds (sub, dec_ctx->xds_ctx, lo);
+			if (context)
+				context->channel = context->new_channel; // Switch from channel 3
+			continue;
+		}
+#endif
+		if (hi>=0x10 && hi<=0x1F) // Non-character code or special/extended char
+			// http://www.theneitherworld.com/mcpoodle/SCC_TOOLS/DOCS/CC_CODES.HTML
+			// http://www.theneitherworld.com/mcpoodle/SCC_TOOLS/DOCS/CC_CHARS.HTML
+		{
+#ifndef MMCCXTR
+			if (!context || context->my_field == 2)
+				in_xds_mode=0; // Back to normal (CEA 608-8.6.2)
+#endif
+			if (!context) // Not XDS and we don't have a writebuffer, nothing else would have an effect
+				continue;
+
+			// We were writing characters before, start a new line for
+			// diagnostic output from disCommand()
+			if (context->textprinted == 1 )
+			{
+				ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\n");
+				context->textprinted = 0;
+			}
+
+			if (context->last_c1 == hi && context->last_c2 == lo)
+			{
+				// Duplicate dual code, discard. Correct to do it only in
+				// non-XDS, XDS codes shall not be repeated.
+				ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "Skipping command %02X,%02X Duplicate\n", hi, lo);
+				// Ignore only the first repetition
+				context->last_c1=-1;
+				context->last_c2 = -1;
+				continue;
+			}
+			context->last_c1 = hi;
+			context->last_c2 = lo;
+			wrote_to_screen = disCommand(hi, lo, context, sub);
+			if (sub->got_output)
+			{
+				i += 2; // Otherwise we wouldn't be counting this byte pair
+				break;
+			}
+		}
+		else
+		{
+#ifndef MMCCXTR
+			if (in_xds_mode && (context == NULL || context->my_field == 2))
+			{
+				process_xds_bytes (dec_ctx->xds_ctx, hi, lo);
+				continue;
+			}
+#endif
+			if (!context) // No XDS code after this point, and user doesn't want captions.
+				continue;
+
+			context->last_c1 = -1;
+			context->last_c2 = -1;
+
+			if (hi>=0x20) // Standard characters (always in pairs)
+			{
+				// Only print if the channel is active
+				if (context->channel != context->my_channel)
+					continue;
+
+				if( context->textprinted == 0 )
+				{
+					ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "\n");
+					context->textprinted = 1;
+				}
+
+				handle_single(hi, context);
+				handle_single(lo, context);
+				wrote_to_screen=1;
+				context->last_c1 = 0;
+				context->last_c2 = 0;
+			}
+
+			if (!context->textprinted && context->channel == context->my_channel)
+			{   // Current FTS information after the characters are shown
+				ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "Current FTS: %s\n", print_mstime_static(get_fts(dec_ctx->timing, context->my_field)));
+				//printf("  N:%u", unsigned(fts_now) );
+				//printf("  G:%u", unsigned(fts_global) );
+				//printf("  F:%d %d %d %d\n",
+				//	   current_field, cb_field1, cb_field2, cb_708 );
+			}
+
+			if (wrote_to_screen && context->settings->direct_rollup && // If direct_rollup is enabled and
+					(context->mode == MODE_FAKE_ROLLUP_1 || // we are in rollup mode, write now.
+					 context->mode == MODE_ROLLUP_2 ||
+					 context->mode == MODE_ROLLUP_3 ||
+					 context->mode == MODE_ROLLUP_4))
+			{
+				// We don't increase screenfuls_counter here.
+				write_cc_buffer(context, sub);
+				context->current_visible_start_ms = get_visible_start(context->timing, context->my_field);
+			}
+		}
+		if (wrote_to_screen && context->cc_to_stdout)
+			fflush (stdout);
+	} // for
+	return i;
+}
+
+
+/* Return a pointer to a string that holds the printable characters
+ * of the caption data block. FOR DEBUG PURPOSES ONLY! */
+unsigned char *debug_608_to_ASC (unsigned char *cc_data, int channel)
+{
+	static unsigned char output[3];
+
+	unsigned char cc_valid = (cc_data[0] & 4) >>2;
+	unsigned char cc_type = cc_data[0] & 3;
+	unsigned char hi, lo;
+
+	output[0]=' ';
+	output[1]=' ';
+	output[2]='\x00';
+
+	if (cc_valid && cc_type==channel)
+	{
+		hi = cc_data[1] & 0x7F; // Get rid of parity bit
+		lo = cc_data[2] & 0x7F; // Get rid of parity bit
+		if (hi>=0x20)
+		{
+			output[0]=hi;
+			output[1]=(lo>=20 ? lo : '.');
+			output[2]='\x00';
+		}
+		else
+		{
+			output[0]='<';
+			output[1]='>';
+			output[2]='\x00';
+		}
+	}
+	return output;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_decoders_608.h Added

@@ -0,0 +1,148 @@
+#ifndef CCX_DECODER_608_H
+#define CCX_DECODER_608_H 
+#include "ccx_common_platform.h"
+#include "ccx_common_structs.h"
+#include "ccx_decoders_structs.h"
+
+extern LLONG ts_start_of_xds;
+
+/*
+   This variable (ccx_decoder_608_report) holds data on the cc channels & xds packets that are encountered during file parse.
+   This can be interesting if you just want to know what kind of data a file holds that has 608 packets. CCExtractor uses it
+   for the report functionality.
+ */
+struct ccx_decoder_608_report
+{
+	uint8_t xds : 1;
+	uint8_t cc_channels[4];
+};
+
+typedef struct ccx_decoder_608_settings
+{
+	int direct_rollup;           // Write roll-up captions directly instead of line by line?
+	int force_rollup;            // 0=Disabled, 1, 2 or 3=max lines in roll-up mode
+	int no_rollup;               // If 1, write one line at a time
+	unsigned char default_color; // Default color to use.
+	int screens_to_process;      // How many screenfuls we want? Use -1 for unlimited
+	struct ccx_decoder_608_report *report;
+} ccx_decoder_608_settings;
+
+typedef struct ccx_decoder_608_context
+{
+	ccx_decoder_608_settings *settings;
+	eia608_screen buffer1;
+	eia608_screen buffer2;
+	int cursor_row, cursor_column;
+	int visible_buffer;
+	int screenfuls_counter;         // Number of meaningful screenfuls written
+	LLONG current_visible_start_ms; // At what time did the current visible buffer became so?
+	enum cc_modes mode;
+	unsigned char last_c1, last_c2;
+	int channel;                    // Currently selected channel
+	unsigned char current_color;    // Color we are currently using to write
+	unsigned char font;             // Font we are currently using to write
+	int rollup_base_row;
+	LLONG ts_start_of_current_line; /* Time at which the first character for current line was received, =-1 no character received yet */
+	LLONG ts_last_char_received;    /* Time at which the last written character was received, =-1 no character received yet */
+	int new_channel;                // The new channel after a channel change
+	int my_field;                   // Used for sanity checks
+	int my_channel;                 // Used for sanity checks
+	long bytes_processed_608;       // To be written ONLY by process_608
+	int have_cursor_position;
+
+	int *halt;                            // Can be used to halt the feeding of caption data. Set to 1 if screens_to_progress != -1 && screenfuls_counter >= screens_to_process
+	int cc_to_stdout;                     // If this is set to 1, the stdout will be flushed when data was written to the screen during a process_608 call.
+	struct ccx_decoder_608_report *report;
+	LLONG subs_delay;                     // ms to delay (or advance) subs
+	enum ccx_output_format output_format; // What kind of output format should be used?
+	int textprinted;
+	struct ccx_common_timing_ctx *timing;
+
+} ccx_decoder_608_context;
+
+
+#define MAX_COLOR 10
+extern const char *color_text[MAX_COLOR][2];
+
+typedef enum ccx_decoder_608_color_code
+{
+	COL_WHITE = 0,
+	COL_GREEN = 1,
+	COL_BLUE = 2,
+	COL_CYAN = 3,
+	COL_RED = 4,
+	COL_YELLOW = 5,
+	COL_MAGENTA = 6,
+	COL_USERDEFINED = 7,
+	COL_BLACK = 8,
+	COL_TRANSPARENT = 9
+} ccx_decoder_608_color_code;
+
+
+enum font_bits
+{
+	FONT_REGULAR = 0,
+	FONT_ITALICS = 1,
+	FONT_UNDERLINED = 2,
+	FONT_UNDERLINED_ITALICS = 3
+};
+
+enum command_code
+{
+	COM_UNKNOWN = 0,
+	COM_ERASEDISPLAYEDMEMORY = 1,
+	COM_RESUMECAPTIONLOADING = 2,
+	COM_ENDOFCAPTION = 3,
+	COM_TABOFFSET1 = 4,
+	COM_TABOFFSET2 = 5,
+	COM_TABOFFSET3 = 6,
+	COM_ROLLUP2 = 7,
+	COM_ROLLUP3 = 8,
+	COM_ROLLUP4 = 9,
+	COM_CARRIAGERETURN = 10,
+	COM_ERASENONDISPLAYEDMEMORY = 11,
+	COM_BACKSPACE = 12,
+	COM_RESUMETEXTDISPLAY = 13,
+	COM_ALARMOFF =14,
+	COM_ALARMON = 15,
+	COM_DELETETOENDOFROW = 16,
+	COM_RESUMEDIRECTCAPTIONING = 17,
+	// Non existing commands we insert to have the decoder
+	// special stuff for us.
+	COM_FAKE_RULLUP1 = 18
+};
+
+
+void ccx_decoder_608_dinit_library(void **ctx);
+/*
+ *
+ */
+ccx_decoder_608_context* ccx_decoder_608_init_library(struct ccx_decoder_608_settings *settings, int channel,
+		int field, int *halt,
+		int cc_to_stdout,
+		enum ccx_output_format output_format, struct ccx_common_timing_ctx *timing);
+
+/**
+ * @param data raw cc608 data to be processed
+ *
+ * @param length length of data passed
+ *
+ * @param private_data context of cc608 where important information related to 608
+ * 		  are stored.
+ *
+ * @param sub pointer to subtitle should be memset to 0 when passed first time
+ *            subtitle are stored when structure return
+ *
+ * @return number of bytes used from data, -1 when any error is encountered
+ */
+int process608(const unsigned char *data, int length, void *private_data, struct cc_subtitle *sub);
+
+/**
+ * Issue a EraseDisplayedMemory here so if there's any captions pending
+ * they get written to cc_subtitle
+ */
+void flush_608_context(ccx_decoder_608_context *context, struct cc_subtitle *sub);
+
+int write_cc_buffer(ccx_decoder_608_context *context, struct cc_subtitle *sub);
+
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_decoders_708.h Added

@@ -0,0 +1,377 @@
+#ifndef _INCLUDE_708_
+#define _INCLUDE_708_
+
+#include <sys/stat.h>
+#include "ccx_common_platform.h"
+#include "ccx_common_constants.h"
+#include "ccx_common_structs.h"
+
+#define CCX_DTVCC_MAX_PACKET_LENGTH 128 //According to EIA-708B, part 5
+#define CCX_DTVCC_MAX_SERVICES 63
+
+#define CCX_DTVCC_MAX_ROWS 15
+/**
+ * This value should be 32, but there were 16-bit encoded samples (from Korea),
+ * where RowCount calculated another way and equals 46 (23[8bit]*2)
+ */
+#define CCX_DTVCC_MAX_COLUMNS (32*2)
+
+#define CCX_DTVCC_SCREENGRID_ROWS 75
+#define CCX_DTVCC_SCREENGRID_COLUMNS 210
+
+#define CCX_DTVCC_MAX_WINDOWS 8
+#define NOT_OVERLAPPED 0
+#define OVERLAPPING_WITH_HIGH_PRIORITY 0
+#define OVERLAPPED_BY_HIGH_PRIORITY 1
+
+#define CCX_DTVCC_FILENAME_TEMPLATE ".p%u.svc%02u"
+
+#define CCX_DTVCC_NO_LAST_SEQUENCE -1
+
+enum CCX_DTVCC_COMMANDS_C0_CODES
+{
+	CCX_DTVCC_C0_NUL = 	0x00,
+	CCX_DTVCC_C0_ETX = 	0x03,
+	CCX_DTVCC_C0_BS = 	0x08,
+	CCX_DTVCC_C0_FF = 	0x0c,
+	CCX_DTVCC_C0_CR = 	0x0d,
+	CCX_DTVCC_C0_HCR = 	0x0e,
+	CCX_DTVCC_C0_EXT1 = 0x10,
+	CCX_DTVCC_C0_P16 = 	0x18
+};
+
+enum CCX_DTVCC_COMMANDS_C1_CODES
+{
+	CCX_DTVCC_C1_CW0 = 0x80,
+	CCX_DTVCC_C1_CW1 = 0x81,
+	CCX_DTVCC_C1_CW2 = 0x82,
+	CCX_DTVCC_C1_CW3 = 0x83,
+	CCX_DTVCC_C1_CW4 = 0x84,
+	CCX_DTVCC_C1_CW5 = 0x85,
+	CCX_DTVCC_C1_CW6 = 0x86,
+	CCX_DTVCC_C1_CW7 = 0x87,
+	CCX_DTVCC_C1_CLW = 0x88,
+	CCX_DTVCC_C1_DSW = 0x89,
+	CCX_DTVCC_C1_HDW = 0x8A,
+	CCX_DTVCC_C1_TGW = 0x8B,
+	CCX_DTVCC_C1_DLW = 0x8C,
+	CCX_DTVCC_C1_DLY = 0x8D,
+	CCX_DTVCC_C1_DLC = 0x8E,
+	CCX_DTVCC_C1_RST = 0x8F,
+	CCX_DTVCC_C1_SPA = 0x90,
+	CCX_DTVCC_C1_SPC = 0x91,
+	CCX_DTVCC_C1_SPL = 0x92,
+	CCX_DTVCC_C1_RSV93 = 0x93,
+	CCX_DTVCC_C1_RSV94 = 0x94,
+	CCX_DTVCC_C1_RSV95 = 0x95,
+	CCX_DTVCC_C1_RSV96 = 0x96,
+	CCX_DTVCC_C1_SWA = 0x97,
+	CCX_DTVCC_C1_DF0 = 0x98,
+	CCX_DTVCC_C1_DF1 = 0x99,
+	CCX_DTVCC_C1_DF2 = 0x9A,
+	CCX_DTVCC_C1_DF3 = 0x9B,
+	CCX_DTVCC_C1_DF4 = 0x9C,
+	CCX_DTVCC_C1_DF5 = 0x9D,
+	CCX_DTVCC_C1_DF6 = 0x9E,
+	CCX_DTVCC_C1_DF7 = 0x9F
+};
+
+struct CCX_DTVCC_S_COMMANDS_C1
+{
+	int code;
+	const char *name;
+	const char *description;
+	int length;
+};
+
+enum ccx_dtvcc_window_justify
+{
+	CCX_DTVCC_WINDOW_JUSTIFY_LEFT	= 0,
+	CCX_DTVCC_WINDOW_JUSTIFY_RIGHT	= 1,
+	CCX_DTVCC_WINDOW_JUSTIFY_CENTER	= 2,
+	CCX_DTVCC_WINDOW_JUSTIFY_FULL	= 3
+};
+
+enum ccx_dtvcc_window_pd //Print Direction
+{
+	CCX_DTVCC_WINDOW_PD_LEFT_RIGHT = 0, //left -> right
+	CCX_DTVCC_WINDOW_PD_RIGHT_LEFT = 1,
+	CCX_DTVCC_WINDOW_PD_TOP_BOTTOM = 2,
+	CCX_DTVCC_WINDOW_PD_BOTTOM_TOP = 3
+};
+
+enum ccx_dtvcc_window_sd //Scroll Direction
+{
+	CCX_DTVCC_WINDOW_SD_LEFT_RIGHT = 0,
+	CCX_DTVCC_WINDOW_SD_RIGHT_LEFT = 1,
+	CCX_DTVCC_WINDOW_SD_TOP_BOTTOM = 2,
+	CCX_DTVCC_WINDOW_SD_BOTTOM_TOP = 3
+};
+
+enum ccx_dtvcc_window_sde //Scroll Display Effect
+{
+	CCX_DTVCC_WINDOW_SDE_SNAP = 0,
+	CCX_DTVCC_WINDOW_SDE_FADE = 1,
+	CCX_DTVCC_WINDOW_SDE_WIPE = 2
+};
+
+enum ccx_dtvcc_window_ed //Effect Direction
+{
+	CCX_DTVCC_WINDOW_ED_LEFT_RIGHT = 0,
+	CCX_DTVCC_WINDOW_ED_RIGHT_LEFT = 1,
+	CCX_DTVCC_WINDOW_ED_TOP_BOTTOM = 2,
+	CCX_DTVCC_WINDOW_ED_BOTTOM_TOP = 3
+};
+
+enum ccx_dtvcc_window_fo //Fill Opacity
+{
+	CCX_DTVCC_WINDOW_FO_SOLID		= 0,
+	CCX_DTVCC_WINDOW_FO_FLASH		= 1,
+	CCX_DTVCC_WINDOW_FO_TRANSLUCENT	= 2,
+	CCX_DTVCC_WINDOW_FO_TRANSPARENT = 3
+};
+
+enum ccx_dtvcc_window_border
+{
+	CCX_DTVCC_WINDOW_BORDER_NONE			= 0,
+	CCX_DTVCC_WINDOW_BORDER_RAISED			= 1,
+	CCX_DTVCC_WINDOW_BORDER_DEPRESSED		= 2,
+	CCX_DTVCC_WINDOW_BORDER_UNIFORM			= 3,
+	CCX_DTVCC_WINDOW_BORDER_SHADOW_LEFT		= 4,
+	CCX_DTVCC_WINDOW_BORDER_SHADOW_RIGHT	= 5
+};
+
+enum ccx_dtvcc_pen_size
+{
+	CCX_DTVCC_PEN_SIZE_SMALL 	= 0,
+	CCX_DTVCC_PEN_SIZE_STANDART = 1,
+	CCX_DTVCC_PEN_SIZE_LARGE	= 2
+};
+
+enum ccx_dtvcc_pen_font_style
+{
+	CCX_DTVCC_PEN_FONT_STYLE_DEFAULT_OR_UNDEFINED					= 0,
+	CCX_DTVCC_PEN_FONT_STYLE_MONOSPACED_WITH_SERIFS					= 1,
+	CCX_DTVCC_PEN_FONT_STYLE_PROPORTIONALLY_SPACED_WITH_SERIFS		= 2,
+	CCX_DTVCC_PEN_FONT_STYLE_MONOSPACED_WITHOUT_SERIFS				= 3,
+	CCX_DTVCC_PEN_FONT_STYLE_PROPORTIONALLY_SPACED_WITHOUT_SERIFS	= 4,
+	CCX_DTVCC_PEN_FONT_STYLE_CASUAL_FONT_TYPE						= 5,
+	CCX_DTVCC_PEN_FONT_STYLE_CURSIVE_FONT_TYPE						= 6,
+	CCX_DTVCC_PEN_FONT_STYLE_SMALL_CAPITALS							= 7
+};
+
+enum ccx_dtvcc_pen_text_tag
+{
+	CCX_DTVCC_PEN_TEXT_TAG_DIALOG						= 0,
+	CCX_DTVCC_PEN_TEXT_TAG_SOURCE_OR_SPEAKER_ID			= 1,
+	CCX_DTVCC_PEN_TEXT_TAG_ELECTRONIC_VOICE				= 2,
+	CCX_DTVCC_PEN_TEXT_TAG_FOREIGN_LANGUAGE				= 3,
+	CCX_DTVCC_PEN_TEXT_TAG_VOICEOVER					= 4,
+	CCX_DTVCC_PEN_TEXT_TAG_AUDIBLE_TRANSLATION			= 5,
+	CCX_DTVCC_PEN_TEXT_TAG_SUBTITLE_TRANSLATION			= 6,
+	CCX_DTVCC_PEN_TEXT_TAG_VOICE_QUALITY_DESCRIPTION	= 7,
+	CCX_DTVCC_PEN_TEXT_TAG_SONG_LYRICS					= 8,
+	CCX_DTVCC_PEN_TEXT_TAG_SOUND_EFFECT_DESCRIPTION		= 9,
+	CCX_DTVCC_PEN_TEXT_TAG_MUSICAL_SCORE_DESCRIPTION	= 10,
+	CCX_DTVCC_PEN_TEXT_TAG_EXPLETIVE					= 11,
+	CCX_DTVCC_PEN_TEXT_TAG_UNDEFINED_12					= 12,
+	CCX_DTVCC_PEN_TEXT_TAG_UNDEFINED_13					= 13,
+	CCX_DTVCC_PEN_TEXT_TAG_UNDEFINED_14					= 14,
+	CCX_DTVCC_PEN_TEXT_TAG_NOT_TO_BE_DISPLAYED			= 15
+};
+
+enum ccx_dtvcc_pen_offset
+{
+	CCX_DTVCC_PEN_OFFSET_SUBSCRIPT		= 0,
+	CCX_DTVCC_PEN_OFFSET_NORMAL			= 1,
+	CCX_DTVCC_PEN_OFFSET_SUPERSCRIPT	= 2
+};
+
+enum ccx_dtvcc_pen_edge
+{
+	CCX_DTVCC_PEN_EDGE_NONE					= 0,
+	CCX_DTVCC_PEN_EDGE_RAISED				= 1,
+	CCX_DTVCC_PEN_EDGE_DEPRESSED			= 2,
+	CCX_DTVCC_PEN_EDGE_UNIFORM				= 3,
+	CCX_DTVCC_PEN_EDGE_LEFT_DROP_SHADOW		= 4,
+	CCX_DTVCC_PEN_EDGE_RIGHT_DROP_SHADOW	= 5
+};
+
+enum ccx_dtvcc_pen_anchor_point
+{
+	CCX_DTVCC_ANCHOR_POINT_TOP_LEFT 		= 0,
+	CCX_DTVCC_ANCHOR_POINT_TOP_CENTER 		= 1,
+	CCX_DTVCC_ANCHOR_POINT_TOP_RIGHT 		= 2,
+	CCX_DTVCC_ANCHOR_POINT_MIDDLE_LEFT 		= 3,
+	CCX_DTVCC_ANCHOR_POINT_MIDDLE_CENTER 	= 4,
+	CCX_DTVCC_ANCHOR_POINT_MIDDLE_RIGHT 	= 5,
+	CCX_DTVCC_ANCHOR_POINT_BOTTOM_LEFT 		= 6,
+	CCX_DTVCC_ANCHOR_POINT_BOTTOM_CENTER 	= 7,
+	CCX_DTVCC_ANCHOR_POINT_BOTTOM_RIGHT 	= 8
+};
+
+typedef struct ccx_dtvcc_pen_color
+{
+	int fg_color;
+	int fg_opacity;
+	int bg_color;
+	int bg_opacity;
+	int edge_color;
+} ccx_dtvcc_pen_color;
+
+typedef struct ccx_dtvcc_pen_attribs
+{
+	int pen_size;
+	int offset;
+	int text_tag;
+	int font_tag;
+	int edge_type;
+	int underline;
+	int italic;
+} ccx_dtvcc_pen_attribs;
+
+typedef struct ccx_dtvcc_window_attribs
+{
+	int justify;
+	int print_direction;
+	int scroll_direction;
+	int word_wrap;
+	int display_effect;
+	int effect_direction;
+	int effect_speed;
+	int fill_color;
+	int fill_opacity;
+	int border_type;
+	int border_color;
+} ccx_dtvcc_window_attribs;
+
+/**
+ * Since 1-byte and 2-byte symbols could appear in captions and
+ * since we have to keep symbols alignment and several windows could appear on a screen at one time,
+ * we use special structure for holding symbols
+ */
+typedef struct ccx_dtvcc_symbol
+{
+	unsigned short sym; //symbol itself, at least 16 bit
+	unsigned char init; //initialized or not. could be 0 or 1
+} ccx_dtvcc_symbol;
+
+#define CCX_DTVCC_SYM_SET(x, c) {x.init = 1; x.sym = c;}
+#define CCX_DTVCC_SYM_SET_16(x, c1, c2) {x.init = 1; x.sym = (c1 << 8) | c2;}
+#define CCX_DTVCC_SYM(x) ((unsigned char)(x.sym))
+#define CCX_DTVCC_SYM_IS_EMPTY(x) (x.init == 0)
+#define CCX_DTVCC_SYM_IS_SET(x) (x.init == 1)
+
+typedef struct ccx_dtvcc_window
+{
+	int is_defined;
+	int number;
+	int priority;
+	int col_lock;
+	int row_lock;
+	int visible;
+	int anchor_vertical;
+	int relative_pos;
+	int anchor_horizontal;
+	int row_count;
+	int anchor_point;
+	int col_count;
+	int pen_style;
+	int win_style;
+	unsigned char commands[6]; // Commands used to create this window
+	ccx_dtvcc_window_attribs attribs;
+	int pen_row;
+	int pen_column;
+	ccx_dtvcc_symbol *rows[CCX_DTVCC_MAX_ROWS];
+	ccx_dtvcc_pen_color pen_colors[CCX_DTVCC_MAX_ROWS][CCX_DTVCC_SCREENGRID_COLUMNS];
+	ccx_dtvcc_pen_attribs pen_attribs[CCX_DTVCC_MAX_ROWS][CCX_DTVCC_SCREENGRID_COLUMNS];
+	ccx_dtvcc_pen_color pen_color_pattern;
+	ccx_dtvcc_pen_attribs pen_attribs_pattern;
+	int memory_reserved;
+	int is_empty;
+	LLONG time_ms_show;
+	LLONG time_ms_hide;
+} ccx_dtvcc_window;
+
+typedef struct dtvcc_tv_screen
+{
+	ccx_dtvcc_symbol chars[CCX_DTVCC_SCREENGRID_ROWS][CCX_DTVCC_SCREENGRID_COLUMNS];
+	ccx_dtvcc_pen_color pen_colors[CCX_DTVCC_SCREENGRID_ROWS][CCX_DTVCC_SCREENGRID_COLUMNS];
+	ccx_dtvcc_pen_attribs pen_attribs[CCX_DTVCC_SCREENGRID_ROWS][CCX_DTVCC_SCREENGRID_COLUMNS];
+	LLONG time_ms_show;
+	LLONG time_ms_hide;
+	unsigned int cc_count;
+	int service_number;
+} dtvcc_tv_screen;
+
+/**
+ * Holds data on the CEA 708 services that are encountered during file parse
+ * This can be interesting, so CCExtractor uses it for the report functionality.
+ */
+typedef struct ccx_decoder_dtvcc_report
+{
+	int reset_count;
+	unsigned services[CCX_DTVCC_MAX_SERVICES];
+} ccx_decoder_dtvcc_report;
+
+typedef struct ccx_dtvcc_service_decoder
+{
+	ccx_dtvcc_window windows[CCX_DTVCC_MAX_WINDOWS];
+	int current_window;
+	dtvcc_tv_screen *tv;
+	int cc_count;
+} ccx_dtvcc_service_decoder;
+
+typedef struct ccx_decoder_dtvcc_settings
+{
+	int enabled;
+	int print_file_reports;
+	int no_rollup;
+	ccx_decoder_dtvcc_report *report;
+	int active_services_count;
+	int services_enabled[CCX_DTVCC_MAX_SERVICES];
+	struct ccx_common_timing_ctx *timing;
+} ccx_decoder_dtvcc_settings;
+
+/**
+ * TODO
+ * solution requires "sink" or "writer" entity to write captions to output file
+ * decoders have to know nothing about output files
+ */
+
+typedef struct ccx_dtvcc_ctx
+{
+	int is_active;
+	int active_services_count;
+	int services_active[CCX_DTVCC_MAX_SERVICES]; //0 - inactive, 1 - active
+	int report_enabled;
+
+	ccx_decoder_dtvcc_report *report;
+
+	ccx_dtvcc_service_decoder decoders[CCX_DTVCC_MAX_SERVICES];
+
+	unsigned char current_packet[CCX_DTVCC_MAX_PACKET_LENGTH];
+	int current_packet_length;
+
+	int last_sequence;
+
+	void *encoder; //we can't include header, so keeping it this way
+	int no_rollup;
+	struct ccx_common_timing_ctx *timing;
+} ccx_dtvcc_ctx;
+
+
+void ccx_dtvcc_clear_packet(ccx_dtvcc_ctx *ctx);
+void ccx_dtvcc_windows_reset(ccx_dtvcc_service_decoder *decoder);
+void ccx_dtvcc_decoder_flush(ccx_dtvcc_ctx *dtvcc, ccx_dtvcc_service_decoder *decoder);
+
+void ccx_dtvcc_process_current_packet(ccx_dtvcc_ctx *dtvcc);
+void ccx_dtvcc_process_service_block(ccx_dtvcc_ctx *dtvcc,
+									 ccx_dtvcc_service_decoder *decoder,
+									 unsigned char *data,
+									 int data_length);
+
+ccx_dtvcc_pen_color ccx_dtvcc_default_pen_color;
+ccx_dtvcc_pen_attribs ccx_dtvcc_default_pen_attribs;
+
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_decoders_common.c Added

@@ -0,0 +1,615 @@
+/* Functions used by both the 608 and 708 decoders. An effort should be
+made to reuse, not duplicate, as many functions as possible */
+
+#include "ccx_decoders_common.h"
+#include "ccx_common_structs.h"
+#include "ccx_common_char_encoding.h"
+#include "ccx_common_constants.h"
+#include "ccx_common_timing.h"
+#include "ccx_common_common.h"
+#include "lib_ccx.h"
+#include "ccx_decoders_608.h"
+#ifndef MMCCXTR
+#include "ccx_decoders_708.h"
+#include "ccx_decoders_xds.h"
+#include "ccx_decoders_vbi.h"
+#include "ccx_dtvcc.h"
+#endif
+
+#ifndef MMCCXTR
+uint64_t utc_refvalue = UINT64_MAX;  /* _UI64_MAX means don't use UNIX, 0 = use current system time as reference, +1 use a specific reference */
+extern int in_xds_mode;
+#else
+static const int in_xds_mode=0;
+#endif
+
+
+/* This function returns a FTS that is guaranteed to be at least 1 ms later than the end of the previous screen. It shouldn't be needed
+   obviously but it guarantees there's no timing overlap */
+LLONG get_visible_start (struct ccx_common_timing_ctx *ctx, int current_field)
+{
+	LLONG fts = get_fts(ctx, current_field);
+	if (fts <= ctx->minimum_fts)
+		fts = ctx->minimum_fts + 1;
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "Visible Start time=%s\n", print_mstime_static(fts));
+	return fts;
+}
+
+/* This function returns the current FTS and saves it so it can be used by ctxget_visible_start */
+LLONG get_visible_end (struct ccx_common_timing_ctx *ctx, int current_field)
+{
+	LLONG fts = get_fts(ctx, current_field);
+	if (fts > ctx->minimum_fts)
+		ctx->minimum_fts = fts;
+	ccx_common_logging.debug_ftn(CCX_DMT_DECODER_608, "Visible End time=%s\n", print_mstime_static(fts));
+	return fts;
+}
+
+int process_cc_data (struct lib_cc_decode *ctx, unsigned char *cc_data, int cc_count, struct cc_subtitle *sub)
+{
+	int ret = -1;
+	for (int j = 0; j < cc_count * 3; j = j + 3)
+	{
+		if (validate_cc_data_pair( cc_data + j ) )
+			continue;
+		ret = do_cb(ctx, cc_data + j, sub);
+		if (ret == 1) //1 means success here
+			ret = 0;
+	}
+	return ret;
+}
+int validate_cc_data_pair (unsigned char *cc_data_pair)
+{
+	unsigned char cc_valid = (*cc_data_pair & 4) >>2;
+	unsigned char cc_type = *cc_data_pair & 3;
+
+	if (!cc_valid)
+		return -1;
+
+	if (cc_type==0 || cc_type==1)
+	{
+		// For EIA-608 data we verify parity.
+		if (!cc608_parity_table[cc_data_pair[2]])
+		{
+			// If the second byte doesn't pass parity, ignore pair
+			return -1;
+		}
+		if (!cc608_parity_table[cc_data_pair[1]])
+		{
+			// The first byte doesn't pass parity, we replace it with a solid blank
+			// and process the pair.
+			cc_data_pair[1]=0x7F;
+		}
+	}
+	return 0;
+
+}
+int do_cb (struct lib_cc_decode *ctx, unsigned char *cc_block, struct cc_subtitle *sub)
+{
+	unsigned char cc_valid = (*cc_block & 4) >>2;
+	unsigned char cc_type = *cc_block & 3;
+
+	int timeok = 1;
+
+	if ( ctx->fix_padding
+		&& cc_valid==0 && cc_type <= 1 // Only fix NTSC packets
+		&& cc_block[1]==0 && cc_block[2]==0 )
+	{
+		/* Padding */
+		cc_valid=1;
+		cc_block[1]=0x80;
+		cc_block[2]=0x80;
+	}
+
+#ifndef MMCCXTR
+	if ( ctx->write_format!=CCX_OF_RAW && // In raw we cannot skip padding because timing depends on it
+		 ctx->write_format!=CCX_OF_DVDRAW &&
+		(cc_block[0]==0xFA || cc_block[0]==0xFC || cc_block[0]==0xFD )
+		&& (cc_block[1]&0x7F)==0 && (cc_block[2]&0x7F)==0) // CFS: Skip non-data, makes debugging harder.
+		return 1;
+#endif
+
+	// Print raw data with FTS.
+	dbg_print(CCX_DMT_CBRAW, "%s   %d   %02X:%c%c:%02X", print_mstime_static(ctx->timing->fts_now + ctx->timing->fts_global),in_xds_mode,
+			cc_block[0], cc_block[1]&0x7f,cc_block[2]&0x7f, cc_block[2]);
+
+	/* In theory the writercwtdata() function could return early and not
+	 * go through the 608/708 cases below.  We do that to get accurate
+	 * counts for cb_field1, cb_field2 and cb_708.
+	 * Note that printdata() and dtvcc_process_data() must not be called for
+	 * the CCX_OF_RCWT case. */
+
+	if (cc_valid || cc_type==3)
+	{
+		ctx->cc_stats[cc_type]++;
+
+		switch (cc_type)
+		{
+			case 0:
+				dbg_print(CCX_DMT_CBRAW, "    %s   ..   ..\n",  debug_608_to_ASC( cc_block, 0));
+
+				ctx->current_field = 1;
+				ctx->saw_caption_block = 1;
+
+				if (ctx->extraction_start.set &&
+						get_fts(ctx->timing, ctx->current_field) < ctx->extraction_start.time_in_ms)
+					timeok = 0;
+				if (ctx->extraction_end.set &&
+						get_fts(ctx->timing, ctx->current_field) > ctx->extraction_end.time_in_ms)
+				{
+					timeok = 0;
+					ctx->processed_enough=1;
+				}
+				if (timeok)
+				{
+#ifndef MMCCXTR
+					if(ctx->write_format!=CCX_OF_RCWT)
+#endif
+						printdata (ctx, cc_block+1,2,0,0, sub);
+#ifndef MMCCXTR
+					else
+						writercwtdata(ctx, cc_block, sub);
+#endif
+				}
+				cb_field1++;
+				break;
+			case 1:
+				dbg_print(CCX_DMT_CBRAW, "    ..   %s   ..\n",  debug_608_to_ASC( cc_block, 1));
+
+				ctx->current_field = 2;
+				ctx->saw_caption_block = 1;
+
+				if (ctx->extraction_start.set &&
+						get_fts(ctx->timing, ctx->current_field) < ctx->extraction_start.time_in_ms)
+					timeok = 0;
+				if (ctx->extraction_end.set &&
+						get_fts(ctx->timing, ctx->current_field) > ctx->extraction_end.time_in_ms)
+				{
+					timeok = 0;
+					ctx->processed_enough=1;
+				}
+				if (timeok)
+				{
+#ifndef MMCCXTR
+					if(ctx->write_format!=CCX_OF_RCWT)
+#endif
+						printdata (ctx, 0,0,cc_block+1,2, sub);
+#ifndef MMCCXTR
+					else
+						writercwtdata(ctx, cc_block, sub);
+#endif
+				}
+				cb_field2++;
+				break;
+#ifndef MMCCXTR
+			case 2: //EIA-708
+				// DTVCC packet data
+				// Fall through
+			case 3: //EIA-708
+				dbg_print(CCX_DMT_CBRAW, "    ..   ..   DD\n");
+
+				// DTVCC packet start
+				ctx->current_field = 3;
+
+				if (ctx->extraction_start.set &&
+						get_fts(ctx->timing, ctx->current_field) < ctx->extraction_start.time_in_ms)
+					timeok = 0;
+				if (ctx->extraction_end.set &&
+						get_fts(ctx->timing, ctx->current_field) > ctx->extraction_end.time_in_ms)
+				{
+					timeok = 0;
+					ctx->processed_enough=1;
+				}
+				char temp[4];
+				temp[0]=cc_valid;
+				temp[1]=cc_type;
+				temp[2]=cc_block[1];
+				temp[3]=cc_block[2];
+				if (timeok)
+				{
+					if (ctx->write_format != CCX_OF_RCWT)
+						ccx_dtvcc_process_data(ctx, (const unsigned char *) temp, 4);
+					else
+						writercwtdata(ctx, cc_block, sub);
+				}
+				cb_708++;
+				// Check for bytes read
+				// printf ("Warning: Losing EIA-708 data!\n");
+				break;
+#endif
+			default:
+				fatal(CCX_COMMON_EXIT_BUG_BUG, "In do_cb: Impossible value for cc_type, Please file a bug report on GitHub.\n");
+		} // switch (cc_type)
+	} // cc_valid
+	else
+	{
+		dbg_print(CCX_DMT_CBRAW, "    ..   ..   ..\n");
+		dbg_print(CCX_DMT_VERBOSE, "Found !(cc_valid || cc_type==3) - ignore this block\n");
+	}
+
+	return 1;
+}
+
+void dinit_cc_decode(struct lib_cc_decode **ctx)
+{
+	struct lib_cc_decode *lctx = *ctx;
+#ifndef MMCCXTR
+	ccx_dtvcc_free(&lctx->dtvcc);
+	dinit_avc(&lctx->avc_ctx);
+#endif
+	ccx_decoder_608_dinit_library(&lctx->context_cc608_field_1);
+	ccx_decoder_608_dinit_library(&lctx->context_cc608_field_2);
+	dinit_timing_ctx(&lctx->timing);
+	free_decoder_context(lctx->prev);
+	free_subtitle(lctx->dec_sub.prev);
+	freep(ctx);
+}
+
+struct lib_cc_decode* init_cc_decode (struct ccx_decoders_common_settings_t *setting)
+{
+	struct lib_cc_decode *ctx = NULL;
+
+	ctx = malloc(sizeof(struct lib_cc_decode));
+	if(!ctx)
+		return NULL;
+
+#ifndef MMCCXTR
+	ctx->avc_ctx = init_avc();
+#endif
+	ctx->codec = setting->codec;
+	ctx->timing = init_timing_ctx(&ccx_common_timing_settings);
+
+	setting->settings_dtvcc->timing = ctx->timing;
+
+	setting->settings_608->no_rollup = setting->no_rollup;
+	setting->settings_dtvcc->no_rollup = setting->no_rollup;
+	ctx->no_rollup = setting->no_rollup;
+	ctx->noscte20 = setting->noscte20;
+
+#ifndef MMCCXTR
+	ctx->dtvcc = ccx_dtvcc_init(setting->settings_dtvcc);
+	ctx->dtvcc->is_active = setting->settings_dtvcc->enabled;
+#endif
+
+	if(setting->codec == CCX_CODEC_ATSC_CC)
+	{
+		// Prepare 608 context
+		ctx->context_cc608_field_1 = ccx_decoder_608_init_library(
+				setting->settings_608,
+				setting->cc_channel,
+				1,
+				&ctx->processed_enough,
+				setting->cc_to_stdout,
+				setting->output_format,
+				ctx->timing
+				);
+		ctx->context_cc608_field_2 = ccx_decoder_608_init_library(
+				setting->settings_608,
+				setting->cc_channel,
+				2,
+				&ctx->processed_enough,
+				setting->cc_to_stdout,
+				setting->output_format,
+				ctx->timing
+				);
+	}
+	else
+	{
+		ctx->context_cc608_field_1 = NULL;
+		ctx->context_cc608_field_2 = NULL;
+	}
+	ctx->current_field = 1;
+#ifndef MMCCXTR
+	ctx->private_data = setting->private_data;
+#endif
+	ctx->fix_padding = setting->fix_padding;
+	ctx->write_format =  setting->output_format;
+	ctx->subs_delay =  setting->subs_delay;
+	ctx->extract = setting->extract;
+	ctx->fullbin = setting->fullbin;
+	ctx->hauppauge_mode = setting->hauppauge_mode;
+	ctx->saw_caption_block = 0;
+	ctx->program_number = setting->program_number;
+	ctx->processed_enough = 0;
+	ctx->max_gop_length = 0;
+	ctx->has_ccdata_buffered = 0;
+	ctx->in_bufferdatatype = CCX_UNKNOWN;
+	ctx->frames_since_last_gop  = 0;
+	ctx->total_pulldownfields   = 0;
+	ctx->total_pulldownframes   = 0;
+	ctx->stat_numuserheaders    = 0;
+	ctx->stat_dvdccheaders      = 0;
+	ctx->stat_scte20ccheaders   = 0;
+	ctx->stat_replay5000headers = 0;
+	ctx->stat_replay4000headers = 0;
+	ctx->stat_dishheaders       = 0;
+	ctx->stat_hdtv              = 0;
+	ctx->stat_divicom           = 0;
+	ctx->false_pict_header = 0;
+
+	memcpy(&ctx->extraction_start, &setting->extraction_start,sizeof(struct ccx_boundary_time));
+	memcpy(&ctx->extraction_end, &setting->extraction_end,sizeof(struct ccx_boundary_time));
+
+#ifndef MMCCXTR
+	if (setting->send_to_srv)
+		ctx->writedata = net_send_cc;
+	else if (setting->output_format==CCX_OF_RAW ||
+		setting->output_format==CCX_OF_DVDRAW ||
+		setting->output_format==CCX_OF_RCWT )
+		ctx->writedata = writeraw;
+	else if (setting->output_format==CCX_OF_SMPTETT ||
+		setting->output_format==CCX_OF_SAMI ||
+		setting->output_format==CCX_OF_SRT ||
+		setting->output_format==CCX_OF_SSA ||
+		setting->output_format == CCX_OF_WEBVTT ||
+		setting->output_format==CCX_OF_TRANSCRIPT ||
+		setting->output_format==CCX_OF_SPUPNG ||
+		setting->output_format==CCX_OF_SIMPLE_XML ||
+		setting->output_format==CCX_OF_G608 ||
+		setting->output_format==CCX_OF_NULL ||
+		setting->output_format==CCX_OF_CURL)
+#else
+	if (setting->output_format==CCX_OF_SRT)
+#endif
+		ctx->writedata = process608;
+	else
+		fatal(CCX_COMMON_EXIT_BUG_BUG, "Invalid Write Format Selected");
+
+	memset (&ctx->dec_sub, 0,sizeof(ctx->dec_sub));
+
+	// Initialize HDTV caption buffer
+	init_hdcc(ctx);
+
+	ctx->current_hor_size = 0;
+	ctx->current_vert_size = 0;
+	ctx->current_aspect_ratio = 0;
+	ctx->current_frame_rate = 4; // Assume standard fps, 29.97
+
+        //Variables used while parsing elementary stream
+	ctx->no_bitstream_error = 0;
+	ctx->saw_seqgoppic = 0;
+	ctx->in_pic_data = 0;
+
+	ctx->current_progressive_sequence = 2;
+	ctx->current_pulldownfields = 32768;
+
+	ctx->temporal_reference = 0;
+	ctx->maxtref = 0;
+	ctx->picture_coding_type = CCX_FRAME_TYPE_RESET_OR_UNKNOWN;
+	ctx->num_key_frames = 0;
+	ctx->picture_structure = 0;
+	ctx->top_field_first = 0;
+	ctx->repeat_first_field = 0;
+	ctx->progressive_frame = 0;
+	ctx->pulldownfields = 0;
+        //es parser related variable ends here
+
+	memset(ctx->cc_stats, 0, 4 * sizeof(int));
+
+	ctx->anchor_seq_number = -1;
+#ifndef MMCCXTR
+	// Init XDS buffers
+	if(setting->output_format!=CCX_OF_TRANSCRIPT)
+	{
+		setting->xds_write_to_file = 0;
+	}
+	ctx->xds_ctx = ccx_decoders_xds_init_library(ctx->timing, setting->xds_write_to_file);
+
+	ctx->vbi_decoder = NULL;
+	ctx->ocr_quantmode = setting->ocr_quantmode;
+#endif
+	return ctx;
+}
+
+void flush_cc_decode(struct lib_cc_decode *ctx, struct cc_subtitle *sub)
+{
+	if(ctx->codec == CCX_CODEC_ATSC_CC)
+	{
+		if (ctx->extract != 2)
+		{
+#ifndef MMCCXTR
+			if (ctx->write_format==CCX_OF_SMPTETT || ctx->write_format==CCX_OF_SAMI ||
+					ctx->write_format==CCX_OF_SRT || ctx->write_format==CCX_OF_TRANSCRIPT ||
+					ctx->write_format == CCX_OF_WEBVTT || ctx->write_format == CCX_OF_SPUPNG ||
+					ctx->write_format == CCX_OF_SSA)
+#endif
+			{
+				flush_608_context(ctx->context_cc608_field_1, sub);
+			}
+#ifndef MMCCXTR
+			else if(ctx->write_format == CCX_OF_RCWT)
+			{
+				// Write last header and data
+				writercwtdata (ctx, NULL, sub);
+			}
+#endif
+		}
+		if (ctx->extract != 1)
+		{
+#ifndef MMCCXTR
+			if (ctx->write_format == CCX_OF_SMPTETT || ctx->write_format == CCX_OF_SAMI ||
+					ctx->write_format == CCX_OF_SRT || ctx->write_format == CCX_OF_TRANSCRIPT ||
+					ctx->write_format == CCX_OF_WEBVTT || ctx->write_format == CCX_OF_SPUPNG ||
+					ctx->write_format == CCX_OF_SSA)
+#endif
+			{
+				flush_608_context(ctx->context_cc608_field_2, sub);
+			}
+		}
+	}
+#ifndef MMCCXTR
+	if (ctx->dtvcc->is_active)
+	{
+		for (int i = 0; i < CCX_DTVCC_MAX_SERVICES; i++)
+		{
+			ccx_dtvcc_service_decoder *decoder = &ctx->dtvcc->decoders[i];
+			if (!ctx->dtvcc->services_active[i])
+				continue;
+			if (decoder->cc_count > 0)
+			{
+				ctx->current_field = 3;
+				ccx_dtvcc_decoder_flush(ctx->dtvcc, decoder);
+			}
+		}
+	}
+#endif
+}
+struct encoder_ctx* copy_encoder_context(struct encoder_ctx *ctx)
+{
+	struct encoder_ctx *ctx_copy = NULL;
+	ctx_copy = malloc(sizeof(struct encoder_ctx));
+	memcpy(ctx_copy, ctx, sizeof(struct encoder_ctx));
+
+	if (ctx->buffer)
+	{
+		ctx_copy->buffer = malloc(ctx->capacity * sizeof(unsigned char));
+		memcpy(ctx_copy->buffer, ctx->buffer, ctx->capacity * sizeof(unsigned char));
+	}
+	if (ctx->first_input_file)
+	{
+		ctx_copy->first_input_file = malloc(strlen(ctx->first_input_file) * sizeof(char));
+		memcpy(ctx_copy->first_input_file, ctx->first_input_file, strlen(ctx->first_input_file) * sizeof(char));
+	}
+	if (ctx->out)
+	{
+		ctx_copy->out = malloc(sizeof(struct ccx_s_write));
+		memcpy(ctx_copy->out, ctx->out, sizeof(struct ccx_s_write));
+	}
+	if (ctx->timing)
+	{
+		ctx_copy->timing = malloc(sizeof(struct ccx_common_timing_ctx));
+		memcpy(ctx_copy->timing, ctx->timing, sizeof(struct ccx_common_timing_ctx));
+	}
+	if (ctx->transcript_settings)
+	{
+		ctx_copy->transcript_settings = malloc(sizeof(struct ccx_encoders_transcript_format));
+		memcpy(ctx_copy->transcript_settings, ctx->transcript_settings, sizeof(struct ccx_encoders_transcript_format));
+	}
+	if (ctx->subline)
+	{
+		ctx_copy->subline = malloc(SUBLINESIZE);
+		memcpy(ctx_copy->subline, ctx->subline, SUBLINESIZE);
+	}
+	if (ctx->start_credits_text)
+	{
+		ctx_copy->start_credits_text = malloc(strlen(ctx->start_credits_text) * sizeof(char));
+		memcpy(ctx_copy->start_credits_text, ctx->start_credits_text, (strlen(ctx->start_credits_text) + 1) * sizeof(char));
+	}
+	if (ctx->end_credits_text)
+	{
+		ctx_copy->end_credits_text = malloc(strlen(ctx->end_credits_text) * sizeof(char));
+		memcpy(ctx_copy->end_credits_text, ctx->end_credits_text, (strlen(ctx->end_credits_text) + 1) * sizeof(char));
+	}
+	return ctx_copy;
+}
+struct lib_cc_decode* copy_decoder_context(struct lib_cc_decode *ctx)
+{
+	struct lib_cc_decode *ctx_copy = NULL;
+	ctx_copy = malloc(sizeof(struct lib_cc_decode));
+	memcpy(ctx_copy, ctx, sizeof(struct lib_cc_decode));
+
+	if (ctx->context_cc608_field_1)
+	{
+		ctx_copy->context_cc608_field_1 = malloc(sizeof(struct ccx_decoder_608_context));
+		memcpy(ctx_copy->context_cc608_field_1, ctx->context_cc608_field_1, sizeof(struct ccx_decoder_608_context));
+	}
+	if (ctx->context_cc608_field_2)
+	{
+		ctx_copy->context_cc608_field_2 = malloc(sizeof(struct ccx_decoder_608_context));
+		memcpy(ctx_copy->context_cc608_field_2, ctx->context_cc608_field_2, sizeof(struct ccx_decoder_608_context));
+	}
+	if (ctx->timing)
+	{
+		ctx_copy->timing = malloc(sizeof(struct ccx_common_timing_ctx));
+		memcpy(ctx_copy->timing, ctx->timing, sizeof(struct ccx_common_timing_ctx));
+	}
+#ifndef MMCCXTR
+	if (ctx->avc_ctx)
+	{
+		ctx_copy->avc_ctx = malloc(sizeof(struct avc_ctx));
+		memcpy(ctx_copy->avc_ctx, ctx->avc_ctx, sizeof(struct avc_ctx));
+	}
+	ctx_copy->private_data = NULL;
+	if (ctx->dtvcc)
+	{
+		ctx_copy->dtvcc = malloc(sizeof(struct ccx_dtvcc_ctx));
+		memcpy(ctx_copy->dtvcc, ctx->dtvcc, sizeof(struct ccx_dtvcc_ctx));
+	}
+	if (ctx->xds_ctx)
+	{
+		ctx_copy->xds_ctx = malloc(sizeof(struct ccx_decoders_xds_context));
+		memcpy(ctx_copy->xds_ctx, ctx->xds_ctx, sizeof(struct ccx_decoders_xds_context));
+	}
+	if (ctx->vbi_decoder)
+	{
+		ctx_copy->vbi_decoder = malloc(sizeof(struct ccx_decoder_vbi_ctx));
+		memcpy(ctx_copy->vbi_decoder, ctx->vbi_decoder, sizeof(struct ccx_decoder_vbi_ctx));
+	}
+#endif
+	return ctx_copy;
+}
+struct cc_subtitle* copy_subtitle(struct cc_subtitle *sub)
+{
+	struct cc_subtitle *sub_copy = NULL;
+	sub_copy = malloc(sizeof(struct cc_subtitle));
+	memcpy(sub_copy, sub, sizeof(struct cc_subtitle));
+	sub_copy->datatype = sub->datatype;
+
+	if (sub->data)
+	{
+		sub_copy->data = malloc(sub->nb_data * sizeof(struct eia608_screen));
+		memcpy(sub_copy->data, sub->data, sub->nb_data * sizeof(struct eia608_screen));
+	}
+	return sub_copy;
+}
+void free_encoder_context(struct encoder_ctx *ctx)
+{
+	if (!ctx)
+		return;
+
+	freep(&ctx->first_input_file);
+	freep(&ctx->buffer);
+	freep(&ctx->out);
+	freep(&ctx->timing);
+	freep(&ctx->transcript_settings);
+	freep(&ctx->subline);
+	freep(&ctx->start_credits_text);
+	freep(&ctx->end_credits_text);
+	freep(&ctx->prev);
+    freep(&ctx->last_string);
+	freep(&ctx);
+}
+void free_decoder_context(struct lib_cc_decode *ctx)
+{
+	if (!ctx)
+		return;
+
+	freep(&ctx->context_cc608_field_1);
+	freep(&ctx->context_cc608_field_2);
+	freep(&ctx->timing);
+#ifndef MMCCXTR
+	freep(&ctx->avc_ctx);
+	freep(&ctx->private_data);
+	freep(&ctx->dtvcc);
+	freep(&ctx->xds_ctx);
+	freep(&ctx->vbi_decoder);
+#endif
+	freep(&ctx);
+}
+void free_subtitle(struct cc_subtitle* sub)
+{
+	if (!sub)
+		return;
+
+	if (sub->datatype == CC_DATATYPE_DVB)
+	{
+		struct cc_bitmap *bitmap=(struct cc_bitmap *) sub->data;
+		if (bitmap)
+		{
+			freep(&bitmap->data0);
+			freep(&bitmap->data1);
+		}
+	}
+	freep(&sub->data);
+	freep(&sub);
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_decoders_common.h Added

@@ -0,0 +1,36 @@
+#ifndef _CC_DECODER_COMMON
+#define _CC_DECODER_COMMON
+
+#include "ccx_common_platform.h"
+#include "ccx_common_constants.h"
+#include "ccx_common_structs.h"
+#include "ccx_decoders_structs.h"
+#include "ccx_common_option.h"
+
+#ifndef MMCCXTR
+extern uint64_t utc_refvalue; // UTC referential value
+#endif
+
+// Declarations
+LLONG get_visible_start (struct ccx_common_timing_ctx *ctx, int current_field);
+LLONG get_visible_end (struct ccx_common_timing_ctx *ctx, int current_field);
+
+unsigned int get_decoder_str_basic(unsigned char *buffer, unsigned char *line, int trim_subs, enum ccx_encoding_type encoding);
+
+void ccx_decoders_common_settings_init(LLONG subs_delay, enum ccx_output_format output_format);
+
+int validate_cc_data_pair (unsigned char *cc_data_pair);
+int process_cc_data (struct lib_cc_decode *ctx, unsigned char *cc_data, int cc_count, struct cc_subtitle *sub);
+int do_cb (struct lib_cc_decode *ctx, unsigned char *cc_block, struct cc_subtitle *sub);
+void printdata (struct lib_cc_decode *ctx, const unsigned char *data1, int length1,
+                const unsigned char *data2, int length2, struct cc_subtitle *sub);
+struct lib_cc_decode* init_cc_decode (struct ccx_decoders_common_settings_t *setting);
+void dinit_cc_decode(struct lib_cc_decode **ctx);
+void flush_cc_decode(struct lib_cc_decode *ctx, struct cc_subtitle *sub);
+struct encoder_ctx* copy_encoder_context(struct encoder_ctx *ctx);
+struct lib_cc_decode* copy_decoder_context(struct lib_cc_decode *ctx);
+struct cc_subtitle* copy_subtitle(struct cc_subtitle *sub);
+void free_encoder_context(struct encoder_ctx *ctx);
+void free_decoder_context(struct lib_cc_decode *ctx);
+void free_subtitle(struct cc_subtitle* sub);
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_decoders_structs.h Added

@@ -0,0 +1,215 @@
+#ifndef CCX_DECODERS_STRUCTS_H
+#define CCX_DECODERS_STRUCTS_H
+
+#include "ccx_common_platform.h"
+#include "ccx_common_constants.h"
+#include "ccx_common_timing.h"
+#include "ccx_common_structs.h"
+#include "list.h"
+#include "ccx_decoders_708.h"
+// Define max width in characters/columns on the screen
+#define CCX_DECODER_608_SCREEN_WIDTH  32
+#define MAXBFRAMES 50
+#define SORTBUF (2*MAXBFRAMES+1)
+
+
+/* flag raised when end of display marker arrives in Dvb Subtitle */
+#define SUB_EOD_MARKER (1 << 0 )
+struct cc_bitmap
+{
+	int x;
+	int y;
+	int w;
+	int h;
+	int nb_colors;
+	unsigned char *data0;
+	unsigned char *data1;
+	int linesize0;
+	int linesize1;
+#ifdef ENABLE_OCR
+	char *ocr_text;
+#endif
+};
+
+enum ccx_eia608_format
+{
+	SFORMAT_CC_SCREEN,
+	SFORMAT_CC_LINE,
+	SFORMAT_XDS
+};
+
+enum cc_modes
+{
+	MODE_POPON = 0,
+	MODE_ROLLUP_2 = 1,
+	MODE_ROLLUP_3 = 2,
+	MODE_ROLLUP_4 = 3,
+	MODE_TEXT = 4,
+	MODE_PAINTON = 5,
+	// Fake modes to emulate stuff
+	MODE_FAKE_ROLLUP_1 = 100
+};
+
+/**
+* This structure have fields which need to be ignored according to format,
+* for example if format is SFORMAT_XDS then all fields other then
+* xds related (xds_str, xds_len and  cur_xds_packet_class) should be
+* ignored and not to be dereferenced.
+*
+* TODO use union inside struct for each kind of fields
+*/
+typedef struct eia608_screen // A CC buffer
+{
+	/** format of data inside this structure */
+	enum ccx_eia608_format format;
+	unsigned char characters[15][33];
+	unsigned char colors[15][33];
+	unsigned char fonts[15][33]; // Extra char at the end for a 0
+	int row_used[15];            // Any data in row?
+	int empty;                   // Buffer completely empty?
+	/** start time of this CC buffer */
+	LLONG start_time;
+	/** end time of this CC buffer */
+	LLONG end_time;
+	enum cc_modes mode;
+	int channel;  // Currently selected channel
+	int my_field; // Used for sanity checks
+	/** XDS string */
+	char *xds_str;
+	/** length of XDS string */
+	size_t xds_len;
+	/** Class of XDS string */
+	int cur_xds_packet_class;
+} eia608_screen;
+
+struct ccx_decoders_common_settings_t
+{
+	LLONG subs_delay;                                          // ms to delay (or advance) subs
+	enum ccx_output_format output_format;                      // What kind of output format should be used?
+	int fix_padding;                                           // Replace 0000 with 8080 in HDTV (needed for some cards)
+	struct ccx_boundary_time extraction_start, extraction_end; // Segment we actually process
+	int cc_to_stdout;
+	int extract;                                               // Extract 1st, 2nd or both fields
+	int fullbin;                                               // Disable pruning of padding cc blocks
+	int no_rollup;
+	int noscte20;
+	struct ccx_decoder_608_settings *settings_608;             // Contains the settings for the 608 decoder.
+	ccx_decoder_dtvcc_settings *settings_dtvcc;                // Same for cea 708 captions decoder (dtvcc)
+	int cc_channel;                                            // Channel we want to dump in srt mode
+	unsigned send_to_srv;
+	unsigned int hauppauge_mode;                               // If 1, use PID=1003, process specially and so on
+	int program_number;
+	enum ccx_code_type codec;
+	int xds_write_to_file;
+	void *private_data;
+	int ocr_quantmode;
+};
+
+struct lib_cc_decode
+{
+	int cc_stats[4];
+	int saw_caption_block;
+	int processed_enough; // If 1, we have enough lines, time, etc.
+
+	/* 608 contexts - note that this shouldn't be global, they should be
+	per program */
+	void *context_cc608_field_1;
+	void *context_cc608_field_2;
+
+	int no_rollup;                                             // If 1, write one line at a time
+	int noscte20;
+	int fix_padding;                                           // Replace 0000 with 8080 in HDTV (needed for some cards)
+	enum ccx_output_format write_format;                       // 0 = Raw, 1 = srt, 2 = SMI
+	struct ccx_boundary_time extraction_start, extraction_end; // Segment we actually process
+	LLONG subs_delay;                                          // ms to delay (or advance) subs
+	int extract;                                               // Extract 1st, 2nd or both fields
+	int fullbin;                                               // Disable pruning of padding cc blocks
+	struct cc_subtitle dec_sub;
+	enum ccx_bufferdata_type in_bufferdatatype;
+	unsigned int hauppauge_mode;                               // If 1, use PID=1003, process specially and so on
+
+	int frames_since_last_gop;
+	/* GOP-based timing */
+	int saw_gop_header;
+	/* Time info for timed-transcript */
+	int max_gop_length;  // (Maximum) length of a group of pictures
+	int last_gop_length; // Length of the previous group of pictures
+	unsigned total_pulldownfields;
+	unsigned total_pulldownframes;
+	int program_number;
+	struct list_head list;
+	struct ccx_common_timing_ctx *timing;
+	enum ccx_code_type codec;
+	// Set to true if data is buffered
+	int has_ccdata_buffered;
+	int is_alloc;
+
+#ifndef MMCCXTR
+	struct avc_ctx *avc_ctx;
+	void *private_data;
+#endif
+
+	/* General video information */
+	unsigned int current_hor_size;
+	unsigned int current_vert_size;
+	unsigned int current_aspect_ratio;
+	unsigned int current_frame_rate; // Assume standard fps, 29.97
+
+	/* Required in es_function.c */
+	int no_bitstream_error;
+	int saw_seqgoppic;
+	int in_pic_data;
+
+	unsigned int current_progressive_sequence;
+	unsigned int current_pulldownfields ;
+
+	int temporal_reference;
+	enum ccx_frame_type picture_coding_type;
+	unsigned num_key_frames;
+	unsigned picture_structure;
+	unsigned repeat_first_field;
+	unsigned progressive_frame;
+	unsigned pulldownfields;
+	/* Required in es_function.c and es_userdata.c */
+	unsigned top_field_first; // Needs to be global
+
+    /* Stats. Modified in es_userdata.c*/
+    int stat_numuserheaders;
+    int stat_dvdccheaders;
+    int stat_scte20ccheaders;
+    int stat_replay5000headers;
+    int stat_replay4000headers;
+    int stat_dishheaders;
+    int stat_hdtv;
+    int stat_divicom;
+    int false_pict_header;
+
+#ifndef MMCCXTR
+	ccx_dtvcc_ctx *dtvcc;
+#endif
+	int current_field;
+	// Analyse/use the picture information
+	int maxtref; // Use to remember the temporal reference number
+
+	int cc_data_count[SORTBUF];
+	// Store fts;
+	LLONG cc_fts[SORTBUF];
+	// Store HD CC packets
+	unsigned char cc_data_pkts[SORTBUF][10*31*3+1]; // *10, because MP4 seems to have different limits
+
+	// The sequence number of the current anchor frame.  All currently read
+	// B-Frames belong to this I- or P-frame.
+	int anchor_seq_number;
+#ifndef MMCCXTR
+	struct ccx_decoders_xds_context *xds_ctx;
+	struct ccx_decoder_vbi_ctx *vbi_decoder;
+#endif
+
+	int (*writedata)(const unsigned char *data, int length, void *private_data, struct cc_subtitle *sub);
+
+	//dvb subtitle related
+	int ocr_quantmode;
+	struct lib_cc_decode *prev;
+};
+
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_demuxer.c Added

@@ -0,0 +1,462 @@
+#include "ccx_demuxer.h"
+#include "activity.h"
+#include "lib_ccx.h"
+#include "utility.h"
+#ifndef MMCCXTR
+#include "ffmpeg_intgr.h"
+#endif
+
+static void ccx_demuxer_reset(struct ccx_demuxer *ctx)
+{
+	ctx->startbytes_pos=0;
+	ctx->startbytes_avail=0;
+#ifndef MMCCXTR
+	ctx->num_of_PIDs = 0;
+	memset(ctx->have_PIDs, -1, (MAX_PSI_PID + 1) * sizeof(int));
+	memset (ctx->PIDs_seen, 0, 65536*sizeof (int));
+	for (int i = 0; i < (MAX_PSI_PID + 1); i++)
+	{
+		ctx->min_pts[i] = UINT64_MAX;
+	}
+	memset(ctx->stream_id_of_each_pid, 0, (MAX_PSI_PID + 1) * sizeof(uint8_t));
+	memset (ctx->PIDs_programs, 0, 65536*sizeof (struct PMT_entry *));
+#endif
+}
+
+static void ccx_demuxer_close(struct ccx_demuxer *ctx)
+{ 
+	ctx->past = 0;
+	if (ctx->infd!=-1 && ccx_options.input_source==CCX_DS_FILE)
+	{
+		close (ctx->infd);
+		ctx->infd=-1;
+		activity_input_file_closed();
+	}
+}
+
+static int ccx_demuxer_isopen(struct ccx_demuxer *ctx)
+{
+	return ctx->infd != -1;
+}
+static int ccx_demuxer_open(struct ccx_demuxer *ctx, const char *file)
+{
+	ctx->past = 0;
+	ctx->min_global_timestamp = 0;
+	ctx->global_timestamp_inited = 0;
+	ctx->last_global_timestamp = 0;
+	ctx->offset_global_timestamp = 0;
+
+#ifdef ENABLE_FFMPEG
+	ctx->ffmpeg_ctx =  init_ffmpeg(file);
+	if(ctx->ffmpeg_ctx)
+	{
+		ctx->stream_mode = CCX_SM_FFMPEG;
+		ctx->auto_stream = CCX_SM_FFMPEG;
+		return 0;
+	}
+	else
+	{
+		mprint ("\rFailed to initialized ffmpeg falling back to legacy\n");
+	}
+#endif
+	init_file_buffer(ctx);
+	if (ccx_options.input_source==CCX_DS_STDIN)
+	{
+		if (ctx->infd != -1) // Means we had already processed stdin. So we're done.
+		{
+			if (ccx_options.print_file_reports)
+				print_file_report(ctx->parent);
+			return -1;
+		}
+		ctx->infd = 0;
+		mprint ("\n\r-----------------------------------------------------------------\n");
+		mprint ("\rReading from standard input\n");
+	}
+#ifndef MMCCXTR
+	else if (ccx_options.input_source == CCX_DS_NETWORK)
+	{
+		if (ctx->infd != -1) // Means we have already bound a socket.
+		{
+			if (ccx_options.print_file_reports)
+				print_file_report(ctx->parent);
+
+			return -1;
+		}
+
+		ctx->infd = start_upd_srv(ccx_options.udpsrc, ccx_options.udpaddr, ccx_options.udpport);
+		if(ctx->infd < 0)
+		{
+			print_error(ccx_options.gui_mode_reports,"socket() failed.");
+			return CCX_COMMON_EXIT_BUG_BUG;
+		}
+
+	}
+
+	else if (ccx_options.input_source == CCX_DS_TCP)
+	{
+		if (ctx->infd != -1)
+		{
+			if (ccx_options.print_file_reports)
+				print_file_report(ctx->parent);
+
+			return -1;
+		}
+
+		ctx->infd = start_tcp_srv(ccx_options.tcpport, ccx_options.tcp_password);
+	}
+#endif
+	else
+	{
+#ifdef _WIN32
+		ctx->infd = OPEN (file, O_RDONLY | O_BINARY);
+#else
+		ctx->infd = OPEN (file, O_RDONLY);
+#endif
+		if (ctx->infd < 0)
+			return -1;
+	}
+
+#ifndef MMCCXTR
+	if (ctx->auto_stream == CCX_SM_AUTODETECT)
+	{
+		detect_stream_type(ctx);
+		switch (ctx->stream_mode)
+		{
+			case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
+				mprint ("\rFile seems to be an elementary stream, enabling ES mode\n");
+				break;
+			case CCX_SM_TRANSPORT:
+				mprint ("\rFile seems to be a transport stream, enabling TS mode\n");
+				break;
+			case CCX_SM_PROGRAM:
+				mprint ("\rFile seems to be a program stream, enabling PS mode\n");
+				break;
+			case CCX_SM_ASF:
+				mprint ("\rFile seems to be an ASF, enabling DVR-MS mode\n");
+				break;
+			case CCX_SM_WTV:
+				mprint ("\rFile seems to be a WTV, enabling WTV mode\n");
+				break;
+			case CCX_SM_MCPOODLESRAW:
+				mprint ("\rFile seems to be McPoodle raw data\n");
+				break;
+			case CCX_SM_RCWT:
+				mprint ("\rFile seems to be a raw caption with time data\n");
+				break;
+			case CCX_SM_MP4:
+				mprint ("\rFile seems to be a MP4\n");
+				break;
+			case CCX_SM_GXF:
+				mprint ("\rFile seems to be a GXF\n");
+				break;
+			case CCX_SM_MKV:
+				mprint ("\rFile seems to be a Matroska/WebM container\n");
+				break;
+#ifdef WTV_DEBUG
+			case CCX_SM_HEX_DUMP:
+				mprint ("\rFile seems to be an hexadecimal dump\n");					
+				break;
+#endif
+			case CCX_SM_MXF:
+				mprint ("\rFile seems to be an MXF\n");
+				break;
+			case CCX_SM_MYTH:
+			case CCX_SM_AUTODETECT:
+				fatal(CCX_COMMON_EXIT_BUG_BUG, "In ccx_demuxer_open: Impossible value in stream_mode. Please file a bug report on GitHub.\n");
+				break;
+		}
+	}
+	else
+#endif
+	{
+		ctx->stream_mode = ctx->auto_stream;
+	}
+
+#ifndef MMCCXTR
+	// The myth loop autodetect will only be used with ES or PS streams
+	switch (ccx_options.auto_myth)
+	{
+		case 0:
+			// Use whatever stream mode says
+			break;
+		case 1:
+			// Force stream mode to myth
+			ctx->stream_mode=CCX_SM_MYTH;
+			break;
+		case 2:
+			// autodetect myth files, but only if it does not conflict with
+			// the current stream mode
+			switch (ctx->stream_mode)
+			{
+				case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
+				case CCX_SM_PROGRAM:
+					if ( detect_myth(ctx) )
+					{
+						ctx->stream_mode=CCX_SM_MYTH;
+					}
+					break;
+				default:
+					// Keep stream_mode
+					break;
+			}
+			break;					
+	}
+#endif
+
+	return 0;
+}
+LLONG ccx_demuxer_get_file_size (struct ccx_demuxer *ctx)
+{
+	LLONG ret = 0;
+	int in = ctx->infd;
+	LLONG current=LSEEK (in, 0, SEEK_CUR);
+	LLONG length = LSEEK (in,0,SEEK_END);
+	if(current < 0 ||length < 0)
+		return -1;
+
+	ret = LSEEK (in, current, SEEK_SET);
+	if (ret < 0)
+		return -1;
+
+	return length;
+}
+
+static int ccx_demuxer_get_stream_mode(struct ccx_demuxer *ctx)
+{
+	return ctx->stream_mode;
+}
+
+
+static void ccx_demuxer_print_cfg(struct ccx_demuxer *ctx)
+{
+	switch (ctx->auto_stream)
+	{
+#ifndef MMCCXTR
+		case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
+			mprint ("Elementary");
+			break;
+		case CCX_SM_TRANSPORT:
+			mprint ("Transport");
+			break;
+		case CCX_SM_PROGRAM:
+			mprint ("Program");
+			break;
+		case CCX_SM_ASF:
+			mprint ("DVR-MS");
+			break;
+		case CCX_SM_WTV:
+			mprint ("Windows Television (WTV)");
+			break;
+		case CCX_SM_MCPOODLESRAW:
+			mprint ("McPoodle's raw");
+			break;
+		case CCX_SM_AUTODETECT:
+			mprint ("Autodetect");
+			break;
+#endif
+		case CCX_SM_RCWT:
+			mprint ("BIN");
+			break;
+#ifndef MMCCXTR
+		case CCX_SM_MP4:
+			mprint ("MP4");
+			break;
+		case CCX_SM_MKV:
+			mprint("MKV");
+			break;
+		case CCX_SM_MXF:
+			mprint("MXF");
+			break;
+#endif
+#ifdef WTV_DEBUG
+		case CCX_SM_HEX_DUMP:
+			mprint ("Hex");
+			break;
+#endif
+		default:
+			fatal(CCX_COMMON_EXIT_BUG_BUG, "BUG: Unknown stream mode. Please file a bug report on Github.\n");
+			break;
+	}
+}
+int ccx_demuxer_write_es(struct ccx_demuxer *ctx, unsigned char* buf, size_t len)
+{
+	if (ctx->fh_out_elementarystream!=NULL)
+		fwrite (buf, 1, len,ctx->fh_out_elementarystream);
+	return CCX_OK;
+}
+
+void ccx_demuxer_delete(struct ccx_demuxer **ctx)
+{
+	struct ccx_demuxer *lctx = *ctx;
+	int i;
+#ifndef MMCCXTR
+	dinit_cap(lctx);
+	freep(&lctx->last_pat_payload);
+
+	for (i = 0; i < MAX_PSI_PID; i++)
+	{
+		if(lctx->PID_buffers[i]!=NULL && lctx->PID_buffers[i]->buffer!=NULL)
+		{
+			free(lctx->PID_buffers[i]->buffer);
+			lctx->PID_buffers[i]->buffer=NULL;
+			lctx->PID_buffers[i]->buffer_length=0;
+		}
+		freep(&lctx->PID_buffers[i]);
+	}
+	for (i = 0; i < MAX_PID; i++)
+	{
+		if( lctx->PIDs_programs[i])
+			freep(lctx->PIDs_programs + i);
+	}
+#endif
+	if (lctx->fh_out_elementarystream != NULL)
+		fclose (lctx->fh_out_elementarystream);
+
+	freep(&lctx->filebuffer);
+	freep(ctx);
+}
+
+struct ccx_demuxer *init_demuxer(void *parent, struct demuxer_cfg *cfg)
+{
+	int i;
+	struct ccx_demuxer *ctx = malloc(sizeof(struct ccx_demuxer));
+	if(!ctx)
+		return NULL;
+
+	ctx->infd = -1;//Set to -1 to indicate no file is open.
+#ifndef MMCCXTR
+	ctx->m2ts = cfg->m2ts;
+#endif
+	ctx->auto_stream = cfg->auto_stream;
+	ctx->stream_mode = CCX_SM_ELEMENTARY_OR_NOT_FOUND;
+
+#ifndef MMCCXTR
+	ctx->ts_autoprogram = cfg->ts_autoprogram;
+	ctx->ts_allprogram = cfg->ts_allprogram;
+	ctx->ts_datastreamtype = cfg->ts_datastreamtype;
+	ctx->nb_program = 0;
+	ctx->multi_stream_per_prog = 0;
+
+	for (int i = 0; i < MAX_PROGRAM; i++)
+	{
+		ctx->pinfo[i].has_all_min_pts = 0;
+		for (int j = 0; j < COUNT; j++)
+		{
+			ctx->pinfo[i].got_important_streams_min_pts[j] = UINT64_MAX;
+		}
+		ctx->pinfo[i].initialized_ocr = 0;
+		ctx->pinfo[i].version = 0xFF; // Not real in a real stream since it's 5 bits. FF => Not initialized
+	}
+
+	if(cfg->ts_forced_program  != -1)
+	{
+		ctx->pinfo[ctx->nb_program].pid = CCX_UNKNOWN;
+		ctx->pinfo[ctx->nb_program].program_number = cfg->ts_forced_program;
+		ctx->flag_ts_forced_pn = CCX_TRUE;
+		ctx->nb_program++;
+	}
+	else
+	{
+		ctx->flag_ts_forced_pn = CCX_FALSE;
+	}
+#endif
+
+	INIT_LIST_HEAD(&ctx->cinfo_tree.all_stream);
+	INIT_LIST_HEAD(&ctx->cinfo_tree.sib_stream);
+	INIT_LIST_HEAD(&ctx->cinfo_tree.pg_stream);
+
+	ctx->codec = cfg->codec;
+
+#ifndef MMCCXTR
+	ctx->flag_ts_forced_cappid = CCX_FALSE;
+	for(i = 0; i < cfg->nb_ts_cappid; i++)
+	{
+		if(ctx->codec == CCX_CODEC_ANY)
+			update_capinfo(ctx, cfg->ts_cappids[i], cfg->ts_datastreamtype, CCX_CODEC_NONE, 0, NULL);
+		else
+			update_capinfo(ctx, cfg->ts_cappids[i], cfg->ts_datastreamtype, ctx->codec, 0, NULL);
+	}
+
+	ctx->flag_ts_forced_cappid = cfg->nb_ts_cappid ? CCX_TRUE : CCX_FALSE;
+#endif
+	ctx->nocodec = cfg->nocodec;
+
+	ctx->reset = ccx_demuxer_reset;
+	ctx->close = ccx_demuxer_close;
+	ctx->open = ccx_demuxer_open;
+	ctx->is_open = ccx_demuxer_isopen;
+	ctx->get_filesize = ccx_demuxer_get_file_size;
+	ctx->get_stream_mode = ccx_demuxer_get_stream_mode;
+	ctx->print_cfg = ccx_demuxer_print_cfg;
+	ctx->write_es = ccx_demuxer_write_es;
+#ifndef MMCCXTR
+	ctx->hauppauge_warning_shown = 0;
+#endif
+	ctx->parent = parent;
+#ifndef MMCCXTR
+	ctx->last_pat_payload = NULL;
+	ctx->last_pat_length = 0;
+#endif
+
+	ctx->fh_out_elementarystream = NULL;
+	ctx->warning_program_not_found_shown = CCX_FALSE;
+	ctx->strangeheader = 0;
+#ifndef MMCCXTR
+	memset(&ctx->freport, 0, sizeof(ctx->freport));
+#endif
+	if (cfg->out_elementarystream_filename != NULL)
+	{
+		if ((ctx->fh_out_elementarystream = fopen (cfg->out_elementarystream_filename,"wb"))==NULL)
+		{
+			print_error(CCX_COMMON_EXIT_FILE_CREATION_FAILED, "Unable to open clean file: %s \nDetails : %s .\n", cfg->out_elementarystream_filename,strerror(errno)); //printing specific error - Permission Denied/ Wrong Path etc..
+			return NULL;
+		}
+	}
+
+#ifndef MMCCXTR
+	for(i = 0; i < MAX_PSI_PID; i++)
+		ctx->PID_buffers[i]=NULL;
+
+	init_ts(ctx);
+#endif
+	ctx->filebuffer = NULL;
+
+	return ctx;
+}
+
+void delete_demuxer_data(struct demuxer_data *data)
+{
+	free(data->buffer);
+	free(data);
+}
+
+struct demuxer_data* alloc_demuxer_data(void)
+{
+	struct demuxer_data* data = malloc(sizeof(struct demuxer_data));
+
+	if(!data)
+	{
+		return NULL;
+	}
+	data->buffer = (unsigned char *) malloc (BUFSIZE);
+	if(!data->buffer)
+	{
+		free(data);
+		return NULL;
+	}
+	data->len = 0;
+	data->bufferdatatype = CCX_PES;
+
+	data->program_number = -1;
+	data->stream_pid = -1;
+	data->codec = CCX_CODEC_NONE;
+	data->len = 0;
+	data->pts = CCX_NOPTS;
+	data->rollover_bits = 0;
+	data->tb.num = 1;
+	data->tb.den = 90000;
+	data->next_stream = 0;
+	data->next_program = 0;
+	return data;
+	
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_demuxer.h Added

@@ -0,0 +1,212 @@
+#ifndef CCX_DEMUXER_H
+#define CCX_DEMUXER_H
+#include "ccx_common_constants.h"
+#include "ccx_common_option.h"
+#ifndef MMCCXTR
+#include "ts_functions.h"
+#endif
+#include "list.h"
+#include "activity.h"
+#include "utility.h"
+
+/* Report information */
+#define SUB_STREAMS_CNT 10
+#define MAX_PID 65536
+#define MAX_NUM_OF_STREAMIDS 51
+#define MAX_PSI_PID 8191
+#define TS_PMT_MAP_SIZE 128
+#define MAX_PROGRAM 128
+#define MAX_PROGRAM_NAME_LEN 128
+
+enum STREAM_TYPE
+{
+	PRIVATE_STREAM_1 = 0,
+	AUDIO,
+	VIDEO,
+	COUNT
+};
+struct ccx_demux_report
+{
+        unsigned program_cnt;
+        unsigned dvb_sub_pid[SUB_STREAMS_CNT];
+        unsigned tlt_sub_pid[SUB_STREAMS_CNT];
+        unsigned mp4_cc_track_cnt;
+};
+
+struct program_info
+{
+	int pid;
+	int program_number;
+	int initialized_ocr; // Avoid initializing the OCR more than once
+	uint8_t analysed_PMT_once:1;
+	uint8_t version;
+	uint8_t saved_section[1021];
+	int32_t crc;
+	uint8_t valid_crc:1;
+	char name[MAX_PROGRAM_NAME_LEN];
+	/**
+	 * -1 pid represent that pcr_pid is not available
+	 */
+	int16_t pcr_pid;
+	uint64_t got_important_streams_min_pts[COUNT];
+	int has_all_min_pts;
+};
+
+struct cap_info
+{
+	int pid;
+	int program_number;
+	enum ccx_stream_type stream;
+	enum ccx_code_type codec;
+	long capbufsize;
+	unsigned char *capbuf;
+	long capbuflen; // Bytes read in capbuf
+	int saw_pesstart;
+	int prev_counter;
+	void *codec_private_data;
+	int ignore;
+
+	/**
+	  List joining all stream in TS
+	*/
+	struct list_head all_stream;
+	/**
+	  List joining all sibling Stream in Program
+	*/
+	struct list_head sib_head;
+	struct list_head sib_stream;
+	/**
+	  List joining all sibling Stream in Program
+	*/
+	struct list_head pg_stream;
+
+};
+struct ccx_demuxer
+{
+#ifndef MMCCXTR
+	int m2ts;
+#endif
+	enum ccx_stream_mode_enum stream_mode;
+	enum ccx_stream_mode_enum auto_stream;
+
+	// Small buffer to help us with the initial sync
+	unsigned char startbytes[STARTBYTESLENGTH];
+	unsigned int startbytes_pos;
+	int startbytes_avail;
+
+#ifndef MMCCXTR
+	// User Specified Param
+	int ts_autoprogram;
+	int ts_allprogram;
+	int flag_ts_forced_pn;
+	int flag_ts_forced_cappid;
+	int ts_datastreamtype;
+
+
+	struct program_info pinfo[MAX_PROGRAM];
+	int nb_program;
+#endif
+	/* subtitle codec type */
+	enum ccx_code_type codec;
+	enum ccx_code_type nocodec;
+	struct cap_info cinfo_tree;
+
+	/* File handles */
+	FILE *fh_out_elementarystream;
+	int infd;   // descriptor number to input.
+	LLONG past; /* Position in file, if in sync same as ftell()  */
+
+	// TODO relates to fts_global
+	int64_t global_timestamp;
+	int64_t min_global_timestamp;
+	int64_t offset_global_timestamp;
+	int64_t last_global_timestamp;
+	int global_timestamp_inited;
+
+#ifndef MMCCXTR
+	struct PSI_buffer *PID_buffers[MAX_PSI_PID];
+	int PIDs_seen[MAX_PID];
+
+	/*51 possible stream ids in total, 0xbd is private stream, 0xbe is padding stream, 
+	0xbf private stream 2, 0xc0 - 0xdf audio, 0xe0 - 0xef video 
+	(stream ids range from 0xbd to 0xef so 0xef - 0xbd + 1 = 51)*/
+	//uint8_t found_stream_ids[MAX_NUM_OF_STREAMIDS]; 
+
+	uint8_t stream_id_of_each_pid[MAX_PSI_PID + 1];
+	uint64_t min_pts[MAX_PSI_PID + 1];
+	int have_PIDs[MAX_PSI_PID + 1];
+	int num_of_PIDs;
+
+	struct PMT_entry *PIDs_programs[MAX_PID];
+	struct ccx_demux_report freport;
+
+	/* Hauppauge support */
+	unsigned hauppauge_warning_shown; // Did we detect a possible Hauppauge capture and told the user already?
+
+	int multi_stream_per_prog;
+
+	unsigned char *last_pat_payload;
+	unsigned last_pat_length;
+#endif
+
+	unsigned char *filebuffer;
+	LLONG filebuffer_start;      // Position of buffer start relative to file
+	unsigned int filebuffer_pos; // Position of pointer relative to buffer start
+	unsigned int bytesinbuffer;  // Number of bytes we actually have on buffer
+
+	int warning_program_not_found_shown;
+
+	// Remember if the last header was valid. Used to suppress too much output
+	// and the expected unrecognized first header for TiVo files.
+	int strangeheader;
+#ifdef ENABLE_FFMPEG
+	void *ffmpeg_ctx;
+#endif
+
+	void *parent;
+
+	//Will contain actual Demuxer Context
+	void *private_data;
+	void (*print_cfg)(struct ccx_demuxer *ctx);
+	void (*reset)(struct ccx_demuxer *ctx);
+	void (*close)(struct ccx_demuxer *ctx);
+	int (*open)(struct ccx_demuxer *ctx, const char *file_name);
+	int (*is_open)(struct ccx_demuxer *ctx);
+	int (*get_stream_mode)(struct ccx_demuxer *ctx);
+	LLONG (*get_filesize) (struct ccx_demuxer *ctx);
+	int (*write_es)(struct ccx_demuxer *ctx, unsigned char* buf, size_t len);
+};
+
+struct demuxer_data
+{
+	int program_number;
+	int stream_pid;
+	enum ccx_code_type codec;
+	enum ccx_bufferdata_type bufferdatatype;
+	unsigned char *buffer;
+	size_t len;
+	unsigned int rollover_bits; // The PTS rolls over every 26 hours and that can happen in the middle of a stream.
+	LLONG pts;
+	struct ccx_rational tb;
+	struct demuxer_data *next_stream;
+	struct demuxer_data *next_program;
+};
+
+struct cap_info *get_sib_stream_by_type(struct cap_info* program, enum ccx_code_type type);
+struct ccx_demuxer *init_demuxer(void *parent, struct demuxer_cfg *cfg);
+void ccx_demuxer_delete(struct ccx_demuxer **ctx);
+struct demuxer_data* alloc_demuxer_data(void);
+void delete_demuxer_data(struct demuxer_data *data);
+int update_capinfo(struct ccx_demuxer *ctx, int pid, enum ccx_stream_type stream, enum ccx_code_type codec, int pn, void *private_data);
+struct cap_info * get_cinfo(struct ccx_demuxer *ctx, int pid);
+int need_cap_info(struct ccx_demuxer *ctx, int program_number);
+int need_cap_info_for_pid(struct ccx_demuxer *ctx, int pid);
+struct demuxer_data *get_best_data(struct demuxer_data *data);
+struct demuxer_data *get_data_stream(struct demuxer_data *data, int pid);
+int get_best_stream(struct ccx_demuxer *ctx);
+void ignore_other_stream(struct ccx_demuxer *ctx, int pid);
+void dinit_cap (struct ccx_demuxer *ctx);
+int get_programme_number(struct ccx_demuxer *ctx, int pid);
+struct cap_info* get_best_sib_stream(struct cap_info* program);
+void ignore_other_sib_stream(struct cap_info* head, int pid);
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_encoders_common.c Added

@@ -0,0 +1,1466 @@
+#include "ccx_decoders_common.h"
+#include "ccx_encoders_common.h"
+#include "utility.h"
+#ifndef MMCCXTR
+#include "ocr.h"
+#endif
+#include "ccx_decoders_608.h"
+#ifndef MMCCXTR
+#include "ccx_decoders_708.h"
+#include "ccx_decoders_708_output.h"
+#include "ccx_encoders_xds.h"
+#endif
+#include "ccx_encoders_helpers.h"
+#include "../ccextractor.h"
+#ifdef ENABLE_SHARING
+#include "ccx_share.h"
+#endif //ENABLE_SHARING
+
+#ifdef WIN32
+int fsync(int fd)
+{
+	return FlushFileBuffers((HANDLE)_get_osfhandle(fd)) ? 0 : -1;
+}
+#endif
+
+#ifndef MMCCXTR
+// These are the default settings for plain transcripts. No times, no CC or caption mode, and no XDS.
+ccx_encoders_transcript_format ccx_encoders_default_transcript_settings =
+{
+	.showStartTime = 0,
+	.showEndTime = 0,
+	.showMode = 0,
+	.showCC = 0,
+	.relativeTimestamp = 1,
+	.xds = 0,
+	.useColors = 1,
+	.isFinal = 0
+};
+
+//TODO sami header doesn't carry about CRLF/LF option
+static const char *sami_header= // TODO: Revise the \n\
+</STYLE>\n\
+</HEAD>\n\n\
+<BODY>\n";
+
+static const char *ssa_header=
+"[Script Info]\n\
+Title: Default file\n\
+ScriptType: v4.00+\n\
+\n\
+[V4+ Styles]\n\
+Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n\
+Style: Default,Arial,20,&H00FFFFFF,&H000000FF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,1,1,2,10,10,10,0\n\
+\n\
+[Events]\n\
+Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n\
+\n";
+
+/*	
+
+TODO -- Set correct values for "ttp:dropMode", "ttp:frameRate" .Using common for now.
+
+ Extra reference, 
+
+	24 frame/sec (film, ATSC, 2k, 4k, 6k)
+	25 frame/sec (PAL (Europe, Uruguay, Argentina, Australia), SECAM, DVB, ATSC)
+	29.97 (30 ÷ 1.001) frame/sec (NTSC American System (US, Canada, Mexico, Colombia, etc.), ATSC, PAL-M (Brazil))
+	30 frame/sec (ATSC)
+	
+	Find framerate, then use it find dropmode.
+	
+*/
+static const char *smptett_header = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>\n"
+			"  <tt xmlns=\"http://www.w3.org/ns/ttml\" xmlns:ttp=\"http://www.w3.org/ns/ttml#parameter\" ttp:dropMode=\"dropNTSC\" ttp:frameRate=\"30\" ttp:frameRateMultiplier=\"1000 1001\" ttp:timeBase=\"smpte\" xmlns:m608=\"http://www.smpte-ra.org/schemas/2052-1/2010/smpte-tt#cea608\" xmlns:smpte=\"http://www.smpte-ra.org/schemas/2052-1/2010/smpte-tt\" xmlns:ttm=\"http://www.w3.org/ns/ttml#metadata\" xmlns:tts=\"http://www.w3.org/ns/ttml#styling\">\n"
+//			"  <tt xmlns=\"http://www.w3.org/ns/ttml\" xmlns:ttp=\"http://www.w3.org/ns/ttml#parameter\" xmlns:m608=\"http://www.smpte-ra.org/schemas/2052-1/2010/smpte-tt#cea608\" xmlns:smpte=\"http://www.smpte-ra.org/schemas/2052-1/2010/smpte-tt\" xmlns:ttm=\"http://www.w3.org/ns/ttml#metadata\" xmlns:tts=\"http://www.w3.org/ns/ttml#styling\">\n"
+			"  <head>\n"
+			"    <styling>\n"
+			"      <style tts:color=\"white\" tts:fontFamily=\"monospace\" tts:fontWeight=\"normal\" tts:textAlign=\"left\" xml:id=\"basic\"/>\n"
+			"    </styling>\n"
+			"    <layout>\n"
+			"      <region tts:backgroundColor=\"transparent\" xml:id=\"pop1\"/>\n"
+			"      <region tts:backgroundColor=\"transparent\" xml:id=\"paint\"/>\n"
+			"      <region tts:backgroundColor=\"transparent\" xml:id=\"rollup2\"/>\n"
+			"      <region tts:backgroundColor=\"transparent\" xml:id=\"rollup3\"/>\n"
+			"      <region tts:backgroundColor=\"transparent\" xml:id=\"rollup4\"/>\n"
+			"    </layout>\n"
+			"    <metadata/>\n"
+			"    <smpte:information m608:captionService=\"F1C1CC\" m608:channel=\"cc1\"/>\n"
+			"  </head>\n"
+			"  <body>\n"
+			"    <div>\n";
+
+static const char *webvtt_header[] = {"WEBVTT","\r\n","\r\n","STYLE","\r\n","\r\n",NULL};
+
+static const char *simple_xml_header = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\r\n<captions>\r\n";
+#endif
+
+void find_limit_characters(unsigned char *line, int *first_non_blank, int *last_non_blank, int max_len)
+{
+	*last_non_blank = -1;
+	*first_non_blank = -1;
+	for (int i = 0; i < max_len; i++)
+	{
+		unsigned char c = line[i];
+		if (c != ' ' && c != 0x89 )
+		{
+			if (*first_non_blank == -1)
+				*first_non_blank = i;
+			*last_non_blank = i;
+		}
+		if (c == '\0' || c == '\n' || c == '\r')
+			break;
+	}
+}
+
+unsigned int utf8_to_latin1_map(const unsigned int code)
+{
+    /* Code points 0 to U+00FF are the same in both. */
+    if (code < 256U)
+        return code;
+
+    switch (code)
+	{
+    case 0x0152U:
+		return 188U; /* U+0152 = 0xBC: OE ligature */
+    case 0x0153U:
+		return 189U; /* U+0153 = 0xBD: oe ligature */
+    case 0x0160U:
+		return 166U; /* U+0160 = 0xA6: S with caron */
+    case 0x0161U: return 168U; /* U+0161 = 0xA8: s with caron */
+    case 0x0178U: return 190U; /* U+0178 = 0xBE: Y with diaresis */
+    case 0x017DU: return 180U; /* U+017D = 0xB4: Z with caron */
+    case 0x017EU: return 184U; /* U+017E = 0xB8: z with caron */
+    case 0x20ACU: return 164U; /* U+20AC = 0xA4: Euro */
+    default:      return 256U;
+    }
+}
+
+int change_utf8_encoding(unsigned char* dest, unsigned char* src, int len, enum ccx_encoding_type out_enc)
+{
+	unsigned char *orig = dest; // Keep for calculating length
+	unsigned char *orig_src = src; // Keep for calculating length
+	for (int i = 0; src < orig_src + len;)
+	{
+		unsigned char c = src[i];
+		int c_len = 0;
+
+		if ( c < 0x80 )
+			c_len = 1;
+		else if ( ( c & 0x20 ) == 0 )
+			c_len = 2;
+		else if ( ( c & 0x10 ) == 0 )
+			c_len = 3;
+		else if ( ( c & 0x08 ) == 0 )
+			c_len = 4;
+		else if ( ( c & 0x04 ) == 0 )
+			c_len = 5;
+
+		switch (out_enc)
+		{
+		case CCX_ENC_UTF_8:
+			memcpy(dest, src, len);
+			return len;
+		case CCX_ENC_LATIN_1:
+			if (c_len == 1)
+				*dest++ = *src;
+			else if (c_len == 2)
+			{
+				if ((src[1] & 0x40) == 0)
+				{
+					c = utf8_to_latin1_map((((unsigned int)(src[0] & 0x1F)) << 6)
+							|  ((unsigned int)(src[1] & 0x3F)));
+					if (c < 256)
+						*dest++ = c;
+					else
+						*dest++ = '?';
+				}
+				else
+					*dest++ = '?';
+			}
+			else if (c_len == 3)
+			{
+				if ((src[1] & 0x40) == 0 && (src[2] & 0x40) == 0 )
+				{
+					c = utf8_to_latin1_map( (((unsigned int)(src[0] & 0x0F)) << 12)
+						| (((unsigned int)(src[1] & 0x3F)) << 6)
+						|  ((unsigned int)(src[2] & 0x3F)) );
+					if (c < 256)
+						*dest++ = c;
+					else
+						*dest++ = '?';
+				}
+			}
+			else if (c_len == 4)
+			{
+				if ((src[1] & 0x40) == 0 &&
+					(src[2] & 0x40) == 0 &&
+					(src[3] & 0x40) == 0)
+				{
+					c = utf8_to_latin1_map( (((unsigned int)(src[0] & 0x07)) << 18)
+						| (((unsigned int)(src[1] & 0x3F)) << 12)
+						| (((unsigned int)(src[2] & 0x3F)) << 6)
+						|  ((unsigned int)(src[3] & 0x3F)) );
+					if (c < 256)
+						*(dest++) = c;
+					else
+						*dest++ = '?';
+				}
+				else
+					*dest++ = '?';
+			}
+			else if (c_len == 5)
+			{
+				if ((src[1] & 0x40) == 0 &&
+					(src[2] & 0x40) == 0 &&
+					(src[3] & 0x40) == 0 &&
+					(src[4] & 0x40) == 0)
+				{
+					c = utf8_to_latin1_map( (((unsigned int)(src[0] & 0x03)) << 24U)
+						| (((unsigned int)(src[1] & 0x3F)) << 18U)
+						| (((unsigned int)(src[2] & 0x3F)) << 12U)
+						| (((unsigned int)(src[3] & 0x3F)) << 6U)
+						|  ((unsigned int)(src[4] & 0x3FU)) );
+					if (c < 256)
+						*(dest++) = c;
+					else
+						*dest++ = '?';
+				}
+				else
+					*dest++ = '?';
+			}
+			else
+				*dest++ = '?';
+			break;
+		case CCX_ENC_UNICODE:
+			return CCX_ENOSUPP;
+		case CCX_ENC_ASCII:
+			if (c_len == 1)
+				*dest++ = *src;
+			else
+				*dest++ = '?';
+		default:
+			return CCX_ENOSUPP;
+		}
+		src += c_len;
+	}
+	*dest = 0;
+	return (dest - orig); // Return length
+}
+
+int change_latin1_encoding(unsigned char* dest, unsigned char* src, int len, enum ccx_encoding_type out_enc)
+{
+	return CCX_ENOSUPP;
+}
+
+int change_unicode_encoding(unsigned char* dest, unsigned char* src, int len, enum ccx_encoding_type out_enc)
+{
+	return CCX_ENOSUPP;
+}
+
+int change_ascii_encoding(unsigned char* dest, unsigned char* src, int len, enum ccx_encoding_type out_enc)
+{
+	unsigned char *orig = dest; // Keep for calculating length
+	int bytes = 0;
+	for (int i = 0; i < len; i++)
+	{
+		char c = src[i];
+		switch (out_enc)
+		{
+		case CCX_ENC_UTF_8:
+			bytes = get_char_in_utf_8(dest, c);
+			break;
+		case CCX_ENC_LATIN_1:
+			get_char_in_latin_1(dest, c);
+			bytes = 1;
+			break;
+		case CCX_ENC_UNICODE:
+			get_char_in_unicode(dest, c);
+			bytes = 2;
+			break;
+		case CCX_ENC_ASCII:
+			memcpy(dest, src, len);
+			return len;
+		default:
+			return CCX_ENOSUPP;
+		}
+		dest += bytes;
+	}
+	*dest = 0;
+	return (dest - orig); // Return length
+}
+
+int get_str_basic(unsigned char *out_buffer, unsigned char *in_buffer, int trim_subs,
+	enum ccx_encoding_type in_enc, enum ccx_encoding_type out_enc, int max_len)
+{
+	int last_non_blank = -1;
+	int first_non_blank = -1;
+	int len = 0;
+	find_limit_characters(in_buffer, &first_non_blank, &last_non_blank, max_len);
+	if (!trim_subs)
+		first_non_blank = 0;
+
+	if (first_non_blank == -1)
+	{
+		*out_buffer = 0;
+		return 0;
+	}
+
+
+	// change encoding only when required
+	switch (in_enc)
+	{
+	case CCX_ENC_UTF_8:
+		len = change_utf8_encoding(out_buffer, in_buffer + first_non_blank, last_non_blank-first_non_blank+1, out_enc);
+		break;
+	case CCX_ENC_LATIN_1:
+		len = change_latin1_encoding(out_buffer, in_buffer + first_non_blank, last_non_blank-first_non_blank+1, out_enc);
+		break;
+	case CCX_ENC_UNICODE:
+		len = change_unicode_encoding(out_buffer, in_buffer + first_non_blank, last_non_blank-first_non_blank+1, out_enc);
+		break;
+	case CCX_ENC_ASCII:
+		len = change_ascii_encoding(out_buffer, in_buffer + first_non_blank, last_non_blank-first_non_blank+1, out_enc);
+		break;
+	}
+	if (len < 0)
+		mprint("WARNING: Could not encode in specified format\n");
+	else if (len == CCX_ENOSUPP)
+	// we only support ASCII to other encoding std
+		mprint("WARNING: Encoding is not yet supported\n");
+	else
+		return (unsigned)len; // Return length
+
+	return 0; // Return length
+}
+
+int write_subtitle_file_footer(struct encoder_ctx *ctx,struct ccx_s_write *out)
+{
+	int used;
+	int ret = 0;
+	char str[1024];
+
+	switch (ctx->write_format)
+	{
+#ifndef MMCCXTR
+		case CCX_OF_SAMI:
+			sprintf ((char *) str,"</BODY></SAMI>\n");
+			if (ctx->encoding != CCX_ENC_UNICODE)
+			{
+				dbg_print(CCX_DMT_DECODER_608, "\r%s\n", str);
+			}
+			used = encode_line (ctx, ctx->buffer,(unsigned char *) str);
+			ret = write(out->fh, ctx->buffer, used);
+			if (ret != used)
+			{
+				mprint("WARNING: loss of data\n");
+			}
+			break;
+		case CCX_OF_SMPTETT:
+			sprintf ((char *) str,"    </div>\n  </body>\n</tt>\n");
+			if (ctx->encoding != CCX_ENC_UNICODE)
+			{
+				dbg_print(CCX_DMT_DECODER_608, "\r%s\n", str);
+			}
+			used = encode_line (ctx, ctx->buffer,(unsigned char *) str);
+			ret = write (out->fh, ctx->buffer, used);
+			if (ret != used)
+			{
+				mprint("WARNING: loss of data\n");
+			}
+			break;
+		case CCX_OF_SPUPNG:
+			write_spumux_footer(out);
+			break;
+		case CCX_OF_SIMPLE_XML:
+			sprintf ((char *) str,"</captions>\n");
+			if (ctx->encoding != CCX_ENC_UNICODE)
+			{
+				dbg_print(CCX_DMT_DECODER_608, "\r%s\n", str);
+			}
+			used = encode_line (ctx, ctx->buffer,(unsigned char *) str);
+			ret = write (out->fh, ctx->buffer, used);
+			if (ret != used)
+			{
+				mprint("WARNING: loss of data\n");
+			}
+			break;
+#endif
+		default: // Nothing to do, no footer on this format
+			break;
+	}
+
+	return ret;
+}
+
+
+static int write_bom(struct encoder_ctx *ctx, struct ccx_s_write *out)
+{
+	int ret = 0;
+	if (!ctx->no_bom){
+		if (ctx->encoding == CCX_ENC_UTF_8){ // Write BOM
+			ret = write(out->fh, UTF8_BOM, sizeof(UTF8_BOM));
+			if ( ret < sizeof(UTF8_BOM)) {
+				mprint("WARNING: Unable tp write UTF BOM\n");
+				return -1;
+			}
+
+		}
+		if (ctx->encoding == CCX_ENC_UNICODE){ // Write BOM
+			ret = write(out->fh, LITTLE_ENDIAN_BOM, sizeof(LITTLE_ENDIAN_BOM));
+			if ( ret < sizeof(LITTLE_ENDIAN_BOM)) {
+				mprint("WARNING: Unable to write LITTLE_ENDIAN_BOM \n");
+				return -1;
+			}
+		}
+	}
+	return ret;
+}
+static int write_subtitle_file_header(struct encoder_ctx *ctx, struct ccx_s_write *out)
+{
+	int used;
+	int ret = 0;
+	int header_size = 0;
+	switch (ctx->write_format)
+	{
+		case CCX_OF_SRT: // Subrip subtitles have no header
+#ifndef MMCCXTR
+		case CCX_OF_G608:
+			ret = write_bom(ctx, out);
+			if(ret < 0)
+				return -1;
+			break;
+		case CCX_OF_SSA:
+			ret = write_bom(ctx, out);
+			if(ret < 0)
+				return -1;
+			REQUEST_BUFFER_CAPACITY(ctx,strlen (ssa_header)*3);
+			used = encode_line (ctx, ctx->buffer,(unsigned char *) ssa_header);
+			ret = write (out->fh, ctx->buffer, used);
+			if(ret < used)
+			{
+				mprint("WARNING: Unable to write complete Buffer \n");
+				return -1;
+			}
+			break;
+		case CCX_OF_WEBVTT:
+			ret = write_bom(ctx, out);
+			if (ret < 0)
+				return -1;
+			for(int i = 0; webvtt_header[i]!=NULL ;i++)
+			{
+				header_size += strlen(webvtt_header[i]); // Find total size of the header
+			}
+			REQUEST_BUFFER_CAPACITY(ctx, header_size*3);
+			for(int i = 0; webvtt_header[i]!=NULL;i++)
+			{
+				if(ccx_options.enc_cfg.line_terminator_lf == 1 && strcmp(webvtt_header[i],"\r\n")==0) // If -lf parameter passed, write LF instead of CRLF
+				{
+					used = encode_line (ctx, ctx->buffer,(unsigned char *) "\n");
+				} 
+				else
+				{
+					used = encode_line (ctx, ctx->buffer,(unsigned char *) webvtt_header[i]);
+				}
+				ret = write (out->fh, ctx->buffer,used);
+				if(ret < used)
+				{
+					mprint("WARNING: Unable to write complete Buffer \n");
+					return -1;
+				}
+			}
+			break;
+		case CCX_OF_SAMI: // This header brought to you by McPoodle's CCASDI
+			//fprintf_encoded (wb->fh, sami_header);
+			ret = write_bom(ctx, out);
+			if(ret < 0)
+				return -1;
+			REQUEST_BUFFER_CAPACITY(ctx,strlen (sami_header)*3);
+			used = encode_line (ctx, ctx->buffer,(unsigned char *) sami_header);
+			ret = write (out->fh, ctx->buffer, used);
+			if(ret < used)
+			{
+				mprint("WARNING: Unable to write complete Buffer \n");
+				return -1;
+			}
+			break;
+		case CCX_OF_SMPTETT: // This header brought to you by McPoodle's CCASDI
+			//fprintf_encoded (wb->fh, sami_header);
+			ret = write_bom(ctx, out);
+			if(ret < 0)
+				return -1;
+			REQUEST_BUFFER_CAPACITY(ctx,strlen (smptett_header)*3);
+			used=encode_line (ctx, ctx->buffer,(unsigned char *) smptett_header);
+			ret = write(out->fh, ctx->buffer, used);
+			if(ret < used)
+			{
+				mprint("WARNING: Unable to write complete Buffer \n");
+				return -1;
+			}
+			break;
+		case CCX_OF_RCWT: // Write header
+			rcwt_header[7] = ctx->in_fileformat; // sets file format version
+
+			if (ctx->send_to_srv)
+				net_send_header(rcwt_header, sizeof(rcwt_header));
+			else
+			{
+				ret = write(out->fh, rcwt_header, sizeof(rcwt_header));
+				if(ret < 0)
+				{
+					mprint("Unable to write rcwt header\n");
+					return -1;
+				}
+			}
+
+			break;
+		case CCX_OF_RAW:
+			ret = write(out->fh,BROADCAST_HEADER, sizeof(BROADCAST_HEADER));
+			if(ret < sizeof(BROADCAST_HEADER))
+			{
+				mprint("Unable to write Raw header\n");
+				return -1;
+			}
+			break;
+		case CCX_OF_SPUPNG:
+			ret = write_bom(ctx, out);
+			if(ret < 0)
+				return -1;
+			write_spumux_header(ctx, out);
+			break;
+		case CCX_OF_TRANSCRIPT: // No header. Fall thru
+			ret = write_bom(ctx, out);
+			if(ret < 0)
+				return -1;
+			break;
+		case CCX_OF_SIMPLE_XML: // No header. Fall thru
+			ret = write_bom(ctx, out);
+			if(ret < 0)
+				return -1;
+			REQUEST_BUFFER_CAPACITY(ctx,strlen (simple_xml_header)*3);
+			used=encode_line (ctx, ctx->buffer,(unsigned char *) simple_xml_header);
+			ret = write(out->fh, ctx->buffer, used);
+			if(ret < used)
+			{
+				mprint("WARNING: Unable to write complete Buffer \n");
+				return -1;
+			}
+			break;
+#endif
+		default:
+			break;
+	}
+
+	return ret;
+}
+
+#ifndef MMCCXTR
+int write_cc_subtitle_as_simplexml(struct cc_subtitle *sub, struct encoder_ctx *context)
+{
+	int length;
+	int ret = 0;
+	char *str;
+	char *save_str;
+	struct cc_subtitle *osub = sub;
+	struct cc_subtitle *lsub = sub;
+
+	while(sub)
+	{
+		str = sub->data;
+
+		str = strtok_r(str, "\r\n", &save_str);
+		do
+		{
+			length = get_str_basic(context->subline, (unsigned char*)str, context->trim_subs, sub->enc_type, context->encoding, strlen(str));
+			if (length <= 0)
+			{
+				continue;
+			}
+			ret = write(context->out->fh, context->encoded_crlf, context->encoded_crlf_length);
+			if(ret <  context->encoded_crlf_length)
+			{
+				mprint("Warning:Loss of data\n");
+			}
+
+		} while ( (str = strtok_r(NULL, "\r\n", &save_str) ));
+
+		freep(&sub->data);
+		lsub = sub;
+		sub = sub->next;
+	}
+	while(lsub != osub)
+	{
+		sub = lsub->prev;
+		freep(&lsub);
+		lsub = sub;
+	}
+
+	return ret;
+}
+
+void write_cc_line_as_simplexml(struct eia608_screen *data, struct encoder_ctx *context, int line_number)
+{
+	int ret;
+	int length = 0;
+	char *cap = "<caption>";
+	char *cap1 = "</caption>";
+	if (context->sentence_cap)
+	{
+		if (clever_capitalize (context, line_number, data))
+			correct_case_with_dictionary(line_number, data);
+	}
+	length = get_str_basic (context->subline, data->characters[line_number],
+			context->trim_subs, CCX_ENC_ASCII, context->encoding, CCX_DECODER_608_SCREEN_WIDTH);
+
+	ret = write(context->out->fh, cap, strlen(cap));
+	ret = write(context->out->fh, context->subline, length);
+	if(ret < length)
+	{
+		mprint("Warning:Loss of data\n");
+	}
+	ret = write(context->out->fh, cap1, strlen(cap1));
+	ret = write(context->out->fh, context->encoded_crlf, context->encoded_crlf_length);
+
+}
+
+
+int write_cc_buffer_as_simplexml(struct eia608_screen *data, struct encoder_ctx *context)
+{
+	int wrote_something = 0;
+
+	for (int i=0;i<15;i++)
+	{
+		if (data->row_used[i])
+		{
+			write_cc_line_as_simplexml(data, context, i);
+		}
+		wrote_something=1;
+	}
+	return wrote_something;
+}
+
+
+//Dummy Function for support DVB in simple xml
+int write_cc_bitmap_as_simplexml(struct cc_subtitle *sub, struct encoder_ctx *context)
+{
+	int ret = 0;
+
+	sub->nb_data = 0;
+	freep(&sub->data);
+	return ret;
+}
+
+#endif
+
+/**
+ * @brief Function to add credits at end of subtitles File
+ *
+ * @param context encoder context in which you want to add credits at end
+ *
+ * @param out output context which usually keeps file handler
+ */
+static void try_to_add_end_credits(struct encoder_ctx *context, struct ccx_s_write *out, LLONG current_fts)
+{
+	LLONG window, length, st, end;
+	if (out->fh == -1)
+		return;
+	window = current_fts - context->last_displayed_subs_ms - 1;
+	if (window < context->endcreditsforatleast.time_in_ms) // Won't happen, window is too short
+		return;
+	length = context->endcreditsforatmost.time_in_ms > window ?
+		window : context->endcreditsforatmost.time_in_ms;
+
+	st = current_fts - length - 1;
+	end = current_fts;
+
+	switch (context->write_format)
+	{
+		case CCX_OF_SRT:
+			write_stringz_as_srt(context->end_credits_text, context, st, end);
+			break;
+#ifndef MMCCXTR
+		case CCX_OF_SSA:
+			write_stringz_as_ssa(context->end_credits_text, context, st, end);
+			break;
+		case CCX_OF_WEBVTT:
+			write_stringz_as_webvtt(context->end_credits_text, context, st, end);
+			break;
+		case CCX_OF_SAMI:
+			write_stringz_as_sami(context->end_credits_text, context, st, end);
+			break;
+		case CCX_OF_SMPTETT:
+			write_stringz_as_smptett(context->end_credits_text, context, st, end);
+			break ;
+#endif
+		default:
+			// Do nothing for the rest
+			break;
+	}
+}
+
+void try_to_add_start_credits(struct encoder_ctx *context,LLONG start_ms)
+{
+	LLONG st, end, window, length;
+	LLONG l = start_ms + context->subs_delay;
+	// We have a windows from last_displayed_subs_ms to l - we need to see if it fits
+
+	if (l < context->startcreditsnotbefore.time_in_ms) // Too early
+		return;
+
+	if (context->last_displayed_subs_ms+1 > context->startcreditsnotafter.time_in_ms) // Too late
+		return;
+
+	st = context->startcreditsnotbefore.time_in_ms>(context->last_displayed_subs_ms+1) ?
+		context->startcreditsnotbefore.time_in_ms : (context->last_displayed_subs_ms+1); // When would credits actually start
+
+	end = context->startcreditsnotafter.time_in_ms<(l-1) ?
+		context->startcreditsnotafter.time_in_ms : (l-1);
+
+	window = end-st; // Allowable time in MS
+
+	if (context->startcreditsforatleast.time_in_ms>window) // Window is too short
+		return;
+
+	length=context->startcreditsforatmost.time_in_ms > window ?
+		window : context->startcreditsforatmost.time_in_ms;
+
+	dbg_print(CCX_DMT_VERBOSE, "Last subs: %lld   Current position: %lld\n",
+			context->last_displayed_subs_ms, l);
+	dbg_print(CCX_DMT_VERBOSE, "Not before: %lld   Not after: %lld\n",
+			context->startcreditsnotbefore.time_in_ms,
+			context->startcreditsnotafter.time_in_ms);
+	dbg_print(CCX_DMT_VERBOSE, "Start of window: %lld   End of window: %lld\n",st,end);
+
+	if (window>length+2)
+	{
+		// Center in time window
+		LLONG pad=window-length;
+		st+=(pad/2);
+	}
+	end=st+length;
+	switch (context->write_format)
+	{
+		case CCX_OF_SRT:
+			write_stringz_as_srt(context->start_credits_text,context,st,end);
+			break;
+#ifndef MMCCXTR
+		case CCX_OF_SSA:
+			write_stringz_as_ssa(context->start_credits_text,context,st,end);
+			break;
+		case CCX_OF_WEBVTT:
+			write_stringz_as_webvtt(context->start_credits_text, context, st, end);
+			break;
+		case CCX_OF_SAMI:
+			write_stringz_as_sami(context->start_credits_text, context, st, end);
+			break;
+		case CCX_OF_SMPTETT:
+			write_stringz_as_smptett(context->start_credits_text, context, st, end);
+			break;
+#endif
+		default:
+			// Do nothing for the rest
+			break;
+	}
+	context->startcredits_displayed=1;
+	return;
+
+
+}
+
+static void dinit_output_ctx(struct encoder_ctx *ctx)
+{
+	int i;
+	for(i = 0; i < ctx->nb_out; i++)
+		dinit_write(ctx->out + i);
+	freep(&ctx->out);
+
+#ifndef MMCCXTR
+	if (ctx->dtvcc_extract)
+	{
+		for (i = 0; i < CCX_DTVCC_MAX_SERVICES; i++)
+			ccx_dtvcc_writer_cleanup(&ctx->dtvcc_writers[i]);
+	}
+#endif
+}
+
+static int init_output_ctx(struct encoder_ctx *ctx, struct encoder_cfg *cfg)
+{
+	int ret = EXIT_OK;
+	int nb_lang;
+	char *basefilename = NULL; // Input filename without the extension
+	char *extension = NULL; // Input filename without the extension
+
+#define check_ret(filename) 	if (ret != EXIT_OK)	\
+				{									\
+					fatal(CCX_COMMON_EXIT_FILE_CREATION_FAILED,"Failed to open output file: %s\nDetails : %s\n", filename, strerror(errno)); \
+					return ret;						\
+				}
+
+	if (cfg->cc_to_stdout == CCX_FALSE && cfg->send_to_srv == CCX_FALSE && cfg->extract == 12)
+		nb_lang = 2;
+	else
+		nb_lang = 1;
+
+	ctx->out = malloc(sizeof(struct ccx_s_write) * nb_lang);
+	if(!ctx->out)
+		return -1;
+	ctx->nb_out = nb_lang;
+	ctx->keep_output_closed = cfg->keep_output_closed;
+	ctx->force_flush = cfg->force_flush;
+	ctx->ucla = cfg->ucla;
+
+	if(ctx->generates_file && cfg->cc_to_stdout == CCX_FALSE && cfg->send_to_srv == CCX_FALSE)
+	{
+		if (cfg->output_filename != NULL)
+		{
+			// Use the given output file name for the field specified by
+			// the -1, -2 switch. If -12 is used, the filename is used for
+			// field 1.
+			if (cfg->extract == 12)
+			{
+				basefilename = get_basename(cfg->output_filename);
+				extension = get_file_extension(cfg->write_format);
+
+				ret = init_write(&ctx->out[0], strdup(cfg->output_filename), cfg->with_semaphore);
+				check_ret(cfg->output_filename);
+				ret = init_write(&ctx->out[1], create_outfilename(basefilename, "_2", extension), cfg->with_semaphore);
+				check_ret(ctx->out[1].filename);
+			}
+			else
+			{
+				ret = init_write(ctx->out, strdup(cfg->output_filename), cfg->with_semaphore );
+				check_ret(cfg->output_filename);
+			}
+		}
+		else if (cfg->write_format != CCX_OF_NULL)
+		{
+            basefilename = get_basename(ctx->first_input_file);
+            extension = get_file_extension(cfg->write_format);
+			if (basefilename == NULL)
+			{
+				basefilename = get_basename("untitled");
+			}
+
+			if (cfg->extract == 12)
+			{
+				ret = init_write(&ctx->out[0], create_outfilename(basefilename, "_1", extension), cfg->with_semaphore);
+				check_ret(ctx->out[0].filename);
+				ret = init_write(&ctx->out[1], create_outfilename(basefilename, "_2", extension), cfg->with_semaphore);
+				check_ret(ctx->out[1].filename);
+			}
+			else
+			{
+				ret = init_write(ctx->out, create_outfilename(basefilename, NULL, extension), cfg->with_semaphore);
+				check_ret(ctx->out->filename);
+			}
+		}
+
+		freep(&basefilename);
+		freep(&extension);
+	}
+
+	if (cfg->cc_to_stdout == CCX_TRUE)
+	{
+		ctx->out[0].fh = STDOUT_FILENO;
+		ctx->out[0].filename = NULL;
+		ctx->out[0].with_semaphore = 0;
+		ctx->out[0].semaphore_filename = NULL;
+		mprint ("Sending captions to stdout.\n");
+	}
+
+#ifndef MMCCXTR
+	if (cfg->send_to_srv == CCX_TRUE)
+	{
+		ctx->out[0].fh = -1;
+		ctx->out[0].filename = NULL;
+
+		connect_to_srv(ccx_options.srv_addr, ccx_options.srv_port, ccx_options.tcp_desc, ccx_options.tcp_password);
+	}
+
+	if (cfg->dtvcc_extract)
+	{
+		for (int i = 0; i < CCX_DTVCC_MAX_SERVICES; i++)
+		{
+			if (!cfg->services_enabled[i])
+			{
+				ctx->dtvcc_writers[i].fd = -1;
+				ctx->dtvcc_writers[i].filename = NULL;
+				ctx->dtvcc_writers[i].cd = (iconv_t) -1;
+				continue;
+			}
+
+			if (cfg->cc_to_stdout)
+			{
+				ctx->dtvcc_writers[i].fd = STDOUT_FILENO;
+				ctx->dtvcc_writers[i].filename = NULL;
+				ctx->dtvcc_writers[i].cd = (iconv_t) -1;
+			}
+			else
+			{
+				if (cfg->output_filename)
+					basefilename = get_basename(cfg->output_filename);
+				else
+					basefilename = get_basename(ctx->first_input_file);
+
+				ccx_dtvcc_writer_init(&ctx->dtvcc_writers[i], basefilename,
+									  ctx->program_number, i + 1, cfg->write_format, cfg);
+				free(basefilename);
+			}
+		}
+	}
+#endif
+
+	if(ret)
+	{
+		print_error(cfg->gui_mode_reports,
+			"Output filename is same as one of input filenames. Check output parameters.\n");
+		return CCX_COMMON_EXIT_FILE_CREATION_FAILED;
+	}
+
+	return EXIT_OK;
+}
+
+/**
+ * @param current_fts used while calculating window for end credits
+ */
+void dinit_encoder(struct encoder_ctx **arg, LLONG current_fts)
+{
+	struct encoder_ctx *ctx = *arg;
+	int i;
+	if(!ctx)
+		return;
+	for (i = 0; i < ctx->nb_out; i++)
+	{
+		if (ctx->end_credits_text!=NULL)
+			try_to_add_end_credits(ctx, ctx->out + i, current_fts);
+		write_subtitle_file_footer(ctx, ctx->out + i);
+	}
+
+	free_encoder_context(ctx->prev);
+	dinit_output_ctx(ctx);
+	freep(&ctx->subline);
+	freep(&ctx->buffer);
+	ctx->capacity = 0;
+	freep(arg);
+}
+
+int reset_output_ctx(struct encoder_ctx *ctx, struct encoder_cfg *cfg)
+{
+	dinit_output_ctx(ctx);
+	return init_output_ctx(ctx, cfg);
+}
+
+struct encoder_ctx *init_encoder(struct encoder_cfg *opt)
+{
+	int ret;
+	int i;
+	struct encoder_ctx *ctx = malloc(sizeof(struct encoder_ctx));
+	if(!ctx)
+		return NULL;
+
+	ctx->buffer = (unsigned char *) malloc (INITIAL_ENC_BUFFER_CAPACITY);
+	if (!ctx->buffer)
+	{
+		free(ctx);
+		return NULL;
+	}
+
+	ctx->capacity=INITIAL_ENC_BUFFER_CAPACITY;
+	ctx->srt_counter = 0;
+	ctx->cea_708_counter = 0;
+	ctx->wrote_webvtt_header = 0;
+
+	ctx->program_number = opt->program_number;
+	ctx->send_to_srv = opt->send_to_srv;
+	ctx->multiple_files = opt->multiple_files;
+	ctx->first_input_file = opt->first_input_file;
+
+	if (opt->write_format == CCX_OF_NULL || opt->write_format == CCX_OF_CURL)
+		ctx->generates_file = 0;
+	else
+		ctx->generates_file = 1;
+
+	ret = init_output_ctx(ctx, opt);
+	if (ret != EXIT_OK)
+	{
+		freep(&ctx->buffer);
+		free(ctx);
+		return NULL;
+	}
+	ctx->in_fileformat = opt->in_format;
+
+	/** used in case of SUB_EOD_MARKER */
+	ctx->prev_start = -1;
+	ctx->subs_delay = opt->subs_delay;
+	ctx->last_displayed_subs_ms = 0;
+	ctx->date_format = opt->date_format;
+	ctx->millis_separator = opt->millis_separator;
+	ctx->startcredits_displayed = 0;
+
+	ctx->encoding = opt->encoding;
+	ctx->write_format = opt->write_format;
+
+    ctx->is_mkv = 0;
+    ctx->last_string = NULL;
+
+	ctx->transcript_settings = &opt->transcript_settings;
+	ctx->no_bom = opt->no_bom;
+	ctx->sentence_cap = opt->sentence_cap;
+	ctx->trim_subs = opt->trim_subs;
+	ctx->autodash = opt->autodash;
+	ctx->no_font_color = opt->no_font_color;
+	ctx->no_type_setting = opt->no_type_setting;
+	ctx->gui_mode_reports = opt->gui_mode_reports;
+	ctx->extract = opt->extract;
+	ctx->keep_output_closed = opt->keep_output_closed;
+	ctx->force_flush = opt->force_flush;
+	ctx->ucla = opt->ucla;
+
+	ctx->sbs_enabled = opt->splitbysentence;
+
+	ctx->subline = (unsigned char *) malloc (SUBLINESIZE);
+	if(!ctx->subline)
+	{
+		freep(&ctx->out);
+		freep(&ctx->buffer);
+		free(ctx);
+		return NULL;
+	}
+
+	ctx->start_credits_text = opt->start_credits_text;
+	ctx->end_credits_text = opt->end_credits_text;
+	ctx->startcreditsnotbefore = opt->startcreditsnotbefore;
+	ctx->startcreditsnotafter = opt->startcreditsnotafter;
+	ctx->startcreditsforatleast = opt->startcreditsforatleast;
+	ctx->startcreditsforatmost = opt->startcreditsforatmost;
+	ctx->endcreditsforatleast = opt->endcreditsforatleast;
+	ctx->endcreditsforatmost = opt->endcreditsforatmost;
+
+	ctx->new_sentence = 1; // Capitalize next letter?
+	if (opt->line_terminator_lf)
+		ctx->encoded_crlf_length = encode_line(ctx, ctx->encoded_crlf, (unsigned char *) "\n");
+	else
+		ctx->encoded_crlf_length = encode_line(ctx, ctx->encoded_crlf, (unsigned char *) "\r\n");
+
+	ctx->encoded_br_length = encode_line(ctx, ctx->encoded_br, (unsigned char *) "<br>");
+
+	for (i = 0; i < ctx->nb_out; i++)
+	 	write_subtitle_file_header(ctx,ctx->out+i);
+
+	ctx->dtvcc_extract = opt->dtvcc_extract;
+
+	ctx->segment_pending = 0;
+	ctx->segment_last_key_frame = 0;
+	ctx->nospupngocr = opt->nospupngocr;
+
+	ctx->prev = NULL;
+	return ctx;
+}
+
+void set_encoder_rcwt_fileformat(struct encoder_ctx *ctx, short int format)
+{
+	if(ctx)
+	{
+		ctx->in_fileformat = format;
+	}
+}
+
+static int write_newline(struct encoder_ctx *ctx, int lang)
+{
+	return write(ctx->out[lang].fh, ctx->encoded_crlf, ctx->encoded_crlf_length);
+}
+
+struct ccx_s_write *get_output_ctx(struct encoder_ctx *ctx, int lan)
+{
+	if (ctx->extract == 12 && lan == 2)
+	{
+		return ctx->out+1;
+	}
+	else
+	{
+		return ctx->out;
+	}
+}
+
+int encode_sub(struct encoder_ctx *context, struct cc_subtitle *sub)
+{
+	int wrote_something = 0;
+	int ret = 0;
+
+	if(!context)
+		return CCX_OK;
+
+#ifndef MMCCXTR
+	context = change_filename(context);
+#endif
+
+#ifdef ENABLE_SHARING
+	if (ccx_options.sharing_enabled)
+		ccx_share_send(sub);
+#endif //ENABLE_SHARING
+
+	if (context->sbs_enabled)
+	{
+		// Write to a buffer that is later s+plit to generate split
+		// in sentences
+#ifndef MMCCXTR
+		if (sub->type == CC_BITMAP)
+			sub = reformat_cc_bitmap_through_sentence_buffer(sub, context);
+#endif
+
+		if (NULL==sub)
+			return wrote_something;
+	}
+
+	// Write subtitles as they come
+		if (sub->type == CC_608)
+		{
+			struct eia608_screen *data = NULL;
+			struct ccx_s_write *out;
+			for (data = sub->data; sub->nb_data; sub->nb_data--, data++)
+			{
+				// Determine context based on channel. This replaces the code that was above, as this was incomplete (for cases where -12 was used for example)
+				out = get_output_ctx(context, data->my_field);
+
+#ifndef MMCCXTR
+				if (data->format == SFORMAT_XDS)
+				{
+					data->end_time = data->end_time + context->subs_delay;
+					xds_write_transcript_line_prefix(context, out, data->start_time, data->end_time, data->cur_xds_packet_class);
+					if (data->xds_len > 0)
+					{
+						ret = write(out->fh, data->xds_str, data->xds_len);
+						if (ret < data->xds_len)
+						{
+							mprint("WARNING:Loss of data\n");
+						}
+					}
+					freep(&data->xds_str);
+					write_newline(context, 0);
+					continue;
+				}
+#endif
+
+				data->end_time = data->end_time + context->subs_delay;
+
+#ifndef MMCCXTR
+				if (utc_refvalue != UINT64_MAX)
+				{
+					if (data->start_time != -1)
+						data->start_time += utc_refvalue * 1000;
+					data->end_time += utc_refvalue * 1000;
+				}
+#endif
+
+#ifdef PYTHON_API
+                pass_cc_buffer_to_python(data, context);
+#else
+                switch (context->write_format)
+                {
+                    case CCX_OF_SRT:
+                        if (!context->startcredits_displayed && context->start_credits_text != NULL)
+                            try_to_add_start_credits(context, data->start_time);
+                        wrote_something = write_cc_buffer_as_srt(data, context);
+                        break;
+#ifndef MMCCXTR
+                    case CCX_OF_SSA:
+                        if (!context->startcredits_displayed && context->start_credits_text != NULL)
+                            try_to_add_start_credits(context, data->start_time);
+                        wrote_something = write_cc_buffer_as_ssa(data, context);
+                        break;
+                    case CCX_OF_G608:
+                        wrote_something = write_cc_buffer_as_g608(data, context);
+                        break;
+                    case CCX_OF_WEBVTT:
+                        if (!context->startcredits_displayed && context->start_credits_text != NULL)
+                            try_to_add_start_credits(context, data->start_time);
+                        wrote_something = write_cc_buffer_as_webvtt(data, context);
+                        break;
+                    case CCX_OF_SAMI:
+                        if (!context->startcredits_displayed && context->start_credits_text != NULL)
+                            try_to_add_start_credits(context, data->start_time);
+                        wrote_something = write_cc_buffer_as_sami(data, context);
+                        break;
+                    case CCX_OF_SMPTETT:
+                        if (!context->startcredits_displayed && context->start_credits_text != NULL)
+                            try_to_add_start_credits(context, data->start_time);
+                        wrote_something = write_cc_buffer_as_smptett(data, context);
+                        break;
+                    case CCX_OF_TRANSCRIPT:
+                        wrote_something = write_cc_buffer_as_transcript2(data, context);
+                        break;
+                    case CCX_OF_SPUPNG:
+                        wrote_something = write_cc_buffer_as_spupng(data, context);
+                        break;
+                    case CCX_OF_SIMPLE_XML:
+                        if (ccx_options.keep_output_closed && context->out->temporarily_closed)
+                        {
+                            temporarily_open_output(context->out);
+                            write_subtitle_file_header(context, context->out);
+                        }
+                        wrote_something = write_cc_buffer_as_simplexml(data, context);
+                        if (ccx_options.keep_output_closed)
+                        {
+                            write_subtitle_file_footer(context, context->out);
+                            temporarily_close_output(context->out);
+                        }
+                        break;
+#endif
+                    default:
+                        break;
+                }
+				if (wrote_something)
+					context->last_displayed_subs_ms = data->end_time;
+
+				if (context->gui_mode_reports)
+					write_cc_buffer_to_gui(sub->data, context);
+#endif // PYTHON_API
+			}
+			freep(&sub->data);
+		}
+#ifndef MMCCXTR
+		if (sub->type == CC_BITMAP)
+		{
+			switch (context->write_format)
+			{
+			case CCX_OF_SRT:
+				if (!context->startcredits_displayed && context->start_credits_text != NULL)
+					try_to_add_start_credits(context, sub->start_time);
+				wrote_something = write_cc_bitmap_as_srt(sub, context);
+				break;
+            case CCX_OF_SSA:
+				if (!context->startcredits_displayed && context->start_credits_text != NULL)
+					try_to_add_start_credits(context, sub->start_time);
+					wrote_something = write_cc_bitmap_as_ssa(sub, context);
+				break;
+			case CCX_OF_WEBVTT:
+				if (!context->startcredits_displayed && context->start_credits_text != NULL)
+					try_to_add_start_credits(context, sub->start_time);
+				wrote_something = write_cc_bitmap_as_webvtt(sub, context);
+				break;
+			case CCX_OF_SAMI:
+				if (!context->startcredits_displayed && context->start_credits_text != NULL)
+					try_to_add_start_credits(context, sub->start_time);
+				wrote_something = write_cc_bitmap_as_sami(sub, context);
+				break;
+			case CCX_OF_SMPTETT:
+				if (!context->startcredits_displayed && context->start_credits_text != NULL)
+					try_to_add_start_credits(context, sub->start_time);
+				wrote_something = write_cc_bitmap_as_smptett(sub, context);
+				break;
+			case CCX_OF_TRANSCRIPT:
+				wrote_something = write_cc_bitmap_as_transcript(sub, context);
+				break;
+			case CCX_OF_SPUPNG:
+				wrote_something = write_cc_bitmap_as_spupng(sub, context);
+				break;
+			case CCX_OF_SIMPLE_XML:
+				wrote_something = write_cc_bitmap_as_simplexml(sub, context);
+				break;
+#ifdef WITH_LIBCURL
+			case CCX_OF_CURL:
+				wrote_something = write_cc_bitmap_as_libcurl(sub, context);
+				break;
+#endif
+			default:
+				break;
+			}
+
+		}
+		if (sub->type == CC_RAW)
+		{
+			if (context->send_to_srv)
+				net_send_header(sub->data, sub->nb_data);
+			else
+			{
+				ret = write(context->out->fh, sub->data, sub->nb_data);
+				if (ret < sub->nb_data) {
+					mprint("WARNING: Loss of data\n");
+				}
+			}
+			sub->nb_data = 0;
+		}
+		if (sub->type == CC_TEXT)
+		{
+			switch (context->write_format)
+			{
+			case CCX_OF_SRT:
+				if (!context->startcredits_displayed && context->start_credits_text != NULL)
+					try_to_add_start_credits(context, sub->start_time);
+				wrote_something = write_cc_subtitle_as_srt(sub, context);
+				break;
+			case CCX_OF_SSA:
+				if (!context->startcredits_displayed && context->start_credits_text != NULL)
+					try_to_add_start_credits(context, sub->start_time);
+				wrote_something = write_cc_subtitle_as_ssa(sub, context);
+				break;
+			case CCX_OF_WEBVTT:
+				if (!context->startcredits_displayed && context->start_credits_text != NULL)
+					try_to_add_start_credits(context, sub->start_time);
+				wrote_something = write_cc_subtitle_as_webvtt(sub, context);
+				break;
+			case CCX_OF_SAMI:
+				if (!context->startcredits_displayed && context->start_credits_text != NULL)
+					try_to_add_start_credits(context, sub->start_time);
+				wrote_something = write_cc_subtitle_as_sami(sub, context);
+				break;
+			case CCX_OF_SMPTETT:
+				if (!context->startcredits_displayed && context->start_credits_text != NULL)
+					try_to_add_start_credits(context, sub->start_time);
+				wrote_something = write_cc_subtitle_as_smptett(sub, context);
+				break;
+			case CCX_OF_TRANSCRIPT:
+				wrote_something = write_cc_subtitle_as_transcript(sub, context);
+				break;
+			case CCX_OF_SPUPNG:
+				wrote_something = write_cc_subtitle_as_spupng(sub, context);
+				break;
+			case CCX_OF_SIMPLE_XML:
+				wrote_something = write_cc_subtitle_as_simplexml(sub, context);
+				break;
+			default:
+				break;
+			}
+			sub->nb_data = 0;
+		}
+#endif
+
+	if (!sub->nb_data)
+		freep(&sub->data);
+	if (wrote_something && context->force_flush)
+		fsync(context->out->fh); // Don't buffer
+	return wrote_something;
+}
+
+void write_cc_buffer_to_gui(struct eia608_screen *data, struct encoder_ctx *context)
+{
+	unsigned h1, m1, s1, ms1;
+	unsigned h2, m2, s2, ms2;
+	LLONG ms_start;
+	int with_data = 0;
+
+	for (int i = 0; i<15; i++)
+	{
+		if (data->row_used[i])
+			with_data = 1;
+	}
+	if (!with_data)
+		return;
+
+	ms_start = data->start_time;
+
+	ms_start += context->subs_delay;
+	if (ms_start<0) // Drop screens that because of subs_delay start too early
+		return;
+	int time_reported = 0;
+	for (int i = 0; i<15; i++)
+	{
+		if (data->row_used[i])
+		{
+			fprintf(stderr, "###SUBTITLE#");
+			if (!time_reported)
+			{
+				LLONG ms_end = data->end_time;
+				millis_to_time(ms_start, &h1, &m1, &s1, &ms1);
+				millis_to_time(ms_end - 1, &h2, &m2, &s2, &ms2); // -1 To prevent overlapping with next line.
+				// Note, only MM:SS here as we need to save space in the preview window
+				fprintf(stderr, "%02u:%02u#%02u:%02u#",
+					h1 * 60 + m1, s1, h2 * 60 + m2, s2);
+				time_reported = 1;
+			}
+			else
+				fprintf(stderr, "##");
+
+			// We don't capitalize here because whatever function that was used
+			// before to write to file already took care of it.
+			int length = get_decoder_line_encoded_for_gui(context->subline, i, data);
+			fwrite(context->subline, 1, length, stderr);
+			fwrite("\n", 1, 1, stderr);
+		}
+	}
+	fflush(stderr);
+}
+
+unsigned int get_line_encoded(struct encoder_ctx *ctx, unsigned char *buffer, int line_num, struct eia608_screen *data)
+{
+	unsigned char *orig = buffer; // Keep for debugging
+	unsigned char *line = data->characters[line_num];
+	for (int i = 0; i < 33; i++)
+	{
+		int bytes = 0;
+		switch (ctx->encoding)
+		{
+		case CCX_ENC_UTF_8:
+			bytes = get_char_in_utf_8(buffer, line[i]);
+			break;
+		case CCX_ENC_LATIN_1:
+			get_char_in_latin_1(buffer, line[i]);
+			bytes = 1;
+			break;
+		case CCX_ENC_UNICODE:
+			get_char_in_unicode(buffer, line[i]);
+			bytes = 2;
+		case CCX_ENC_ASCII:
+		    *buffer = line[i];
+			bytes = 1;
+			break;
+		}
+		buffer += bytes;
+	}
+	return (unsigned int)(buffer - orig); // Return length
+}
+unsigned int get_color_encoded(struct encoder_ctx *ctx, unsigned char *buffer, int line_num, struct eia608_screen *data)
+{
+	unsigned char *orig = buffer; // Keep for debugging
+	for (int i = 0; i < 32; i++)
+	{
+		if (data->colors[line_num][i] < 10)
+			*buffer++ = data->colors[line_num][i] + '0';
+		else
+			*buffer++ = 'E';
+	}
+	*buffer = 0;
+	return (unsigned)(buffer - orig); // Return length
+}
+unsigned int get_font_encoded(struct encoder_ctx *ctx, unsigned char *buffer, int line_num, struct eia608_screen *data)
+{
+	unsigned char *orig = buffer; // Keep for debugging
+	for (int i = 0; i < 32; i++)
+	{
+		if(data->fonts[line_num][i] == FONT_REGULAR)
+			*buffer++ = 'R';
+		else if(data->fonts[line_num][i] == FONT_UNDERLINED_ITALICS)
+			*buffer++ = 'B';
+		else if(data->fonts[line_num][i] == FONT_UNDERLINED)
+			*buffer++ = 'U';
+		else if(data->fonts[line_num][i] == FONT_ITALICS)
+			*buffer++ = 'I';
+		else
+			*buffer++ = 'E';
+	}
+	return (unsigned)(buffer - orig); // Return length
+}
+
+void switch_output_file(struct lib_ccx_ctx *ctx, struct encoder_ctx *enc_ctx, int track_id) {
+	if (enc_ctx->out->filename != NULL) { // Close and release the previous handle
+		free(enc_ctx->out->filename);
+		close(enc_ctx->out->fh);
+	}
+	char *ext = get_file_extension(ctx->write_format);
+	char suffix[32];
+	sprintf(suffix, "_%d", track_id);
+	enc_ctx->out->filename = create_outfilename(get_basename(enc_ctx->first_input_file), suffix, ext);
+	enc_ctx->out->fh = open(enc_ctx->out->filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, S_IREAD | S_IWRITE);
+
+	// Reset counters as we switch output file.
+	enc_ctx->cea_708_counter = 0;
+	enc_ctx->srt_counter = 0;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_encoders_common.h Added

@@ -0,0 +1,241 @@
+#ifndef _CC_ENCODER_COMMON_H
+#define _CC_ENCODER_COMMON_H
+
+#ifndef MMCCXTR
+#ifdef WIN32
+	#include "..\\win_iconv\\iconv.h"
+#else
+	#include "iconv.h"
+#endif
+#endif
+
+#include "ccx_common_structs.h"
+#include "ccx_decoders_structs.h"
+#include "ccx_encoders_structs.h"
+#include "ccx_common_option.h"
+
+#define REQUEST_BUFFER_CAPACITY(ctx,length) if (length>ctx->capacity) \
+{ctx->capacity = length * 2; ctx->buffer = (unsigned char*)realloc(ctx->buffer, ctx->capacity); \
+if (ctx->buffer == NULL) { fatal(EXIT_NOT_ENOUGH_MEMORY, "Not enough memory for reallocating buffer, bailing out\n"); } \
+}
+
+// CC page dimensions
+#define ROWS                    15
+#define COLUMNS                 32
+
+typedef struct ccx_dtvcc_writer_ctx
+{
+	int fd;
+	char *filename;
+#ifndef MMCCXTR
+	iconv_t cd;
+#endif
+} ccx_dtvcc_writer_ctx;
+
+typedef struct ccx_sbs_utf8_character
+{
+	int32_t ch;
+	LLONG ts;
+	char encoded[4];
+	int enc_len;
+} ccx_sbs_utf8_character;
+
+/**
+ * Context of encoder, This structure gives single interface
+ * to all encoder
+ */
+struct encoder_ctx
+{
+	/* common buffer used by all encoder */
+	unsigned char *buffer;
+	/* capacity of buffer */
+	unsigned int capacity;
+	/* keep count of srt subtitle*/
+	unsigned int srt_counter;
+	/* keep count of CEA-708 subtitle*/
+	unsigned int cea_708_counter;
+
+	/* Did we write the WebVTT header already? */
+	unsigned int wrote_webvtt_header;
+
+	/* Input outputs */
+	/* Flag giving hint that output is send to server through network */
+	unsigned int send_to_srv;
+	/* Used only in Spupng output */
+	int multiple_files;
+	/* Used only in Spupng output and creating name of output file*/
+	char *first_input_file;
+	/* Its array with length of number of languages */
+	struct ccx_s_write *out;
+	/* number of member in array of write out array */
+	int nb_out;
+	/* Input file format used in Teletext for exceptional output */
+	unsigned int in_fileformat; //1 = Normal, 2 = Teletext
+	/* Keep output file closed when not actually writing to it and start over each time (add headers, etc) */
+	unsigned int keep_output_closed;
+	/* Force a flush on the file buffer whenever content is written */
+	int force_flush;
+	/* Keep track of whether -UCLA used */
+	int ucla;
+
+	struct ccx_common_timing_ctx *timing; /* Some encoders need access to PTS, such as WebVTT */
+
+	/* Flag saying BOM to be written in each output file */
+	enum ccx_encoding_type encoding;
+	enum ccx_output_format write_format;                        // 0=Raw, 1=srt, 2=SMI
+	int generates_file;
+	struct ccx_encoders_transcript_format *transcript_settings; // Keeps the settings for generating transcript output files.
+	int no_bom;
+	int sentence_cap ;                                          // FIX CASE? = Fix case?
+
+	int trim_subs;                                              // "    Remove spaces at sides?    "
+	int autodash;                                               // Add dashes (-) before each speaker automatically?
+	int no_font_color;
+	int no_type_setting;
+	int gui_mode_reports;                                       // If 1, output in stderr progress updates so the GUI can grab them
+	unsigned char *subline;                                     // Temp storage for storing each line
+	int extract;
+
+	int dtvcc_extract;                                          // 1 or 0 depending if we have to handle dtvcc
+	ccx_dtvcc_writer_ctx dtvcc_writers[CCX_DTVCC_MAX_SERVICES];
+
+	/* Timing related variables*/
+	/* start time of previous sub */
+	LLONG prev_start;
+	LLONG subs_delay;
+	LLONG last_displayed_subs_ms;
+	enum ccx_output_date_format date_format;
+	char millis_separator;
+
+	/* Credit stuff */
+	int startcredits_displayed;
+	char *start_credits_text;
+	char *end_credits_text;
+	struct ccx_boundary_time startcreditsnotbefore, startcreditsnotafter;   // Where to insert start credits, if possible
+	struct ccx_boundary_time startcreditsforatleast, startcreditsforatmost; // How long to display them?
+	struct ccx_boundary_time endcreditsforatleast, endcreditsforatmost;
+
+	// Preencoded strings
+	unsigned char encoded_crlf[16];
+	unsigned int encoded_crlf_length;
+	unsigned char encoded_br[16];
+	unsigned int encoded_br_length;
+
+	int new_sentence; // Capitalize next letter?
+
+	int program_number;
+	struct list_head list;
+
+	/* split-by-sentence stuff */
+	int sbs_enabled;
+
+	//for dvb subs
+	struct encoder_ctx* prev;
+	int write_previous;
+    //for dvb in .mkv
+    int is_mkv; //are we working with .mkv file
+    char* last_string; //last recognized DVB sub
+
+	// Segmenting
+	int segment_pending;
+	int segment_last_key_frame;
+
+	// OCR in SPUPNG
+	int nospupngocr;
+};
+
+#define INITIAL_ENC_BUFFER_CAPACITY	2048
+/**
+ * Inialize encoder context with output context
+ * allocate initial memory to buffer of context
+ * write subtitle header to file refrenced by
+ * output context
+ *
+ * @param cfg Option to initilaize encoder cfg params
+ *
+ * @return Allocated and properly initilaized Encoder Context, NULL on failure
+ */
+struct encoder_ctx *init_encoder(struct encoder_cfg *opt);
+
+/**
+ * try to add end credits in subtitle file and then write subtitle
+ * footer
+ *
+ * deallocate encoder ctx, so before using encoder_ctx again
+ * after deallocating user need to allocate encoder ctx again
+ *
+ * @oaram arg pointer to initialized encoder ctx using init_encoder
+ * 
+ * @param current_fts to calculate window for end credits
+ */
+void dinit_encoder(struct encoder_ctx **arg, LLONG current_fts);
+
+/**
+ * @param ctx encoder context
+ * @param sub subtitle context returned by decoder
+ */
+int encode_sub(struct encoder_ctx *ctx,struct cc_subtitle *sub);
+
+int write_cc_buffer_as_srt            (struct eia608_screen *data, struct encoder_ctx *context);
+int write_cc_buffer_as_ssa            (struct eia608_screen *data, struct encoder_ctx *context);
+int write_cc_buffer_as_webvtt         (struct eia608_screen *data, struct encoder_ctx *context);
+int write_cc_buffer_as_sami           (struct eia608_screen *data, struct encoder_ctx *context);
+int write_cc_buffer_as_smptett        (struct eia608_screen *data, struct encoder_ctx *context);
+int write_cc_buffer_as_spupng         (struct eia608_screen *data, struct encoder_ctx *context);
+void write_cc_buffer_to_gui           (struct eia608_screen *data, struct encoder_ctx *context);
+
+int write_cc_buffer_as_g608           (struct eia608_screen *data, struct encoder_ctx *context);
+int write_cc_buffer_as_transcript2    (struct eia608_screen *data, struct encoder_ctx *context);
+
+void write_cc_line_as_transcript2     (struct eia608_screen *data, struct encoder_ctx *context, int line_number);
+
+int write_cc_subtitle_as_srt          (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_subtitle_as_ssa          (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_subtitle_as_webvtt       (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_subtitle_as_sami         (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_subtitle_as_smptett      (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_subtitle_as_spupng       (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_subtitle_as_transcript   (struct cc_subtitle *sub, struct encoder_ctx *context);
+
+
+int write_stringz_as_srt              (char *string, struct encoder_ctx *context, LLONG ms_start, LLONG ms_end);
+int write_stringz_as_ssa              (char *string, struct encoder_ctx *context, LLONG ms_start, LLONG ms_end);
+int write_stringz_as_webvtt           (char *string, struct encoder_ctx *context, LLONG ms_start, LLONG ms_end);
+int write_stringz_as_sami             (char *string, struct encoder_ctx *context, LLONG ms_start, LLONG ms_end);
+void write_stringz_as_smptett         (char *string, struct encoder_ctx *context, LLONG ms_start, LLONG ms_end);
+
+
+int write_cc_bitmap_as_srt             (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_bitmap_as_ssa             (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_bitmap_as_webvtt          (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_bitmap_as_sami            (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_bitmap_as_smptett         (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_bitmap_as_spupng          (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_bitmap_as_transcript      (struct cc_subtitle *sub, struct encoder_ctx *context);
+int write_cc_bitmap_as_libcurl         (struct cc_subtitle *sub, struct encoder_ctx *context);
+
+void write_spumux_header(struct encoder_ctx *ctx, struct ccx_s_write *out);
+void write_spumux_footer(struct ccx_s_write *out);
+
+struct cc_subtitle * reformat_cc_bitmap_through_sentence_buffer (struct cc_subtitle *sub, struct encoder_ctx *context);
+
+void set_encoder_last_displayed_subs_ms(struct encoder_ctx *ctx, LLONG last_displayed_subs_ms);
+void set_encoder_subs_delay(struct encoder_ctx *ctx, LLONG subs_delay);
+void set_encoder_startcredits_displayed(struct encoder_ctx *ctx, int startcredits_displayed);
+void set_encoder_rcwt_fileformat(struct encoder_ctx *ctx, short int format);
+
+int reset_output_ctx(struct encoder_ctx *ctx, struct encoder_cfg *cfg);
+
+void find_limit_characters(unsigned char *line, int *first_non_blank, int *last_non_blank, int max_len);
+int get_str_basic(unsigned char *out_buffer, unsigned char *in_buffer, int trim_subs,
+	enum ccx_encoding_type in_enc, enum ccx_encoding_type out_enc, int max_len);
+
+
+unsigned int get_line_encoded(struct encoder_ctx *ctx, unsigned char *buffer, int line_num, struct eia608_screen *data);
+unsigned int get_color_encoded(struct encoder_ctx *ctx, unsigned char *buffer, int line_num, struct eia608_screen *data);
+unsigned int get_font_encoded(struct encoder_ctx *ctx, unsigned char *buffer, int line_num, struct eia608_screen *data);
+int pass_cc_buffer_to_python(struct eia608_screen *data, struct encoder_ctx *context);
+
+struct lib_ccx_ctx;
+void switch_output_file(struct lib_ccx_ctx *ctx, struct encoder_ctx *enc_ctx, int track_id);
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_encoders_helpers.c Added

@@ -0,0 +1,473 @@
+#include "ccx_encoders_helpers.h"
+#include "ccx_common_char_encoding.h"
+#include "ccx_common_constants.h"
+#include "ccx_common_structs.h"
+#include "ccx_decoders_common.h"
+#include "ccx_encoders_common.h"
+
+#ifdef _MSC_VER
+#define strcasecmp stricmp
+#endif
+
+// userdefined rgb color
+unsigned char usercolor_rgb[8] = "";
+
+static int spell_builtin_added = 0; // so we don't do it twice
+// Case arrays
+char **spell_lower = NULL;
+char **spell_correct = NULL;
+int spell_words = 0;
+int spell_capacity = 0;
+// Some basic English words, so user-defined doesn't have to
+// include the common stuff
+static const char *spell_builtin[] =
+{
+	"I", "I'd", "I've", "I'd", "I'll",
+	"January", "February", "March", "April", // May skipped intentionally
+	"June", "July", "August", "September", "October", "November",
+	"December", "Monday", "Tuesday", "Wednesday", "Thursday",
+	"Friday", "Saturday", "Sunday", "Halloween", "United States",
+	"Spain", "France", "Italy", "England",
+	NULL
+};
+
+int string_cmp_function(const void *p1, const void *p2, void *arg)
+{
+	return strcasecmp(*(char**)p1, *(char**)p2);
+}
+int __cdecl string_cmp(const void *p1, const void *p2)
+{
+	return string_cmp_function(p1, p2, NULL);
+}
+
+void correct_case_with_dictionary(int line_num, struct eia608_screen *data)
+{
+	char delim[64] = {
+		' ', '\n', '\r', 0x89, 0x99,
+		'!', '"', '#', '%', '&',
+		'\'', '(', ')', ';', '<',
+		'=', '>', '?', '[', '\\',
+		']', '*', '+', ',', '-',
+		'.', '/', ':', '^', '_',
+		'{', '|', '}', '~', '\0' };
+
+	char *line = strdup(((char*)data->characters[line_num]));
+	char *oline = (char*)data->characters[line_num];
+	char *c = strtok(line, delim);
+	if (c == NULL)
+	{
+		free(line);
+		return;
+	}
+	do
+	{
+		char **index = bsearch(&c, spell_lower, spell_words, sizeof(*spell_lower), string_cmp);
+
+		if (index)
+		{
+			char *correct_c = *(spell_correct + (index - spell_lower));
+			size_t len = strlen(correct_c);
+			memcpy(oline + (c - line), correct_c, len);
+		}
+	} while ((c = strtok(NULL, delim)) != NULL);
+	free(line);
+}
+
+void telx_correct_case(char *sub_line)
+{
+	char delim[64] = {
+		' ', '\n', '\r', 0x89, 0x99,
+		'!', '"', '#', '%', '&',
+		'\'', '(', ')', ';', '<',
+		'=', '>', '?', '[', '\\',
+		']', '*', '+', ',', '-',
+		'.', '/', ':', '^', '_',
+		'{', '|', '}', '~', '\0' };
+
+	char *line = strdup(((char*)sub_line));
+	char *oline = (char*)sub_line;
+	char *c = strtok(line, delim);
+	if (c == NULL)
+	{
+		free(line);
+		return;
+	}
+	do
+	{
+		char **index = bsearch(&c, spell_lower, spell_words, sizeof(*spell_lower), string_cmp);
+
+		if (index)
+		{
+			char *correct_c = *(spell_correct + (index - spell_lower));
+			size_t len = strlen(correct_c);
+			memcpy(oline + (c - line), correct_c, len);
+		}
+	} while ((c = strtok(NULL, delim)) != NULL);
+	free(line);
+}
+
+int is_all_caps(struct encoder_ctx *context, int line_num, struct eia608_screen *data)
+{
+	int saw_upper = 0, saw_lower = 0;
+
+	for (int i = 0; i < CCX_DECODER_608_SCREEN_WIDTH; i++)
+	{
+		if (islower(data->characters[line_num][i]))
+			saw_lower = 1;
+		else if (isupper(data->characters[line_num][i]))
+			saw_upper = 1;
+	}
+	return (saw_upper && !saw_lower); // 1 if we've seen upper and not lower, 0 otherwise
+}
+
+int clever_capitalize(struct encoder_ctx *context, int line_num, struct eia608_screen *data)
+{
+	// CFS: Tried doing to clever (see below) but some channels do all uppercase except for
+	// notes for deaf people (such as "(narrator)" which messes things up.
+		// First find out if we actually need to do it, don't mess with lines that come OK
+		//int doit = is_all_caps(context, line_num, data);
+	int doit = 1;
+
+	for (int i = 0; i < CCX_DECODER_608_SCREEN_WIDTH; i++)
+	{
+		switch (data->characters[line_num][i])
+		{
+		case ' ':
+		case 0x89: // This is a transparent space
+		case '-':
+			break;
+		case '.': // Fallthrough
+		case '?': // Fallthrough
+		case '!':
+		case ':':
+			context->new_sentence = 1;
+			break;
+		default:
+			if (doit)
+			{
+				if (context->new_sentence)
+					data->characters[line_num][i] = cctoupper(data->characters[line_num][i]);
+				else
+					data->characters[line_num][i] = cctolower(data->characters[line_num][i]);
+			}
+			context->new_sentence = 0;
+			break;
+		}
+	}
+	return doit;
+}
+
+// Encodes a generic string. Note that since we use the encoders for closed caption
+// data, text would have to be encoded as CCs... so using special characters here
+// it's a bad idea.
+unsigned encode_line(struct encoder_ctx *ctx, unsigned char *buffer, unsigned char *text)
+{
+	unsigned bytes = 0;
+	while (*text)
+	{
+		switch (ctx->encoding)
+		{
+		case CCX_ENC_UTF_8:
+		case CCX_ENC_LATIN_1:
+			*buffer = *text;
+			bytes++;
+			buffer++;
+			break;
+		case CCX_ENC_UNICODE:
+			*buffer = *text;
+			*(buffer + 1) = 0;
+			bytes += 2;
+			buffer += 2;
+			break;
+		}
+		text++;
+	}
+	*buffer = 0;
+	return bytes;
+}
+
+unsigned get_decoder_line_encoded_for_gui(unsigned char *buffer, int line_num, struct eia608_screen *data)
+{
+	unsigned char *line = data->characters[line_num];
+	unsigned char *orig = buffer; // Keep for debugging
+	int first = 0, last = 31;
+	find_limit_characters(line, &first, &last, CCX_DECODER_608_SCREEN_WIDTH);
+	for (int i = first; i <= last; i++)
+	{
+		get_char_in_latin_1(buffer, line[i]);
+		buffer++;
+	}
+	*buffer = 0;
+	return (unsigned)(buffer - orig); // Return length
+
+}
+
+unsigned char *close_tag(struct encoder_ctx *ctx, unsigned char *buffer, char *tagstack, char tagtype, int *punderlined, int *pitalics, int *pchanged_font)
+{
+	for (int l = strlen(tagstack) - 1; l >= 0; l--)
+	{
+		char cur = tagstack[l];
+		switch (cur)
+		{
+		case 'F':
+			buffer += encode_line(ctx, buffer, (unsigned char *) "</font>");
+			(*pchanged_font)--;
+			break;
+		case 'U':
+			buffer += encode_line(ctx, buffer, (unsigned char *) "</u>");
+			(*punderlined)--;
+			break;
+		case 'I':
+			buffer += encode_line(ctx, buffer, (unsigned char *) "</i>");
+			(*pitalics)--;
+			break;
+		}
+		tagstack[l] = 0; // Remove from stack
+		if (cur == tagtype) // We closed up to the required tag, done
+			return buffer;
+	}
+	if (tagtype != 'A') // All
+		ccx_common_logging.fatal_ftn(CCX_COMMON_EXIT_BUG_BUG, "Mismatched tags in encoding, this is a bug, please report");
+	return buffer;
+}
+
+unsigned get_decoder_line_encoded(struct encoder_ctx *ctx, unsigned char *buffer, int line_num, struct eia608_screen *data)
+{
+	int col = COL_WHITE;
+	int underlined = 0;
+	int italics = 0;
+	int changed_font = 0;
+	char tagstack[128] = ""; // Keep track of opening/closing tags
+
+	unsigned char *line = data->characters[line_num];
+	unsigned char *orig = buffer; // Keep for debugging
+	int first = 0, last = 31;
+	if (ctx->trim_subs)
+		find_limit_characters(line, &first, &last, CCX_DECODER_608_SCREEN_WIDTH);
+	for (int i = first; i <= last; i++)
+	{
+		// Handle color
+		int its_col = data->colors[line_num][i];
+		if (its_col != col  && !ctx->no_font_color &&
+			!(col == COL_USERDEFINED && its_col == COL_WHITE)) // Don't replace user defined with white
+		{
+			if (changed_font)
+				buffer = close_tag(ctx, buffer, tagstack, 'F', &underlined, &italics, &changed_font);
+
+			// Add new font tag
+			if ( MAX_COLOR > its_col)
+				buffer += encode_line(ctx, buffer, (unsigned char*)color_text[its_col][1]);
+			else
+			{
+				ccx_common_logging.log_ftn("WARNING:get_decoder_line_encoded:Invalid Color index Selected %d\n", its_col);
+				its_col = COL_WHITE;
+			}
+
+			if (its_col == COL_USERDEFINED)
+			{
+				// The previous sentence doesn't copy the whole
+				// <font> tag, just up to the quote before the color
+				buffer += encode_line(ctx, buffer, (unsigned char*)usercolor_rgb);
+				buffer += encode_line(ctx, buffer, (unsigned char*) "\">");
+			}
+			if (color_text[its_col][1][0]) // That means a <font> was added to the buffer
+			{
+				strcat(tagstack, "F");
+				changed_font++;
+			}
+			col = its_col;
+		}
+		// Handle underlined
+		int is_underlined = data->fonts[line_num][i] & FONT_UNDERLINED;
+		if (is_underlined && underlined == 0 && !ctx->no_type_setting) // Open underline
+		{
+			buffer += encode_line(ctx, buffer, (unsigned char *) "<u>");
+			strcat(tagstack, "U");
+			underlined++;
+		}
+		if (is_underlined == 0 && underlined && !ctx->no_type_setting) // Close underline
+		{
+			buffer = close_tag(ctx, buffer, tagstack, 'U', &underlined, &italics, &changed_font);
+		}
+		// Handle italics
+		int has_ita = data->fonts[line_num][i] & FONT_ITALICS;
+		if (has_ita && italics == 0 && !ctx->no_type_setting) // Open italics
+		{
+			buffer += encode_line(ctx, buffer, (unsigned char *) "<i>");
+			strcat(tagstack, "I");
+			italics++;
+		}
+		if (has_ita == 0 && italics && !ctx->no_type_setting) // Close italics
+		{
+			buffer = close_tag(ctx, buffer, tagstack, 'I', &underlined, &italics, &changed_font);
+		}
+		int bytes = 0;
+		switch (ctx->encoding)
+		{
+		case CCX_ENC_UTF_8:
+			bytes = get_char_in_utf_8(buffer, line[i]);
+			break;
+		case CCX_ENC_LATIN_1:
+			get_char_in_latin_1(buffer, line[i]);
+			bytes = 1;
+			break;
+		case CCX_ENC_UNICODE:
+			get_char_in_unicode(buffer, line[i]);
+			bytes = 2;
+			break;
+		}
+		buffer += bytes;
+	}
+	buffer = close_tag(ctx, buffer, tagstack, 'A', &underlined, &italics, &changed_font);
+	if (underlined || italics || changed_font)
+		ccx_common_logging.fatal_ftn(CCX_COMMON_EXIT_BUG_BUG, "Not all tags closed in encoding, this is a bug, please report.\n");
+	*buffer = 0;
+	return (unsigned)(buffer - orig); // Return length
+}
+
+void get_sentence_borders(int *first, int *last, int line_num, struct eia608_screen *data) {
+	*first = 0;
+	*last = 32;
+	while (data->colors[line_num][*first] == COL_TRANSPARENT)
+		(*first)++;
+	while (data->colors[line_num][*last] == COL_TRANSPARENT)
+		(*last)--;
+}
+
+/*void delete_all_lines_but_current(ccx_decoder_608_context *context, struct eia608_screen *data, int row)
+{
+for (int i=0;i<15;i++)
+{
+if (i!=row)
+{
+memset(data->characters[i], ' ', CCX_DECODER_608_SCREEN_WIDTH);
+data->characters[i][CCX_DECODER_608_SCREEN_WIDTH] = 0;
+memset(data->colors[i], context->settings.default_color, CCX_DECODER_608_SCREEN_WIDTH + 1);
+memset(data->fonts[i], FONT_REGULAR, CCX_DECODER_608_SCREEN_WIDTH + 1);
+data->row_used[i]=0;
+}
+}
+}*/
+
+/*void fprintf_encoded (struct encoder_ctx *ctx,FILE *fh, const char *string)
+{
+int used;
+REQUEST_BUFFER_CAPACITY(ctx,strlen (string)*3);
+used=encode_line (ctx->buffer,(unsigned char *) string);
+fwrite (ctx->buffer,used,1,fh);
+}*/
+
+int add_word(const char *word)
+{
+	char *new_lower;
+	char *new_correct;
+	char **ptr_lower;
+	char **ptr_correct;
+	int i;
+	if (spell_words == spell_capacity)
+	{
+		// Time to grow
+		spell_capacity += 50;
+		ptr_lower = (char **)realloc(spell_lower, sizeof (char *)*
+			spell_capacity);
+		ptr_correct = (char **)realloc(spell_correct, sizeof (char *)*
+			spell_capacity);
+	}
+	else
+	{
+		ptr_lower = spell_lower;
+		ptr_correct = spell_correct;
+	}
+	size_t len = strlen(word);
+	new_lower = (char *)malloc(len + 1);
+	new_correct = (char *)malloc(len + 1);
+	if (ptr_lower == NULL || ptr_correct == NULL ||
+		new_lower == NULL || new_correct == NULL)
+	{
+		spell_capacity = 0;
+		for (i = 0; i < spell_words; i++)
+		{
+			freep(&spell_lower[spell_words]);
+			freep(&spell_correct[spell_words]);
+		}
+		freep(&spell_lower);
+		freep(&spell_correct);
+		freep(&ptr_lower);
+		freep(&ptr_correct);
+		freep(&new_lower);
+		freep(&new_correct);
+		spell_words = 0;
+		return -1;
+	}
+	else
+	{
+		spell_lower = ptr_lower;
+		spell_correct = ptr_correct;
+	}
+	strcpy(new_correct, word);
+	for (size_t i = 0; i<len; i++)
+	{
+		char c = new_correct[i];
+		c = tolower(c); // TO-DO: Add Spanish characters
+		new_lower[i] = c;
+	}
+	new_lower[len] = 0;
+	spell_lower[spell_words] = new_lower;
+	spell_correct[spell_words] = new_correct;
+	spell_words++;
+	return 0;
+}
+
+
+int add_built_in_words(void)
+{
+	if (!spell_builtin_added)
+	{
+		int i = 0;
+		while (spell_builtin[i] != NULL)
+		{
+			if (add_word(spell_builtin[i]))
+				return -1;
+			i++;
+		}
+		spell_builtin_added = 1;
+	}
+	return 0;
+}
+
+/**
+* @param base points to the start of the array
+* @param nb   number of element in array
+* @param size size of each element
+* @param compar Comparison function, which is called with three argument
+*               that point to the objects being compared and arg.
+*		compare Function should return an integer less than, equal to,
+*		or greater than zero if p1 is found, respectively, to be less than,
+*		to match, or be greater than p2.
+* @param arg argument passed as it is, to compare function
+*/
+void shell_sort(void *base, int nb, size_t size, int(*compar)(const void*p1, const void *p2, void*arg), void *arg)
+{
+	unsigned char *lbase = (unsigned char*)base;
+	unsigned char *tmp = (unsigned char*)malloc(size);
+	for (int gap = nb / 2; gap > 0; gap = gap / 2)
+	{
+		int p, j;
+		for (p = gap; p < nb; p++)
+		{
+			memcpy(tmp, lbase + (p *size), size);
+			for (j = p; j >= gap && (compar(tmp, lbase + ((j - gap) * size), arg) < 0); j -= gap)
+			{
+				memcpy(lbase + (j*size), lbase + ((j - gap) * size), size);
+			}
+			memcpy(lbase + (j *size), tmp, size);
+		}
+	}
+	free(tmp);
+}
+
+void ccx_encoders_helpers_perform_shellsort_words(void)
+{
+	shell_sort(spell_lower, spell_words, sizeof(*spell_lower), string_cmp_function, NULL);
+	shell_sort(spell_correct, spell_words, sizeof(*spell_correct), string_cmp_function, NULL);
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_encoders_helpers.h Added

@@ -0,0 +1,50 @@
+#ifndef _CCX_ENCODERS_HELPERS_H
+#define _CCX_ENCODERS_HELPERS_H
+
+#include "ccx_common_common.h"
+#include "ccx_common_constants.h"
+#include "ccx_decoders_structs.h"
+#include "ccx_decoders_608.h"
+#include "ccx_encoders_common.h"
+#ifndef MMCCXTR
+#include "png.h"
+#endif
+
+extern char **spell_lower;
+extern char **spell_correct;
+extern int spell_words;
+extern int spell_capacity;
+
+extern unsigned char usercolor_rgb[8];
+
+struct ccx_encoders_helpers_settings_t {
+	int trim_subs;
+	int no_font_color;
+	int no_type_setting;
+	enum ccx_encoding_type encoding;
+};
+
+// Helper functions
+void correct_case_with_dictionary(int line_num, struct eia608_screen *data);
+int is_all_caps(struct encoder_ctx *context, int line_num, struct eia608_screen *data);
+int clever_capitalize(struct encoder_ctx *context, int line_num, struct eia608_screen *data);
+void telx_correct_case(char *sub_line);
+unsigned get_decoder_line_encoded_for_gui(unsigned char *buffer, int line_num, struct eia608_screen *data);
+unsigned get_decoder_line_encoded(struct encoder_ctx *ctx, unsigned char *buffer, int line_num, struct eia608_screen *data);
+void get_sentence_borders(int *first, int *last, int line_num, struct eia608_screen *data);
+
+int __cdecl string_cmp(const void *p1, const void *p2);
+int string_cmp_function(const void *p1, const void *p2, void *arg);
+int add_built_in_words(void);
+int add_word(const char *word);
+unsigned encode_line (struct encoder_ctx *ctx, unsigned char *buffer, unsigned char *text);
+
+void shell_sort(void *base, int nb, size_t size, int(*compar)(const void*p1, const void *p2, void*arg), void *arg);
+
+void ccx_encoders_helpers_perform_shellsort_words(void);
+void ccx_encoders_helpers_setup(enum ccx_encoding_type encoding, int no_font_color, int no_type_setting, int trim_subs);
+
+#ifndef MMCCXTR
+int mapclut_paletee(png_color *palette, png_byte *alpha, uint32_t *clut, uint8_t depth);
+#endif
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_encoders_srt.c Added

@@ -0,0 +1,318 @@
+#include "lib_ccx.h"
+#include "ccx_common_option.h"
+#include "ccx_encoders_common.h"
+#include "utility.h"
+#include "ccx_encoders_helpers.h"
+#ifndef MMCCXTR
+#include "ocr.h"
+#endif
+#include "../ccextractor.h"
+
+static void cwrite(int fd, const void *buf, size_t count)
+{
+	size_t r = write(fd,buf,count);
+	if (r!=count)
+	{
+		fatal (EXIT_READ_ERROR, "Error writing output file!\n");
+	}
+}
+
+/* The timing here is not PTS based, but output based, i.e. user delay must be accounted for
+   if there is any */
+int write_stringz_as_srt(char *string, struct encoder_ctx *context, LLONG ms_start, LLONG ms_end)
+{
+	int used;
+	unsigned h1,m1,s1,ms1;
+	unsigned h2,m2,s2,ms2;
+	char timeline[128];
+
+	if(!string || !string[0])
+		return 0;
+
+	if (ms_start<0) // Drop screens that because of subs_delay start too early
+		return 0;
+
+	millis_to_time (ms_start,&h1,&m1,&s1,&ms1);
+	millis_to_time (ms_end-1,&h2,&m2,&s2,&ms2); // -1 To prevent overlapping with next line.
+	context->srt_counter++;
+	sprintf(timeline, "%u%s", context->srt_counter, context->encoded_crlf);
+	used = encode_line(context, context->buffer,(unsigned char *) timeline);
+	cwrite(context->out->fh, context->buffer, used);
+	sprintf (timeline, "%02u:%02u:%02u,%03u --> %02u:%02u:%02u,%03u%s",
+		h1, m1, s1, ms1, h2, m2, s2, ms2, context->encoded_crlf);
+	used = encode_line(context, context->buffer,(unsigned char *) timeline);
+	dbg_print(CCX_DMT_DECODER_608, "\n- - - SRT caption - - -\n");
+	dbg_print(CCX_DMT_DECODER_608, "%s",timeline);
+
+	cwrite(context->out->fh, context->buffer, used);
+	int len=strlen (string);
+	unsigned char *unescaped= (unsigned char *) malloc (len+1);
+	unsigned char *el = (unsigned char *) malloc (len*3+1); // Be generous
+	if (el==NULL || unescaped==NULL)
+		fatal (EXIT_NOT_ENOUGH_MEMORY, "In write_stringz_as_srt() - not enough memory.\n");
+	int pos_r=0;
+	int pos_w=0;
+	// Scan for \n in the string and replace it with a 0
+	while (pos_r<len)
+	{
+		if (string[pos_r]=='\\' && string[pos_r+1]=='n')
+		{
+			unescaped[pos_w]=0;
+			pos_r+=2;
+		}
+		else
+		{
+			unescaped[pos_w]=string[pos_r];
+			pos_r++;
+		}
+		pos_w++;
+	}
+	unescaped[pos_w]=0;
+	// Now read the unescaped string (now several string'z and write them)
+	unsigned char *begin=unescaped;
+	while (begin<unescaped+len)
+	{
+		unsigned int u = encode_line (context, el, begin);
+		if (context->encoding != CCX_ENC_UNICODE)
+		{
+			dbg_print(CCX_DMT_DECODER_608, "\r");
+			dbg_print(CCX_DMT_DECODER_608, "%s\n",context->subline);
+		}
+		cwrite(context->out->fh, el, u);
+		cwrite(context->out->fh, context->encoded_crlf, context->encoded_crlf_length);
+		begin+= strlen ((const char *) begin)+1;
+	}
+
+	dbg_print(CCX_DMT_DECODER_608, "- - - - - - - - - - - -\r\n");
+
+	cwrite(context->out->fh, context->encoded_crlf, context->encoded_crlf_length);
+	free(el);
+	free(unescaped);
+
+	return 0;
+}
+
+int write_cc_bitmap_as_srt(struct cc_subtitle *sub, struct encoder_ctx *context)
+{
+	int ret = 0;
+#ifdef ENABLE_OCR
+	struct cc_bitmap* rect;
+	LLONG ms_start, ms_end;
+	unsigned h1,m1,s1,ms1;
+	unsigned h2,m2,s2,ms2;
+	char timeline[128];
+	int len = 0;
+	int used;
+	int i = 0;
+	char *str;
+
+	ms_start = sub->start_time + context->subs_delay;
+	ms_end = sub->end_time + context->subs_delay;
+
+    if (ms_start<0) // Drop screens that because of subs_delay start too early
+        return 0;
+
+	if(sub->nb_data == 0 )
+		return 0;
+
+	if(sub->flags & SUB_EOD_MARKER)
+		context->prev_start =  sub->start_time;
+
+	str = paraof_ocrtext(sub, context->encoded_crlf, context->encoded_crlf_length);
+	if (str)
+	{
+        if(context->is_mkv == 1) {
+            // Save recognized string for later use in matroska.c
+            context->last_string = str;
+        } else {
+            if (context->prev_start != -1 || !(sub->flags & SUB_EOD_MARKER))
+            {
+                millis_to_time (ms_start,&h1,&m1,&s1,&ms1);
+                millis_to_time (ms_end-1,&h2,&m2,&s2,&ms2); // -1 To prevent overlapping with next line.
+                context->srt_counter++;
+                sprintf(timeline, "%u%s", context->srt_counter, context->encoded_crlf);
+                used = encode_line(context, context->buffer,(unsigned char *) timeline);
+                write(context->out->fh, context->buffer, used);
+                sprintf (timeline, "%02u:%02u:%02u,%03u --> %02u:%02u:%02u,%03u%s",
+                         h1, m1, s1, ms1, h2, m2, s2, ms2, context->encoded_crlf);
+                used = encode_line(context, context->buffer,(unsigned char *) timeline);
+                write (context->out->fh, context->buffer, used);
+                len = strlen(str);
+                write (context->out->fh, str, len);
+                write (context->out->fh, context->encoded_crlf, context->encoded_crlf_length);
+            }
+            freep(&str);
+        }
+	}
+	for(i = 0, rect = sub->data; i < sub->nb_data; i++, rect++)
+	{
+		if (rect)
+		{
+			freep(&rect->data0);
+			freep(&rect->data1);
+		}
+	}
+#endif
+	sub->nb_data = 0;
+	freep(&sub->data);
+	return ret;
+
+}
+
+int write_cc_subtitle_as_srt(struct cc_subtitle *sub,struct encoder_ctx *context)
+{
+	int ret = 0;
+	struct cc_subtitle *osub = sub;
+	struct cc_subtitle *lsub = sub;
+
+	while(sub)
+	{
+		if(sub->type == CC_TEXT)
+		{
+			ret = write_stringz_as_srt(sub->data, context, sub->start_time + context->subs_delay, sub->end_time + context->subs_delay);
+			freep(&sub->data);
+			sub->nb_data = 0;
+			ret = 1;
+		}
+		lsub = sub;
+		sub = sub->next;
+	}
+	while(lsub != osub)
+	{
+		sub = lsub->prev;
+		freep(&lsub);
+		lsub = sub;
+	}
+
+	return ret;
+}
+int write_cc_buffer_as_srt(struct eia608_screen *data, struct encoder_ctx *context)
+{
+	int used;
+	unsigned h1,m1,s1,ms1;
+	unsigned h2,m2,s2,ms2;
+	LLONG ms_start, ms_end;
+	int wrote_something = 0;
+	ms_start = data->start_time;
+
+	int prev_line_start=-1, prev_line_end=-1; // Column in which the previous line started and ended, for autodash
+	int prev_line_center1=-1, prev_line_center2=-1; // Center column of previous line text
+	int empty_buf=1;
+	for (int i=0;i<15;i++)
+	{
+		if (data->row_used[i])
+		{
+			empty_buf=0;
+			break;
+		}
+	}
+	if (empty_buf) // Prevent writing empty screens. Not needed in .srt
+		return 0;
+
+	ms_start+=context->subs_delay;
+	if (ms_start<0) // Drop screens that because of subs_delay start too early
+		return 0;
+
+	ms_end = data->end_time;
+
+	millis_to_time (ms_start,&h1,&m1,&s1,&ms1);
+	millis_to_time (ms_end-1,&h2,&m2,&s2,&ms2); // -1 To prevent overlapping with next line.
+	char timeline[128];
+	context->srt_counter++;
+	sprintf(timeline, "%u%s", context->srt_counter, context->encoded_crlf);
+	used = encode_line(context, context->buffer,(unsigned char *) timeline);
+	cwrite(context->out->fh, context->buffer, used);
+
+	sprintf (timeline, "%02u:%02u:%02u,%03u --> %02u:%02u:%02u,%03u%s",
+		h1, m1, s1, ms1, h2, m2, s2, ms2, context->encoded_crlf);
+	used = encode_line(context, context->buffer,(unsigned char *) timeline);
+
+	dbg_print(CCX_DMT_DECODER_608, "\n- - - SRT caption ( %d) - - -\n", context->srt_counter);
+	dbg_print(CCX_DMT_DECODER_608, "%s",timeline);
+
+	cwrite(context->out->fh, context->buffer, used);
+	for (int i=0;i<15;i++)
+	{
+		if (data->row_used[i])
+		{
+			if (context->sentence_cap)
+			{
+				if (clever_capitalize (context, i, data))
+					correct_case_with_dictionary(i, data);
+			}
+			if (context->autodash && context->trim_subs)
+			{
+				int first=0, last=31, center1=-1, center2=-1;
+				unsigned char *line = data->characters[i];
+				int do_dash=1, colon_pos=-1;
+				find_limit_characters(line, &first, &last, CCX_DECODER_608_SCREEN_WIDTH);
+				if (first==-1 || last==-1)  // Probably a bug somewhere though
+					break;
+				// Is there a speaker named, for example: TOM: What are you doing?
+				for (int j=first;j<=last;j++)
+				{
+					if (line[j]==':')
+					{
+						colon_pos=j;
+						break;
+					}
+					if (!isupper (line[j]))
+						break;
+				}
+				if (prev_line_start==-1)
+					do_dash=0;
+				if (first==prev_line_start) // Case of left alignment
+					do_dash=0;
+				if (last==prev_line_end)  // Right align
+					do_dash=0;
+				if (first>prev_line_start && last<prev_line_end) // Fully contained
+					do_dash=0;
+				if ((first>prev_line_start && first<prev_line_end) || // Overlap
+						(last>prev_line_start && last<prev_line_end))
+					do_dash=0;
+
+				center1=(first+last)/2;
+				if (colon_pos!=-1)
+				{
+					while (colon_pos<CCX_DECODER_608_SCREEN_WIDTH &&
+							(line[colon_pos]==':' ||
+							 line[colon_pos]==' ' ||
+							 line[colon_pos]==0x89))
+						colon_pos++; // Find actual text
+					center2=(colon_pos+last)/2;
+				}
+				else
+					center2=center1;
+
+				if (center1>=prev_line_center1-1 && center1<=prev_line_center1+1 && center1!=-1) // Center align
+					do_dash=0;
+				if (center2>=prev_line_center2-2 && center1<=prev_line_center2+2 && center1!=-1) // Center align
+					do_dash=0;
+
+				if (do_dash)
+					cwrite(context->out->fh, "- ", 2);
+				prev_line_start=first;
+				prev_line_end=last;
+				prev_line_center1=center1;
+				prev_line_center2=center2;
+
+			}
+			int length = get_decoder_line_encoded (context, context->subline, i, data);
+			if (context->encoding!=CCX_ENC_UNICODE)
+			{
+				dbg_print(CCX_DMT_DECODER_608, "\r");
+				dbg_print(CCX_DMT_DECODER_608, "%s\n",context->subline);
+			}
+			cwrite(context->out->fh, context->subline, length);
+			cwrite(context->out->fh, context->encoded_crlf, context->encoded_crlf_length);
+			wrote_something=1;
+			// fprintf (wb->fh,context->encoded_crlf);
+		}
+	}
+	dbg_print(CCX_DMT_DECODER_608, "- - - - - - - - - - - -\r\n");
+
+	// fprintf (wb->fh, context->encoded_crlf);
+    cwrite(context->out->fh, context->encoded_crlf, context->encoded_crlf_length);
+    //printf("$ = %s\n",context->encoded_crlf);
+	return wrote_something;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/ccx_encoders_structs.h Added

@@ -0,0 +1,31 @@
+#ifndef CCX_ENCODERS_STRUCTS_H
+#define CCX_ENCODERS_STRUCTS_H
+
+typedef struct ccx_encoders_transcript_format {
+	// TODO: add more options, and (perhaps) reduce other ccextractor options?
+	int showStartTime, showEndTime; // Show start and/or end time.
+	int showMode;                   // Show which mode if available (E.G.: POP, RU1, ...)
+	int showCC;                     // Show which CC channel has been captured.
+	int relativeTimestamp;          // Timestamps relative to start of sample or in UTC?
+	int xds;                        // Show XDS or not
+	int useColors;                  // Add colors or no colors
+	int isFinal;                    // Used to determine if these parameters should be changed afterwards.
+
+} ccx_encoders_transcript_format;
+
+struct ccx_s_write
+{
+	int fh;
+	int temporarily_closed; // 1 means the file was created OK before but we released the handle
+	char *filename;
+	void* spupng_data;
+	int with_semaphore;     // 1 means create a .sem file when the file is open and delete it when it's closed
+	char *semaphore_filename;
+	int with_playlist;      // For m3u8 /webvtt: If 1, we'll generate a playlist and segments
+	char *playlist_filename; 
+	int renaming_extension; //Used for file rotations
+	int append_mode;        /* Append the file. Prevent overwriting of files */
+
+};
+
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/compile_info.h Added

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/compile_info_real.h Added

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/file_buffer.h Added

@@ -0,0 +1,97 @@
+#ifndef FILE_BUFFER_H
+#define FILE_BUFFER_H
+
+/**
+ * Read from buffer if there is insufficient data then cache the buffer
+ *
+ * @param ctx ccx_demuxer context properly initilaized ccx_demuxer with some input
+ *            Not to be NULL, since ctx is derefrenced inside this function
+ *
+ * @param buffer if buffer then it must be allocated to at;east bytes len as 
+ *               passed in third argument, If buffer is NULL then those number of bytes
+ *               are skipped from input.
+ * @param bytes number of bytes to be read from file buffer.
+ *
+ * @return 0 or number of bytes, if returned 0 then op should check error number to know 
+ *              details of error 
+ */
+size_t buffered_read_opt (struct ccx_demuxer *ctx, unsigned char *buffer, size_t bytes);
+
+
+/**
+ * Skip bytes from file buffer and if needed also seek file for number of bytes.
+ *
+ */
+static size_t inline  buffered_skip(struct ccx_demuxer *ctx, unsigned int bytes)
+{
+	size_t result;
+	if (bytes <= ctx->bytesinbuffer - ctx->filebuffer_pos)
+	{
+		ctx->filebuffer_pos += bytes;
+		result = bytes;
+	}
+	else
+	{
+		result = buffered_read_opt (ctx, NULL, bytes);
+	}
+	return result;
+}
+
+/**
+ * Read bytes from file buffer and if needed also read file for number of bytes.
+ *
+ */
+static size_t inline buffered_read(struct ccx_demuxer *ctx, unsigned char *buffer, size_t bytes)
+{
+	size_t result;
+	if (bytes <= ctx->bytesinbuffer - ctx->filebuffer_pos)
+	{
+		if (buffer != NULL)
+			memcpy (buffer, ctx->filebuffer + ctx->filebuffer_pos, bytes);
+		ctx->filebuffer_pos+=bytes;
+		result = bytes;
+	}
+	else
+	{
+		result = buffered_read_opt (ctx, buffer, bytes);
+#ifndef MMCCXTR
+		if (ccx_options.gui_mode_reports && ccx_options.input_source == CCX_DS_NETWORK)
+		{
+			net_activity_gui++;
+			if (!(net_activity_gui%1000))
+				activity_report_data_read();
+		}
+#endif
+	}
+	return result;
+}
+
+/**
+ * Read single byte from file buffer and if needed also read file for number of bytes.
+ *
+ */
+static size_t inline buffered_read_byte(struct ccx_demuxer *ctx, unsigned char *buffer)
+{
+	size_t result;
+	if (ctx->bytesinbuffer - ctx->filebuffer_pos)
+	{
+		if (buffer)
+		{
+			*buffer=ctx->filebuffer[ctx->filebuffer_pos];
+			ctx->filebuffer_pos++;
+			result = 1;
+		}
+	}
+	else
+		result = buffered_read_opt (ctx, buffer, 1);
+
+	return result;
+}
+
+unsigned short buffered_get_be16(struct ccx_demuxer *ctx);
+unsigned char buffered_get_byte (struct ccx_demuxer *ctx);
+unsigned int buffered_get_be32(struct ccx_demuxer *ctx);
+unsigned short buffered_get_le16(struct ccx_demuxer *ctx);
+unsigned int buffered_get_le32(struct ccx_demuxer *ctx);
+uint64_t buffered_get_be64(struct ccx_demuxer *ctx);
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/file_functions.c Added

@@ -0,0 +1,561 @@
+#include "lib_ccx.h"
+#include "ccx_common_option.h"
+#include "activity.h"
+#include "file_buffer.h"
+#ifndef MMCCXTR
+long FILEBUFFERSIZE = 1024*1024*16; // 16 Mbytes no less. Minimize number of real read calls()
+#else
+long FILEBUFFERSIZE = 512;
+#endif
+
+#ifdef _WIN32
+WSADATA wsaData = {0};
+int iResult = 0;
+#endif
+
+LLONG get_file_size (int in)
+{
+	int ret = 0;
+	LLONG current = LSEEK (in, 0, SEEK_CUR);
+	LLONG length  = LSEEK (in, 0, SEEK_END);
+	if(current < 0 ||length < 0)
+		return -1;
+
+	ret = LSEEK (in, current, SEEK_SET);
+	if (ret < 0)
+		return -1;
+
+	return length;
+}
+
+LLONG get_total_file_size (struct lib_ccx_ctx *ctx) // -1 if one of the file(s) failed to open
+{
+	LLONG ts=0;
+	int h;
+	for (int i = 0; i < ctx->num_input_files; i++)
+	{
+		if (0 == strcmp(ctx->inputfile[i], "-")) // Skip stdin
+			continue;
+#ifdef _WIN32
+		h = OPEN (ctx->inputfile[i], O_RDONLY | O_BINARY);
+#else
+		h = OPEN (ctx->inputfile[i], O_RDONLY);
+#endif
+
+		if (h == -1) {
+			switch (errno)
+			{
+			case ENOENT:
+				return -1 * ENOENT;
+			case EACCES:
+				return -1 * EACCES;
+			case EINVAL:
+				return -1 * EINVAL;
+			case EMFILE:
+				return -1 * EMFILE;
+			default:
+				return -1;
+			}
+		}
+
+		if (!ccx_options.live_stream)
+			ts += get_file_size (h);
+		close (h);
+	}
+	return ts;
+}
+
+void prepare_for_new_file (struct lib_ccx_ctx *ctx)
+{
+	// Init per file variables
+	ctx->last_reported_progress =-1;
+	ctx->stat_numuserheaders    = 0;
+	ctx->stat_dvdccheaders      = 0;
+	ctx->stat_scte20ccheaders   = 0;
+	ctx->stat_replay5000headers = 0;
+	ctx->stat_replay4000headers = 0;
+	ctx->stat_dishheaders       = 0;
+	ctx->stat_hdtv              = 0;
+	ctx->stat_divicom           = 0;
+	total_frames_count          = 0;
+	ctx->false_pict_header      = 0;
+	frames_since_ref_time       = 0;
+	gop_time.inited             = 0;
+	first_gop_time.inited       = 0;
+	gop_rollover                = 0;
+	printed_gop.inited          = 0;
+	pts_big_change              = 0;
+#ifndef MMCCXTR
+	firstcall                   = 1;
+
+	if(ctx->epg_inited)
+	{
+		for(int x = 0; x < 0xfff; x++)
+		{
+			ctx->epg_buffers[x].buffer   = NULL;
+			ctx->epg_buffers[x].ccounter = 0;
+		}
+		for (int i = 0; i < TS_PMT_MAP_SIZE; i++)
+		{
+			ctx->eit_programs[i].array_len = 0;
+			ctx->eit_current_events[i] = -1;
+		}
+		ctx->epg_last_output      = -1;
+		ctx->epg_last_live_output = -1;
+	}
+#endif
+}
+
+/* Close input file if there is one and let the GUI know */
+void close_input_file (struct lib_ccx_ctx *ctx)
+{
+	ctx->demux_ctx->close(ctx->demux_ctx);
+}
+
+/* Close current file and open next one in list -if any- */
+/* bytesinbuffer is the number of bytes read (in some buffer) that haven't been added
+to 'past' yet. We provide this number to switch_to_next_file() so a final sanity check
+can be done */
+
+int switch_to_next_file (struct lib_ccx_ctx *ctx, LLONG bytesinbuffer)
+{
+	int ret = 0;
+	if (ctx->current_file == -1 || !ccx_options.binary_concat)
+	{
+		ctx->demux_ctx->reset(ctx->demux_ctx);
+	}
+
+	switch(ccx_options.input_source)
+	{
+		case CCX_DS_STDIN:
+		case CCX_DS_NETWORK:
+		case CCX_DS_TCP:
+			ret = ctx->demux_ctx->open(ctx->demux_ctx, NULL);
+			if (ret < 0)
+				return 0;
+			else if (ret)
+				return ret;
+			else
+				return 1;
+			break;
+		default:
+			break;
+	}
+	/* Close current and make sure things are still sane */
+	if (ctx->demux_ctx->is_open(ctx->demux_ctx))
+	{
+		dbg_print(CCX_DMT_708, "[CEA-708] The 708 decoder was reset [%d] times.\n", ctx->freport.data_from_708->reset_count);
+		if (ccx_options.print_file_reports)
+			print_file_report(ctx);
+
+		if (ctx->inputsize > 0 && ((ctx->demux_ctx->past+bytesinbuffer) < ctx->inputsize) && is_decoder_processed_enough(ctx) == CCX_FALSE)
+		{
+			mprint("\n\n\n\nATTENTION!!!!!!\n");
+			mprint("In switch_to_next_file(): Processing of %s %d ended prematurely %lld < %lld, please send bug report.\n\n",
+					ctx->inputfile[ctx->current_file], ctx->current_file, ctx->demux_ctx->past, ctx->inputsize);
+		}
+		close_input_file (ctx);
+
+		if (ccx_options.binary_concat)
+		{
+			ctx->total_past     += ctx->inputsize;
+			ctx->demux_ctx->past = 0; // Reset always or at the end we'll have double the size
+		}
+	}
+	for (;;)
+	{
+		ctx->current_file++;
+		if (ctx->current_file >= ctx->num_input_files)
+			break;
+
+		// The following \n keeps the progress percentage from being overwritten.
+		mprint ("\n\r-----------------------------------------------------------------\n");
+		mprint ("\rOpening file: %s\n", ctx->inputfile[ctx->current_file]);
+		ret = ctx->demux_ctx->open(ctx->demux_ctx, ctx->inputfile[ctx->current_file]);
+		if (ret < 0)
+			mprint ("\rWarning: Unable to open input file [%s]\n", ctx->inputfile[ctx->current_file]);
+		else
+		{
+			activity_input_file_open (ctx->inputfile[ctx->current_file]);
+			if (!ccx_options.live_stream)
+			{
+				ctx->inputsize = ctx->demux_ctx->get_filesize (ctx->demux_ctx);
+				if (!ccx_options.binary_concat)
+					ctx->total_inputsize = ctx->inputsize;
+			}
+			return 1; // Succeeded
+		}
+	}
+	return 0;
+}
+
+void position_sanity_check(struct ccx_demuxer *ctx)
+{
+#ifdef SANITY_CHECK
+	if (ctx->infd!=-1)
+	{
+		LLONG realpos = LSEEK (ctx->infd,0,SEEK_CUR);
+		if (realpos == -1) // Happens for example when infd==stdin.
+			return;
+		if (realpos != ctx->past - ctx->filebuffer_pos + ctx->bytesinbuffer)
+		{
+			fatal (CCX_COMMON_EXIT_BUG_BUG, "Position desync, THIS IS A BUG. Real pos =%lld, past=%lld.\n", realpos, ctx->past);
+		}
+	}
+#endif
+}
+
+
+int init_file_buffer(struct ccx_demuxer *ctx)
+{
+	ctx->filebuffer_start = 0;
+	ctx->filebuffer_pos = 0;
+	if (ctx->filebuffer == NULL)
+	{
+		ctx->filebuffer = (unsigned char *) malloc (FILEBUFFERSIZE);
+		ctx->bytesinbuffer = 0;
+	}
+	if (ctx->filebuffer == NULL)
+	{
+		return -1;
+	}
+	return 0;
+}
+
+void buffered_seek (struct ccx_demuxer *ctx, int offset)
+{
+	position_sanity_check(ctx);
+	if (offset < 0)
+	{
+		ctx->filebuffer_pos += offset;
+		if (ctx->filebuffer_pos < 0)
+		{
+			// We got into the start buffer (hopefully)
+			if ((ctx->filebuffer_pos + ctx->startbytes_pos) < 0)
+			{
+				fatal (CCX_COMMON_EXIT_BUG_BUG, "PANIC: Attempt to seek before buffer start, this is a bug!");
+			}
+			ctx->startbytes_pos += ctx->filebuffer_pos;
+			ctx->filebuffer_pos = 0;
+		}
+	}
+	else
+	{
+		buffered_read_opt (ctx, NULL, offset);
+		position_sanity_check(ctx);
+	}
+}
+
+void sleepandchecktimeout (time_t start)
+{
+	if (ccx_options.input_source == CCX_DS_STDIN)
+	{
+		// CFS: Not 100% sure about this. Fine for files, not so sure what happens if stdin is
+		// real time input from hardware.
+		sleep_secs (1);
+		ccx_options.live_stream = 0;
+		return;
+	}
+
+	if (ccx_options.live_stream == -1) // Just sleep, no timeout to check
+	{
+		sleep_secs (1);
+		return;
+	}
+	if (time(NULL) > start + ccx_options.live_stream) // More than live_stream seconds elapsed. No more live
+		ccx_options.live_stream = 0;
+	else
+		sleep_secs(1);
+}
+
+void return_to_buffer (struct ccx_demuxer *ctx, unsigned char *buffer, unsigned int bytes)
+{
+	if (bytes == ctx->filebuffer_pos)
+	{
+		// Usually we're just going back in the buffer and memcpy would be
+		// unnecessary, but we do it in case we intentionally messed with the
+		// buffer
+		memcpy (ctx->filebuffer, buffer, bytes);
+		ctx->filebuffer_pos = 0;
+		return;
+	}
+	if (ctx->filebuffer_pos > 0) // Discard old bytes, because we may need the space
+	{
+		// Non optimal since data is moved later again but we don't care since
+		// we're never here in ccextractor.
+		memmove (ctx->filebuffer, ctx->filebuffer + ctx->filebuffer_pos, ctx->bytesinbuffer-ctx->filebuffer_pos);
+		ctx->bytesinbuffer  = 0;
+		ctx->filebuffer_pos = 0;
+	}
+
+	if (ctx->bytesinbuffer + bytes > FILEBUFFERSIZE)
+		fatal (CCX_COMMON_EXIT_BUG_BUG, "Invalid return_to_buffer() - please submit a bug report.");
+
+	memmove (ctx->filebuffer + bytes, ctx->filebuffer, ctx->bytesinbuffer);
+	memcpy (ctx->filebuffer, buffer, bytes);
+	ctx->bytesinbuffer += bytes;
+}
+
+/**
+ * @param buffer can be NULL, in case when user want to just buffer it or skip some data.
+ *
+ * Global options that have effect on this function are following
+ * 1) ccx_options.live_stream
+ * 2) ccx_options.buffer_input
+ * 3) ccx_options.input_source
+ * 4) ccx_options.binary_concat
+ *
+ * TODO instead of using global ccx_options move them to ccx_demuxer
+ */
+size_t buffered_read_opt (struct ccx_demuxer *ctx, unsigned char *buffer, size_t bytes)
+{
+	size_t origin_buffer_size = bytes;
+	size_t copied   = 0;
+	time_t seconds = 0;
+
+	position_sanity_check(ctx);
+
+	if (ccx_options.live_stream > 0)
+		time (&seconds);
+
+	if (ccx_options.buffer_input || ctx->filebuffer_pos < ctx->bytesinbuffer)
+	{
+		// Needs to return data from filebuffer_start+pos to filebuffer_start+pos+bytes-1;
+		int eof = (ctx->infd == -1);
+
+		while ((!eof || ccx_options.live_stream) && bytes)
+		{
+			if (terminate_asap)
+				break;
+			if (eof)
+			{
+				// No more data available immediately, we sleep a while to give time
+				// for the data to come up
+				sleepandchecktimeout (seconds);
+			}
+			size_t ready = ctx->bytesinbuffer - ctx->filebuffer_pos;
+			if (ready == 0) // We really need to read more
+			{
+				if (!ccx_options.buffer_input)
+				{
+					// We got in the buffering code because of the initial buffer for
+					// detection stuff. However we don't want more buffering so
+					// we do the rest directly on the final buffer.
+					int i;
+					do
+					{
+						// No code for network support here, because network is always
+						// buffered - if here, then it must be files.
+						if (buffer != NULL) // Read
+						{
+							i = read (ctx->infd, buffer, bytes);
+							if( i == -1)
+								fatal (EXIT_READ_ERROR, "Error reading input file!\n");
+							buffer += i;
+						}
+						else // Seek
+						{
+							LLONG op, np;
+							op = LSEEK (ctx->infd, 0, SEEK_CUR); // Get current pos
+							if (op + bytes < 0) // Would mean moving beyond start of file: Not supported
+								return 0;
+							np = LSEEK (ctx->infd, bytes, SEEK_CUR); // Pos after moving
+							i = (int) (np - op);
+						}
+						// if both above lseek returned -1 (error); i would be 0 here and
+						// in case when its not live stream copied would decrease and bytes would...
+						if (i == 0 && ccx_options.live_stream)
+						{
+							if (ccx_options.input_source == CCX_DS_STDIN)
+							{
+								ccx_options.live_stream = 0;
+								break;
+							}
+							else
+							{
+								sleepandchecktimeout (seconds);
+							}
+						}
+						else
+						{
+							copied += i;
+							bytes  -= i;
+						}
+
+					}
+					while ((i || ccx_options.live_stream ||
+								(ccx_options.binary_concat && switch_to_next_file(ctx->parent, copied))) && bytes);
+					return copied;
+				}
+				// Keep the last 8 bytes, so we have a guaranteed
+				// working seek (-8) - needed by mythtv.
+				int keep = ctx->bytesinbuffer > 8 ? 8 : ctx->bytesinbuffer;
+				memmove (ctx->filebuffer, ctx->filebuffer+(FILEBUFFERSIZE-keep),keep);
+				int i;
+				if (ccx_options.input_source == CCX_DS_FILE || ccx_options.input_source == CCX_DS_STDIN)
+					i = read (ctx->infd, ctx->filebuffer + keep, FILEBUFFERSIZE-keep);
+#ifndef MMCCXTR
+				else if (ccx_options.input_source == CCX_DS_TCP)
+					i = net_tcp_read(ctx->infd, (char *) ctx->filebuffer + keep, FILEBUFFERSIZE - keep);
+				else
+					i = net_udp_read(ctx->infd, (char*) ctx->filebuffer + keep, FILEBUFFERSIZE - keep, ccx_options.udpsrc, ccx_options.udpaddr);
+#else
+				else i=-1;
+#endif
+				if (terminate_asap) /* Looks like receiving a signal here will trigger a -1, so check that first */
+					break;
+				if (i == -1)
+					fatal (EXIT_READ_ERROR, "Error reading input stream!\n");
+				if (i == 0)
+				{
+					/* If live stream, don't try to switch - acknowledge eof here as it won't
+					   cause a loop end */
+					if (ccx_options.live_stream || ((struct lib_ccx_ctx *)ctx->parent)->inputsize <= origin_buffer_size || !(ccx_options.binary_concat && switch_to_next_file(ctx->parent, copied)))
+						eof = 1;
+				}
+				ctx->filebuffer_pos = keep;
+				ctx->bytesinbuffer = (int) i + keep;
+				ready = i;
+			}
+			int copy = (int) (ready>=bytes ? bytes:ready);
+			if (copy)
+			{
+				if (buffer != NULL)
+				{
+					memcpy (buffer, ctx->filebuffer + ctx->filebuffer_pos, copy);
+					buffer += copy;
+				}
+				ctx->filebuffer_pos += copy;
+				bytes  -= copy;
+				copied += copy;
+			}
+		}
+	}
+	else // Read without buffering
+	{
+
+		if (buffer != NULL)
+		{
+			int i;
+			while (bytes > 0 && ctx->infd != -1 &&
+					((i = read(ctx->infd, buffer, bytes)) != 0 || ccx_options.live_stream ||
+					 (ccx_options.binary_concat && switch_to_next_file(ctx->parent, copied))))
+			{
+				if (terminate_asap)
+					break;
+				if( i == -1)
+					fatal (EXIT_READ_ERROR, "Error reading input file!\n");
+				else if (i == 0)
+					sleepandchecktimeout (seconds);
+				else
+				{
+					copied += i;
+					bytes  -= i;
+					buffer += i;
+				}
+			}
+			return copied;
+		}
+		while (bytes != 0 && ctx->infd != -1)
+		{
+			LLONG op, np;
+			if (terminate_asap)
+				break;
+			op = LSEEK (ctx->infd, 0, SEEK_CUR); // Get current pos
+			if (op + bytes < 0) // Would mean moving beyond start of file: Not supported
+				return 0;
+
+			np     = LSEEK (ctx->infd, bytes, SEEK_CUR); // Pos after moving
+			if (op == -1 && np == -1) // Possibly a pipe that doesn't like "skipping"
+			{
+				char c;
+				for (size_t i = 0; i<bytes; i++)
+				{
+					if(1!=read(ctx->infd, &c, 1))
+						fatal (EXIT_READ_ERROR, "Error reading input file!\n");
+				}
+				copied = bytes;
+			}
+			else
+				copied = copied + (np - op);
+			bytes  = bytes- (unsigned int) copied;
+			if (copied == 0)
+			{
+				if (ccx_options.live_stream)
+					sleepandchecktimeout (seconds);
+				else
+				{
+					if (ccx_options.binary_concat)
+						switch_to_next_file(ctx->parent, 0);
+					else
+						break;
+				}
+			}
+		}
+	}
+	return copied;
+}
+
+uint16_t buffered_get_be16(struct ccx_demuxer *ctx)
+{
+	unsigned char a,b;
+	unsigned char *a_p = &a; // Just to suppress warnings
+	unsigned char *b_p = &b;
+	buffered_read_byte(ctx, a_p);
+	ctx->past++;
+	buffered_read_byte(ctx, b_p);
+	ctx->past++;
+	return ( (unsigned short) (a<<8) )| ( (unsigned short) b);
+}
+
+unsigned char buffered_get_byte (struct ccx_demuxer *ctx)
+{
+	unsigned char b;
+	unsigned char *b_p = &b;
+	size_t result;
+
+	result = buffered_read_byte(ctx, b_p);
+	if (result == 1)
+	{
+		ctx->past++;
+		return b;
+	}
+	else
+		return 0;
+}
+
+uint32_t buffered_get_be32(struct ccx_demuxer *ctx)
+{
+	unsigned int val;
+	val = buffered_get_be16(ctx) << 16;
+	val |= buffered_get_be16(ctx);
+	return val;
+}
+
+unsigned short buffered_get_le16(struct ccx_demuxer *ctx)
+{
+	unsigned char a,b;
+	unsigned char *a_p = &a; // Just to suppress warnings
+	unsigned char *b_p = &b;
+	buffered_read_byte(ctx, a_p);
+	ctx->past++;
+	buffered_read_byte(ctx, b_p);
+	ctx->past++;
+	return ( (unsigned short) (b<<8) )| ( (unsigned short) a);
+}
+
+unsigned int buffered_get_le32(struct ccx_demuxer *ctx)
+{
+	unsigned int val;
+	val = buffered_get_le16(ctx);
+	val |= buffered_get_le16(ctx) << 16;
+	return val;
+}
+
+uint64_t buffered_get_be64(struct ccx_demuxer *ctx)
+{
+	uint64_t val;
+	val = (uint64_t)buffered_get_be32(ctx) << 32;
+	val |= buffered_get_be32(ctx);
+	return val;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/general_loop.c Added

@@ -0,0 +1,1346 @@
+#include "lib_ccx.h"
+#include "ccx_common_option.h"
+#ifdef _WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+#ifndef MMCCXTR
+#include "dvb_subtitle_decoder.h"
+#include "ccx_encoders_common.h"
+#endif
+#include "activity.h"
+#include "utility.h"
+#include "ccx_demuxer.h"
+#include "file_buffer.h"
+#ifndef MMCCXTR
+#include "ccx_decoders_isdb.h"
+#include "ffmpeg_intgr.h"
+#include "ccx_gxf.h"
+#include "dvd_subtitle_decoder.h"
+#include "ccx_demuxer_mxf.h"
+#endif
+
+int end_of_file=0; // End of file?
+
+
+const static unsigned char DO_NOTHING[] = {0x80, 0x80};
+
+#ifndef MMCCXTR
+
+// Program stream specific data grabber
+int ps_get_more_data(struct lib_ccx_ctx *ctx, struct demuxer_data ** ppdata)
+{
+	int enough = 0;
+	int payload_read = 0;
+	size_t result;
+
+	static unsigned vpesnum=0;
+
+	unsigned char nextheader[512]; // Next header in PS
+	int falsepack=0;
+	struct demuxer_data *data;
+
+	if(!*ppdata)
+	{
+		*ppdata = alloc_demuxer_data();
+		if(!*ppdata)
+			return -1;
+		data = *ppdata;
+		//TODO Set to dummy, find and set actual value
+		data->program_number = 1;
+		data->stream_pid = 1;
+		data->codec  = CCX_CODEC_ATSC_CC;
+	}
+	else
+	{
+		data = *ppdata;
+	}
+
+	// Read and return the next video PES payload
+	do
+	{
+		if (BUFSIZE-data->len<500)
+		{
+			mprint("Less than 500 left\n");
+			enough=1; // Stop when less than 500 bytes are left in buffer
+		}
+		else
+		{
+			result = buffered_read(ctx->demux_ctx, nextheader, 6);
+			ctx->demux_ctx->past += result;
+			if (result != 6)
+			{
+				// Consider this the end of the show.
+				end_of_file=1;
+				break;
+			}
+
+			// Search for a header that is not a picture header (nextheader[3]!=0x00)
+			while ( !(nextheader[0]==0x00 && nextheader[1]==0x00
+						&& nextheader[2]==0x01 && nextheader[3]!=0x00) )
+			{
+				if( !ctx->demux_ctx->strangeheader )
+				{
+					mprint ("\nNot a recognized header. Searching for next header.\n");
+					dump (CCX_DMT_GENERIC_NOTICES, nextheader,6,0,0);
+					// Only print the message once per loop / unrecognized header
+					ctx->demux_ctx->strangeheader = 1;
+				}
+
+				unsigned char *newheader;
+				// The amount of bytes read into nextheader by the buffered_read above
+				int hlen = 6;
+				// Find first 0x00
+				// If there is a 00 in the first element we need to advance
+				// one step as clearly bytes 1,2,3 are wrong
+				newheader = (unsigned char *) memchr (nextheader+1, 0, hlen-1);
+				if (newheader != NULL )
+				{
+					int atpos = newheader-nextheader;
+
+					memmove (nextheader,newheader,(size_t)(hlen-atpos));
+					result = buffered_read(ctx->demux_ctx, nextheader+(hlen-atpos),atpos);
+					ctx->demux_ctx->past += result;
+					if (result != atpos)
+					{
+						end_of_file=1;
+						break;
+					}
+				}
+				else
+				{
+					result = buffered_read(ctx->demux_ctx, nextheader, hlen);
+					ctx->demux_ctx->past+=result;
+					if (result!=hlen)
+					{
+						end_of_file=1;
+						break;
+					}
+				}
+			}
+			if (end_of_file)
+			{
+				// No more headers
+				break;
+			}
+			// Found 00-00-01 in nextheader, assume a regular header
+			ctx->demux_ctx->strangeheader = 0;
+
+			// PACK header
+			if ( nextheader[3]==0xBA)
+			{
+				dbg_print(CCX_DMT_VERBOSE, "PACK header\n");
+				result = buffered_read(ctx->demux_ctx, nextheader+6,8);
+				ctx->demux_ctx->past+=result;
+				if (result!=8)
+				{
+					// Consider this the end of the show.
+					end_of_file=1;
+					break;
+				}
+
+				if ( (nextheader[4]&0xC4)!=0x44 || !(nextheader[6]&0x04)
+						|| !(nextheader[8]&0x04) || !(nextheader[9]&0x01)
+						|| (nextheader[12]&0x03)!=0x03 )
+				{
+					// broken pack header
+					falsepack=1;
+				}
+				// We don't need SCR/SCR_ext
+				int stufflen=nextheader[13]&0x07;
+
+				if (falsepack)
+				{
+					mprint ("Warning: Defective Pack header\n");
+				}
+
+				// If not defect, load stuffing
+				buffered_skip (ctx->demux_ctx, (int) stufflen);
+				ctx->demux_ctx->past+=stufflen;
+				// fake a result value as something was skipped
+				result=1;
+				continue;
+			}
+			//PES Header
+			//Private Stream 1 (non MPEG audio , subpictures)
+			else if (nextheader[3] == 0xBD)
+			{
+				uint16_t packetlength = (nextheader[4] << 8) | nextheader[5];
+				int ret, datalen;
+				//TODO: read PES Header extension , skipped for now
+				// read_video_pes_header() might do
+				buffered_skip (ctx->demux_ctx, 2);
+				ctx->demux_ctx->past += 2;
+				ret = buffered_read(ctx->demux_ctx, nextheader+6, 1); // PES header data length (extension)
+				ctx->demux_ctx->past += 1;
+				if(ret != 1)
+				{
+					end_of_file = 1;
+					break;
+				}
+				buffered_skip(ctx->demux_ctx, (int)nextheader[6]);
+				ctx->demux_ctx->past += (int)nextheader[6];
+
+				//Substream ID
+				ret = buffered_read(ctx->demux_ctx, nextheader+7, 1);
+				ctx->demux_ctx->past += 1;
+				if(ret != 1)
+				{
+					end_of_file = 1;
+					break;
+				}
+
+				datalen = packetlength - 4 - nextheader[6];
+				// dbg_print(CCX_DMT_VERBOSE, "datalen :%d packetlen :%" PRIu16 " pes header ext :%d\n", datalen, packetlength, nextheader[6]);
+
+				//Subtitle substream ID 0x20 - 0x39 (32 possible)
+				if( nextheader[7] >= 0x20 && nextheader[7] < 0x40)
+				{
+					dbg_print(CCX_DMT_VERBOSE, "Subtitle found Stream id:%02x\n", nextheader[7]);
+					result = buffered_read(ctx->demux_ctx, data->buffer, datalen);
+					ctx->demux_ctx->past += datalen;
+					if(result != datalen)
+					{
+						end_of_file = 1;
+						break;
+					}
+					if (result>0)
+					{
+						payload_read+=(int) result;
+					}
+					//FIXME: Temporary bypass
+					data->bufferdatatype = CCX_DVD_SUBTITLE;
+
+					data->len = result;
+					enough = 1;
+
+					continue;
+				}
+				else
+				{
+					data->bufferdatatype = CCX_PES;
+					//Non Subtitle packet
+					buffered_skip(ctx->demux_ctx, datalen);
+					ctx->demux_ctx->past += datalen;
+					// fake a result value as something was skipped
+					result=1;
+
+					continue;
+				}
+
+			}
+			// Some PES stream
+			else if (nextheader[3]>=0xBB && nextheader[3]<=0xDF)
+			{
+				// System header
+				// nextheader[3]==0xBB
+				// 0xBD Private 1
+				// 0xBE PAdding
+				// 0xBF Private 2
+				// 0xC0-0DF audio
+
+				unsigned headerlen=nextheader[4]<<8 | nextheader[5];
+
+				dbg_print(CCX_DMT_VERBOSE, "non Video PES (type 0x%2X) - len %u\n",
+						nextheader[3], headerlen);
+
+				// The 15000 here is quite arbitrary, the longest packages I
+				// know of are 12302 bytes (Private 1 data in RTL recording).
+				if ( headerlen > 15000 )
+				{
+					mprint("Suspicious non Video PES (type 0x%2X) - len %u\n",
+							nextheader[3], headerlen);
+					mprint("Do not skip over, search for next.\n");
+					headerlen = 2;
+				}
+				data->bufferdatatype = CCX_PES;
+
+				// Skip over it
+				buffered_skip (ctx->demux_ctx, (int) headerlen);
+				ctx->demux_ctx->past+=headerlen;
+				// fake a result value as something was skipped
+				result=1;
+
+				continue;
+			}
+			// Read the next video PES
+			else if ((nextheader[3]&0xf0)==0xe0)
+			{
+				int hlen; // Dummy variable, unused
+				int ret;
+				size_t peslen;
+				ret = read_video_pes_header(ctx->demux_ctx, data, nextheader, &hlen, 0);
+				if (ret < 0)
+				{
+					end_of_file=1;
+					break;
+				}
+				else
+				{
+					peslen = ret;
+				}
+
+				vpesnum++;
+				dbg_print(CCX_DMT_VERBOSE, "PES video packet #%u\n", vpesnum);
+
+				//peslen is unsigned since loop would have already broken if it was negative
+				int want = (int) ((BUFSIZE-data->len) > peslen ? peslen : (BUFSIZE-data->len));
+
+				if (want != peslen) {
+					mprint("General LOOP: want(%d) != peslen(%d) \n", want, peslen);
+					continue;
+				}
+				if (want == 0) // Found package with header but without payload
+				{
+					continue;
+				}
+
+				data->bufferdatatype = CCX_PES;
+
+				result = buffered_read (ctx->demux_ctx, data->buffer+data->len, want);
+				ctx->demux_ctx->past=ctx->demux_ctx->past+result;
+				if (result>0) {
+					payload_read+=(int) result;
+				}
+				data->len+=result;
+
+				if (result!=want) { // Not complete - EOF
+					end_of_file=1;
+					break;
+				}
+				enough = 1; // We got one PES
+
+			} else {
+				// If we are here this is an unknown header type
+				mprint("Unknown header %02X\n", nextheader[3]);
+				ctx->demux_ctx->strangeheader = 1;
+			}
+		}
+	}
+	while (result!=0 && !enough && BUFSIZE!=data->len);
+
+	dbg_print(CCX_DMT_VERBOSE, "PES data read: %d\n", payload_read);
+	// printf("payload\n");
+
+	if(!payload_read)
+		return CCX_EOF;
+	return payload_read;
+}
+
+
+// Returns number of bytes read, or CCX_OF for EOF
+int general_get_more_data(struct lib_ccx_ctx *ctx, struct demuxer_data **data)
+{
+	int bytesread = 0;
+	int want;
+	int result;
+	struct demuxer_data *ptr;
+	if(!*data)
+	{
+		*data = alloc_demuxer_data();
+		if(!*data)
+			return -1;
+		ptr = *data;
+		//Dummy program numbers
+		ptr->program_number = 1;
+		ptr->stream_pid = 0x100;
+		ptr->codec = CCX_CODEC_ATSC_CC;
+	}
+	ptr = *data;
+
+	do
+	{
+		want = (int) (BUFSIZE - ptr->len);
+		result = buffered_read (ctx->demux_ctx, ptr->buffer + ptr->len, want); // This is a macro.
+		// 'result' HAS the number of bytes read
+		ctx->demux_ctx->past=ctx->demux_ctx->past+result;
+		ptr->len += result;
+		bytesread += (int) result;
+	} while (result!=0 && result!=want);
+
+	if (!bytesread)
+		return CCX_EOF;
+
+	return bytesread;
+}
+#ifdef WTV_DEBUG
+// Hexadecimal dump process
+void process_hex (struct lib_ccx_ctx *ctx, char *filename)
+{
+	size_t max=(size_t) ctx->inputsize+1; // Enough for the whole thing. Hex dumps are small so we can be lazy here
+	char *line=(char *) malloc (max);
+	/* const char *mpeg_header="00 00 01 b2 43 43 01 f8 "; // Always present */
+	FILE *fr = fopen (filename, "rt");
+	unsigned char *bytes=NULL;
+	unsigned byte_count=0;
+	int warning_shown=0;
+	struct demuxer_data *data = alloc_demuxer_data();
+	while(fgets(line, max-1, fr) != NULL)
+	{
+		char *c1, *c2=NULL; // Positions for first and second colons
+		/* int len; */
+		long timing;
+		if (line[0]==';') // Skip comments
+			continue;
+		c1=strchr (line,':');
+		if (c1) c2=strchr (c1+1,':');
+		if (!c2) // Line doesn't contain what we want
+			continue;
+		*c1=0;
+		*c2=0;
+		/* len=atoi (line); */
+		timing=atol (c1+2)*(MPEG_CLOCK_FREQ/1000);
+		current_pts=timing;
+		if (pts_set==0)
+			pts_set=1;
+		set_fts();
+		c2++;
+/*
+		if (strlen (c2)==8)
+		{
+			unsigned char high1=c2[1];
+			unsigned char low1=c2[2];
+			int value1=hex_to_int (high1,low1);
+			unsigned char high2=c2[4];
+			unsigned char low2=c2[5];
+			int value2=hex_to_int (high2,low2);
+			buffer[0]=value1;
+			buffer[1]=value2;
+			data->windedx =2;
+			process_raw();
+			continue;
+		}
+		if (strlen (c2)<=(strlen (mpeg_header)+1))
+			continue; */
+		c2++; // Skip blank
+		/*
+		if (strncmp (c2,mpeg_header,strlen (mpeg_header))) // No idea how to deal with this.
+		{
+			if (!warning_shown)
+			{
+				warning_shown=1;
+				mprint ("\nWarning: This file contains data I can't process: Please submit .hex for analysis!\n");
+			}
+			continue;
+		}
+		// OK, seems like a decent chunk of CCdata.
+		c2+=strlen (mpeg_header);
+		*/
+		byte_count=strlen (c2)/3;
+		/*
+		if (atoi (line)!=byte_count+strlen (mpeg_header)/3) // Number of bytes reported don't match actual contents
+			continue;
+			*/
+		if (atoi (line)!=byte_count) // Number of bytes reported don't match actual contents
+			continue;
+		if (!byte_count) // Nothing to get from this line except timing info, already done.
+			continue;
+		bytes=(unsigned char *) malloc (byte_count);
+		if (!bytes)
+			fatal (EXIT_NOT_ENOUGH_MEMORY, "In process_hex: Out of memory to store processed hex value.\n");
+		unsigned char *bytes=(unsigned char *) malloc (byte_count);
+		for (unsigned i=0;i<byte_count;i++)
+		{
+			unsigned char high=c2[0];
+			unsigned char low=c2[1];
+			int value=hex_to_int (high,low);
+			if (value==-1)
+				fatal (EXIT_FAILURE, "In process_hex: Incorrect format, unexpected non-hex string.");
+			bytes[i]=value;
+			c2+=3;
+		}
+		memcpy (data->buffer, bytes, byte_count);
+		data->len = byte_count;
+		process_raw();
+		continue;
+		// New wtv format, everything else hopefully obsolete
+
+		int ok=0; // Were we able to process the line?
+		// Attempt to detect how the data is encoded.
+		// Case 1 (seen in all elderman's samples):
+		// 18 : 467 : 00 00 01 b2 43 43 01 f8 03 42 ff fd 54 80 fc 94 2c ff
+		// Always 03 after header, then something unknown (seen 42, 43, c2, c3...),
+		// then ff, then data with field info, and terminated with ff.
+		if (byte_count>3 && bytes[0]==0x03 &&
+			bytes[2]==0xff && bytes[byte_count-1]==0xff)
+		{
+			ok=1;
+			for (unsigned i=3; i<byte_count-2; i+=3)
+			{
+				data->len = 3;
+				ctx->buffer[0]=bytes[i];
+				ctx->buffer[1]=bytes[i+1];
+				ctx->buffer[2]=bytes[i+2];
+				process_raw_with_field();
+			}
+		}
+		// Case 2 (seen in P2Pfiend samples):
+		// Seems to match McPoodle's descriptions on DVD encoding
+		else
+		{
+			unsigned char magic=bytes[0];
+			/* unsigned extra_field_flag=magic&1; */
+			unsigned caption_count=((magic>>1)&0x1F);
+			unsigned filler=((magic>>6)&1);
+			/* unsigned pattern=((magic>>7)&1); */
+			int always_ff=1;
+			int current_field = 0;
+			if (filler==0 && caption_count*6==byte_count-1) // Note that we are ignoring the extra field for now...
+			{
+				ok=1;
+				for (unsigned i=1; i<byte_count-2; i+=3)
+					if (bytes[i]!=0xff)
+					{
+						// If we only find FF in the first byte then either there's only field 1 data, OR
+						// there's alternating field 1 and field 2 data. Don't know how to tell apart. For now
+						// let's assume that always FF means alternating.
+						always_ff=0;
+						break;
+					}
+
+				for (unsigned i=1; i<byte_count-2; i+=3)
+				{
+					inbuf=3;
+					if (always_ff) // Try to tell apart the fields based on the pattern field.
+					{
+						ctx->buffer[0] = current_field | 4; // | 4 to enable the 'valid' bit
+						current_field  = !current_field;
+					}
+					else
+						ctx->buffer[0]=bytes[i];
+
+					ctx->buffer[1]=bytes[i+1];
+					ctx->buffer[2]=bytes[i+2];
+					process_raw_with_field();
+				}
+			}
+		}
+		if (!ok && !warning_shown)
+		{
+			warning_shown=1;
+			mprint ("\nWarning: This file contains data I can't process: Please submit .hex for analysis!\n");
+		}
+		free (bytes);
+	}
+	fclose(fr);
+}
+#endif
+// Raw file process
+int raw_loop (struct lib_ccx_ctx *ctx)
+{
+	LLONG ret;
+	struct demuxer_data *data = NULL;
+	struct cc_subtitle *dec_sub = NULL;
+	struct encoder_ctx *enc_ctx = update_encoder_list(ctx);
+	struct lib_cc_decode *dec_ctx = NULL;
+	int caps = 0;
+
+	dec_ctx = update_decoder_list(ctx);
+	dec_sub = &dec_ctx->dec_sub;
+
+	set_current_pts(dec_ctx->timing, 90);
+	set_fts(dec_ctx->timing); // Now set the FTS related variables
+
+	do
+	{
+		if (terminate_asap)
+			break;
+
+		ret = general_get_more_data(ctx, &data);
+		if(ret == CCX_EOF)
+			break;
+
+		ret = process_raw(dec_ctx, dec_sub, data->buffer, data->len);
+		if (dec_sub->got_output)
+		{
+			caps = 1;
+			encode_sub(enc_ctx, dec_sub);
+			dec_sub->got_output = 0;
+		}
+
+		//int ccblocks = cb_field1;
+		add_current_pts(dec_ctx->timing, cb_field1*1001/30*(MPEG_CLOCK_FREQ/1000));
+		set_fts(dec_ctx->timing); // Now set the FTS related variables including fts_max
+
+
+	} while (data->len);
+	free(data);
+	return caps;
+}
+
+/* Process inbuf bytes in buffer holding raw caption data (three byte packets, the first being the field).
+ * The number of processed bytes is returned. */
+size_t process_raw_with_field(struct lib_cc_decode *dec_ctx, struct cc_subtitle *sub, unsigned char* buffer, size_t len)
+{
+	unsigned char data[3];
+	size_t i;
+	data[0]=0x04; // Field 1
+	dec_ctx->current_field = 1;
+
+	for (i = 0; i < len; i=i+3)
+	{
+		if ( !dec_ctx->saw_caption_block && *(buffer+i)==0xff && *(buffer+i+1)==0xff)
+		{
+			// Skip broadcast header
+		}
+		else
+		{
+			data[0] = buffer[i];
+			data[1] = buffer[i+1];
+			data[2] = buffer[i+2];
+
+			// do_cb increases the cb_field1 counter so that get_fts()
+			// is correct.
+			do_cb(dec_ctx, data, sub);
+		}
+	}
+	return len;
+}
+
+/* Process inbuf bytes in buffer holding raw caption data (two byte packets).
+ * The number of processed bytes is returned. */
+size_t process_raw(struct lib_cc_decode *ctx, struct cc_subtitle *sub, unsigned char *buffer, size_t len)
+{
+	unsigned char data[3];
+	size_t i;
+	data[0]=0x04; // Field 1
+
+	for (i = 0; i < len; i = i+2)
+	{
+		if ( !ctx->saw_caption_block && *(buffer+i)==0xff && *(buffer+i+1)==0xff)
+		{
+			// Skip broadcast header
+		}
+		else
+		{
+			data[1] = buffer[i];
+			data[2] = buffer[i+1];
+
+			// do_cb increases the cb_field1 counter so that get_fts()
+			// is correct.
+			do_cb(ctx, data, sub);
+		}
+	}
+	return len;
+}
+
+void delete_datalist(struct demuxer_data *list)
+{
+	struct demuxer_data *slist = list;
+
+	while(list)
+	{
+		slist = list;
+		list = list->next_stream;
+		delete_demuxer_data(slist);
+
+	}
+}
+int process_data(struct encoder_ctx *enc_ctx, struct lib_cc_decode *dec_ctx, struct demuxer_data *data_node)
+{
+	size_t got; // Means 'consumed' from buffer actually
+	int ret = 0;
+	static LLONG last_pts = 0x01FFFFFFFFLL;
+	struct cc_subtitle *dec_sub = &dec_ctx->dec_sub;
+
+	if (dec_ctx->hauppauge_mode)
+	{
+		got = process_raw_with_field(dec_ctx, dec_sub, data_node->buffer, data_node->len);
+		if (dec_ctx->timing->pts_set)
+			set_fts(dec_ctx->timing); // Try to fix timing from TS data
+	}
+	else if(data_node->bufferdatatype == CCX_DVB_SUBTITLE)
+	{
+		ret=dvbsub_decode(enc_ctx, dec_ctx, data_node->buffer + 2, data_node->len - 2, dec_sub);
+		if (ret<0)
+			mprint ("Return from dvbsub_decode: %d\n", ret);
+		set_fts(dec_ctx->timing);
+		got = data_node->len;
+	}
+	else if (data_node->bufferdatatype == CCX_PES)
+	{
+		dec_ctx->in_bufferdatatype = CCX_PES;
+		got = process_m2v (dec_ctx, data_node->buffer, data_node->len, dec_sub);
+	}
+	else if (data_node->bufferdatatype == CCX_DVD_SUBTITLE)
+	{
+		if(dec_ctx-> is_alloc == 0)
+		{
+			dec_ctx->private_data = init_dvdsub_decode();
+			dec_ctx->is_alloc = 1;
+		}
+		process_spu (dec_ctx, data_node->buffer, data_node->len, dec_sub);
+		got = data_node->len;
+	}
+	else if (data_node->bufferdatatype == CCX_TELETEXT)
+	{
+		//telxcc_update_gt(dec_ctx->private_data, ctx->demux_ctx->global_timestamp);
+		if (enc_ctx) {
+			ret = tlt_process_pes_packet(dec_ctx, data_node->buffer, data_node->len, dec_sub, enc_ctx->sentence_cap);
+			if (ret == CCX_EINVAL)
+				return ret;
+		}
+		got = data_node->len;
+	}
+	else if (data_node->bufferdatatype == CCX_PRIVATE_MPEG2_CC)
+	{
+		got = data_node->len; // Do nothing. Still don't know how to process it
+	}
+	else if (data_node->bufferdatatype == CCX_RAW) // Raw two byte 608 data from DVR-MS/ASF
+	{
+		// The asf_get_more_data() loop sets current_pts when possible
+		if (dec_ctx->timing->pts_set == 0)
+		{
+			mprint("DVR-MS/ASF file without useful time stamps - count blocks.\n");
+			// Otherwise rely on counting blocks
+			dec_ctx->timing->current_pts = 12345; // Pick a valid PTS time
+			dec_ctx->timing->pts_set = 1;
+		}
+
+		if (dec_ctx->timing->current_pts != last_pts)
+		{
+			// Only initialize the FTS values and reset the cb
+			// counters when the PTS is different. This happens frequently
+			// with ASF files.
+
+			if (dec_ctx->timing->min_pts==0x01FFFFFFFFLL)
+			{
+				// First call
+				fts_at_gop_start = 0;
+			}
+			else
+				fts_at_gop_start = get_fts(dec_ctx->timing, dec_ctx->current_field);
+
+			frames_since_ref_time = 0;
+			set_fts(dec_ctx->timing);
+
+			last_pts = dec_ctx->timing->current_pts;
+		}
+
+		dbg_print(CCX_DMT_VIDES, "PTS: %s (%8u)",
+				print_mstime_static(dec_ctx->timing->current_pts/(MPEG_CLOCK_FREQ/1000)),
+				(unsigned) (dec_ctx->timing->current_pts));
+		dbg_print(CCX_DMT_VIDES, "  FTS: %s\n", print_mstime_static(get_fts(dec_ctx->timing, dec_ctx->current_field)));
+
+		got = process_raw(dec_ctx, dec_sub, data_node->buffer, data_node->len);
+	}
+	else if (data_node->bufferdatatype == CCX_H264) // H.264 data from TS file
+	{
+		dec_ctx->in_bufferdatatype = CCX_H264;
+		got = process_avc(dec_ctx, data_node->buffer, data_node->len, dec_sub);
+	}
+	else if (data_node->bufferdatatype == CCX_RAW_TYPE)
+	{
+		got = process_raw_with_field(dec_ctx, dec_sub, data_node->buffer, data_node->len);
+	}
+	else if (data_node->bufferdatatype == CCX_ISDB_SUBTITLE)
+	{
+		isdbsub_decode(dec_ctx, data_node->buffer, data_node->len, dec_sub);
+		got = data_node->len;
+	}
+	else
+		fatal(CCX_COMMON_EXIT_BUG_BUG, "In process_data: datanode->buffer is of unknown data type!");
+
+	if (got > data_node->len)
+	{
+		mprint ("BUG BUG\n");
+	}
+
+
+//	ctx->demux_ctx->write_es(ctx->demux_ctx, data_node->buffer, (size_t) (data_node->len - got));
+
+	/* Get rid of the bytes we already processed */
+	if (data_node)
+	{
+		if ( got > 0 )
+		{
+			memmove (data_node->buffer,data_node->buffer+got,(size_t) (data_node->len - got));
+			data_node->len -= got;
+		}
+	}
+
+	if (data_node->bufferdatatype != CCX_DVB_SUBTITLE && dec_sub->got_output)
+	{
+		ret = 1;
+		encode_sub(enc_ctx, dec_sub);
+		dec_sub->got_output = 0;
+	}
+	return ret;
+}
+
+void segment_output_file(struct lib_ccx_ctx *ctx, struct lib_cc_decode *dec_ctx)
+{
+	LLONG cur_sec;
+	LLONG t;
+	struct encoder_ctx *enc_ctx;
+	int segment_now = 0;
+
+
+	t = get_fts(dec_ctx->timing, dec_ctx->current_field);
+	if (!t && ctx->demux_ctx->global_timestamp_inited)
+		t = ctx->demux_ctx->global_timestamp - ctx->demux_ctx->min_global_timestamp;
+
+#if SEGMENT_BY_FILE_TIME
+	cur_sec = t/1000;
+#else
+	cur_sec = time(NULL);
+#endif
+
+	if (ctx->system_start_time == -1)
+		ctx->system_start_time = cur_sec;
+
+	cur_sec = cur_sec - ctx->system_start_time;
+
+	if (ctx->out_interval < 1)
+		return;
+
+	if (cur_sec / ctx->out_interval > ctx->segment_counter)
+	{
+		enc_ctx = get_encoder_by_pn(ctx, dec_ctx->program_number);
+		// segment_now = 1;
+		if (!ctx->segment_on_key_frames_only ||	
+			dec_ctx->picture_coding_type == CCX_FRAME_TYPE_I_FRAME) // Segment only when an I-Frame is found
+		{			
+			segment_now = 1;
+			enc_ctx->segment_pending = 0;
+			enc_ctx->segment_last_key_frame = 0;
+		}
+		else
+		{
+			if (enc_ctx->segment_pending) // We already knew we had to segment but can we do it?
+			{
+				if (dec_ctx->num_key_frames>enc_ctx->segment_last_key_frame)
+				{
+					// Yes, there's been a key frame since we last checked
+					segment_now = 1;
+					enc_ctx->segment_pending = 0;
+					enc_ctx->segment_last_key_frame = 0;
+				}
+			}
+			else
+			{
+				// Make a note of current I frame count,
+				enc_ctx->segment_pending=1;
+				enc_ctx->segment_last_key_frame=dec_ctx->num_key_frames;
+			}
+		}
+	}
+
+	if (segment_now)
+	{		
+		{	
+			ctx->segment_counter++;
+			if (enc_ctx)
+			{
+				//list_del(&enc_ctx->list);
+				//dinit_encoder(&enc_ctx, t);
+				char *extension = get_file_extension(ccx_options.enc_cfg.write_format);
+				sprintf(ccx_options.enc_cfg.output_filename, "%s_%06d%s", ctx->basefilename, ctx->segment_counter + 1, extension);
+				reset_output_ctx(enc_ctx, &ccx_options.enc_cfg);
+			}
+		}
+	}
+}
+
+int general_loop(struct lib_ccx_ctx *ctx)
+{
+	struct lib_cc_decode *dec_ctx = NULL;
+	enum ccx_stream_mode_enum stream_mode;
+	struct demuxer_data *datalist = NULL;
+	struct demuxer_data *data_node = NULL;
+	int (*get_more_data)(struct lib_ccx_ctx *c, struct demuxer_data **d);
+	int ret;
+	int caps = 0;
+
+	uint64_t min_pts = UINT64_MAX;
+
+	stream_mode = ctx->demux_ctx->get_stream_mode(ctx->demux_ctx);
+
+	if(stream_mode == CCX_SM_TRANSPORT && ctx->write_format == CCX_OF_NULL)
+		ctx->multiprogram = 1;
+
+	switch (stream_mode)
+	{
+		case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
+			get_more_data = &general_get_more_data;
+			break;
+		case CCX_SM_TRANSPORT:
+			get_more_data = &ts_get_more_data;
+			break;
+		case CCX_SM_PROGRAM:
+			get_more_data = &ps_get_more_data;
+			break;
+		case CCX_SM_ASF:
+			get_more_data = &asf_get_more_data;
+			break;
+		case CCX_SM_WTV:
+			get_more_data = &wtv_get_more_data;
+			break;
+		case CCX_SM_GXF:
+			get_more_data = &ccx_gxf_get_more_data;
+			break;
+#ifdef ENABLE_FFMPEG
+		case CCX_SM_FFMPEG:
+			get_more_data = &ffmpeg_get_more_data;
+			break;
+#endif
+		case CCX_SM_MXF:
+			get_more_data = ccx_mxf_getmoredata;
+			break;
+		default:
+			fatal(CCX_COMMON_EXIT_BUG_BUG, "In general_loop: Impossible value for stream_mode");
+	}
+
+	end_of_file = 0;
+	while (!terminate_asap && !end_of_file && is_decoder_processed_enough(ctx) == CCX_FALSE)
+	{
+		// GET MORE DATA IN BUFFER
+		position_sanity_check(ctx->demux_ctx);
+		ret = get_more_data(ctx, &datalist);
+		if (ret == CCX_EOF)
+		{
+			end_of_file = 1;
+		}
+		if (!datalist)
+			continue;
+		position_sanity_check(ctx->demux_ctx);
+		if(!ctx->multiprogram)
+		{
+			struct cap_info* cinfo = NULL;
+			struct encoder_ctx *enc_ctx = NULL;
+			// Find most promising stream: teletext, DVB, ISDB, ATSC, in that order
+			int pid = get_best_stream(ctx->demux_ctx);
+			if(pid < 0)
+			{
+				data_node = get_best_data(datalist);
+			}
+			else
+			{
+				ignore_other_stream(ctx->demux_ctx, pid);
+				data_node = get_data_stream(datalist, pid);
+			}
+			if (ccx_options.analyze_video_stream)
+			{
+				int video_pid= get_video_stream(ctx->demux_ctx);
+				if (video_pid != pid && video_pid!=-1)
+				{					
+					struct cap_info* cinfo_video = get_cinfo(ctx->demux_ctx, pid); // Must be pid, not video_pid or DVB crashes (possibly buffer consumption?) - TODO
+					struct lib_cc_decode *dec_ctx_video = update_decoder_list_cinfo(ctx, cinfo_video);
+					struct cc_subtitle *dec_sub_video = &dec_ctx_video->dec_sub;
+					struct demuxer_data *data_node_video = get_data_stream(datalist, video_pid);					
+					if (data_node_video)
+					{
+						if (data_node_video->pts != CCX_NOPTS)
+						{
+							struct ccx_rational tb = { 1,MPEG_CLOCK_FREQ };
+							LLONG pts;
+							if (data_node_video->tb.num != 1 || data_node_video->tb.den != MPEG_CLOCK_FREQ)
+							{
+								pts = change_timebase(data_node_video->pts, data_node_video->tb, tb);
+							}
+							else
+								pts = data_node_video->pts;
+							set_current_pts(dec_ctx_video->timing, pts);
+							set_fts(dec_ctx_video->timing);
+						}
+						size_t got = process_m2v(dec_ctx_video, data_node_video->buffer, data_node_video->len, dec_sub_video);
+						if (got > 0)
+						{
+							memmove(data_node_video->buffer, data_node_video->buffer + got, (size_t)(data_node_video->len - got));
+							data_node_video->len -= got;
+						}
+					}
+				}
+			}
+
+			cinfo = get_cinfo(ctx->demux_ctx, pid);
+			enc_ctx = update_encoder_list_cinfo(ctx, cinfo);
+			dec_ctx = update_decoder_list_cinfo(ctx, cinfo);
+			dec_ctx->dtvcc->encoder = (void *)enc_ctx; //WARN: otherwise cea-708 will not work
+
+			if (dec_ctx->timing->min_pts == 0x01FFFFFFFFLL) //if we didn't set the min_pts of the program
+			{
+				int p_index = 0; //program index
+				for (int i = 0; i < ctx->demux_ctx->nb_program; i++)
+				{
+					if (dec_ctx->program_number == ctx->demux_ctx->pinfo[i].program_number)
+					{
+						p_index = i;
+						break;
+					}
+				}
+
+				if (dec_ctx->codec == CCX_CODEC_TELETEXT) //even if there's no sub data, we still need to set the min_pts
+				{
+					if (ctx->demux_ctx->pinfo[p_index].got_important_streams_min_pts[PRIVATE_STREAM_1] != UINT64_MAX) //Teletext is synced with subtitle packet PTS
+					{
+						min_pts = ctx->demux_ctx->pinfo[p_index].got_important_streams_min_pts[PRIVATE_STREAM_1];
+						set_current_pts(dec_ctx->timing, min_pts);
+						set_fts(dec_ctx->timing);
+					}
+				}
+				if (dec_ctx->codec == CCX_CODEC_DVB) //DVB will always have to be in sync with audio (no matter the min_pts of the other streams)
+				{
+					if (ctx->demux_ctx->pinfo[p_index].got_important_streams_min_pts[AUDIO] != UINT64_MAX) //it means we got the first pts for audio
+					{
+						min_pts = ctx->demux_ctx->pinfo[p_index].got_important_streams_min_pts[AUDIO];
+						set_current_pts(dec_ctx->timing, min_pts);
+						set_fts(dec_ctx->timing);
+					}
+				}
+			}
+
+			if (enc_ctx)
+				enc_ctx->timing = dec_ctx->timing;
+
+			if (!data_node) //no sub data, no need to process non-existing data
+				continue;
+
+			if(data_node->pts != CCX_NOPTS)
+			{
+				struct ccx_rational tb = {1,MPEG_CLOCK_FREQ};
+				LLONG pts;
+				if(data_node->tb.num != 1 || data_node->tb.den != MPEG_CLOCK_FREQ)
+				{
+					pts = change_timebase(data_node->pts, data_node->tb, tb);
+				}
+				else
+					pts = data_node->pts;
+				set_current_pts(dec_ctx->timing, pts); 
+				set_fts(dec_ctx->timing);
+			}
+
+			if( data_node->bufferdatatype == CCX_ISDB_SUBTITLE)
+			{
+				uint64_t tstamp;
+				if(ctx->demux_ctx->global_timestamp_inited)
+				{
+					tstamp = ( ctx->demux_ctx->global_timestamp + ctx->demux_ctx->offset_global_timestamp )
+								- ctx->demux_ctx->min_global_timestamp;
+				}
+				else
+				{
+					// Fix if global timestamp not inited
+					tstamp = get_fts(dec_ctx->timing, dec_ctx->current_field);
+				}
+				isdb_set_global_time(dec_ctx, tstamp);
+			}
+			if (data_node->bufferdatatype == CCX_TELETEXT && dec_ctx->private_data) //if we have teletext subs, we set the min_pts here
+				set_tlt_delta(dec_ctx, min_pts);
+			ret = process_data(enc_ctx, dec_ctx, data_node);
+			if (enc_ctx != NULL) {
+			        if (enc_ctx->srt_counter || enc_ctx->cea_708_counter || dec_ctx->saw_caption_block || ret == 1)
+				        caps = 1;
+			}
+
+			// Process the last subtitle for DVB
+			if (!(!terminate_asap && !end_of_file && is_decoder_processed_enough(ctx) == CCX_FALSE)) {
+				if (data_node->bufferdatatype == CCX_DVB_SUBTITLE && dec_ctx->dec_sub.prev->end_time == 0) {
+					dec_ctx->dec_sub.prev->end_time = (dec_ctx->timing->current_pts - dec_ctx->timing->min_pts) / (MPEG_CLOCK_FREQ / 1000);
+					if (enc_ctx != NULL)
+					        encode_sub(enc_ctx->prev, dec_ctx->dec_sub.prev);
+					dec_ctx->dec_sub.prev->got_output = 0;
+				}
+			}
+			if( ret == CCX_EINVAL)
+				break;
+		}
+		else
+		{
+			struct cap_info* cinfo = NULL;
+			struct cap_info* program_iter;
+			struct cap_info *ptr = &ctx->demux_ctx->cinfo_tree;
+			struct encoder_ctx *enc_ctx = NULL;
+			list_for_each_entry(program_iter, &ptr->pg_stream, pg_stream, struct cap_info)
+			{
+				cinfo = get_best_sib_stream(program_iter);
+				if(!cinfo)
+				{
+					data_node = get_best_data(datalist);
+				}
+				else
+				{
+					ignore_other_sib_stream(program_iter, cinfo->pid);
+					data_node = get_data_stream(datalist, cinfo->pid);
+				}
+
+				enc_ctx = update_encoder_list_cinfo(ctx, cinfo);
+				dec_ctx = update_decoder_list_cinfo(ctx, cinfo);
+				dec_ctx->dtvcc->encoder = (void *)enc_ctx; //WARN: otherwise cea-708 will not work
+				
+				if (dec_ctx->timing->min_pts == 0x01FFFFFFFFLL) //if we didn't set the min_pts of the program
+				{
+					int p_index = 0; //program index
+					for (int i = 0; i < ctx->demux_ctx->nb_program; i++)
+					{
+						if (dec_ctx->program_number == ctx->demux_ctx->pinfo[i].program_number)
+						{
+							p_index = i;
+							break;
+						}
+					}
+
+					if (dec_ctx->codec == CCX_CODEC_TELETEXT) //even if there's no sub data, we still need to set the min_pts
+					{
+						if (ctx->demux_ctx->pinfo[p_index].got_important_streams_min_pts[PRIVATE_STREAM_1] != UINT64_MAX) //Teletext is synced with subtitle packet PTS
+						{
+							min_pts = ctx->demux_ctx->pinfo[p_index].got_important_streams_min_pts[PRIVATE_STREAM_1]; //it means we got the first pts for private stream 1
+							set_current_pts(dec_ctx->timing, min_pts);
+							set_fts(dec_ctx->timing);
+						}
+					}
+					if (dec_ctx->codec == CCX_CODEC_DVB) //DVB will always have to be in sync with audio (no matter the min_pts of the other streams)
+					{
+						if (ctx->demux_ctx->pinfo[p_index].got_important_streams_min_pts[AUDIO] != UINT64_MAX) //it means we got the first pts for audio
+						{
+							min_pts = ctx->demux_ctx->pinfo[p_index].got_important_streams_min_pts[AUDIO];
+							set_current_pts(dec_ctx->timing, min_pts);
+							set_fts(dec_ctx->timing);
+						}
+					}
+				}
+
+				if (enc_ctx)
+					enc_ctx->timing = dec_ctx->timing;
+
+				if (!data_node)
+					continue;
+				
+				if(data_node->pts != CCX_NOPTS)
+					set_current_pts(dec_ctx->timing, data_node->pts);
+
+				ret = process_data(enc_ctx, dec_ctx, data_node);
+				if (enc_ctx != NULL){
+				     if (
+					(enc_ctx && (enc_ctx->srt_counter || enc_ctx->cea_708_counter) ||
+						dec_ctx->saw_caption_block || ret == 1)
+					)
+					caps = 1;
+				}
+				// Process the last subtitle for DVB
+				if (!(!terminate_asap && !end_of_file && is_decoder_processed_enough(ctx) == CCX_FALSE)) {
+					if (data_node->bufferdatatype == CCX_DVB_SUBTITLE && dec_ctx && dec_ctx->dec_sub.prev && dec_ctx->dec_sub.prev->end_time == 0) {
+						dec_ctx->dec_sub.prev->end_time = (dec_ctx->timing->current_pts - dec_ctx->timing->min_pts) / (MPEG_CLOCK_FREQ / 1000);
+						if (enc_ctx != NULL)
+						    encode_sub(enc_ctx->prev, dec_ctx->dec_sub.prev);
+						dec_ctx->dec_sub.prev->got_output = 0;
+					}
+				}
+			}
+			if (!data_node)
+				continue;
+		}
+		if (ctx->live_stream)
+		{
+			int cur_sec = (int) (get_fts(dec_ctx->timing, dec_ctx->current_field) / 1000);
+			int th=cur_sec/10;
+			if (ctx->last_reported_progress!=th)
+			{
+				activity_progress (-1,cur_sec/60, cur_sec%60);
+				ctx->last_reported_progress = th;
+			}
+		}
+		else
+		{
+			if (ctx->total_inputsize>255) // Less than 255 leads to division by zero below.
+			{
+				int progress = (int) ((((ctx->total_past+ctx->demux_ctx->past)>>8)*100)/(ctx->total_inputsize>>8));
+				if (ctx->last_reported_progress != progress)
+				{
+					LLONG t=get_fts(dec_ctx->timing, dec_ctx->current_field);
+					if (!t && ctx->demux_ctx->global_timestamp_inited)
+						t=ctx->demux_ctx->global_timestamp - ctx->demux_ctx->min_global_timestamp;
+					int cur_sec = (int) (t / 1000);
+					activity_progress(progress, cur_sec/60, cur_sec%60);
+					ctx->last_reported_progress = progress;
+				}
+			}
+		}
+		
+		//void segment_output_file(struct lib_ccx_ctx *ctx, struct lib_cc_decode *dec_ctx);
+		segment_output_file(ctx, dec_ctx);
+
+		if (ccx_options.send_to_srv)
+			net_check_conn();
+	}
+
+	list_for_each_entry(dec_ctx, &ctx->dec_ctx_head, list, struct lib_cc_decode)
+	{
+
+		if (dec_ctx->codec == CCX_CODEC_TELETEXT)
+			telxcc_close(&dec_ctx->private_data, &dec_ctx->dec_sub);
+		// Flush remaining HD captions
+		if (dec_ctx->has_ccdata_buffered)
+					process_hdcc(dec_ctx, &dec_ctx->dec_sub);
+
+		mprint ("\nNumber of NAL_type_7: %ld\n",dec_ctx->avc_ctx->num_nal_unit_type_7);
+		mprint ("Number of VCL_HRD: %ld\n",dec_ctx->avc_ctx->num_vcl_hrd);
+		mprint ("Number of NAL HRD: %ld\n",dec_ctx->avc_ctx->num_nal_hrd);
+		mprint ("Number of jump-in-frames: %ld\n",dec_ctx->avc_ctx->num_jump_in_frames);
+		mprint ("Number of num_unexpected_sei_length: %ld", dec_ctx->avc_ctx->num_unexpected_sei_length);
+		free(dec_ctx->xds_ctx);
+	}
+
+	delete_datalist(datalist);
+	if (ctx->total_past!=ctx->total_inputsize && ctx->binary_concat && is_decoder_processed_enough(ctx))
+	{
+		mprint("\n\n\n\nATTENTION!!!!!!\n");
+		mprint("Processing of %s %d ended prematurely %lld < %lld, please send bug report.\n\n",
+				ctx->inputfile[ctx->current_file], ctx->current_file, ctx->demux_ctx->past, ctx->inputsize);
+	}
+	return caps;
+}
+
+#endif
+
+// Raw caption with FTS file process
+int rcwt_loop(struct lib_ccx_ctx *ctx)
+{
+	unsigned char *parsebuf;
+	long parsebufsize = 1024;
+	unsigned char buf[TELETEXT_CHUNK_LEN] = "";
+	struct lib_cc_decode *dec_ctx = NULL;
+	struct cc_subtitle *dec_sub = NULL;
+	LLONG currfts;
+	uint16_t cbcount = 0;
+	int bread = 0; // Bytes read
+	int caps = 0;
+	LLONG result;
+	struct encoder_ctx *enc_ctx = update_encoder_list(ctx);
+#ifndef MMCCXTR
+	struct TeletextCtx *telctx;
+#endif
+	// As BUFSIZE is a macro this is just a reminder
+	if (BUFSIZE < (3*0xFFFF + 10))
+		fatal (CCX_COMMON_EXIT_BUG_BUG, "In rcwt_loop: BUFSIZE too small for RCWT caption block.\n");
+
+	// Generic buffer to hold some data
+	parsebuf = (unsigned char*)malloc(1024);
+
+
+	result = buffered_read(ctx->demux_ctx, parsebuf, 11);
+	ctx->demux_ctx->past += result;
+	bread += (int) result;
+	if (result != 11)
+	{
+		mprint("Premature end of file!\n");
+		end_of_file = 1;
+		return -1;
+	}
+
+	// Expecting RCWT header
+	if( !memcmp(parsebuf, "\xCC\xCC\xED", 3 ) )
+	{
+		dbg_print(CCX_DMT_PARSE, "\nRCWT header\n");
+		dbg_print(CCX_DMT_PARSE, "File created by %02X version %02X%02X\nFile format revision: %02X%02X\n",
+				parsebuf[3], parsebuf[4], parsebuf[5],
+				parsebuf[6], parsebuf[7]);
+
+	}
+	else
+	{
+		fatal(EXIT_MISSING_RCWT_HEADER, "In rcwt_loop: Missing RCWT header. Abort.\n");
+	}
+
+	dec_ctx = update_decoder_list(ctx);
+#ifndef MMCCXTR
+	dec_ctx->dtvcc->encoder = (void *)enc_ctx; //WARN: otherwise cea-708 will not work
+	if (parsebuf[6] == 0 && parsebuf[7] == 2)
+	{
+		dec_ctx->codec = CCX_CODEC_TELETEXT;
+		dec_ctx->private_data = telxcc_init();
+	}
+#endif
+	dec_sub = &dec_ctx->dec_sub;
+#ifndef MMCCXTR
+	telctx =dec_ctx->private_data;
+#endif
+
+	/* Set minimum and current pts since rcwt has correct time */
+	dec_ctx->timing->min_pts = 0;
+	dec_ctx->timing->current_pts = 0;
+
+	// Loop until no more data is found
+	while(1)
+	{
+#ifndef MMCCXTR
+		if (parsebuf[6] == 0 && parsebuf[7] == 2)
+		{
+			result = buffered_read(ctx->demux_ctx, buf, TELETEXT_CHUNK_LEN);
+			ctx->demux_ctx->past += result;
+			if (result != TELETEXT_CHUNK_LEN){
+			  telxcc_dump_prev_page(telctx,dec_sub);
+				break;
+			}
+			tlt_read_rcwt(dec_ctx->private_data, buf, dec_sub);
+			if(dec_sub->got_output == CCX_TRUE)
+			{
+				encode_sub(enc_ctx, dec_sub);
+				dec_sub->got_output = 0;
+				caps=1;
+			}
+			continue;
+		}
+#endif
+
+		// Read the data header
+		result = buffered_read(ctx->demux_ctx, parsebuf, 10);
+		ctx->demux_ctx->past+=result;
+		bread+=(int) result;
+
+		if (result!=10)
+		{
+			if (result!=0)
+				mprint("Premature end of file!\n");
+
+			// We are done
+			end_of_file=1;
+			break;
+		}
+		currfts = *((LLONG*)(parsebuf));
+		cbcount = *((uint16_t*)(parsebuf+8));
+
+		dbg_print(CCX_DMT_PARSE, "RCWT data header FTS: %s  blocks: %u\n",
+				print_mstime_static(currfts), cbcount);
+
+		if ( cbcount > 0 )
+		{
+			if ( cbcount*3 > parsebufsize) {
+				parsebuf = (unsigned char*)realloc(parsebuf, cbcount*3);
+				if (!parsebuf)
+					fatal(EXIT_NOT_ENOUGH_MEMORY, "In rcwt_loop: Out of memory allocating parsebuf.");
+				parsebufsize = cbcount*3;
+			}
+			result = buffered_read(ctx->demux_ctx, parsebuf, cbcount*3);
+			ctx->demux_ctx->past+=result;
+			bread+=(int) result;
+			if (result!=cbcount*3)
+			{
+				mprint("Premature end of file!\n");
+				end_of_file=1;
+				break;
+			}
+
+			// Process the data
+			set_current_pts(dec_ctx->timing, currfts*(MPEG_CLOCK_FREQ/1000));
+			set_fts(dec_ctx->timing); // Now set the FTS related variables
+
+			for (int j=0; j<cbcount*3; j=j+3)
+			{
+				do_cb(dec_ctx, parsebuf+j, dec_sub);
+			}
+		}
+		if (dec_sub->got_output)
+		{
+			caps = 1;
+			encode_sub(enc_ctx, dec_sub);
+			dec_sub->got_output = 0;
+		}
+	} // end while(1)
+
+	dbg_print(CCX_DMT_PARSE, "Processed %d bytes\n", bread);
+	free(parsebuf);
+	return caps;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/lib_ccx.c Added

@@ -0,0 +1,450 @@
+#include "lib_ccx.h"
+#include "ccx_common_option.h"
+#include "activity.h"
+#include "utility.h"
+#ifndef MMCCXTR
+#include "dvb_subtitle_decoder.h"
+#include "ccx_decoders_708.h"
+#include "ccx_decoders_isdb.h"
+#endif
+
+struct ccx_common_logging_t ccx_common_logging;
+static struct ccx_decoders_common_settings_t *init_decoder_setting(
+		struct ccx_s_options *opt)
+{
+	struct ccx_decoders_common_settings_t *setting;
+
+	setting = malloc(sizeof(struct ccx_decoders_common_settings_t));
+	if(!setting)
+		return NULL;
+
+	setting->subs_delay = opt->subs_delay;
+	setting->output_format = opt->write_format;
+	setting->fix_padding = opt->fix_padding;
+	setting->extract = opt->extract;
+	setting->fullbin = opt->fullbin;
+	setting->no_rollup = opt->no_rollup;
+	setting->noscte20 = opt->noscte20;
+	memcpy(&setting->extraction_start,&opt->extraction_start,sizeof(struct ccx_boundary_time));
+	memcpy(&setting->extraction_end,&opt->extraction_end,sizeof(struct ccx_boundary_time));
+	setting->cc_to_stdout = opt->cc_to_stdout;
+	setting->settings_608 = &opt->settings_608;
+	setting->settings_dtvcc = &opt->settings_dtvcc;
+	setting->cc_channel = opt->cc_channel;
+	setting->send_to_srv = opt->send_to_srv;
+	setting->hauppauge_mode = opt->hauppauge_mode;
+	setting->xds_write_to_file = opt->transcript_settings.xds;
+	setting->ocr_quantmode = opt->ocr_quantmode;
+	
+	return setting;
+}
+static void dinit_decoder_setting (struct ccx_decoders_common_settings_t **setting)
+{
+	freep(setting);
+}
+
+
+static int init_ctx_outbase(struct ccx_s_options *opt, struct lib_ccx_ctx *ctx)
+{
+	char *file;
+
+	if (opt->output_filename)
+	{
+		ctx->basefilename = get_basename(opt->output_filename);
+	}
+	else
+	{
+		switch (opt->input_source)
+		{
+			case CCX_DS_FILE:
+				if(!ctx->inputfile || !ctx->inputfile[0])
+				{
+					errno = EINVAL;
+					return -1;
+				}
+				file = ctx->inputfile[0];
+				break;
+			case CCX_DS_STDIN:
+				file = "stdin";
+				break;
+			case CCX_DS_NETWORK:
+			case CCX_DS_TCP:
+				file = "network";
+				break;
+			default:
+				errno = EINVAL;
+				return -1;
+		}
+
+		ctx->basefilename = get_basename(file);
+	}
+	return 0;
+}
+
+struct encoder_ctx *get_encoder_by_pn(struct lib_ccx_ctx *ctx, int pn)
+{
+	struct  encoder_ctx *enc_ctx;
+	list_for_each_entry(enc_ctx, &ctx->enc_ctx_head, list, struct encoder_ctx)
+	{
+		if (enc_ctx && enc_ctx->program_number == pn)
+			return enc_ctx;
+	}
+	return NULL;
+}
+
+struct lib_ccx_ctx* init_libraries(struct ccx_s_options *opt)
+{
+	int ret = 0;
+
+	struct lib_ccx_ctx *ctx = malloc(sizeof(struct lib_ccx_ctx));
+	if(!ctx)
+		ccx_common_logging.fatal_ftn(EXIT_NOT_ENOUGH_MEMORY, "init_libraries: Not enough memory allocating lib_ccx_ctx context.");
+	memset(ctx, 0, sizeof(struct lib_ccx_ctx));
+
+#ifndef MMCCXTR
+	if(opt->xmltv)
+	{
+		ctx->epg_inited = 1;
+		ctx->epg_buffers = (struct PSI_buffer *)malloc(sizeof(struct PSI_buffer)*(0xfff+1));
+		ctx->eit_programs = (struct EIT_program *)malloc(sizeof(struct EIT_program)*(TS_PMT_MAP_SIZE+1));
+		ctx->eit_current_events = (int32_t *)malloc(sizeof(int32_t)*(TS_PMT_MAP_SIZE+1));
+		ctx->ATSC_source_pg_map = (int16_t *)malloc(sizeof(int16_t)*(0xffff));
+		memset(ctx->epg_buffers, 0, sizeof(struct PSI_buffer)*(0xfff+1));
+		memset(ctx->eit_programs, 0, sizeof(struct EIT_program)*(TS_PMT_MAP_SIZE+1));
+		memset(ctx->eit_current_events, 0, sizeof(int32_t)*(TS_PMT_MAP_SIZE+1));
+		memset(ctx->ATSC_source_pg_map, 0, sizeof(int16_t)*(0xffff));
+		if(!ctx->epg_buffers || !ctx->eit_programs || !ctx->eit_current_events || !ctx->ATSC_source_pg_map)
+			ccx_common_logging.fatal_ftn(EXIT_NOT_ENOUGH_MEMORY, "lib_ccx_ctx");
+	}
+	else
+#endif
+	{
+		ctx->epg_inited = 0;
+		ctx->epg_buffers = NULL;
+		ctx->eit_programs = NULL;
+		ctx->eit_current_events = NULL;
+		ctx->ATSC_source_pg_map = NULL;
+	}
+
+	struct ccx_decoder_608_report *report_608 = malloc(sizeof(struct ccx_decoder_608_report));
+	if (!report_608)
+		ccx_common_logging.fatal_ftn(EXIT_NOT_ENOUGH_MEMORY, "init_libraries: Not enough memory allocating report_608");
+	memset(report_608, 0, sizeof(struct ccx_decoder_608_report));
+
+	ccx_decoder_dtvcc_report *report_dtvcc = (ccx_decoder_dtvcc_report *)
+			malloc(sizeof(ccx_decoder_dtvcc_report));
+	if (!report_dtvcc)
+		ccx_common_logging.fatal_ftn(EXIT_NOT_ENOUGH_MEMORY, "init_libraries: Not enough memory allocating report_dtvcc");
+	memset(report_dtvcc, 0, sizeof(ccx_decoder_dtvcc_report));
+
+	// Initialize some constants
+	ctx->screens_to_process = -1;
+	ctx->current_file = -1;
+
+	// Set logging functions for libraries
+	ccx_common_logging.debug_ftn = &dbg_print;
+	ccx_common_logging.debug_mask = opt->debug_mask;
+	ccx_common_logging.fatal_ftn = &fatal;
+	ccx_common_logging.log_ftn = &mprint;
+	ccx_common_logging.gui_ftn = &activity_library_process;
+
+	// Init shared decoder settings
+	ctx->dec_global_setting = init_decoder_setting(opt);
+	if (!ctx->dec_global_setting){
+		free(report_dtvcc);
+		return NULL;
+    }
+
+	// Need to set the 608 data for the report to the correct variable.
+	ctx->freport.data_from_608 = report_608;
+	ctx->dec_global_setting->settings_608->report = report_608;
+	ctx->freport.data_from_708 = report_dtvcc;
+	ctx->dec_global_setting->settings_dtvcc->report = report_dtvcc;
+	ctx->mp4_cfg.mp4vidtrack = opt->mp4vidtrack;
+	//Initialize input files
+	ctx->inputfile = opt->inputfile;
+	ctx->num_input_files = opt->num_input_files;
+
+	ret = init_ctx_outbase(opt, ctx);
+	if (ret < 0) {
+		goto end;
+	}
+	ctx->extension = get_file_extension(opt->write_format);
+
+	ctx->subs_delay = opt->subs_delay;
+
+	ctx->pesheaderbuf = (unsigned char *) malloc (188); // Never larger anyway
+
+	ctx->cc_to_stdout = opt->cc_to_stdout;
+	ctx->pes_header_to_stdout = opt->pes_header_to_stdout;
+	ctx->ignore_pts_jumps = opt->ignore_pts_jumps;
+
+	ctx->hauppauge_mode = opt->hauppauge_mode;
+	ctx->live_stream = opt->live_stream;
+	ctx->binary_concat = opt->binary_concat;
+	build_parity_table();
+
+	ctx->demux_ctx = init_demuxer(ctx, &opt->demux_cfg);
+	INIT_LIST_HEAD(&ctx->dec_ctx_head);
+	INIT_LIST_HEAD(&ctx->enc_ctx_head);
+
+	// Init timing
+	ccx_common_timing_init(&ctx->demux_ctx->past,opt->nosync);
+	ctx->multiprogram = opt->multiprogram;
+	ctx->write_format = opt->write_format;
+	ctx->out_interval = opt->out_interval;
+	ctx->segment_on_key_frames_only = opt->segment_on_key_frames_only;
+	ctx->segment_counter = 0;
+	ctx->system_start_time = -1;
+
+end:
+	if (ret != EXIT_OK)
+	{
+		free(ctx);
+		return NULL;
+	}
+	return ctx;
+}
+
+void dinit_libraries( struct lib_ccx_ctx **ctx)
+{
+	struct lib_ccx_ctx *lctx = *ctx;
+	struct encoder_ctx *enc_ctx;
+	struct lib_cc_decode *dec_ctx;
+	struct lib_cc_decode *dec_ctx1;
+	int i;
+	list_for_each_entry_safe(dec_ctx, dec_ctx1, &lctx->dec_ctx_head, list, struct lib_cc_decode)
+	{
+		LLONG cfts;
+#ifndef MMCCXTR
+		if (dec_ctx->codec == CCX_CODEC_DVB)
+			dvbsub_close_decoder(&dec_ctx->private_data);
+		//Test memory for teletext
+		else if (dec_ctx->codec == CCX_CODEC_TELETEXT)
+			telxcc_close(&dec_ctx->private_data, &dec_ctx->dec_sub);
+		else if (dec_ctx->codec == CCX_CODEC_ISDB_CC)
+			delete_isdb_decoder(&dec_ctx->private_data);
+#endif
+
+		flush_cc_decode(dec_ctx, &dec_ctx->dec_sub);
+		cfts = get_fts(dec_ctx->timing, dec_ctx->current_field);
+		enc_ctx = get_encoder_by_pn(lctx, dec_ctx->program_number);
+		if (enc_ctx && dec_ctx->dec_sub.got_output == CCX_TRUE)
+		{
+			encode_sub(enc_ctx, &dec_ctx->dec_sub);
+			dec_ctx->dec_sub.got_output = CCX_FALSE;
+		}
+		list_del(&dec_ctx->list);
+		dinit_cc_decode(&dec_ctx);
+		if (enc_ctx)
+		{
+			list_del(&enc_ctx->list);
+			dinit_encoder(&enc_ctx, cfts);
+		}
+	}
+
+#ifndef MMCCXTR
+	// free EPG memory
+	EPG_free(lctx);
+#endif
+	freep(&lctx->freport.data_from_608);
+	freep(&lctx->freport.data_from_708);
+	ccx_demuxer_delete(&lctx->demux_ctx);
+	dinit_decoder_setting(&lctx->dec_global_setting);
+	freep(&ccx_options.enc_cfg.output_filename);
+	freep(&lctx->basefilename);
+	freep(&lctx->pesheaderbuf);
+	for(i = 0;i < lctx->num_input_files;i++)
+		freep(&lctx->inputfile[i]);
+	freep(&lctx->inputfile);
+	freep(ctx);
+}
+
+int is_decoder_processed_enough(struct lib_ccx_ctx *ctx)
+{
+	struct lib_cc_decode *dec_ctx;
+	list_for_each_entry(dec_ctx, &ctx->dec_ctx_head, list, struct lib_cc_decode)
+	{
+		if (dec_ctx->processed_enough == CCX_TRUE && ctx->multiprogram == CCX_FALSE)
+			return CCX_TRUE;
+	}
+
+	return CCX_FALSE;
+}
+struct lib_cc_decode *update_decoder_list(struct lib_ccx_ctx *ctx)
+{
+	struct lib_cc_decode *dec_ctx;
+	list_for_each_entry(dec_ctx, &ctx->dec_ctx_head, list, struct lib_cc_decode)
+	{
+		return dec_ctx;
+	}
+
+	if (list_empty(&ctx->dec_ctx_head))
+	{
+		ctx->dec_global_setting->codec = CCX_CODEC_ATSC_CC;
+		ctx->dec_global_setting->program_number = 0;
+		dec_ctx = init_cc_decode(ctx->dec_global_setting);
+		if (!dec_ctx)
+			fatal(EXIT_NOT_ENOUGH_MEMORY, "In update_decoder_list: Not enough memory to init_cc_decode.\n");
+		list_add_tail( &(dec_ctx->list), &(ctx->dec_ctx_head) );
+
+		//DVB related
+		dec_ctx->prev = NULL;
+		dec_ctx->dec_sub.prev = NULL;
+		if (dec_ctx->codec == CCX_CODEC_DVB)
+		{
+			dec_ctx->prev = malloc(sizeof(struct lib_cc_decode));
+			dec_ctx->dec_sub.prev = malloc(sizeof(struct cc_subtitle));
+			memset (dec_ctx->dec_sub.prev, 0,sizeof(struct cc_subtitle));
+		}
+	}
+	return dec_ctx;
+}
+
+struct lib_cc_decode *update_decoder_list_cinfo(struct lib_ccx_ctx *ctx, struct cap_info* cinfo)
+{
+	struct lib_cc_decode *dec_ctx = NULL;
+
+	list_for_each_entry(dec_ctx, &ctx->dec_ctx_head, list, struct lib_cc_decode)
+	{
+		if (!cinfo || ctx->multiprogram == CCX_FALSE)
+			return dec_ctx;
+
+		if (dec_ctx->program_number == cinfo->program_number)
+			return dec_ctx;
+	}
+	if(cinfo)
+	{
+		ctx->dec_global_setting->program_number = cinfo->program_number;
+		ctx->dec_global_setting->codec = cinfo->codec;
+		ctx->dec_global_setting->private_data = cinfo->codec_private_data;
+	}
+	else
+	{
+		ctx->dec_global_setting->program_number = 0;
+		ctx->dec_global_setting->codec = CCX_CODEC_ATSC_CC;
+	}
+	if(ctx->multiprogram == CCX_FALSE)
+	{
+		if (list_empty(&ctx->dec_ctx_head))
+		{
+			dec_ctx = init_cc_decode(ctx->dec_global_setting);
+			if (!dec_ctx)
+				fatal(EXIT_NOT_ENOUGH_MEMORY, "In update_decoder_list_cinfo: Not enough memory allocating dec_ctx (multiprogram == false)\n");
+			list_add_tail( &(dec_ctx->list), &(ctx->dec_ctx_head) );
+		}
+	}
+	else
+	{
+		dec_ctx = init_cc_decode(ctx->dec_global_setting);
+		if (!dec_ctx)
+			fatal(EXIT_NOT_ENOUGH_MEMORY, "In update_decoder_list_cinfo: Not enough memory allocating dec_ctx ((multiprogram == true)\n");
+		list_add_tail( &(dec_ctx->list), &(ctx->dec_ctx_head) );
+	}
+
+	//DVB related
+	dec_ctx->prev = NULL;
+	dec_ctx->dec_sub.prev = NULL;
+
+	return dec_ctx;
+}
+
+struct encoder_ctx *update_encoder_list_cinfo(struct lib_ccx_ctx *ctx, struct cap_info* cinfo)
+{
+	struct encoder_ctx *enc_ctx;
+	unsigned int pn = 0;
+	unsigned char in_format = 1;
+	char *extension;
+
+
+#ifndef MMCCXTR
+	if (ctx->write_format == CCX_OF_NULL)
+		return NULL;
+#endif
+
+	if(cinfo)
+	{
+		pn = cinfo->program_number;
+		if (cinfo->codec == CCX_CODEC_ISDB_CC)
+			in_format = 3;
+		else if (cinfo->codec == CCX_CODEC_TELETEXT)
+			in_format = 2;
+		else
+			in_format = 1;
+	}
+	list_for_each_entry(enc_ctx, &ctx->enc_ctx_head, list, struct encoder_ctx)
+	{
+		if ( ctx->multiprogram == CCX_FALSE)
+			return enc_ctx;
+
+		if (enc_ctx->program_number == pn)
+			return enc_ctx;
+	}
+
+	extension = get_file_extension(ccx_options.enc_cfg.write_format);
+	if (!extension && ccx_options.enc_cfg.write_format != CCX_OF_CURL)
+		return NULL;
+
+	if(ctx->multiprogram == CCX_FALSE)
+	{
+		if(ctx->out_interval != -1)
+		{
+			int len;
+
+			len = strlen(ctx->basefilename) + 10 + strlen(extension);
+
+			freep(&ccx_options.enc_cfg.output_filename);
+			ccx_options.enc_cfg.output_filename = malloc(len);
+
+			sprintf(ccx_options.enc_cfg.output_filename, "%s_%06d%s", ctx->basefilename, ctx->segment_counter+1, extension);
+		}
+		if (list_empty(&ctx->enc_ctx_head))
+		{
+			ccx_options.enc_cfg.program_number = pn;
+			ccx_options.enc_cfg.in_format = in_format;
+			enc_ctx = init_encoder(&ccx_options.enc_cfg);
+			if (!enc_ctx)
+				return NULL;
+			list_add_tail( &(enc_ctx->list), &(ctx->enc_ctx_head) );
+		}
+	}
+	else
+	{
+		int len;
+
+		len = strlen(ctx->basefilename) + 10 + strlen(extension);
+
+		ccx_options.enc_cfg.program_number = pn;
+		ccx_options.enc_cfg.output_filename = malloc(len);
+		if (!ccx_options.enc_cfg.output_filename)
+		{
+			freep(&extension);
+			return NULL;
+		}
+
+		sprintf(ccx_options.enc_cfg.output_filename, "%s_%d%s", ctx->basefilename, pn, extension);
+		enc_ctx = init_encoder(&ccx_options.enc_cfg);
+		if (!enc_ctx)
+		{
+			freep(&extension);
+			freep(&ccx_options.enc_cfg.output_filename);
+			return NULL;
+		}
+
+		list_add_tail( &(enc_ctx->list), &(ctx->enc_ctx_head) );
+		freep(&extension);
+		freep(&ccx_options.enc_cfg.output_filename);
+	}
+	// DVB related
+	enc_ctx->prev = NULL;
+	if (cinfo)
+		if (cinfo->codec == CCX_CODEC_DVB)
+			enc_ctx->write_previous = 0;
+	freep(&extension);
+	return enc_ctx;
+}
+
+struct encoder_ctx *update_encoder_list(struct lib_ccx_ctx *ctx)
+{
+	return update_encoder_list_cinfo(ctx, NULL);
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/lib_ccx.h Added

@@ -0,0 +1,317 @@
+#ifndef CCX_CCEXTRACTOR_H
+#define CCX_CCEXTRACTOR_H
+
+#define VERSION "0.88"
+
+// Load common includes and constants for library usage
+#include "ccx_common_platform.h"
+#include "ccx_common_constants.h"
+#include "ccx_common_common.h"
+#include "ccx_common_char_encoding.h"
+#include "ccx_common_structs.h"
+#include "ccx_common_timing.h"
+#include "ccx_common_option.h"
+
+#include "ccx_demuxer.h"
+#include "ccx_encoders_common.h"
+#include "ccx_decoders_common.h"
+#include "bitstream.h"
+
+#ifndef MMCCXTR
+#include "networking.h"
+#include "avc_functions.h"
+#include "teletext.h"
+#endif
+
+#ifdef WITH_LIBCURL
+#include <curl/curl.h>
+#endif
+
+//#include "ccx_decoders_708.h"
+
+/* Report information */
+#define SUB_STREAMS_CNT 10
+
+#define TELETEXT_CHUNK_LEN 1 + 8 + 44
+struct file_report
+{
+	unsigned width;
+	unsigned height;
+	unsigned aspect_ratio;
+	unsigned frame_rate;
+	struct ccx_decoder_608_report *data_from_608;
+	struct ccx_decoder_dtvcc_report *data_from_708;
+	unsigned mp4_cc_track_cnt;
+};
+
+// Stuff for telxcc.c
+struct ccx_s_teletext_config
+{
+	uint8_t verbose : 1;                                       // should telxcc be verbose?
+	uint16_t page;                                             // teletext page containing cc we want to filter
+	uint16_t tid;                                              // 13-bit packet ID for teletext stream
+	double offset;                                             // time offset in seconds
+	uint8_t bom : 1;                                           // print UTF-8 BOM characters at the beginning of output
+	uint8_t nonempty : 1;                                      // produce at least one (dummy) frame
+	// uint8_t se_mode : 1;                                    // search engine compatible mode => Uses CCExtractor's write_format
+	// uint64_t utc_refvalue;                                  // UTC referential value => Moved to ccx_decoders_common, so can be used for other decoders (608/xds) too
+	uint16_t user_page;                                        // Page selected by user, which MIGHT be different to 'page' depending on autodetection stuff
+	int dolevdist;											   // 0=Don't attempt to correct errors
+	int levdistmincnt, levdistmaxpct;                          // Means 2 fails or less is "the same", 10% or less is also "the same"
+	struct ccx_boundary_time extraction_start, extraction_end; // Segment we actually process
+	enum ccx_output_format write_format;                       // 0=Raw, 1=srt, 2=SMI
+	int gui_mode_reports;                                      // If 1, output in stderr progress updates so the GUI can grab them
+	enum ccx_output_date_format date_format;
+	int noautotimeref;                                         // Do NOT set time automatically?
+	unsigned send_to_srv;
+	enum ccx_encoding_type encoding;
+	int nofontcolor;
+	int nohtmlescape;
+	char millis_separator;
+    int latrusmap;
+};
+
+struct ccx_s_mp4Cfg
+{
+	unsigned int mp4vidtrack :1;
+};
+
+struct lib_ccx_ctx
+{
+	// Stuff common to both loops
+	unsigned char *pesheaderbuf;
+	LLONG inputsize;
+	LLONG total_inputsize;
+	LLONG total_past; // Only in binary concat mode
+
+	int last_reported_progress;
+
+	/* Stats */
+	int stat_numuserheaders;
+	int stat_dvdccheaders;
+	int stat_scte20ccheaders;
+	int stat_replay5000headers;
+	int stat_replay4000headers;
+	int stat_dishheaders;
+	int stat_hdtv;
+	int stat_divicom;
+	int false_pict_header;
+
+	// int hex_mode=HEX_NONE; // Are we processing an hex file?
+	struct ccx_decoders_common_settings_t *dec_global_setting;
+	struct list_head dec_ctx_head;
+
+	int rawmode; // Broadcast or DVD
+	// See -d from
+
+	int cc_to_stdout; // If 1, captions go to stdout instead of file
+	int pes_header_to_stdout; //If 1, PES Header data will be outputted to console
+	int dvb_debug_traces_to_stdout; // If 1, DVB subtitle debug traces will be outputted to console
+	int ignore_pts_jumps; //If 1, the program will ignore PTS jumps. Sometimes this parameter is required for DVB subs with > 30s pause time
+
+	LLONG subs_delay; // ms to delay (or advance) subs
+
+	int startcredits_displayed;
+	int end_credits_displayed;
+	LLONG last_displayed_subs_ms;    // When did the last subs end?
+	LLONG screens_to_process;        // How many screenfuls we want?
+	char *basefilename;              // Input filename without the extension
+
+	const char *extension;           // Output extension
+	int current_file;                // If current_file!=1, we are processing *inputfile[current_file]
+
+	char **inputfile;                // List of files to process
+	int num_input_files;             // How many?
+
+	unsigned teletext_warning_shown; // Did we detect a possible PAL (with teletext subs) and told the user already?
+
+	int epg_inited;
+	struct PSI_buffer *epg_buffers;
+	struct EIT_program *eit_programs;
+	int32_t *eit_current_events;
+	int16_t *ATSC_source_pg_map;
+	int epg_last_output;
+	int epg_last_live_output;
+	struct file_report freport;
+
+	unsigned int hauppauge_mode;         // If 1, use PID=1003, process specially and so on
+	int live_stream;                     /* -1 -> Not a complete file but a live stream, without timeout
+                                          0 -> A regular file
+                                         >0 -> Live stream with a timeout of this value in seconds */
+	int binary_concat;                   // Disabled by -ve or --videoedited
+	int multiprogram;
+	enum ccx_output_format write_format; // 0=Raw, 1=srt, 2=SMI
+
+	struct ccx_demuxer *demux_ctx;
+	struct list_head enc_ctx_head;
+	struct ccx_s_mp4Cfg mp4_cfg;
+	int out_interval;
+	int segment_on_key_frames_only;
+	int segment_counter;
+	LLONG system_start_time;
+};
+
+
+struct lib_ccx_ctx *init_libraries(struct ccx_s_options *opt);
+void dinit_libraries( struct lib_ccx_ctx **ctx);
+
+//ccextractor.c
+void print_end_msg(void);
+
+//params.c
+int parse_parameters (struct ccx_s_options *opt, int argc, char *argv[]);
+void print_usage (void);
+int atoi_hex (char *s);
+int stringztoms (const char *s, struct ccx_boundary_time *bt);
+
+// general_loop.c
+void position_sanity_check(struct ccx_demuxer *ctx);
+int init_file_buffer(struct ccx_demuxer *ctx);
+int ps_get_more_data(struct lib_ccx_ctx *ctx, struct demuxer_data **ppdata);
+int general_get_more_data(struct lib_ccx_ctx *ctx, struct demuxer_data **data);
+int raw_loop (struct lib_ccx_ctx *ctx);
+size_t process_raw(struct lib_cc_decode *ctx, struct cc_subtitle *sub, unsigned char *buffer, size_t len);
+int general_loop(struct lib_ccx_ctx *ctx);
+void process_hex(struct lib_ccx_ctx *ctx, char *filename);
+int rcwt_loop(struct lib_ccx_ctx *ctx);
+
+extern int end_of_file;
+
+int ccx_mxf_getmoredata(struct lib_ccx_ctx *ctx, struct demuxer_data **ppdata);
+
+// asf_functions.c
+int asf_get_more_data(struct lib_ccx_ctx *ctx, struct demuxer_data **ppdata);
+
+// wtv_functions.c
+int wtv_get_more_data(struct lib_ccx_ctx *ctx, struct demuxer_data **ppdata);
+
+// es_functions.c
+size_t process_m2v(struct lib_cc_decode *ctx, unsigned char *data, size_t length, struct cc_subtitle *sub);
+
+extern unsigned top_field_first;
+
+// es_userdata.c
+int user_data(struct lib_cc_decode *ctx, struct bitstream *ustream, int udtype, struct cc_subtitle *sub);
+
+// bitstream.c - see bitstream.h
+
+// file_functions.c
+LLONG get_file_size (int in);
+LLONG get_total_file_size (struct lib_ccx_ctx *ctx);
+void prepare_for_new_file (struct lib_ccx_ctx *ctx);
+void close_input_file (struct lib_ccx_ctx *ctx);
+int switch_to_next_file (struct lib_ccx_ctx *ctx, LLONG bytesinbuffer);
+void return_to_buffer (struct ccx_demuxer *ctx, unsigned char *buffer, unsigned int bytes);
+
+// sequencing.c
+void init_hdcc (struct lib_cc_decode *ctx);
+void store_hdcc(struct lib_cc_decode *ctx, unsigned char *cc_data, int cc_count, int sequence_number, LLONG current_fts_now, struct cc_subtitle *sub);
+void anchor_hdcc(struct lib_cc_decode *ctx, int seq);
+void process_hdcc (struct lib_cc_decode *ctx, struct cc_subtitle *sub);
+
+// params_dump.c
+void params_dump(struct lib_ccx_ctx *ctx);
+void print_file_report(struct lib_ccx_ctx *ctx);
+
+// output.c
+void dinit_write(struct ccx_s_write *wb);
+int temporarily_open_output(struct ccx_s_write *wb);
+int temporarily_close_output(struct ccx_s_write *wb);
+int init_write(struct ccx_s_write *wb, char *filename, int with_semaphore);
+int writeraw (const unsigned char *data, int length, void *private_data, struct cc_subtitle *sub);
+void flushbuffer (struct lib_ccx_ctx *ctx, struct ccx_s_write *wb, int closefile);
+void writercwtdata (struct lib_cc_decode *ctx, const unsigned char *data, struct cc_subtitle *sub);
+
+// stream_functions.c
+int isValidMP4Box(unsigned char *buffer, size_t position, size_t *nextBoxLocation, int *boxScore);
+void detect_stream_type (struct ccx_demuxer *ctx);
+int detect_myth( struct ccx_demuxer *ctx );
+int read_video_pes_header (struct ccx_demuxer *ctx, struct demuxer_data *data, unsigned char *nextheader, int *headerlength, int sbuflen);
+
+// ts_functions.c
+#ifndef MMCCXTR
+void init_ts(struct ccx_demuxer *ctx);
+int ts_readpacket(struct ccx_demuxer* ctx, struct ts_payload *payload);
+long ts_readstream(struct ccx_demuxer *ctx, struct demuxer_data **data);
+int ts_get_more_data(struct lib_ccx_ctx *ctx, struct demuxer_data **data);
+int write_section(struct ccx_demuxer *ctx, struct ts_payload *payload, unsigned char*buf, int size,  struct program_info *pinfo);
+void ts_buffer_psi_packet(struct ccx_demuxer *ctx);
+int parse_PMT (struct ccx_demuxer *ctx, unsigned char *buf, int len,  struct program_info *pinfo);
+int parse_PAT (struct ccx_demuxer *ctx);
+void parse_EPG_packet (struct lib_ccx_ctx *ctx);
+void EPG_free(struct lib_ccx_ctx *ctx);
+char* EPG_DVB_decode_string(uint8_t *in, size_t size);
+void parse_SDT(struct ccx_demuxer *ctx);
+#endif
+
+// ts_info.c
+int get_video_stream(struct ccx_demuxer *ctx);
+
+// myth.c
+int myth_loop(struct lib_ccx_ctx *ctx);
+
+// matroska.c
+int matroska_loop(struct lib_ccx_ctx *ctx);
+
+// utility.c
+void fatal(int exit_code, const char *fmt, ...);
+void mprint (const char *fmt, ...);
+void sleep_secs (int secs);
+void dump (LLONG mask, unsigned char *start, int l, unsigned long abs_start, unsigned clear_high_bit);
+bool_t in_array(uint16_t *array, uint16_t length, uint16_t element) ;
+int hex_to_int (char high, char low);
+int hex_string_to_int(char* string, int len);
+void timestamp_to_srttime(uint64_t timestamp, char *buffer);
+int levenshtein_dist (const uint64_t *s1, const uint64_t *s2, unsigned s1len, unsigned s2len);
+void millis_to_date (uint64_t timestamp, char *buffer, enum ccx_output_date_format date_format, char millis_separator);
+void signal_handler(int sig_type);
+struct encoder_ctx* change_filename(struct encoder_ctx*);
+#ifndef _WIN32
+void m_signal(int sig, void (*func)(int));
+#endif
+
+
+void buffered_seek (struct ccx_demuxer *ctx, int offset);
+extern void build_parity_table(void);
+
+int tlt_process_pes_packet(struct lib_cc_decode *dec_ctx, uint8_t *buffer, uint16_t size, struct cc_subtitle *sub, int sentence_cap);
+void* telxcc_init(void);
+void telxcc_close(void **ctx, struct cc_subtitle *sub);
+void tlt_read_rcwt(void *codec, unsigned char *buf, struct cc_subtitle *sub);
+void telxcc_configure (void *codec, struct ccx_s_teletext_config *cfg);
+void telxcc_update_gt(void *codec, uint32_t global_timestamp);
+
+extern int strangeheader;
+
+extern const char *desc[256];
+
+
+extern long FILEBUFFERSIZE; // Uppercase because it used to be a define
+
+extern int firstcall;
+
+// From ts_functions
+//extern struct ts_payload payload;
+extern unsigned char tspacket[188];
+extern unsigned char *last_pat_payload;
+extern unsigned last_pat_length;
+extern volatile int terminate_asap;
+
+#define HAUPPAGE_CCPID	1003 // PID for CC's in some Hauppauge recordings
+
+extern unsigned teletext_mode;
+
+#define MAX_TLT_PAGES 1000
+
+#ifndef MMCCXTR
+extern struct ccx_s_teletext_config tlt_config;
+#endif
+
+int is_decoder_processed_enough(struct lib_ccx_ctx *ctx);
+struct lib_cc_decode *update_decoder_list_cinfo(struct lib_ccx_ctx *ctx, struct cap_info* cinfo);
+struct lib_cc_decode *update_decoder_list(struct lib_ccx_ctx *ctx);
+
+struct encoder_ctx *update_encoder_list_cinfo(struct lib_ccx_ctx *ctx, struct cap_info* cinfo);
+struct encoder_ctx * update_encoder_list(struct lib_ccx_ctx *ctx);
+struct encoder_ctx *get_encoder_by_pn(struct lib_ccx_ctx *ctx, int pn);
+#endif

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/list.h Added

@@ -0,0 +1,511 @@
+/**
+ * 
+ * Grabbed from linux kernel source code and fix it for user space
+ * program. Of course, this is a GPL licensed header file.
+ *
+ *
+ */
+#ifndef _LINUX_LIST_H
+#define _LINUX_LIST_H
+#include "ccx_common_platform.h"
+/**
+ * @name from other kernel headers
+ */
+/*@{*/
+
+/**
+ * Get offset of a member
+ */
+
+#ifndef ccx_offsetof
+#define ccx_offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#endif
+
+/**
+ * Casts a member of a structure out to the containing structure
+ * @param ptr        the pointer to the member.
+ * @param type       the type of the container struct this is embedded in.
+ * @param member     the name of the member within the struct.
+ *
+ */
+#define container_of(ptr, type, member) ((type *)( (char *)ptr - ccx_offsetof(type,member) ))
+/*@}*/
+
+
+/*
+ * These are non-NULL pointers that will result in page faults
+ * under normal circumstances, used to verify that nobody uses
+ * non-initialized list entries.
+ */
+#define LIST_POISON1  ((void *) 0x00100100)
+#define LIST_POISON2  ((void *) 0x00200200)
+
+/**
+ * Simple doubly linked list implementation.
+ *
+ * Some of the internal functions ("__xxx") are useful when
+ * manipulating whole lists rather than single entries, as
+ * sometimes we already know the next/prev entries and we can
+ * generate better code by using them directly rather than
+ * using the generic single-entry routines.
+ */
+struct list_head {
+	struct list_head *next, *prev;
+};
+
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
+
+#define LIST_HEAD(name) \
+	struct list_head name = LIST_HEAD_INIT(name)
+
+#define INIT_LIST_HEAD(ptr) do { \
+	(ptr)->next = (ptr); (ptr)->prev = (ptr); \
+} while (0)
+
+/*
+ * Insert a new entry between two known consecutive entries.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_add(struct list_head *new,
+			      struct list_head *prev,
+			      struct list_head *next)
+{
+	next->prev = new;
+	new->next = next;
+	new->prev = prev;
+	prev->next = new;
+}
+
+/**
+ * list_add - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it after
+ *
+ * Insert a new entry after the specified head.
+ * This is good for implementing stacks.
+ */
+static inline void list_add(struct list_head *new, struct list_head *head)
+{
+	__list_add(new, head, head->next);
+}
+
+/**
+ * list_add_tail - add a new entry
+ * @new: new entry to be added
+ * @head: list head to add it before
+ *
+ * Insert a new entry before the specified head.
+ * This is useful for implementing queues.
+ */
+static inline void list_add_tail(struct list_head *new, struct list_head *head)
+{
+	__list_add(new, head->prev, head);
+}
+
+
+/*
+ * Delete a list entry by making the prev/next entries
+ * point to each other.
+ *
+ * This is only for internal list manipulation where we know
+ * the prev/next entries already!
+ */
+static inline void __list_del(struct list_head * prev, struct list_head * next)
+{
+	next->prev = prev;
+	prev->next = next;
+}
+
+/**
+ * list_del - deletes entry from list.
+ * @entry: the element to delete from the list.
+ * Note: list_empty on entry does not return true after this, the entry is
+ * in an undefined state.
+ */
+static inline void list_del(struct list_head *entry)
+{
+	__list_del(entry->prev, entry->next);
+	entry->next = LIST_POISON1;
+	entry->prev = LIST_POISON2;
+}
+
+
+
+/**
+ * list_del_init - deletes entry from list and reinitialize it.
+ * @entry: the element to delete from the list.
+ */
+static inline void list_del_init(struct list_head *entry)
+{
+	__list_del(entry->prev, entry->next);
+	INIT_LIST_HEAD(entry);
+}
+
+/**
+ * list_move - delete from one list and add as another's head
+ * @list: the entry to move
+ * @head: the head that will precede our entry
+ */
+static inline void list_move(struct list_head *list, struct list_head *head)
+{
+        __list_del(list->prev, list->next);
+        list_add(list, head);
+}
+
+/**
+ * list_move_tail - delete from one list and add as another's tail
+ * @list: the entry to move
+ * @head: the head that will follow our entry
+ */
+static inline void list_move_tail(struct list_head *list,
+				  struct list_head *head)
+{
+        __list_del(list->prev, list->next);
+        list_add_tail(list, head);
+}
+
+/**
+ * list_empty - tests whether a list is empty
+ * @head: the list to test.
+ */
+static inline int list_empty(const struct list_head *head)
+{
+	return head->next == head;
+}
+
+static inline void __list_splice(struct list_head *list,
+				 struct list_head *head)
+{
+	struct list_head *first = list->next;
+	struct list_head *last = list->prev;
+	struct list_head *at = head->next;
+
+	first->prev = head;
+	head->next = first;
+
+	last->next = at;
+	at->prev = last;
+}
+
+/**
+ * list_splice - join two lists
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ */
+static inline void list_splice(struct list_head *list, struct list_head *head)
+{
+	if (!list_empty(list))
+		__list_splice(list, head);
+}
+
+/**
+ * list_splice_init - join two lists and reinitialise the emptied list.
+ * @list: the new list to add.
+ * @head: the place to add it in the first list.
+ *
+ * The list at @list is reinitialised
+ */
+static inline void list_splice_init(struct list_head *list,
+				    struct list_head *head)
+{
+	if (!list_empty(list)) {
+		__list_splice(list, head);
+		INIT_LIST_HEAD(list);
+	}
+}
+
+/**
+ * list_entry - get the struct for this entry
+ * @ptr:	the &struct list_head pointer.
+ * @type:	the type of the struct this is embedded in.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_entry(ptr, type, member) \
+	container_of(ptr, type, member)
+
+/**
+ * list_for_each	-	iterate over a list
+ * @pos:	the &struct list_head to use as a loop counter.
+ * @head:	the head for your list.
+ */
+
+#define list_for_each(pos, head) \
+  for (pos = (head)->next; pos != (head);	\
+       pos = pos->next)
+
+/**
+ * __list_for_each	-	iterate over a list
+ * @pos:	the &struct list_head to use as a loop counter.
+ * @head:	the head for your list.
+ *
+ * This variant differs from list_for_each() in that it's the
+ * simplest possible list iteration code, no prefetching is done.
+ * Use this for code that knows the list to be very short (empty
+ * or 1 entry) most of the time.
+ */
+#define __list_for_each(pos, head) \
+	for (pos = (head)->next; pos != (head); pos = pos->next)
+
+/**
+ * list_for_each_prev	-	iterate over a list backwards
+ * @pos:	the &struct list_head to use as a loop counter.
+ * @head:	the head for your list.
+ */
+#define list_for_each_prev(pos, head) \
+	for (pos = (head)->prev; prefetch(pos->prev), pos != (head); \
+        	pos = pos->prev)
+
+/**
+ * list_for_each_safe	-	iterate over a list safe against removal of list entry
+ * @pos:	the &struct list_head to use as a loop counter.
+ * @n:		another &struct list_head to use as temporary storage
+ * @head:	the head for your list.
+ */
+#define list_for_each_safe(pos, n, head) \
+	for (pos = (head)->next, n = pos->next; pos != (head); \
+		pos = n, n = pos->next)
+
+/**
+ * list_for_each_entry	-	iterate over list of given type
+ * @pos:	the type * to use as a loop counter.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ * @type iterator type
+ */
+#define list_for_each_entry(pos, head, member, type)				\
+	for (pos = list_entry((head)->next, type, member);	\
+	     &pos->member != (head);					\
+	     pos = list_entry(pos->member.next, type, member))
+
+/**
+ * list_for_each_entry_reverse - iterate backwards over list of given type.
+ * @pos:	the type * to use as a loop counter.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_reverse(pos, head, member)			\
+	for (pos = list_entry((head)->prev, typeof(*pos), member);	\
+	     &pos->member != (head); 	\
+	     pos = list_entry(pos->member.prev, typeof(*pos), member))
+
+/**
+ * list_prepare_entry - prepare a pos entry for use as a start point in
+ *			list_for_each_entry_continue
+ * @pos:	the type * to use as a start point
+ * @head:	the head of the list
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_prepare_entry(pos, head, member) \
+	((pos) ? : list_entry(head, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_continue -	iterate over list of given type
+ *			continuing after existing point
+ * @pos:	the type * to use as a loop counter.
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_continue(pos, head, member) 		\
+	for (pos = list_entry(pos->member.next, typeof(*pos), member);	\
+	     &pos->member != (head);	\
+	     pos = list_entry(pos->member.next, typeof(*pos), member))
+
+/**
+ * list_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * @pos:	the type * to use as a loop counter.
+ * @n:		another type * to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_safe(pos, n, head, member, type)			\
+	for (pos = list_entry((head)->next, type, member),	\
+		n = list_entry(pos->member.next, type, member);	\
+	     &pos->member != (head); 					\
+	     pos = n, n = list_entry(n->member.next, type, member))
+
+/**
+ * list_for_each_entry_safe_continue -	iterate over list of given type
+ *			continuing after existing point safe against removal of list entry
+ * @pos:	the type * to use as a loop counter.
+ * @n:		another type * to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_safe_continue(pos, n, head, member) 		\
+	for (pos = list_entry(pos->member.next, typeof(*pos), member), 		\
+		n = list_entry(pos->member.next, typeof(*pos), member);		\
+	     &pos->member != (head);						\
+	     pos = n, n = list_entry(n->member.next, typeof(*n), member))
+
+/**
+ * list_for_each_entry_safe_reverse - iterate backwards over list of given type safe against
+ *				      removal of list entry
+ * @pos:	the type * to use as a loop counter.
+ * @n:		another type * to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the list_struct within the struct.
+ */
+#define list_for_each_entry_safe_reverse(pos, n, head, member)		\
+	for (pos = list_entry((head)->prev, typeof(*pos), member),	\
+		n = list_entry(pos->member.prev, typeof(*pos), member);	\
+	     &pos->member != (head); 					\
+	     pos = n, n = list_entry(n->member.prev, typeof(*n), member))
+
+
+
+
+/*
+ * Double linked lists with a single pointer list head.
+ * Mostly useful for hash tables where the two pointer list head is
+ * too wasteful.
+ * You lose the ability to access the tail in O(1).
+ */
+
+struct hlist_head {
+	struct hlist_node *first;
+};
+
+struct hlist_node {
+	struct hlist_node *next, **pprev;
+};
+
+#define HLIST_HEAD_INIT { .first = NULL }
+#define HLIST_HEAD(name) struct hlist_head name = {  .first = NULL }
+#define INIT_HLIST_HEAD(ptr) ((ptr)->first = NULL)
+#define INIT_HLIST_NODE(ptr) ((ptr)->next = NULL, (ptr)->pprev = NULL)
+
+static inline int hlist_unhashed(const struct hlist_node *h)
+{
+	return !h->pprev;
+}
+
+static inline int hlist_empty(const struct hlist_head *h)
+{
+	return !h->first;
+}
+
+static inline void __hlist_del(struct hlist_node *n)
+{
+	struct hlist_node *next = n->next;
+	struct hlist_node **pprev = n->pprev;
+	*pprev = next;
+	if (next)
+		next->pprev = pprev;
+}
+
+static inline void hlist_del(struct hlist_node *n)
+{
+	__hlist_del(n);
+	n->next = LIST_POISON1;
+	n->pprev = LIST_POISON2;
+}
+
+
+static inline void hlist_del_init(struct hlist_node *n)
+{
+	if (n->pprev)  {
+		__hlist_del(n);
+		INIT_HLIST_NODE(n);
+	}
+}
+
+static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
+{
+	struct hlist_node *first = h->first;
+	n->next = first;
+	if (first)
+		first->pprev = &n->next;
+	h->first = n;
+	n->pprev = &h->first;
+}
+
+
+
+/* next must be != NULL */
+static inline void hlist_add_before(struct hlist_node *n,
+					struct hlist_node *next)
+{
+	n->pprev = next->pprev;
+	n->next = next;
+	next->pprev = &n->next;
+	*(n->pprev) = n;
+}
+
+static inline void hlist_add_after(struct hlist_node *n,
+					struct hlist_node *next)
+{
+	next->next = n->next;
+	n->next = next;
+	next->pprev = &n->next;
+
+	if(next->next)
+		next->next->pprev  = &next->next;
+}
+
+
+
+#define hlist_entry(ptr, type, member) container_of(ptr,type,member)
+
+#define hlist_for_each(pos, head) \
+	for (pos = (head)->first; pos && ({ prefetch(pos->next); 1; }); \
+	     pos = pos->next)
+
+#define hlist_for_each_safe(pos, n, head) \
+	for (pos = (head)->first; pos && ({ n = pos->next; 1; }); \
+	     pos = n)
+
+/**
+ * hlist_for_each_entry	- iterate over list of given type
+ * @tpos:	the type * to use as a loop counter.
+ * @pos:	the &struct hlist_node to use as a loop counter.
+ * @head:	the head for your list.
+ * @member:	the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry(tpos, pos, head, member)			 \
+	for (pos = (head)->first;					 \
+	     pos && ({ prefetch(pos->next); 1;}) &&			 \
+		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = pos->next)
+
+/**
+ * hlist_for_each_entry_continue - iterate over a hlist continuing after existing point
+ * @tpos:	the type * to use as a loop counter.
+ * @pos:	the &struct hlist_node to use as a loop counter.
+ * @member:	the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_continue(tpos, pos, member)		 \
+	for (pos = (pos)->next;						 \
+	     pos && ({ prefetch(pos->next); 1;}) &&			 \
+		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = pos->next)
+
+/**
+ * hlist_for_each_entry_from - iterate over a hlist continuing from existing point
+ * @tpos:	the type * to use as a loop counter.
+ * @pos:	the &struct hlist_node to use as a loop counter.
+ * @member:	the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_from(tpos, pos, member)			 \
+	for (; pos && ({ prefetch(pos->next); 1;}) &&			 \
+		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = pos->next)
+
+/**
+ * hlist_for_each_entry_safe - iterate over list of given type safe against removal of list entry
+ * @tpos:	the type * to use as a loop counter.
+ * @pos:	the &struct hlist_node to use as a loop counter.
+ * @n:		another &struct hlist_node to use as temporary storage
+ * @head:	the head for your list.
+ * @member:	the name of the hlist_node within the struct.
+ */
+#define hlist_for_each_entry_safe(tpos, pos, n, head, member) 		 \
+	for (pos = (head)->first;					 \
+	     pos && ({ n = pos->next; 1; }) && 				 \
+		({ tpos = hlist_entry(pos, typeof(*tpos), member); 1;}); \
+	     pos = n)
+
+
+#endif
+

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/output.c Added

@@ -0,0 +1,305 @@
+#include "lib_ccx.h"
+#include "../ccextractor.h"
+#include "ccx_common_option.h"
+#ifdef _WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+
+void dinit_write(struct ccx_s_write *wb)
+{
+#ifdef PYTHON_API
+	return;
+#else
+        if (wb->fh > 0)
+            close(wb->fh);
+        freep(&wb->filename);
+        if (wb->with_semaphore && wb->semaphore_filename)
+            unlink(wb->semaphore_filename);
+        freep(&wb->semaphore_filename);
+#endif
+}
+
+int temporarily_close_output(struct ccx_s_write *wb)
+{
+	close(wb->fh);
+	wb->fh = -1;
+	wb->temporarily_closed = 1;
+	return 0;
+}
+
+int temporarily_open_output(struct ccx_s_write *wb)
+{
+	int t = 0;
+	// Try a few times before giving up. This is because this close/open stuff exists for processes
+	// that demand exclusive access to the file, so often we'll find out that we cannot reopen the
+	// file immediately.
+	while (t < 5 && wb->fh == -1)
+	{
+		wb->fh = open(wb->filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, S_IREAD | S_IWRITE);
+		sleep(1);
+	}
+	if (wb->fh == -1)
+	{
+		return CCX_COMMON_EXIT_FILE_CREATION_FAILED;
+	}
+	wb->temporarily_closed = 0;
+	return EXIT_OK;
+}
+
+
+
+int init_write (struct ccx_s_write *wb, char *filename, int with_semaphore)
+{
+#ifdef PYTHON_API
+    return EXIT_OK;
+#else
+	memset(wb, 0, sizeof(struct ccx_s_write));
+	wb->fh=-1;
+	wb->temporarily_closed = 0;
+	wb->filename = filename;
+        
+	wb->with_semaphore = with_semaphore;
+	wb->append_mode = ccx_options.enc_cfg.append_mode;
+	if(!(wb->append_mode))
+		wb->fh = open (filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, S_IREAD | S_IWRITE);
+	else
+		wb->fh = open (filename, O_RDWR | O_CREAT | O_APPEND | O_BINARY, S_IREAD | S_IWRITE);
+	wb->renaming_extension = 0;
+	if (wb->fh == -1)
+	{
+		return CCX_COMMON_EXIT_FILE_CREATION_FAILED;
+	}
+	if (with_semaphore)
+	{
+		wb->semaphore_filename = (char *)malloc(strlen(filename) + 6);
+		if (!wb->semaphore_filename)
+			return EXIT_NOT_ENOUGH_MEMORY;
+		sprintf(wb->semaphore_filename, "%s.sem", filename);
+		int t = open(wb->semaphore_filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, S_IREAD | S_IWRITE);
+		if (t == -1)
+		{
+			close(wb->fh);
+			return CCX_COMMON_EXIT_FILE_CREATION_FAILED;
+		}
+		close(t);
+	}
+	return EXIT_OK;
+#endif
+}
+
+int writeraw (const unsigned char *data, int length, void *private_data, struct cc_subtitle *sub)
+{
+	unsigned char* sub_data = NULL;
+	// Don't do anything for empty data
+	if (data==NULL)
+		return -1;
+
+	sub->data = realloc(sub->data, length + sub->nb_data);
+	if (!sub->data)
+		return EXIT_NOT_ENOUGH_MEMORY;
+	sub_data = sub->data;
+	sub->datatype = CC_DATATYPE_GENERIC;
+	memcpy(sub_data + sub->nb_data, data, length);
+	sub->got_output = 1;
+	sub->nb_data += length;
+	sub->type = CC_RAW;
+
+
+	return EXIT_SUCCESS;
+}
+
+void writeDVDraw (const unsigned char *data1, int length1,
+                  const unsigned char *data2, int length2,
+				  struct cc_subtitle *sub)
+{
+	/* these are only used by DVD raw mode: */
+	static int loopcount = 1; /* loop 1: 5 elements, loop 2: 8 elements,
+				     loop 3: 11 elements, rest: 15 elements */
+	static int datacount = 0; /* counts within loop */
+
+	if (datacount==0)
+	{
+		writeraw (DVD_HEADER, sizeof (DVD_HEADER), NULL, sub);
+		if (loopcount==1)
+			writeraw (lc1, sizeof (lc1), NULL, sub);
+		if (loopcount==2)
+			writeraw (lc2, sizeof (lc2), NULL, sub);
+		if (loopcount==3)
+		{
+			writeraw (lc3, sizeof (lc3), NULL, sub);
+			if (data2 && length2)
+				writeraw (data2, length2, NULL, sub);
+		}
+		if (loopcount>3)
+		{
+			writeraw (lc4, sizeof (lc4), NULL, sub);
+			if (data2 && length2)
+				writeraw (data2, length2, NULL, sub);
+		}
+	}
+	datacount++;
+	writeraw (lc5, sizeof (lc5), NULL, sub);
+	if (data1 && length1)
+		writeraw (data1, length1, NULL, sub);
+	if (((loopcount == 1) && (datacount < 5)) || ((loopcount == 2) &&
+				(datacount < 8)) || (( loopcount == 3) && (datacount < 11)) ||
+			((loopcount > 3) && (datacount < 15)))
+	{
+		writeraw (lc6, sizeof(lc6), NULL, sub);
+		if (data2 && length2)
+			writeraw (data2, length2, NULL, sub);
+	}
+	else
+	{
+		if (loopcount==1)
+		{
+			writeraw (lc6, sizeof(lc6), NULL, sub);
+			if (data2 && length2)
+				writeraw (data2, length2, NULL, sub);
+		}
+		loopcount++;
+		datacount=0;
+	}
+
+}
+
+void printdata (struct lib_cc_decode *ctx, const unsigned char *data1, int length1,
+                const unsigned char *data2, int length2, struct cc_subtitle *sub)
+{
+#ifndef MMCCXTR
+	if (ctx->write_format==CCX_OF_DVDRAW)
+		writeDVDraw (data1, length1, data2, length2, sub);
+	else /* Broadcast raw or any non-raw */
+#endif
+	{
+		if (length1 && ctx->extract != 2)
+		{
+			ctx->current_field = 1;
+			ctx->writedata(data1, length1, ctx, sub);
+		}
+		if (length2)
+		{
+			ctx->current_field = 2;
+			if (ctx->extract != 1)
+				ctx->writedata(data2, length2, ctx, sub);
+			else // User doesn't want field 2 data, but we want XDS.
+			{
+				ctx->writedata (data2, length2, ctx, sub);
+			}
+		}
+	}
+}
+
+/* Buffer data with the same FTS and write when a new FTS or data==NULL
+ * is encountered */
+void writercwtdata (struct lib_cc_decode *ctx, const unsigned char *data, struct cc_subtitle *sub)
+{
+	static LLONG prevfts = -1;
+	LLONG currfts = ctx->timing->fts_now + ctx->timing->fts_global;
+	static uint16_t cbcount = 0;
+	static int cbempty=0;
+	static unsigned char cbbuffer[0xFFFF*3]; // TODO: use malloc
+	static unsigned char cbheader[8+2];
+
+	if ( (prevfts != currfts && prevfts != -1)
+			|| data == NULL
+			|| cbcount == 0xFFFF)
+	{
+		// Remove trailing empty or 608 padding caption blocks
+		if ( cbcount != 0xFFFF)
+		{
+			unsigned char cc_valid;
+			unsigned char cc_type;
+			int storecbcount=cbcount;
+
+			for( int cb = cbcount-1; cb >= 0 ; cb-- )
+			{
+				cc_valid = (*(cbbuffer+3*cb) & 4) >>2;
+				cc_type = *(cbbuffer+3*cb) & 3;
+
+				// The -fullbin option disables pruning of 608 padding blocks
+				if ( (cc_valid && cc_type <= 1 // Only skip NTSC padding packets
+							&& !ctx->fullbin // Unless we want to keep them
+							&& *(cbbuffer+3*cb+1)==0x80
+							&& *(cbbuffer+3*cb+2)==0x80)
+						|| !(cc_valid || cc_type==3) ) // or unused packets
+				{
+					cbcount--;
+				}
+				else
+				{
+					cb = -1;
+				}
+			}
+			dbg_print(CCX_DMT_CBRAW, "%s Write %d RCWT blocks - skipped %d padding / %d unused blocks.\n",
+					print_mstime_static(prevfts), cbcount, storecbcount - cbcount, cbempty);
+		}
+
+		// New FTS, write data header
+		// RCWT data header (10 bytes):
+		//byte(s)   value   description
+		//0-7       FTS     int64_t number with current FTS
+		//8-9       blocks  Number of 3 byte data blocks with the same FTS that are
+		//                  following this header
+		memcpy(cbheader,&prevfts,8);
+		memcpy(cbheader+8,&cbcount,2);
+
+		if (cbcount > 0)
+		{
+			ctx->writedata(cbheader, 10, ctx->context_cc608_field_1, sub);
+			ctx->writedata(cbbuffer, 3 * cbcount, ctx->context_cc608_field_1, sub);
+		}
+		cbcount = 0;
+		cbempty = 0;
+	}
+
+	if ( data )
+	{
+		// Store the data while the FTS is unchanged
+
+		unsigned char cc_valid = (*data & 4) >> 2;
+		unsigned char cc_type = *data & 3;
+		// Store only non-empty packets
+		if (cc_valid || cc_type==3)
+		{
+			// Store in buffer until we know how many blocks come with
+			// this FTS.
+			memcpy(cbbuffer+cbcount*3, data, 3);
+			cbcount++;
+		}
+		else
+		{
+			cbempty++;
+		}
+	}
+	else
+	{
+		// Write a padding block for field 1 and 2 data if this is the final
+		// call to this function.  This forces the RCWT file to have the
+		// same length as the source video file.
+
+		// currfts currently holds the end time, subtract one block length
+		// so that the FTS corresponds to the time before the last block is
+		// written
+		currfts -= 1001/30;
+
+		memcpy(cbheader,&currfts,8);
+		cbcount = 2;
+		memcpy(cbheader+8,&cbcount,2);
+
+		memcpy(cbbuffer, "\x04\x80\x80", 3); // Field 1 padding
+		memcpy(cbbuffer+3, "\x05\x80\x80", 3); // Field 2 padding
+		ctx->writedata(cbheader, 10, ctx->context_cc608_field_1, sub);
+		ctx->writedata(cbbuffer, 3 * cbcount, ctx->context_cc608_field_1, sub);
+
+		cbcount = 0;
+		cbempty = 0;
+
+		dbg_print(CCX_DMT_CBRAW, "%s Write final padding RCWT blocks.\n",
+				print_mstime_static(currfts));
+	}
+
+	prevfts = currfts;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/params.c Added

@@ -0,0 +1,2642 @@
+#ifndef MMCCXTR
+#include "png.h"
+#include "protobuf-c.h"
+#include "zlib.h"
+#include "gpac/version.h"
+#endif
+#include "lib_ccx.h"
+#include "ccx_common_option.h"
+#include "utility.h"
+#include "activity.h"
+#include "ccx_encoders_helpers.h"
+#include "ccx_common_common.h"
+#include "ccx_decoders_708.h"
+#include "compile_info.h"
+#ifndef MMCCXTR
+#include "../lib_hash/sha2.h"
+#endif
+#include <string.h>
+#include <stdio.h>
+#ifndef MMCCXTR
+#include "utf8proc/utf8proc.h"
+#endif
+
+#ifdef ENABLE_OCR
+#include "tesseract/capi.h"
+#include "allheaders.h"
+#endif
+
+#ifdef ENABLE_HARDSUBX
+#include "hardsubx.h"
+#endif
+
+#ifndef MMCCXTR
+#ifdef _WIN32
+#define DEFAULT_FONT_PATH "C:\\Windows\\Fonts\\calibri.ttf"
+#elif __APPLE__ // MacOS
+#define DEFAULT_FONT_PATH "/System/Library/Fonts/Helvetica.ttc"
+#else // Assume Linux
+#define DEFAULT_FONT_PATH "/usr/share/fonts/truetype/noto/NotoSans-Regular.ttf"
+#endif
+#endif
+
+static int inputfile_capacity=0;
+
+int process_cap_file (char *filename)
+{
+	int ret = 0;
+	FILE *fi = fopen (filename,"rt");
+	if (fi == NULL)
+	{
+		mprint ("\rUnable to open capitalization file: %s\n", filename);
+		return -1;
+	}
+	char line[35]; // For screen width (32)+CRLF+0
+	int num = 0;
+	while (fgets (line,35,fi))
+	{
+		num++;
+		if (line[0] == '#') // Comment
+			continue;
+		char *c = line+strlen (line)-1;
+		while (c >= line && (*c == 0xd || *c == 0xa))
+		{
+			*c = 0;
+			c--;
+		}
+		if (strlen (line)>32)
+		{
+			mprint ("Word in line %d too long, max = 32 characters.\n",num);
+			ret = -1;
+			goto end;
+		}
+		if (strlen (line)>0)
+		{
+			if (add_word (line))
+			{
+				ret = -1;
+				goto end;
+			}
+		}
+	}
+end:
+	fclose (fi);
+	return ret;
+}
+int isanumber (char *s)
+{
+	while (*s)
+	{
+		if (!isdigit (*s))
+			return 0;
+		s++;
+	}
+	return 1;
+}
+
+int parsedelay (struct ccx_s_options *opt, char *par)
+{
+	int sign = 0;
+	char *c = par;
+	while (*c)
+	{
+		if (*c == '-' || *c == '+')
+		{
+			if (c != par) // Sign only at the beginning
+				return 1;
+			if (*c == '-')
+				sign = 1;
+		}
+		else
+		{
+			if (!isdigit (*c))
+				return 1;
+			opt->subs_delay = opt->subs_delay*10 + (*c-'0');
+		}
+		c++;
+	}
+	if (sign)
+		opt->subs_delay = -opt->subs_delay;
+	return 0;
+}
+
+int append_file_to_queue (struct ccx_s_options *opt,char *filename)
+{
+	if(filename[0] == '\0') //skip files with empty file name (ex : ./ccextractor "")
+		return 0;
+	char *c=(char *) malloc (strlen (filename)+1);
+	if (c==NULL)
+		return -1;
+	strcpy (c,filename);
+	if (inputfile_capacity<=opt->num_input_files)
+	{
+		inputfile_capacity+=10;
+		opt->inputfile=(char **) realloc (opt->inputfile,sizeof (char *) * inputfile_capacity);
+		if (opt->inputfile==NULL)
+		{
+			free(c);
+			return -1;
+		}
+	}
+	opt->inputfile[opt->num_input_files]=c;
+	opt->num_input_files++;
+	return 0;
+}
+
+#ifndef MMCCXTR
+int add_file_sequence (struct ccx_s_options *opt, char *filename)
+{
+	int m,n;
+	n = strlen (filename)-1;
+	// Look for the last digit in filename
+	while (n>=0 && !isdigit (filename[n]))
+		n--;
+	if (n==-1) // None. No expansion needed
+		return append_file_to_queue(opt, filename);
+	m=n;
+	while (m>=0 && isdigit (filename[m]))
+		m--;
+	m++;
+	// Here: Significant digits go from filename[m] to filename[n]
+	char *num = (char *) malloc (n-m+2);
+	if(!num)
+		return -1;
+	strncpy (num,filename+m, n-m+1);
+	num[n-m+1]=0;
+	int i = atoi (num);
+	char *temp = (char *) malloc (n-m+3); // For overflows
+	if(!temp)
+	{
+		free(num);
+		return -1;
+	}
+	// printf ("Expanding %d to %d, initial value=%d\n",m,n,i);
+	for (;;)
+	{
+		FILE *f=fopen (filename,"r");
+		if (f==NULL) // Doesn't exist or we can't read it. We're done
+			break;
+		fclose (f);
+		if (append_file_to_queue (opt, filename)) // Memory panic
+		{
+			free(num);
+			free(temp);
+			return -1;
+		}
+		i++;
+		sprintf (temp,"%d",i);
+		if (strlen (temp)>strlen (num)) // From 999 to 1000, etc.
+			break;
+		strncpy (filename+m+(strlen (num)-strlen (temp)),temp,strlen (temp));
+		memset (filename+m,'0',strlen (num)-strlen (temp));
+	}
+	free(num);
+	free(temp);
+	return 0;
+}
+#endif
+
+void set_output_format (struct ccx_s_options *opt, const char *format)
+{
+	opt->write_format_rewritten = 1;
+
+	while (*format=='-')
+		format++;
+
+	if (opt->send_to_srv && strcmp(format, "bin")!=0)
+	{
+		mprint("Output format is changed to bin\n");
+		format = "bin";
+	}
+
+	if (strcmp (format,"srt")==0)
+		opt->write_format=CCX_OF_SRT;
+#ifndef MMCCXTR
+	else if (strcmp (format,"ass")==0 || strcmp (format,"ssa")==0) {
+		opt->write_format = CCX_OF_SSA;
+		if (strcmp (format,"ass")==0)
+			opt->use_ass_instead_of_ssa = 1;
+	}
+	else if (strcmp(format, "webvtt")==0 || strcmp(format, "webvtt-full")==0) {
+		opt->write_format = CCX_OF_WEBVTT;
+		if (strcmp(format, "webvtt-full")==0)
+			opt->use_webvtt_styling = 1;
+	}
+	else if (strcmp(format, "sami") == 0 || strcmp(format, "smi") == 0)
+		opt->write_format=CCX_OF_SAMI;
+	else if (strcmp (format,"transcript")==0 || strcmp (format,"txt")==0)
+	{
+		opt->write_format=CCX_OF_TRANSCRIPT;
+		opt->settings_dtvcc.no_rollup = 1;
+	}
+	else if (strcmp (format,"timedtranscript")==0 || strcmp (format,"ttxt")==0)
+	{
+		opt->write_format=CCX_OF_TRANSCRIPT;
+		if (opt->date_format==ODF_NONE)
+			opt->date_format=ODF_HHMMSSMS;
+		// Sets the right things so that timestamps and the mode are printed.
+		if (!opt->transcript_settings.isFinal){
+			opt->transcript_settings.showStartTime = 1;
+			opt->transcript_settings.showEndTime = 1;
+			opt->transcript_settings.showCC = 0;
+			opt->transcript_settings.showMode = 1;
+		}
+	}
+	else if (strcmp (format,"report")==0)
+	{
+		opt->write_format            = CCX_OF_NULL;
+		opt->messages_target         = 0;
+		opt->print_file_reports      = 1;
+		opt->demux_cfg.ts_allprogram = CCX_TRUE;
+	}
+#endif
+	else if (strcmp (format,"raw")==0)
+		opt->write_format=CCX_OF_RAW;
+#ifndef MMCCXTR
+	else if (strcmp (format, "smptett")==0)
+		opt->write_format=CCX_OF_SMPTETT ;
+	else if (strcmp (format,"bin")==0)
+		opt->write_format=CCX_OF_RCWT;
+	else if (strcmp (format,"null")==0)
+		opt->write_format=CCX_OF_NULL;
+	else if (strcmp (format,"dvdraw")==0)
+		opt->write_format=CCX_OF_DVDRAW;
+	else if (strcmp (format,"spupng")==0)
+		opt->write_format=CCX_OF_SPUPNG;
+	else if (strcmp (format,"simplexml")==0)
+		opt->write_format=CCX_OF_SIMPLE_XML;
+	else if (strcmp (format,"g608")==0)
+		opt->write_format=CCX_OF_G608;
+#ifdef WITH_LIBCURL
+	else if (strcmp(format, "curl") == 0)
+		opt->write_format = CCX_OF_CURL;
+#endif
+#endif
+	else
+		fatal (EXIT_MALFORMED_PARAMETER, "Unknown output file format: %s\n", format);
+}
+
+void set_input_format (struct ccx_s_options *opt, const char *format)
+{
+	if (opt->input_source == CCX_DS_TCP && strcmp(format, "bin")!=0)
+	{
+		mprint("Input format is changed to bin\n");
+		format = "bin";
+	}
+
+	while (*format=='-')
+		format++;
+
+	if (strcmp (format,"es")==0) // Does this actually do anything?
+		opt->demux_cfg.auto_stream = CCX_SM_ELEMENTARY_OR_NOT_FOUND;
+#ifndef MMCCXTR
+	else if (strcmp(format, "ts") == 0)
+	{
+		opt->demux_cfg.auto_stream = CCX_SM_TRANSPORT;
+		opt->demux_cfg.m2ts = 0;
+	}
+	else if (strcmp(format, "m2ts") == 0)
+	{
+		opt->demux_cfg.auto_stream = CCX_SM_TRANSPORT;
+		opt->demux_cfg.m2ts = 1;
+	}
+	else if (strcmp (format,"ps")==0 || strcmp (format,"nots")==0)
+		opt->demux_cfg.auto_stream = CCX_SM_PROGRAM;
+	else if (strcmp (format,"asf")==0 || strcmp (format,"dvr-ms")==0)
+		opt->demux_cfg.auto_stream = CCX_SM_ASF;
+	else if (strcmp (format,"wtv")==0)
+		opt->demux_cfg.auto_stream = CCX_SM_WTV;
+	else if (strcmp (format,"raw")==0)
+		opt->demux_cfg.auto_stream = CCX_SM_MCPOODLESRAW;
+#endif
+	else if (strcmp (format,"bin")==0)
+		opt->demux_cfg.auto_stream = CCX_SM_RCWT;
+#ifndef MMCCXTR
+	else if (strcmp (format,"mp4")==0)
+		opt->demux_cfg.auto_stream = CCX_SM_MP4;
+	else if (strcmp (format,"mkv")==0)
+		opt->demux_cfg.auto_stream = CCX_SM_MKV;
+	else if (strcmp(format, "mxf") == 0)
+		opt->demux_cfg.auto_stream = CCX_SM_MXF;
+#ifdef WTV_DEBUG
+	else if (strcmp (format,"hex")==0)
+		opt->demux_cfg.auto_stream = CCX_SM_HEX_DUMP;
+#endif
+#endif
+	else
+		fatal (EXIT_MALFORMED_PARAMETER, "Unknown input file format: %s\n", format);
+}
+
+void print_usage (void)
+{
+	mprint ("Originally based on McPoodle's tools. Check his page for lots of information\n");
+	mprint ("on closed captions technical details.\n");
+	mprint ("(http://www.theneitherworld.com/mcpoodle/SCC_TOOLS/DOCS/SCC_TOOLS.HTML)\n\n");
+	mprint ("This tool home page:\n");
+	mprint ("http://www.ccextractor.org\n");
+	mprint ("  Extracts closed captions and teletext subtitles from video streams.\n");
+#ifndef MMCCXTR
+	mprint ("    (DVB, .TS, ReplayTV 4000 and 5000, dvr-ms, bttv, Tivo, Dish Network,\n");
+	mprint ("     .mp4, HDHomeRun are known to work).\n\n");
+	mprint ("  Syntax:\n");
+	mprint ("  ccextractor [options] inputfile1 [inputfile2...] [-o outputfilename]\n");
+	mprint ("\n");
+	mprint ("To see This Help Message: -h or --help\n\n");
+	mprint ("File name related options:\n");
+	mprint ("            inputfile: file(s) to process\n");
+	mprint ("    -o outputfilename: Use -o parameters to define output filename if you don't\n");
+	mprint ("                       like the default ones (same as infile plus _1 or _2 when\n");
+	mprint ("                       needed and file extension, e.g. .srt).\n");
+	mprint ("         -cf filename: Write 'clean' data to a file. Cleans means the ES\n");
+	mprint ("                       without TS or PES headers.\n");
+	mprint ("              -stdout: Write output to stdout (console) instead of file. If\n");
+	mprint ("                       stdout is used, then -o can't be used. Also\n");
+	mprint ("                       -stdout will redirect all messages to stderr (error).\n");
+	mprint ("           -pesheader: Dump the PES Header to stdout (console). This is\n");
+	mprint ("                       used for debugging purposes to see the contents\n");
+	mprint ("                       of each PES packet header.\n");
+	mprint ("         -debugdvbsub: Write the DVB subtitle debug traces to console.\n");
+	mprint ("      -ignoreptsjumps: Ignore PTS jumps (default).\n");
+	mprint ("         -fixptsjumps: fix pts jumps. Use this parameter if you\n");
+	mprint ("                       experience timeline resets/jumps in the output.\n");
+	mprint ("               -stdin: Reads input from stdin (console) instead of file.\n");
+	mprint ("You can pass as many input files as you need. They will be processed in order.\n");
+	mprint ("If a file name is suffixed by +, ccextractor will try to follow a numerical\n");
+	mprint ("sequence. For example, DVD001.VOB+ means DVD001.VOB, DVD002.VOB and so on\n");
+	mprint ("until there are no more files.\n");
+	mprint ("Output will be one single file (either raw or srt). Use this if you made your\n");
+	mprint ("recording in several cuts (to skip commercials for example) but you want one\n");
+	mprint ("subtitle file with contiguous timing.\n\n");
+	mprint ("Output file segmentation:\n");
+	mprint ("    -outinterval x output in interval of x seconds\n");
+	mprint ("   --segmentonkeyonly -key: When segmenting files, do it only after a I frame\n");
+	mprint ("                            trying to behave like FFmpeg\n\n");
+	mprint ("Network support:\n");
+	mprint ("            -udp port: Read the input via UDP (listening in the specified port)\n");
+	mprint ("                       instead of reading a file.\n\n");
+	mprint ("            -udp [host:]port: Read the input via UDP (listening in the specified\n");
+	mprint ("                              port) instead of reading a file. Host can be a\n");
+	mprint ("                              hostname or IPv4 address. If host is not specified\n");
+	mprint ("                              then listens on the local host.\n\n");
+	mprint ("            -udp [src@host:]port: Read the input via UDP (listening in the specified\n");
+	mprint ("                              port) instead of reading a file. Host and src can be a\n");
+	mprint ("                              hostname or IPv4 address. If host is not specified\n");
+	mprint ("                              then listens on the local host.\n\n");
+	mprint ("            -sendto host[:port]: Sends data in BIN format to the server\n");
+	mprint ("                                 according to the CCExtractor's protocol over\n");
+	mprint ("                                 TCP. For IPv6 use [address]:port\n");
+	mprint ("            -tcp port: Reads the input data in BIN format according to\n");
+	mprint ("                        CCExtractor's protocol, listening specified port on the\n");
+	mprint ("                        local host\n");
+	mprint ("            -tcppassword password: Sets server password for new connections to\n");
+	mprint ("                                   tcp server\n");
+	mprint ("            -tcpdesc description: Sends to the server short description about\n");
+	mprint ("                                  captions e.g. channel name or file name\n");
+	mprint ("Options that affect what will be processed:\n");
+	mprint ("          -1, -2, -12: Output Field 1 data, Field 2 data, or both\n");
+	mprint ("                       (DEFAULT is -1)\n");
+	mprint ("Use --append to prevent overwriting of existing files. The output will be\n");
+	mprint ("      appended instead.\n");
+	mprint ("                 -cc2: When in srt/sami mode, process captions in channel 2\n");
+	mprint ("                       instead of channel 1.\n");
+	mprint ("-svc --service N1[cs1],N2[cs2]...:\n");
+	mprint ("                       Enable CEA-708 (DTVCC) captions processing for the listed\n");
+	mprint ("                       services. The parameter is a comma delimited list\n");
+	mprint ("                       of services numbers, such as \"1,2\" to process the\n");
+	mprint ("                       primary and secondary language services.\n");
+	mprint ("                       Pass \"all\" to process all services found.\n");
+	mprint ("\n");
+	mprint ("                       If captions in a service are stored in 16-bit encoding,\n");
+	mprint ("                       you can specify what charset or encoding was used. Pass\n");
+	mprint ("                       its name after service number (e.g. \"1[EUC-KR],3\" or\n");
+	mprint ("                       \"all[EUC-KR]\") and it will encode specified charset to\n");
+	mprint ("                       UTF-8 using iconv. See iconv documentation to check if\n");
+	mprint ("                       required encoding/charset is supported.\n");
+	mprint ("\n");
+	mprint ("In general, if you want English subtitles you don't need to use these options\n");
+	mprint ("as they are broadcast in field 1, channel 1. If you want the second language\n");
+	mprint ("(usually Spanish) you may need to try -2, or -cc2, or both.\n\n");
+	mprint ("Input formats:\n");
+	mprint ("       With the exception of McPoodle's raw format, which is just the closed\n");
+	mprint ("       caption data with no other info, CCExtractor can usually detect the\n");
+	mprint ("       input format correctly. To force a specific format:\n\n");
+	mprint ("                  -in=format\n\n");
+	mprint ("       where format is one of these:\n");
+	mprint ("                       ts   -> For Transport Streams.\n");
+	mprint ("                       ps   -> For Program Streams.\n");
+	mprint ("                       es   -> For Elementary Streams.\n");
+	mprint ("                       asf  -> ASF container (such as DVR-MS).\n");
+	mprint ("                       wtv  -> Windows Television (WTV)\n");
+	mprint ("                       bin  -> CCExtractor's own binary format.\n");
+	mprint ("                       raw  -> For McPoodle's raw files.\n");
+	mprint ("                       mp4  -> MP4/MOV/M4V and similar.\n");
+	mprint ("                       m2ts -> BDAV MPEG-2 Transport Stream\n"); 
+	mprint ("                       mkv  -> Matroska container and WebM.\n");
+	mprint ("                       mxf  -> Material Exchange Format (MXF).\n");
+#ifdef WTV_DEBUG
+	mprint ("                       hex  -> Hexadecimal dump as generated by wtvccdump.\n");
+#endif
+	mprint ("       -ts, -ps, -es, -mp4, -wtv, -mkv and -asf/--dvr-ms can be used as shorts.\n\n");
+	mprint ("Output formats:\n\n");
+	mprint ("                 -out=format\n\n");
+	mprint ("       where format is one of these:\n");
+	mprint ("                      srt     -> SubRip (default, so not actually needed).\n");
+	mprint ("                      ass/ssa -> SubStation Alpha.\n");
+	mprint ("                      webvtt  -> WebVTT format\n");
+	mprint ("                      webvtt-full -> WebVTT format with styling\n");
+	mprint ("                      sami    -> MS Synchronized Accesible Media Interface.\n");
+	mprint ("                      bin     -> CC data in CCExtractor's own binary format.\n");
+	mprint ("                      raw     -> CC data in McPoodle's Broadcast format.\n");
+	mprint ("                      dvdraw  -> CC data in McPoodle's DVD format.\n");
+	mprint ("                      txt     -> Transcript (no time codes, no roll-up\n");
+	mprint ("                                 captions, just the plain transcription.\n");
+	mprint ("                      ttxt    -> Timed Transcript (transcription with time\n");
+	mprint ("                                 info)\n");
+	mprint ("                      g608    -> Grid 608 format.\n");
+#ifdef WITH_LIBCURL
+	mprint ("                      curl    -> POST plain transcription frame-by-frame to a\n");
+	mprint ("                                 URL specified by -curlposturl. Don't produce\n");
+	mprint ("                                 any file output.\n");
+#endif
+	mprint ("                      smptett -> SMPTE Timed Text (W3C TTML) format.\n");
+	mprint ("                      spupng  -> Set of .xml and .png files for use with\n");
+	mprint ("                                 dvdauthor's spumux.\n");
+	mprint ("                                 See \"Notes on spupng output format\"\n");
+	mprint ("                      null    -> Don't produce any file output\n");
+	mprint ("                      report  -> Prints to stdout information about captions\n");
+	mprint ("                                 in specified input. Don't produce any file\n");
+	mprint ("                                 output\n\n");
+	mprint ("       -srt, -dvdraw, -sami, -webvtt, -txt, -ttxt and -null can be used as shorts.\n\n");
+
+	mprint ("Options that affect how input files will be processed.\n");
+
+	mprint ("        -gt --goptime: Use GOP for timing instead of PTS. This only applies\n");
+	mprint ("                       to Program or Transport Streams with MPEG2 data and\n");
+	mprint ("                       overrides the default PTS timing.\n");
+	mprint ("                       GOP timing is always used for Elementary Streams.\n");
+	mprint ("    -nogt --nogoptime: Never use GOP timing (use PTS), even if ccextractor\n");
+	mprint ("                       detects GOP timing is the reasonable choice.\n");
+	mprint ("     -fp --fixpadding: Fix padding - some cards (or providers, or whatever)\n");
+	mprint ("                       seem to send 0000 as CC padding instead of 8080. If you\n");
+	mprint ("                       get bad timing, this might solve it.\n");
+	mprint ("               -90090: Use 90090 (instead of 90000) as MPEG clock frequency.\n");
+	mprint ("                       (reported to be needed at least by Panasonic DMR-ES15\n");
+	mprint ("                       DVD Recorder)\n");
+	mprint ("    -ve --videoedited: By default, ccextractor will process input files in\n");
+	mprint ("                       sequence as if they were all one large file (i.e.\n");
+	mprint ("                       split by a generic, non video-aware tool. If you\n");
+	mprint ("                       are processing video hat was split with a editing\n");
+	mprint ("                       tool, use -ve so ccextractor doesn't try to rebuild\n");
+	mprint ("                       the original timing.\n");
+	mprint ("   -s --stream [secs]: Consider the file as a continuous stream that is\n");
+	mprint ("                       growing as ccextractor processes it, so don't try\n");
+	mprint ("                       to figure out its size and don't terminate processing\n");
+	mprint ("                       when reaching the current end (i.e. wait for more\n");
+	mprint ("                       data to arrive). If the optional parameter secs is\n");
+	mprint ("                       present, it means the number of seconds without any\n");
+	mprint ("                       new data after which ccextractor should exit. Use\n");
+	mprint ("                       this parameter if you want to process a live stream\n");
+	mprint ("                       but not kill ccextractor externally.\n");
+	mprint ("                       Note: If -s is used then only one input file is\n");
+	mprint ("                       allowed.\n");
+	mprint ("  -poc  --usepicorder: Use the pic_order_cnt_lsb in AVC/H.264 data streams\n");
+	mprint ("                       to order the CC information.  The default way is to\n");
+	mprint ("                       use the PTS information.  Use this switch only when\n");
+	mprint ("                       needed.\n");
+	mprint ("                -myth: Force MythTV code branch.\n");
+	mprint ("              -nomyth: Disable MythTV code branch.\n");
+	mprint ("                       The MythTV branch is needed for analog captures where\n");
+	mprint ("                       the closed caption data is stored in the VBI, such as\n");
+	mprint ("                       those with bttv cards (Hauppage 250 for example). This\n");
+	mprint ("                       is detected automatically so you don't need to worry\n");
+	mprint ("                       about this unless autodetection doesn't work for you.\n");
+	mprint ("       -wtvconvertfix: This switch works around a bug in Windows 7's built in\n");
+	mprint ("                       software to convert *.wtv to *.dvr-ms. For analog NTSC\n");
+	mprint ("                       recordings the CC information is marked as digital\n");
+	mprint ("                       captions. Use this switch only when needed.\n");
+	mprint ("            -wtvmpeg2: Read the captions from the MPEG2 video stream rather\n");
+	mprint ("                       than the captions stream in WTV files\n");
+	mprint (" -pn --program-number: In TS mode, specifically select a program to process.\n");
+	mprint ("                       Not needed if the TS only has one. If this parameter\n");
+	mprint ("                       is not specified and CCExtractor detects more than one\n");
+	mprint ("                       program in the input, it will list the programs found\n");
+	mprint ("                       and terminate without doing anything, unless\n");
+	mprint ("                       -autoprogram (see below) is used.\n");
+	mprint ("         -autoprogram: If there's more than one program in the stream, just use\n");
+	mprint ("                       the first one we find that contains a suitable stream.\n");
+	mprint ("        -multiprogram: Uses multiple programs from the same input stream.\n");
+	mprint ("             -datapid: Don't try to find out the stream for caption/teletext\n");
+	mprint ("                       data, just use this one instead.\n");
+	mprint ("      -datastreamtype: Instead of selecting the stream by its PID, select it\n");
+	mprint ("                       by its type (pick the stream that has this type in\n");
+	mprint ("                       the PMT)\n");
+	mprint ("          -streamtype: Assume the data is of this type, don't autodetect. This\n");
+	mprint ("                       parameter may be needed if -datapid or -datastreamtype\n");
+	mprint ("                       is used and CCExtractor cannot determine how to process\n");
+	mprint ("                       the stream. The value will usually be 2 (MPEG video) or\n");
+	mprint ("                       6 (MPEG private data).\n");
+	mprint ("    -haup --hauppauge: If the video was recorder using a Hauppauge card, it\n");
+	mprint ("                       might need special processing. This parameter will\n");
+	mprint ("                       force the special treatment.\n");
+	mprint ("         -mp4vidtrack: In MP4 files the closed caption data can be embedded in\n");
+	mprint ("                       the video track or in a dedicated CC track. If a\n");
+	mprint ("                       dedicated track is detected it will be processed instead\n");
+	mprint ("                       of the video track. If you need to force the video track\n");
+	mprint ("                       to be processed instead use this option.\n");
+	mprint ("       -noautotimeref: Some streams come with broadcast date information. When\n");
+	mprint ("                       such data is available, CCExtractor will set its time\n");
+	mprint ("                       reference to the received data. Use this parameter if\n");
+	mprint ("                       you prefer your own reference. Note: Current this only\n");
+	mprint ("                       affects Teletext in timed transcript with -datets.\n");
+	mprint ("           --noscte20: Ignore SCTE-20 data if present.\n");
+	mprint ("  --webvtt-create-css: Create a separate file for CSS instead of inline.\n");
+	mprint ("              -deblev: Enable debug so the calculated distance for each two\n");
+	mprint ("                       strings is displayed. The output includes both strings,\n");
+	mprint ("                       the calculated distance, the maximum allowed distance,\n");
+	mprint ("                       and whether the strings are ultimately considered  \n");
+	mprint ("                       equivalent or not, i.e. the calculated distance is \n");
+	mprint ("                       less or equal than the max allowed..\n");
+	mprint ("-anvid --analyzevideo  Analyze the video stream even if it's not used for\n");
+	mprint ("                       subtitles. This allows to provide video information.\n");
+	mprint ("Levenshtein distance:\n\n");
+	mprint ("  When processing teletext files CCExtractor tries to correct typos by\n");
+	mprint ("  comparing consecutive lines. If line N+1 is almost identical to line N except\n");
+	mprint ("  for minor changes (plus next characters) then it assumes that line N that a\n");
+	mprint ("  typo that was corrected in N+1. This is currently implemented in teletext\n");
+	mprint ("  because it's where samples files that could benefit from this were available.\n");
+	mprint ("  You can adjust, or disable, the algorithm settings with the following\n");
+	mprint ("  parameters.\n\n");
+	mprint ("           -nolevdist: Don't attempt to correct typos with Levenshtein distance.\n");
+	mprint (" -levdistmincnt value: Minimum distance we always allow regardless\n");
+	mprint ("                       of the length of the strings.Default 2. \n");
+	mprint ("                       This means that if the calculated distance \n");
+   	mprint ("                       is 0,1 or 2, we consider the strings to be equivalent.\n");
+	mprint (" -levdistmaxpct value: Maximum distance we allow, as a percentage of\n");
+	mprint ("                       the shortest string length. Default 10%.\n");
+	mprint ("                       For example, consider a comparison of one string of \n");
+	mprint ("	                    30 characters and one of 60 characters. We want to \n");
+	mprint ("                       determine whether the first 30 characters of the longer\n");
+	mprint ("                       string are more or less the same as the shortest string,\n");
+	mprint ("	                    i.e. whether the longest string  is the shortest one\n");
+	mprint ("                       plus new characters and maybe some corrections. Since\n");
+	mprint ("                       the shortest string is 30 characters and  the default\n");
+	mprint ("                       percentage is 10%, we would allow a distance of up \n");
+	mprint ("                       to 3 between the first 30 characters.\n");
+	mprint ("\n");
+	mprint ("Options that affect what kind of output will be produced:\n");
+	mprint ("            -chapters: (Experimental) Produces a chapter file from MP4 files.\n");
+	mprint ("                       Note that this must only be used with MP4 files,\n");
+	mprint ("                       for other files it will simply generate subtitles file.\n");
+	mprint ("                 -bom: Append a BOM (Byte Order Mark) to output files.\n");
+	mprint ("                       Note that most text processing tools in linux will not\n");
+	mprint ("                       like BOM.\n");
+	mprint ("                       This is the default in Windows builds.\n");
+	mprint ("                       -nobom: Do not append a BOM (Byte Order Mark) to output\n");
+	mprint ("                       files. Note that this may break files when using\n");
+	mprint ("                       Windows. This is the default in non-Windows builds.\n");
+	mprint ("             -unicode: Encode subtitles in Unicode instead of Latin-1.\n");
+	mprint ("                -utf8: Encode subtitles in UTF-8 (no longer needed.\n");
+	mprint ("                       because UTF-8 is now the default).\n");
+	mprint ("              -latin1: Encode subtitles in Latin-1\n");
+	mprint ("  -nofc --nofontcolor: For .srt/.sami/.vtt, don't add font color tags.\n");
+	mprint ("  --nohtmlescape: For .srt/.sami/.vtt, don't covert html unsafe character\n");
+	mprint ("-nots --notypesetting: For .srt/.sami/.vtt, don't add typesetting tags.\n");
+	mprint ("                -trim: Trim lines.\n");
+	mprint ("   -dc --defaultcolor: Select a different default color (instead of\n");
+	mprint ("                       white). This causes all output in .srt/.smi/.vtt\n");
+	mprint ("                       files to have a font tag, which makes the files\n");
+	mprint ("                       larger. Add the color you want in RGB, such as\n");
+	mprint ("                       -dc #FF0000 for red.\n");
+	mprint ("    -sc --sentencecap: Sentence capitalization. Use if you hate\n");
+	mprint ("                       ALL CAPS in subtitles.\n");
+	mprint ("-sbs --splitbysentence: Split output text so each frame contains a complete\n");
+	mprint ("                       sentence. Timings are adjusted based on number of\n");
+	mprint ("                       characters\n.");
+	mprint ("  --capfile -caf file: Add the contents of 'file' to the list of words\n");
+	mprint ("                       that must be capitalized. For example, if file\n");
+	mprint ("                       is a plain text file that contains\n\n");
+	mprint ("                       Tony\n");
+	mprint ("                       Alan\n\n");
+	mprint ("                       Whenever those words are found they will be written\n");
+	mprint ("                       exactly as they appear in the file.\n");
+	mprint ("                       Use one line per word. Lines starting with # are\n");
+	mprint ("                       considered comments and discarded.\n\n");
+	mprint ("          -unixts REF: For timed transcripts that have an absolute date\n");
+	mprint ("                       instead of a timestamp relative to the file start), use\n");
+	mprint ("                       this time reference (UNIX timestamp). 0 => Use current\n");
+	mprint ("                       system time.\n");
+	mprint ("                       ccextractor will automatically switch to transport\n");
+	mprint ("                       stream UTC timestamps when available.\n");
+	mprint ("              -datets: In transcripts, write time as YYYYMMDDHHMMss,ms.\n");
+	mprint ("               -sects: In transcripts, write time as ss,ms\n");
+	mprint ("                -UCLA: Transcripts are generated with a specific format\n");
+	mprint ("                       that is convenient for a specific project, feel\n");
+	mprint ("                       free to play with it but be aware that this format\n");
+	mprint ("                       is really live - don't rely on its output format\n");
+	mprint ("                       not changing between versions.\n");
+    mprint ("            -latrusmap Map Latin symbols to Cyrillic ones in special cases\n");
+    mprint ("                       of Russian Teletext files (issue #1086)\n");
+    mprint ("                 -xds: In timed transcripts, all XDS information will be saved\n");
+	mprint ("                       to the output file.\n");
+	mprint ("                  -lf: Use LF (UNIX) instead of CRLF (DOS, Windows) as line\n");
+	mprint ("                       terminator.\n");
+	mprint ("            -autodash: Based on position on screen, attempt to determine\n");
+	mprint ("                       the different speakers and a dash (-) when each\n");
+	mprint ("                       of them talks (.srt/.vtt only, -trim required).\n");
+	mprint ("          -xmltv mode: produce an XMLTV file containing the EPG data from\n");
+	mprint ("                       the source TS file. Mode: 1 = full output\n");
+	mprint ("                       2 = live output. 3 = both\n");
+	mprint (" -xmltvliveinterval x: interval of x seconds between writing live mode xmltv output.\n");
+	mprint ("-xmltvoutputinterval x: interval of x seconds between writing full file xmltv output.\n");
+	mprint ("    -xmltvonlycurrent: Only print current events for xmltv output.\n");
+	mprint ("                 -sem: Create a .sem file for each output file that is open\n");
+	mprint ("                       and delete it on file close.\n");
+	mprint ("             -dvblang: For DVB subtitles, select which language's caption\n");
+	mprint ("                       stream will be processed. e.g. 'eng' for English.\n");
+	mprint ("                       If there are multiple languages, only this specified\n");
+	mprint ("                       language stream will be processed (default).\n");
+	mprint ("             -ocrlang: Manually select the name of the Tesseract .traineddata\n");
+	mprint ("                       file. Helpful if you want to OCR a caption stream of\n");
+	mprint ("                       one language with the data of another language.\n");
+	mprint ("                       e.g. '-dvblang chs -ocrlang chi_tra' will decode the\n");
+	mprint ("                       Chinese (Simplified) caption stream but perform OCR\n");
+	mprint ("                       using the Chinese (Traditional) trained data\n");
+	mprint ("                       This option is also helpful when the traineddata file\n");
+	mprint ("                       has non standard names that don't follow ISO specs\n");
+	mprint ("          -quant mode: How to quantize the bitmap before passing it to tesseract\n");
+	mprint ("                       for OCR'ing.\n");
+	mprint ("                       0: Don't quantize at all.\n");
+	mprint ("                       1: Use CCExtractor's internal function (default).\n");
+	mprint ("                       2: Reduce distinct color count in image for faster results.\n");
+	mprint ("                 -oem: Select the OEM mode for Tesseract, could be 0, 1 or 2.\n");
+	mprint ("                       0: OEM_TESSERACT_ONLY - default value, the fastest mode.\n");
+	mprint ("                       1: OEM_LSTM_ONLY - use LSTM algorithm for recognition.\n");
+	mprint ("                       2: OEM_TESSERACT_LSTM_COMBINED - both algorithms.\n");
+	mprint ("             -mkvlang: For MKV subtitles, select which language's caption\n");
+	mprint ("                       stream will be processed. e.g. 'eng' for English.\n");
+	mprint ("                       Language codes can be either the 3 letters bibliographic\n");
+	mprint ("                       ISO-639-2 form (like \"fre\" for french) or a language\n");
+	mprint ("                       code followed by a dash and a country code for specialities\n");
+	mprint ("                       in languages (like \"fre-ca\" for Canadian French).\n");
+	mprint ("          -nospupngocr When processing DVB don't use the OCR to write the text as\n");
+	mprint ("                       comments in the XML file.\n");
+	mprint ("                -font: Specify the full path of the font that is to be used when\n");
+	mprint ("                       generating SPUPNG files. If not specified, you need to\n");
+	mprint ("                       have the default font installed (Helvetica for macOS, Calibri\n");
+	mprint ("                       for Windows, and Noto for other operating systems at their\n)");
+	mprint ("                       default location\n)");
+	mprint ("\n");
+	mprint ("Options that affect how ccextractor reads and writes (buffering):\n");
+
+	mprint ("    -bi --bufferinput: Forces input buffering.\n");
+	mprint (" -nobi -nobufferinput: Disables input buffering.\n");
+	mprint (" -bs --buffersize val: Specify a size for reading, in bytes (suffix with K or\n");
+	mprint ("                       or M for kilobytes and megabytes). Default is 16M.\n");
+	mprint ("                 -koc: keep-output-close. If used then CCExtractor will close\n");
+	mprint ("                       the output file after writing each subtitle frame and\n");
+	mprint ("                       attempt to create it again when needed.\n");
+	mprint ("     -ff --forceflush: Flush the file buffer whenever content is written.\n");
+	mprint ("\n");
+
+	mprint ("Options that affect the built-in 608 closed caption decoder:\n");
+
+	mprint ("                 -dru: Direct Roll-Up. When in roll-up mode, write character by\n");
+	mprint ("                       character instead of line by line. Note that this\n");
+	mprint ("                       produces (much) larger files.\n");
+	mprint ("     -noru --norollup: If you hate the repeated lines caused by the roll-up\n");
+	mprint ("                       emulation, you can have ccextractor write only one\n");
+	mprint ("                       line at a time, getting rid of these repeated lines.\n");
+	mprint ("     -ru1 / ru2 / ru3: roll-up captions can consist of 2, 3 or 4 visible\n");
+	mprint ("                       lines at any time (the number of lines is part of\n");
+	mprint ("                       the transmission). If having 3 or 4 lines annoys\n");
+	mprint ("                       you you can use -ru to force the decoder to always\n");
+	mprint ("                       use 1, 2 or 3 lines. Note that 1 line is not\n");
+	mprint ("                       a real mode rollup mode, so CCExtractor does what\n");
+	mprint ("                       it can.\n");
+	mprint ("                       In -ru1 the start timestamp is actually the timestamp\n");
+	mprint ("                       of the first character received which is possibly more\n");
+	mprint ("                       accurate.\n");
+	mprint ("\n");
+
+	mprint ("Options that affect timing:\n");
+
+	mprint ("            -delay ms: For srt/sami/webvtt, add this number of milliseconds to\n");
+	mprint ("                       all times. For example, -delay 400 makes subtitles\n");
+	mprint ("                       appear 400ms late. You can also use negative numbers\n");
+	mprint ("                       to make subs appear early.\n");
+	mprint ("Notes on times: -startat and -endat times are used first, then -delay.\n");
+	mprint ("So if you use -srt -startat 3:00 -endat 5:00 -delay 120000, ccextractor will\n");
+	mprint ("generate a .srt file, with only data from 3:00 to 5:00 in the input file(s)\n");
+	mprint ("and then add that (huge) delay, which would make the final file start at\n");
+	mprint ("5:00 and end at 7:00.\n\n");
+
+	mprint ("Options that affect what segment of the input file(s) to process:\n");
+
+	mprint ("        -startat time: Only write caption information that starts after the\n");
+	mprint ("                       given time.\n");
+	mprint ("                       Time can be seconds, MM:SS or HH:MM:SS.\n");
+	mprint ("                       For example, -startat 3:00 means 'start writing from\n");
+	mprint ("                       minute 3.\n");
+	mprint ("          -endat time: Stop processing after the given time (same format as\n");
+	mprint ("                       -startat).\n");
+	mprint ("                       The -startat and -endat options are honored in all\n");
+	mprint ("                       output formats.  In all formats with timing information\n");
+	mprint ("                       the times are unchanged.\n");
+	mprint ("-scr --screenfuls num: Write 'num' screenfuls and terminate processing.\n\n");
+
+	mprint ("Options that affect which codec is to be used have to be searched in input\n");
+
+	mprint ("  If codec type is not selected then first elementary stream suitable for \n"
+			"  subtitle is selected, please consider -teletext -noteletext override this\n"
+			"  option.\n"
+			"      -codec dvbsub    select the dvb subtitle from all elementary stream,\n"
+			"                        if stream of dvb subtitle type is not found then \n"
+			"                        nothing is selected and no subtitle is generated\n"
+			"      -nocodec dvbsub   ignore dvb subtitle and follow default behaviour\n"
+			"      -codec teletext   select the teletext subtitle from elementary stream\n"
+			"      -nocodec teletext ignore teletext subtitle\n"
+			"  NOTE: option given in form -foo=bar ,-foo = bar and --foo=bar are invalid\n"
+			"        valid option are only in form -foo bar\n"
+			"        nocodec and codec parameter must not be same if found to be same \n"
+			"        then parameter of nocodec is ignored, this flag should be passed \n"
+			"        once, more then one are not supported yet and last parameter would \n"
+			"        taken in consideration\n");
+
+	mprint ("Adding start and end credits:\n");
+
+	mprint ("  CCExtractor can _try_ to add a custom message (for credits for example) at\n");
+	mprint ("  the start and end of the file, looking for a window where there are no\n");
+	mprint ("  captions. If there is no such window, then no text will be added.\n");
+	mprint ("  The start window must be between the times given and must have enough time\n");
+	mprint ("  to display the message for at least the specified time.\n");
+	mprint ("        --startcreditstext txt: Write this text as start credits. If there are\n");
+	mprint ("                                several lines, separate them with the\n");
+	mprint ("                                characters \\n, for example Line1\\nLine 2.\n");
+	mprint ("  --startcreditsnotbefore time: Don't display the start credits before this\n");
+	mprint ("                                time (S, or MM:SS). Default: %s\n", DEF_VAL_STARTCREDITSNOTBEFORE);
+	mprint ("   --startcreditsnotafter time: Don't display the start credits after this\n");
+	mprint ("                                time (S, or MM:SS). Default: %s\n", DEF_VAL_STARTCREDITSNOTAFTER);
+	mprint (" --startcreditsforatleast time: Start credits need to be displayed for at least\n");
+	mprint ("                                this time (S, or MM:SS). Default: %s\n", DEF_VAL_STARTCREDITSFORATLEAST);
+	mprint ("  --startcreditsforatmost time: Start credits should be displayed for at most\n");
+	mprint ("                                this time (S, or MM:SS). Default: %s\n", DEF_VAL_STARTCREDITSFORATMOST);
+	mprint ("          --endcreditstext txt: Write this text as end credits. If there are\n");
+	mprint ("                                several lines, separate them with the\n");
+	mprint ("                                characters \\n, for example Line1\\nLine 2.\n");
+	mprint ("   --endcreditsforatleast time: End credits need to be displayed for at least\n");
+	mprint ("                                this time (S, or MM:SS). Default: %s\n", DEF_VAL_ENDCREDITSFORATLEAST);
+	mprint ("    --endcreditsforatmost time: End credits should be displayed for at most\n");
+	mprint ("                                this time (S, or MM:SS). Default: %s\n", DEF_VAL_ENDCREDITSFORATMOST);
+	mprint ("\n");
+
+	mprint ("Options that affect debug data:\n");
+
+	mprint ("               -debug: Show lots of debugging output.\n");
+	mprint ("                 -608: Print debug traces from the EIA-608 decoder.\n");
+	mprint ("                       If you need to submit a bug report, please send\n");
+	mprint ("                       the output from this option.\n");
+	mprint ("                 -708: Print debug information from the (currently\n");
+	mprint ("                       in development) EIA-708 (DTV) decoder.\n");
+	mprint ("              -goppts: Enable lots of time stamp output.\n");
+	mprint ("            -xdsdebug: Enable XDS debug data (lots of it).\n");
+	mprint ("               -vides: Print debug info about the analysed elementary\n");
+	mprint ("                       video stream.\n");
+	mprint ("               -cbraw: Print debug trace with the raw 608/708 data with\n");
+	mprint ("                       time stamps.\n");
+	mprint ("              -nosync: Disable the syncing code.  Only useful for debugging\n");
+	mprint ("                       purposes.\n");
+	mprint ("             -fullbin: Disable the removal of trailing padding blocks\n");
+	mprint ("                       when exporting to bin format.  Only useful for\n");
+	mprint ("                       for debugging purposes.\n");
+	mprint ("          -parsedebug: Print debug info about the parsed container\n");
+	mprint ("                       file. (Only for TS/ASF files at the moment.)\n");
+	mprint ("            -parsePAT: Print Program Association Table dump.\n");
+	mprint ("            -parsePMT: Print Program Map Table dump.\n");
+	mprint("              -dumpdef: Hex-dump defective TS packets.\n");
+	mprint (" -investigate_packets: If no CC packets are detected based on the PMT, try\n");
+	mprint ("                       to find data in all packets by scanning.\n");
+#ifdef ENABLE_SHARING
+	mprint ("       -sharing-debug: Print extracted CC sharing service messages\n");
+#endif //ENABLE_SHARING
+	mprint("\n");
+
+
+	mprint ("Teletext related options:\n");
+
+	mprint ("          -tpage page: Use this page for subtitles (if this parameter\n");
+	mprint ("                       is not used, try to autodetect). In Spain the\n");
+	mprint ("                       page is always 888, may vary in other countries.\n");
+	mprint ("            -tverbose: Enable verbose mode in the teletext decoder.\n\n");
+	mprint ("            -teletext: Force teletext mode even if teletext is not detected.\n");
+	mprint ("                       If used, you should also pass -datapid to specify\n");
+	mprint ("                       the stream ID you want to process.\n");
+	mprint ("          -noteletext: Disable teletext processing. This might be needed\n");
+	mprint ("                       for video streams that have both teletext packets\n");
+	mprint ("                       and CEA-608/708 packets (if teletext is processed\n");
+	mprint ("                       then CEA-608/708 processing is disabled).\n");
+	mprint ("\n");
+
+	mprint ("Transcript customizing options:\n");
+
+	mprint ("    -customtxt format: Use the passed format to customize the (Timed) Transcript\n");
+	mprint ("                       output. The format must be like this: 1100100 (7 digits).\n");
+	mprint ("                       These indicate whether the next things should be\n");
+	mprint ("                       displayed or not in the (timed) transcript. They\n");
+	mprint ("                       represent (in order): \n");
+	mprint ("                           - Display start time\n");
+	mprint ("                           - Display end time\n");
+	mprint ("                           - Display caption mode\n");
+	mprint ("                           - Display caption channel\n");
+	mprint ("                           - Use a relative timestamp ( relative to the sample)\n");
+	mprint ("                           - Display XDS info\n");
+	mprint ("                           - Use colors\n");
+	mprint ("                       Examples:\n");
+	mprint ("                       0000101 is the default setting for transcripts\n");
+	mprint ("                       1110101 is the default for timed transcripts\n");
+	mprint ("                       1111001 is the default setting for -ucla\n");
+	mprint ("                       Make sure you use this parameter after others that might\n");
+	mprint ("                       affect these settings (-out, -ucla, -xds, -txt, \n");
+	mprint ("                       -ttxt ...)\n");
+
+	mprint ("\n");
+
+	mprint ("Communication with other programs and console output:\n");
+
+	mprint ("   --gui_mode_reports: Report progress and interesting events to stderr\n");
+	mprint ("                       in a easy to parse format. This is intended to be\n");
+	mprint ("                       used by other programs. See docs directory for.\n");
+	mprint ("                       details.\n");
+	mprint ("    --no_progress_bar: Suppress the output of the progress bar\n");
+	mprint ("               -quiet: Don't write any message.\n");
+	mprint ("\n");
+#ifdef ENABLE_SHARING
+	mprint ("Sharing extracted captions via TCP:\n");
+	mprint ("      -enable-sharing: Enables real-time sharing of extracted captions\n");
+	mprint ("         -sharing-url: Set url for sharing service in nanomsg format. Default: \"tcp://*:3269\"\n");
+	mprint ("\n");
+
+	mprint ("CCTranslate application integration:\n");
+	mprint ("           -translate: Enable Translation tool and set target languages\n");
+	mprint ("                       in csv format (e.g. -translate ru,fr,it\n");
+	mprint ("      -translate-auth: Set Translation Service authorization data to make translation possible\n");
+	mprint ("                       In case of Google Translate API - API Key\n");
+#endif //ENABLE_SHARING
+
+	mprint ("Notes on the CEA-708 decoder: While it is starting to be useful, it's\n");
+	mprint ("a work in progress. A number of things don't work yet in the decoder\n");
+	mprint ("itself, and many of the auxiliary tools (case conversion to name one)\n");
+	mprint ("won't do anything yet. Feel free to submit samples that cause problems\n");
+	mprint ("and feature requests.\n");
+	mprint ("\n");
+	mprint("Notes on spupng output format:\n");
+	mprint("One .xml file is created per output field. A set of .png files are created in\n");
+	mprint("a directory with the same base name as the corresponding .xml file(s), but with\n");
+	mprint("a .d extension. Each .png file will contain an image representing one caption\n");
+	mprint("and named subNNNN.png, starting with sub0000.png.\n");
+	mprint("For example, the command:\n");
+	mprint("    ccextractor -out=spupng input.mpg\n");
+	mprint("will create the files:\n");
+	mprint("    input.xml\n");
+	mprint("    input.d/sub0000.png\n");
+	mprint("    input.d/sub0001.png\n");
+	mprint("    ...\n");
+	mprint("The command:\n");
+	mprint("    ccextractor -out=spupng -o /tmp/output -12 input.mpg\n");
+	mprint("will create the files:\n");
+	mprint("    /tmp/output_1.xml\n");
+	mprint("    /tmp/output_1.d/sub0000.png\n");
+	mprint("    /tmp/output_1.d/sub0001.png\n");
+	mprint("    ...\n");
+	mprint("    /tmp/output_2.xml\n");
+	mprint("    /tmp/output_2.d/sub0000.png\n");
+	mprint("    /tmp/output_2.d/sub0001.png\n");
+	mprint("    ...\n");
+	mprint("\n");
+	mprint("Burned-in subtitle extraction:\n");
+	mprint("         -hardsubx : Enable the burned-in subtitle extraction subsystem.\n");
+	mprint("\n");
+	mprint("         NOTE: The following options will work only if -hardsubx is \n");
+	mprint("                specified before them:-\n");
+	mprint("\n");
+	mprint("       -tickertext : Search for burned-in ticker text at the bottom of\n");
+	mprint("                     the screen.\n");
+	mprint("\n");
+	mprint("         -ocr_mode : Set the OCR mode to either frame-wise, word-wise\n");
+	mprint("                     or letter wise.\n");
+	mprint("                     e.g. -ocr_mode frame (default), -ocr_mode word, \n");
+	mprint("                     -ocr_mode letter\n");
+	mprint("\n");
+	mprint("         -subcolor : Specify the color of the subtitles\n");
+	mprint("                     Possible values are in the set \n");
+	mprint("                     {white,yellow,green,cyan,blue,magenta,red}.\n");
+	mprint("                     Alternatively, a custom hue value between 1 and 360 \n");
+	mprint("                     may also be specified.\n");
+	mprint("                     e.g. -subcolor white or -subcolor 270 (for violet).\n");
+	mprint("                     Refer to an HSV color chart for values.\n");
+	mprint("\n");
+	mprint(" -min_sub_duration : Specify the minimum duration that a subtitle line \n");
+	mprint("                     must exist on the screen.\n");
+	mprint("                     The value is specified in seconds.\n");
+	mprint("                     A lower value gives better results, but takes more \n");
+	mprint("                     processing time.\n");
+	mprint("                     The recommended value is 0.5 (default).\n");
+	mprint("                     e.g. -min_sub_duration 1.0 (for a duration of 1 second)\n");
+	mprint("\n");
+	mprint("   -detect_italics : Specify whether italics are to be detected from the \n");
+	mprint("                     OCR text.\n");
+	mprint("                     Italic detection automatically enforces the OCR mode \n");
+	mprint("                     to be word-wise");
+	mprint("\n");
+	mprint("      -conf_thresh : Specify the classifier confidence threshold between\n");
+	mprint("                      1 and 100.\n");
+	mprint("                     Try and use a threshold which works for you if you get \n");
+	mprint("                     a lot of garbage text.\n");
+	mprint("                     e.g. -conf_thresh 50\n");
+	mprint("\n");
+	mprint(" -whiteness_thresh : For white subtitles only, specify the luminance \n");
+	mprint("                     threshold between 1 and 100\n");
+	mprint("                     This threshold is content dependent, and adjusting\n");
+	mprint("                     values may give you better results\n");
+	mprint("                     Recommended values are in the range 80 to 100.\n");
+	mprint("                     The default value is 95\n");
+	mprint("\n");
+	mprint("            An example command for burned-in subtitle extraction is as follows:\n");
+	mprint("               ccextractor video.mp4 -hardsubx -subcolor white -detect_italics \n");
+	mprint("                   -whiteness_thresh 90 -conf_thresh 60\n");
+#endif
+	mprint("\n");
+	mprint ("\n         --version : Display current CCExtractor version and detailed information.\n");
+}
+
+#ifndef MMCCXTR
+unsigned char sha256_buf[16384];
+
+char *calculateSHA256(char *location) {
+	int	size_read, bytes_read, fh = 0;
+	SHA256_CTX	ctx256;
+
+	SHA256_Init(&ctx256);
+
+	#ifdef _WIN32
+		fh = OPEN(location, O_RDONLY | O_BINARY);
+	#else
+		fh = OPEN(location, O_RDONLY);
+	#endif
+
+	if (fh < 0) {
+		return "Could not open file";
+	}
+	size_read = 0;
+	while ((bytes_read = read(fh, sha256_buf, 16384)) > 0) {
+		size_read += bytes_read;
+		SHA256_Update(&ctx256, (unsigned char*)sha256_buf, bytes_read);
+	}
+	close(fh);
+	SHA256_End(&ctx256, sha256_buf);
+	return sha256_buf;
+}
+#endif
+
+void version(char *location) {
+	char *leptversion;
+#ifndef MMCCXTR
+	char *hash = calculateSHA256(location);
+#endif
+	mprint("CCExtractor detailed version info\n");
+	mprint("	Version: %s\n", VERSION);
+#ifndef MMCCXTR
+	mprint("	Git commit: %s\n", GIT_COMMIT);
+	mprint("	Compilation date: %s\n", COMPILE_DATE);
+	mprint("	File SHA256: %s\n", hash);
+
+	mprint("Libraries used by CCExtractor\n");
+#ifdef ENABLE_OCR
+	mprint("	Tesseract Version: %s\n", (const char*)TessVersion());
+	leptversion = getLeptonicaVersion();
+	mprint("	Leptonica Version: %s\n", leptversion);
+	lept_free(leptversion);
+#endif
+	mprint("	libGPAC Version: %s\n", GPAC_VERSION);
+	mprint("	zlib: %s\n", ZLIB_VERSION);
+	mprint("	utf8proc Version: %s\n", (const char*) utf8proc_version());
+	mprint("	protobuf-c Version: %s\n", (const char*) protobuf_c_version());
+	mprint("	libpng Version: %s\n", PNG_LIBPNG_VER_STRING);
+	mprint("	FreeType \n");
+	mprint("	libhash\n");
+	mprint("	nuklear\n");
+	mprint("	libzvbi\n");
+
+#else
+#ifdef HAVE_BUILDINFO_H
+#include <gen_buildinfo.h>
+	mprint("	Platform: %s\n", BUILDINFO_ARCH_NAME);
+	mprint("	Compilation date: %s\n", BUILDINFO_BUILD_DATE);
+#endif
+	mprint("	This is a reduced-functionality version\n"
+		"	optimised for DVD closed captions transcoding.\n");
+#endif
+}
+
+#ifndef MMCCXTR
+void parse_708_services (struct ccx_s_options *opts, char *s)
+{
+	const char *all = "all";
+	size_t all_len = strlen(all);
+	int diff = strncmp(s, all, all_len);
+	if (!diff) {
+		size_t s_len = strlen(s);
+		char *charset = NULL;
+		if (s_len > all_len + 2) // '[' and ']'
+			charset = strndup(s + all_len + 1, s_len - all_len - 2);
+
+		opts->settings_dtvcc.enabled = 1;
+		opts->enc_cfg.dtvcc_extract = 1;
+		opts->enc_cfg.all_services_charset = charset;
+
+		opts->enc_cfg.services_charsets = (char **) calloc(sizeof(char *), CCX_DTVCC_MAX_SERVICES);
+		if (!opts->enc_cfg.services_charsets)
+			ccx_common_logging.fatal_ftn(EXIT_NOT_ENOUGH_MEMORY, "parse_708_services");
+		memset(opts->enc_cfg.services_charsets, 0, CCX_DTVCC_MAX_SERVICES * sizeof(char *));
+
+		for (int i = 0; i < CCX_DTVCC_MAX_SERVICES; i++)
+		{
+			opts->settings_dtvcc.services_enabled[i] = 1;
+			opts->enc_cfg.services_enabled[i] = 1;
+		}
+
+		opts->settings_dtvcc.active_services_count = CCX_DTVCC_MAX_SERVICES;
+		return;
+	}
+
+	char *c, *e, *l;
+	if (s == NULL)
+		return;
+	l = s + strlen(s);
+	for (c = s; c < l && *c; )
+	{
+		int svc = -1;
+		while (*c && !isdigit(*c))
+			c++;
+		if (!*c) // We're done
+			break;
+		e = c;
+		while (isdigit (*e))
+			e++;
+		int charset_start_found = (*e == '[');
+		*e = 0;
+		svc = atoi(c);
+		if (svc < 1 || svc > CCX_DTVCC_MAX_SERVICES)
+			fatal(EXIT_MALFORMED_PARAMETER,
+				   "[CEA-708] Malformed parameter: "
+						   "Invalid service number (%d), valid range is 1-%d.", svc, CCX_DTVCC_MAX_SERVICES);
+		opts->settings_dtvcc.services_enabled[svc - 1] = 1;
+		opts->enc_cfg.services_enabled[svc - 1] = 1;
+		opts->settings_dtvcc.enabled = 1;
+		opts->enc_cfg.dtvcc_extract = 1;
+		opts->settings_dtvcc.active_services_count++;
+
+		if (!opts->enc_cfg.services_charsets)
+		{
+			opts->enc_cfg.services_charsets = (char **) calloc(sizeof(char *), CCX_DTVCC_MAX_SERVICES);
+			if (!opts->enc_cfg.services_charsets)
+				ccx_common_logging.fatal_ftn(EXIT_NOT_ENOUGH_MEMORY, "parse_708_services");
+			memset(opts->enc_cfg.services_charsets, 0, CCX_DTVCC_MAX_SERVICES * sizeof(char *));
+		}
+
+		e = e + 1;
+		c = e;
+
+		if (!charset_start_found)
+			continue;
+
+		while (*e && *e != ']' && *e != ',')
+			e++;
+		if (*e == ']')
+		{
+			char *charset = strndup(c, e - c);
+			if (strlen(charset))
+				opts->enc_cfg.services_charsets[svc - 1] = charset;
+			c = e + 1;
+		}
+		else if (!*e)
+		{
+			fatal(EXIT_MALFORMED_PARAMETER,
+				   "[CEA-708] Malformed parameter: missing closing ] in CEA-708 services list");
+		}
+	}
+	if (!opts->settings_dtvcc.active_services_count)
+		fatal(EXIT_MALFORMED_PARAMETER,
+			  "[CEA-708] Malformed parameter: no services");
+}
+#endif
+
+long atol_size (char *s)
+{
+	long val=atoi (s);
+	if (toupper (s[strlen (s)-1])=='M')
+		val=val*1024*1024;
+	else if (toupper (s[strlen (s)-1])=='K')
+		val=val*1024;
+	return val;
+}
+
+int atoi_hex (char *s)
+{
+	if (strlen (s)>2 && s[0]=='0' && (s[1]=='x' || s[1]=='X'))
+	{
+		// Hexadecimal
+		return strtol(s+2, NULL, 16);
+	}
+	else
+	{
+		return atoi (s);
+	}
+}
+
+#ifndef MMCCXTR
+void mkvlang_params_check(char* lang){
+	int initial=0, present=0;
+	for(int char_index=0; char_index < strlen(lang);char_index++){
+			lang[char_index] = cctolower(lang[char_index]);
+			if (lang[char_index]==','){
+					present=char_index;
+					if ((present-initial<6)&&(present-initial!=3))
+							fatal(EXIT_MALFORMED_PARAMETER, "language codes should be xxx,xxx,xxx,....\n");
+
+					else if ((present-initial>3)&&(present-initial!=6))
+						fatal(EXIT_MALFORMED_PARAMETER, "language codes should be xxx-xx,xxx-xx,xxx-xx,....\n");
+
+					if ((present-initial>3)&&(present-initial==6)){
+						size_t length = present-initial;
+						char* block=calloc(length+1,sizeof(char));
+						strncpy(block,lang+initial,length);
+						char* hiphen_pointer = strstr(block,"-");
+						if (!hiphen_pointer)
+								fatal(EXIT_MALFORMED_PARAMETER, "language code is not of the form xxx-xx\n");
+						free(block);
+						}
+					initial=present+1;
+				}
+			}
+
+	//Steps to check for the last lang of multiple mkvlangs provided by the user.
+	present = strlen(lang)-1;
+
+	for(int char_index=strlen(lang)-1; char_index >=0 ;char_index--)
+		if (lang[char_index]==','){
+			initial=char_index+1;
+			break;
+		}
+
+	if ((present-initial<5)&&(present-initial!=2))
+		fatal(EXIT_MALFORMED_PARAMETER, "last language code should be xxx.\n");
+
+	else if ((present-initial>2)&&(present-initial!=5))
+		fatal(EXIT_MALFORMED_PARAMETER, "last language code should be xxx-xx.\n");
+
+	if ((present-initial>2)&&(present-initial==5)){
+					size_t length = present-initial;
+					char* block=calloc(length+1,sizeof(char));
+					strncpy(block,lang+initial,length);
+					char* hiphen_pointer = strstr(block,"-");
+					if (!hiphen_pointer)
+							fatal(EXIT_MALFORMED_PARAMETER, "last language code is not of the form xxx-xx\n");
+					free(block);
+					}
+}
+
+#endif
+
+int parse_parameters (struct ccx_s_options *opt, int argc, char *argv[])
+{
+	// Parse parameters
+	for (int i=1; i<argc; i++)
+	{
+		if (!strcmp (argv[i],"--help") || !strcmp(argv[i], "-h"))
+		{
+			print_usage();
+			return EXIT_WITH_HELP;
+		}
+		if (!strcmp(argv[i], "--version"))
+		{
+			version(argv[0]);
+			return EXIT_WITH_HELP;
+		}
+		if (strcmp (argv[i], "-")==0 || strcmp(argv[i], "-stdin") == 0)
+		{
+#ifdef WIN32
+			setmode(fileno(stdin), O_BINARY);
+#endif
+			opt->input_source=CCX_DS_STDIN;
+			if (!opt->live_stream) opt->live_stream=-1;
+			continue;
+		}
+		if (argv[i][0]!='-')
+		{
+			int rc;
+			if (argv[i][strlen (argv[i])-1]!='+')
+			{
+				rc=append_file_to_queue (opt, argv[i]);
+			}
+			else
+			{
+#ifndef MMCCXTR
+				argv[i][strlen (argv[i])-1]=0;
+				rc=add_file_sequence (opt, argv[i]);
+#else
+				rc=-1;
+#endif
+			}
+			if (rc)
+			{
+				fatal (EXIT_NOT_ENOUGH_MEMORY, "Fatal: Not enough memory to parse parameters.\n");
+			}
+			continue;
+		}
+
+#ifdef ENABLE_HARDSUBX
+		// Parse -hardsubx and related parameters
+		if (strcmp(argv[i], "-hardsubx")==0)
+		{
+			opt->hardsubx = 1;
+			continue;
+		}
+		if (opt->hardsubx == 1)
+		{
+			if (strcmp(argv[i], "-ocr_mode")==0)
+			{
+				if(i < argc - 1)
+				{
+					if(strcmp(argv[i+1], "simple")==0 || strcmp(argv[i+1], "frame")==0)
+					{
+						opt->hardsubx_ocr_mode = HARDSUBX_OCRMODE_FRAME;
+					}
+					else if(strcmp(argv[i+1], "word")==0)
+					{
+						opt->hardsubx_ocr_mode = HARDSUBX_OCRMODE_WORD;
+					}
+					else if(strcmp(argv[i+1], "letter")==0 || strcmp(argv[i+1], "symbol")==0)
+					{
+						opt->hardsubx_ocr_mode = HARDSUBX_OCRMODE_LETTER;
+					}
+					else
+					{
+						fatal (EXIT_MALFORMED_PARAMETER, "-ocr_mode has an invalid value.\nValid values are {frame,word,letter}");
+					}
+				}
+				else
+				{
+					fatal (EXIT_MALFORMED_PARAMETER, "-ocr_mode has no argument.\nValid values are {frame,word,letter}");
+				}
+				i++;
+				continue;
+			}
+			if (strcmp(argv[i], "-subcolor")==0 || strcmp(argv[i], "-sub_color")==0)
+			{
+				if(i < argc - 1)
+				{
+					if(strcmp(argv[i+1], "white")==0)
+					{
+						opt->hardsubx_subcolor = HARDSUBX_COLOR_WHITE;
+						opt->hardsubx_hue = 0.0;
+					}
+					else if(strcmp(argv[i+1], "yellow")==0)
+					{
+						opt->hardsubx_subcolor = HARDSUBX_COLOR_YELLOW;
+						opt->hardsubx_hue = 60.0;
+					}
+					else if(strcmp(argv[i+1], "green")==0)
+					{
+						opt->hardsubx_subcolor = HARDSUBX_COLOR_GREEN;
+						opt->hardsubx_hue = 120.0;
+					}
+					else if(strcmp(argv[i+1], "cyan")==0)
+					{
+						opt->hardsubx_subcolor = HARDSUBX_COLOR_CYAN;
+						opt->hardsubx_hue = 180.0;
+					}
+					else if(strcmp(argv[i+1], "blue")==0)
+					{
+						opt->hardsubx_subcolor = HARDSUBX_COLOR_BLUE;
+						opt->hardsubx_hue = 240.0;
+					}
+					else if(strcmp(argv[i+1], "magenta")==0)
+					{
+						opt->hardsubx_subcolor = HARDSUBX_COLOR_MAGENTA;
+						opt->hardsubx_hue = 300.0;
+					}
+					else if(strcmp(argv[i+1], "red")==0)
+					{
+						opt->hardsubx_subcolor = HARDSUBX_COLOR_RED;
+						opt->hardsubx_hue = 0.0;
+					}
+					else
+					{
+						// Take a custom hue from the user
+						opt->hardsubx_subcolor = HARDSUBX_COLOR_CUSTOM;
+						char *str=(char*)malloc(sizeof(argv[i+1]));
+						sprintf(str,"%s", argv[i+1]); // Done this way to avoid error with getting (i+1)th env variable
+						opt->hardsubx_hue = atof(str);
+						if(opt->hardsubx_hue <= 0.0 || opt->hardsubx_hue > 360.0)
+						{
+							fatal (EXIT_MALFORMED_PARAMETER, "-subcolor has either 0 or an invalid hue value supplied.\nIf you want to detect red subtitles, pass '-subcolor red' or a slightly higher hue value (e.g. 0.1)\n");
+						}
+					}
+				}
+				else
+				{
+					fatal (EXIT_MALFORMED_PARAMETER, "-subcolor has no argument.\nValid values are {white,yellow,green,cyan,blue,magenta,red} or a custom hue value between 0 and 360\n");
+				}
+				i++;
+				continue;
+			}
+			if (strcmp(argv[i], "-min_sub_duration")==0)
+			{
+				if(i < argc - 1)
+				{
+					char *str=(char*)malloc(sizeof(argv[i+1]));
+					sprintf(str,"%s", argv[i+1]); // Done this way to avoid error with getting (i+1)th env variable
+					opt->hardsubx_min_sub_duration = atof(str);
+					if(opt->hardsubx_min_sub_duration == 0.0)
+					{
+						fatal (EXIT_MALFORMED_PARAMETER, "-min_sub_duration has either 0 or an invalid value supplied\n");
+					}
+				}
+				else
+				{
+					fatal (EXIT_MALFORMED_PARAMETER, "-min_sub_duration has no argument.");
+				}
+				i++;
+				continue;
+			}
+			if (strcmp(argv[i], "-detect_italics")==0)
+			{
+				opt->hardsubx_detect_italics = 1;
+				continue;
+			}
+			if (strcmp(argv[i], "-conf_thresh")==0)
+			{
+				if(i < argc - 1)
+				{
+					char *str=(char*)malloc(sizeof(argv[i+1]));
+					sprintf(str,"%s", argv[i+1]); // Done this way to avoid error with getting (i+1)th env variable
+					opt->hardsubx_conf_thresh = atof(str);
+					if(opt->hardsubx_conf_thresh <= 0.0 || opt->hardsubx_conf_thresh > 100.0)
+					{
+						fatal (EXIT_MALFORMED_PARAMETER, "-conf_thresh has either 0 or an invalid value supplied\nValid values are in (0.0,100.0)");
+					}
+				}
+				else
+				{
+					fatal (EXIT_MALFORMED_PARAMETER, "-conf_thresh has no argument.");
+				}
+				i++;
+				continue;
+			}
+			if (strcmp(argv[i], "-whiteness_thresh")==0 || strcmp(argv[i], "-lum_thresh")==0)
+			{
+				if(i < argc - 1)
+				{
+					char *str=(char*)malloc(sizeof(argv[i+1]));
+					sprintf(str,"%s", argv[i+1]); // Done this way to avoid error with getting (i+1)th env variable
+					opt->hardsubx_lum_thresh = atof(str);
+					if(opt->hardsubx_lum_thresh <= 0.0 || opt->hardsubx_conf_thresh > 100.0)
+					{
+						fatal (EXIT_MALFORMED_PARAMETER, "-whiteness_thresh has either 0 or an invalid value supplied\nValid values are in (0.0,100.0)");
+					}
+				}
+				else
+				{
+					fatal (EXIT_MALFORMED_PARAMETER, "-whiteness_thresh has no argument.");
+				}
+				i++;
+				continue;
+			}
+		}
+#endif
+
+#if defined(MMCCXTR) && defined(WIN32)
+		if (strcmp(argv[i], "-debugbreak") == 0){
+			__debugbreak();
+			continue;
+		}
+#endif
+		if (strcmp(argv[i], "-chapters") == 0){
+			opt->extract_chapters= 1;
+			continue;
+		}
+
+		if (strcmp (argv[i],"-bi")==0 ||
+				strcmp (argv[i],"--bufferinput")==0)
+		{
+			opt->buffer_input = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-nobi")==0 ||
+				strcmp (argv[i],"--nobufferinput")==0)
+		{
+			opt->buffer_input = 0;
+			continue;
+		}
+		if (strcmp(argv[i], "-koc") == 0)
+		{
+			opt->keep_output_closed = 1;
+			continue;
+		}
+		if (strcmp(argv[i], "-ff") == 0 || strcmp(argv[i], "--forceflush") == 0)
+		{
+			opt->force_flush = 1;
+			continue;
+		}
+		if (strcmp(argv[i], "--append") == 0)
+		{
+			opt->append_mode = 1;
+			continue;
+		}
+		if ((strcmp (argv[i],"-bs")==0 || strcmp (argv[i],"--buffersize")==0) && i<argc-1)
+		{
+			FILEBUFFERSIZE = atol_size(argv[i+1]);
+			if (FILEBUFFERSIZE<8)
+				FILEBUFFERSIZE=8; // Otherwise crashes are guaranteed at least in MythTV
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-dru")==0)
+		{
+			opt->settings_608.direct_rollup = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-nofc")==0 ||
+				strcmp (argv[i],"--nofontcolor")==0)
+		{
+			opt->nofontcolor=1;
+			continue;
+		}
+		if (strcmp (argv[i],"--nohtmlescape")==0)
+		{
+			opt->nohtmlescape=1;
+			continue;
+		}
+		if (strcmp(argv[i], "-bom") == 0){
+			opt->enc_cfg.no_bom = 0;
+			continue;
+		}
+		if (strcmp(argv[i], "-nobom") == 0){
+			opt->enc_cfg.no_bom = 1;
+			continue;
+		}
+		if (strcmp(argv[i], "-sem") == 0){
+			opt->enc_cfg.with_semaphore = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-nots")==0 ||
+				strcmp (argv[i],"--notypesetting")==0)
+		{
+			opt->notypesetting=1;
+			continue;
+		}
+
+		/* Input file formats */
+		if ( strcmp (argv[i],"-es")==0 ||
+			strcmp (argv[i],"-ts")==0 ||
+			strcmp (argv[i],"-ps")==0 ||
+			strcmp (argv[i],"-nots")==0 ||
+			strcmp (argv[i],"-asf")==0 ||
+			strcmp (argv[i],"-wtv")==0 ||
+			strcmp (argv[i],"-mp4")==0 ||
+			strcmp (argv[i],"-mkv")==0 ||
+			strcmp (argv[i],"--dvr-ms")==0 )
+		{
+			set_input_format (opt, argv[i]);
+			continue;
+		}
+		if (strncmp (argv[i],"-in=", 4)==0)
+		{
+			set_input_format (opt, argv[i]+4);
+			continue;
+		}
+
+		/*user specified subtitle to be selected */
+
+		if(!strcmp (argv[i],"-codec") && i < argc - 1)
+		{
+			i++;
+			if(!strcmp (argv[i],"teletext"))
+			{
+				opt->demux_cfg.codec = CCX_CODEC_TELETEXT;
+			}
+			else if(!strcmp (argv[i],"dvbsub"))
+			{
+				opt->demux_cfg.codec = CCX_CODEC_DVB;
+			}
+			else
+			{
+				mprint("Invalid option for codec %s\n",argv[i]);
+			}
+			continue;
+		}
+		/*user specified subtitle to be selected */
+
+		if(!strcmp (argv[i],"-nocodec") && i < argc - 1)
+		{
+			i++;
+			if(!strcmp (argv[i],"teletext"))
+			{
+				opt->demux_cfg.nocodec = CCX_CODEC_TELETEXT;
+			}
+			else if(!strcmp (argv[i],"dvbsub"))
+			{
+				opt->demux_cfg.nocodec = CCX_CODEC_DVB;
+			}
+			else
+			{
+				mprint("Invalid option for codec %s\n",argv[i]);
+			}
+			continue;
+		}
+
+		if(strcmp(argv[i],"-dvblang")==0 && i < argc-1)
+		{
+			i++;
+			opt->dvblang = (char *)malloc(sizeof(argv[i]));
+			sprintf(opt->dvblang,"%s",argv[i]);
+			for(int char_index=0; char_index < strlen(opt->dvblang);char_index++)
+				opt->dvblang[char_index] = cctolower(opt->dvblang[char_index]);
+			continue;
+		}
+
+		if(strcmp(argv[i],"-ocrlang")==0 && i < argc-1)
+		{
+			i++;
+			opt->ocrlang = (char *)malloc(sizeof(argv[i]));
+			sprintf(opt->ocrlang,"%s",argv[i]);
+			for(int char_index=0; char_index < strlen(opt->ocrlang);char_index++)
+				opt->ocrlang[char_index] = cctolower(opt->ocrlang[char_index]);
+			continue;
+		}
+		if (strcmp(argv[i], "-quant") == 0 && i < argc - 1)
+		{
+			i++;
+			opt->ocr_quantmode = atoi(argv[i]);
+			continue;
+		}
+		if (strcmp(argv[i], "-nospupngocr") == 0)
+		{
+			opt->enc_cfg.nospupngocr = 1;
+			continue;
+		}
+
+
+		if (strcmp(argv[i], "-oem") == 0)
+		{
+			if (i < argc - 1)
+			{
+				char *str = (char*)malloc(sizeof(argv[i + 1]));
+				sprintf(str, "%s", argv[i + 1]);
+				opt->ocr_oem = atoi(str);
+				if (opt->ocr_oem < 0 || opt->ocr_oem > 2)
+				{
+					fatal(EXIT_MALFORMED_PARAMETER, "-oem must be 0, 1 or 2\n");
+				}
+			}
+			else
+			{
+				fatal(EXIT_MALFORMED_PARAMETER, "-oem has no argument.");
+			}
+			i++;
+			continue;
+		}
+
+#ifndef MMCCXTR
+		if(strcmp(argv[i],"-mkvlang")==0 && i < argc-1)
+		{
+			i++;
+			opt->mkvlang = (char *)malloc(sizeof(argv[i]));
+			sprintf(opt->mkvlang,"%s",argv[i]);
+			mkvlang_params_check(opt->mkvlang);
+			continue;
+		}
+#endif
+
+		/* Output file formats */
+		if (strcmp (argv[i],"-srt")==0 ||
+				strcmp (argv[i],"-dvdraw")==0 ||
+				strcmp(argv[i], "-sami") == 0 || strcmp(argv[i], "-smi") == 0 || strcmp(argv[i], "-webvtt") == 0 ||
+				strcmp (argv[i],"--transcript")==0 || strcmp (argv[i],"-txt")==0 ||
+				strcmp (argv[i],"--timedtranscript")==0 || strcmp (argv[i],"-ttxt")==0 ||
+				strcmp (argv[i],"-null")==0)
+		{
+			set_output_format (opt, argv[i]);
+			continue;
+		}
+		if (strncmp (argv[i],"-out=", 5)==0)
+		{
+			set_output_format (opt, argv[i]+5);
+			continue;
+		}
+
+		/* Credit stuff */
+		if ((strcmp (argv[i],"--startcreditstext")==0)
+				&& i<argc-1)
+		{
+			opt->enc_cfg.start_credits_text=argv[i+1];
+			i++;
+			continue;
+		}
+		if ((strcmp (argv[i],"--startcreditsnotbefore")==0)
+				&& i<argc-1)
+		{
+			if (stringztoms (argv[i+1],&opt->enc_cfg.startcreditsnotbefore)==-1)
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "--startcreditsnotbefore only accepts SS, MM:SS or HH:MM:SS\n");
+			}
+			i++;
+			continue;
+		}
+		if ((strcmp (argv[i],"--startcreditsnotafter")==0)
+				&& i<argc-1)
+		{
+			if (stringztoms (argv[i+1],&opt->enc_cfg.startcreditsnotafter)==-1)
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "--startcreditsnotafter only accepts SS, MM:SS or HH:MM:SS\n");
+			}
+			i++;
+			continue;
+		}
+		if ((strcmp (argv[i],"--startcreditsforatleast")==0)
+				&& i<argc-1)
+		{
+			if (stringztoms (argv[i+1],&opt->enc_cfg.startcreditsforatleast)==-1)
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "--startcreditsforatleast only accepts SS, MM:SS or HH:MM:SS\n");
+			}
+			i++;
+			continue;
+		}
+		if ((strcmp (argv[i],"--startcreditsforatmost")==0)
+				&& i<argc-1)
+		{
+			if (stringztoms (argv[i+1],&opt->enc_cfg.startcreditsforatmost)==-1)
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "--startcreditsforatmost only accepts SS, MM:SS or HH:MM:SS\n");
+			}
+			i++;
+			continue;
+		}
+
+		if  ((strcmp (argv[i],"--endcreditstext")==0 )
+				&& i<argc-1)
+		{
+			opt->enc_cfg.end_credits_text=argv[i+1];
+			i++;
+			continue;
+		}
+		if ((strcmp (argv[i],"--endcreditsforatleast")==0)
+				&& i<argc-1)
+		{
+			if (stringztoms (argv[i+1],&opt->enc_cfg.endcreditsforatleast)==-1)
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "--endcreditsforatleast only accepts SS, MM:SS or HH:MM:SS\n");
+			}
+			i++;
+			continue;
+		}
+		if ((strcmp (argv[i],"--endcreditsforatmost")==0)
+				&& i<argc-1)
+		{
+			if (stringztoms (argv[i+1],&opt->enc_cfg.endcreditsforatmost)==-1)
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "--startcreditsforatmost only accepts SS, MM:SS or HH:MM:SS\n");
+			}
+			i++;
+			continue;
+		}
+
+		/* More stuff */
+		if (strcmp (argv[i],"-ve")==0 ||
+				strcmp (argv[i],"--videoedited")==0)
+		{
+			opt->binary_concat=0;
+			continue;
+		}
+		if (strcmp (argv[i],"-12")==0)
+		{
+			opt->extract = 12;
+			continue;
+		}
+		if (strcmp (argv[i],"-gt")==0 ||
+				strcmp (argv[i],"--goptime")==0)
+		{
+			opt->use_gop_as_pts = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-nogt")==0 ||
+				strcmp (argv[i],"--nogoptime")==0)
+		{
+			opt->use_gop_as_pts = -1; // Don't use even if we would want to
+			continue;
+		}
+		if (strcmp (argv[i],"-fp")==0 ||
+				strcmp (argv[i],"--fixpadding")==0)
+		{
+			opt->fix_padding = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-90090")==0)
+		{
+			MPEG_CLOCK_FREQ=90090;
+			continue;
+		}
+		if (strcmp (argv[i],"--noscte20")==0)
+		{
+			opt->noscte20 = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"--webvtt-create-css")==0)
+		{
+			opt->webvtt_create_css = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-noru")==0 ||
+				strcmp (argv[i],"--norollup")==0)
+		{
+			opt->no_rollup = 1;
+			opt->settings_608.no_rollup = 1;
+			opt->settings_dtvcc.no_rollup = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-ru1")==0)
+		{
+			opt->settings_608.force_rollup = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-ru2")==0)
+		{
+			opt->settings_608.force_rollup = 2;
+			continue;
+		}
+		if (strcmp (argv[i],"-ru3")==0)
+		{
+			opt->settings_608.force_rollup = 3;
+			continue;
+		}
+		if (strcmp (argv[i],"-trim")==0)
+		{
+			opt->enc_cfg.trim_subs=1;
+			continue;
+		}
+		if (strcmp (argv[i],"-outinterval")==0 && i<argc-1)
+		{
+			opt->out_interval = atoi(argv[i+1]);
+			i++;
+			continue;
+		}
+		if (strcmp(argv[i], "--segmentonkeyonly") == 0 || strcmp(argv[i], "-key") == 0)
+		{
+			opt->segment_on_key_frames_only = 1;
+			opt->analyze_video_stream = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"--gui_mode_reports")==0)
+		{
+			opt->gui_mode_reports=1;
+			continue;
+		}
+		if (strcmp (argv[i],"--no_progress_bar")==0)
+		{
+			opt->no_progress_bar=1;
+			continue;
+		}
+		if (strcmp (argv[i],"--sentencecap")==0 ||
+				strcmp (argv[i],"-sc")==0)
+		{
+			opt->enc_cfg.sentence_cap=1;
+			continue;
+		}
+		if (strcmp(argv[i], "--splitbysentence") == 0 ||
+			strcmp(argv[i], "-sbs") == 0)
+		{
+			opt->enc_cfg.splitbysentence = 1;
+			continue;
+		}
+
+		if ((strcmp (argv[i],"--capfile")==0 ||
+					strcmp (argv[i],"-caf")==0)
+				&& i<argc-1)
+		{
+			opt->enc_cfg.sentence_cap=1;
+			opt->sentence_cap_file=argv[i+1];
+			i++;
+			continue;
+		}
+#ifndef MMCCXTR
+		if (strcmp (argv[i],"--program-number")==0 ||
+				strcmp (argv[i],"-pn")==0)
+		{
+			if (i==argc-1 // Means no following argument
+					|| !isanumber (argv[i+1])) // Means is not a number
+				opt->demux_cfg.ts_forced_program = -1; // Autodetect
+			else
+			{
+				opt->demux_cfg.ts_forced_program=atoi_hex (argv[i+1]);
+				opt->demux_cfg.ts_forced_program_selected=1;
+				i++;
+			}
+			continue;
+		}
+		if (strcmp (argv[i],"-autoprogram")==0)
+		{
+			opt->demux_cfg.ts_autoprogram=1;
+			continue;
+		}
+		if (strcmp (argv[i],"-multiprogram")==0)
+		{
+			opt->multiprogram = 1;
+			opt->demux_cfg.ts_allprogram = CCX_TRUE;
+			continue;
+		}
+#endif
+		if (strcmp (argv[i],"--stream")==0 ||
+				strcmp (argv[i],"-s")==0)
+		{
+			if (i==argc-1 // Means no following argument
+					|| !isanumber (argv[i+1])) // Means is not a number
+				opt->live_stream=-1; // Live stream without timeout
+			else
+			{
+				opt->live_stream=atoi_hex (argv[i+1]);
+				i++;
+			}
+			continue;
+		}
+		if ((strcmp (argv[i],"--defaultcolor")==0 ||
+					strcmp (argv[i],"-dc")==0)
+				&& i<argc-1)
+		{
+			if (strlen (argv[i+1])!=7 || argv[i+1][0]!='#')
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "--defaultcolor expects a 7 character parameter that starts with #\n");
+			}
+			strcpy ((char *) usercolor_rgb,argv[i+1]);
+			opt->settings_608.default_color = COL_USERDEFINED;
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-delay")==0 && i<argc-1)
+		{
+			if (parsedelay (opt, argv[i+1]))
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "-delay only accept integers (such as -300 or 300)\n");
+			}
+			i++;
+			continue;
+		}
+		if ((strcmp (argv[i],"-scr")==0 ||
+					strcmp (argv[i],"--screenfuls")==0) && i<argc-1)
+		{
+			opt->settings_608.screens_to_process = atoi_hex(argv[i + 1]);
+			if (opt->settings_608.screens_to_process<0)
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "--screenfuls only accepts positive integers.\n");
+			}
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-startat")==0 && i<argc-1)
+		{
+			if (stringztoms (argv[i+1],&opt->extraction_start)==-1)
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "-startat only accepts SS, MM:SS or HH:MM:SS\n");
+			}
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-endat")==0 && i<argc-1)
+		{
+			if (stringztoms (argv[i+1],&opt->extraction_end)==-1)
+			{
+				fatal (EXIT_MALFORMED_PARAMETER, "-endat only accepts SS, MM:SS or HH:MM:SS\n");
+			}
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-1")==0)
+		{
+			opt->extract = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-2")==0)
+		{
+			opt->extract = 2;
+			continue;
+		}
+		if (strcmp (argv[i],"-cc2")==0 || strcmp (argv[i],"-CC2")==0)
+		{
+			opt->cc_channel=2;
+			continue;
+		}
+		if (strcmp (argv[i],"-stdout")==0)
+		{
+			if (opt->messages_target==1) // Only change this if still stdout. -quiet could set it to 0 for example
+				opt->messages_target=2; // stderr
+			opt->cc_to_stdout=1;
+			continue;
+		}
+		if (strcmp(argv[i], "-pesheader") == 0)
+		{
+			opt->pes_header_to_stdout = 1;
+			continue;
+		}
+		if (strcmp(argv[i], "-debugdvbsub") == 0)
+		{
+			opt->debug_mask |= CCX_DMT_DVB;
+			continue;
+		}
+		if (strcmp(argv[i], "-ignoreptsjumps") == 0)
+		{
+			opt->ignore_pts_jumps = 1;
+			continue;
+		}
+		// -ignoreptsjumps counterpart
+		if (strcmp(argv[i], "-fixptsjumps") == 0)
+		{
+			opt->ignore_pts_jumps = 0;
+			continue;
+		}
+		if (strcmp (argv[i],"-quiet")==0)
+		{
+			opt->messages_target=0;
+			continue;
+		}
+		if (strcmp (argv[i],"-debug")==0)
+		{
+			opt->debug_mask |= CCX_DMT_VERBOSE;
+			continue;
+		}
+		if (strcmp (argv[i],"-608")==0)
+		{
+			opt->debug_mask |= CCX_DMT_DECODER_608;
+			continue;
+		}
+		if (strcmp (argv[i],"-deblev")==0)
+		{
+			opt->debug_mask |= CCX_DMT_LEVENSHTEIN;
+			continue;
+		}
+		if (strcmp(argv[i], "-nolevdist") == 0)
+		{
+			opt->dolevdist = 0;
+			continue;
+		}
+		if (strcmp (argv[i],"-levdistmincnt")==0 && i<argc-1)
+		{
+			opt->levdistmincnt = atoi_hex(argv[i+1]);
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-levdistmaxpct")==0 && i<argc-1)
+		{
+			opt->levdistmaxpct = atoi_hex(argv[i+1]);
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-708")==0)
+		{
+			opt->debug_mask |= CCX_DMT_708;
+			continue;
+		}
+		if (strcmp (argv[i],"-goppts")==0)
+		{
+			opt->debug_mask |= CCX_DMT_TIME;
+			continue;
+		}
+		if (strcmp (argv[i],"-vides")==0)
+		{
+			opt->debug_mask |= CCX_DMT_VIDES;
+			opt->analyze_video_stream = 1;
+			continue;
+		}
+		if (strcmp(argv[i], "-anvid") == 0 || strcmp(argv[i], "--analyzevideo") == 0)
+		{
+			opt->analyze_video_stream = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-xds")==0)
+		{
+            // XDS can be set regardless of -UCLA (isFinal) usage.
+			opt->transcript_settings.xds = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-xdsdebug")==0)
+		{
+			opt->transcript_settings.xds = 1;
+			opt->debug_mask |= CCX_DMT_DECODER_XDS;
+			continue;
+		}
+		if (strcmp (argv[i],"-parsedebug")==0)
+		{
+			opt->debug_mask |= CCX_DMT_PARSE;
+			continue;
+		}
+		if (strcmp (argv[i],"-parsePAT")==0 || strcmp (argv[i],"-parsepat")==0)
+		{
+			opt->debug_mask |= CCX_DMT_PAT;
+			continue;
+		}
+		if (strcmp (argv[i],"-parsePMT")==0 || strcmp (argv[i],"-parsepmt")==0)
+		{
+			opt->debug_mask |= CCX_DMT_PMT;
+			continue;
+		}
+		if (strcmp(argv[i], "-dumpdef") == 0)
+		{
+			opt->debug_mask |= CCX_DMT_DUMPDEF;
+			continue;
+		}
+		if (strcmp (argv[i],"-investigate_packets")==0)
+		{
+			opt->investigate_packets=1;
+			continue;
+		}
+		if (strcmp (argv[i],"-cbraw")==0)
+		{
+			opt->debug_mask |= CCX_DMT_CBRAW;
+			continue;
+		}
+#ifndef MMCCXTR
+		if (strcmp (argv[i],"-tverbose")==0)
+		{
+			opt->debug_mask |= CCX_DMT_TELETEXT;
+			tlt_config.verbose=1;
+			continue;
+		}
+#endif
+#ifdef ENABLE_SHARING
+		if (strcmp(argv[i], "-sharing-debug") == 0)
+		{
+			opt->debug_mask |= CCX_DMT_SHARE;
+			continue;
+		}
+#endif //ENABLE_SHARING
+		if (strcmp (argv[i],"-fullbin")==0)
+		{
+			opt->fullbin = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-nosync")==0)
+		{
+			opt->nosync = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-haup")==0 || strcmp (argv[i],"--hauppauge")==0)
+		{
+			opt->hauppauge_mode = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-mp4vidtrack")==0)
+		{
+			opt->mp4vidtrack = 1;
+			continue;
+		}
+		if (strstr (argv[i],"-unicode")!=NULL)
+		{
+			opt->enc_cfg.encoding=CCX_ENC_UNICODE;
+			continue;
+		}
+		if (strstr (argv[i],"-utf8")!=NULL)
+		{
+			opt->enc_cfg.encoding=CCX_ENC_UTF_8;
+			continue;
+		}
+		if (strstr (argv[i],"-latin1")!=NULL)
+		{
+			opt->enc_cfg.encoding=CCX_ENC_LATIN_1;
+			continue;
+		}
+		if (strcmp (argv[i],"-poc")==0 || strcmp (argv[i],"--usepicorder")==0)
+		{
+			opt->usepicorder = 1;
+			continue;
+		}
+		if (strstr (argv[i],"-myth")!=NULL)
+		{
+			opt->auto_myth=1;
+			continue;
+		}
+		if (strstr (argv[i],"-nomyth")!=NULL)
+		{
+			opt->auto_myth=0;
+			continue;
+		}
+		if (strstr (argv[i],"-wtvconvertfix")!=NULL)
+		{
+			opt->wtvconvertfix=1;
+			continue;
+		}
+		if (strstr (argv[i],"-wtvmpeg2")!=NULL)
+		{
+			opt->wtvmpeg2=1;
+			continue;
+		}
+		if (strcmp (argv[i],"-o")==0 && i<argc-1)
+		{
+			opt->output_filename = argv[i+1];
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-cf")==0 && i<argc-1)
+		{
+			opt->demux_cfg.out_elementarystream_filename = argv[i+1];
+			i++;
+			continue;
+		}
+#ifndef MMCCXTR
+		if ( (strcmp (argv[i],"-svc")==0 || strcmp (argv[i],"--service")==0) &&
+				i<argc-1)
+		{
+			parse_708_services(opt, argv[i + 1]);
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-datapid")==0 && i<argc-1)
+		{
+			opt->demux_cfg.ts_cappids[opt->demux_cfg.nb_ts_cappid] = atoi_hex(argv[i+1]);
+			opt->demux_cfg.nb_ts_cappid++;
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-datastreamtype")==0 && i<argc-1)
+		{
+			opt->demux_cfg.ts_datastreamtype = atoi_hex(argv[i+1]);
+			i++;
+			continue;
+		}
+		if (strcmp (argv[i],"-streamtype")==0 && i<argc-1)
+		{
+			opt->demux_cfg.ts_forced_streamtype = atoi_hex(argv[i+1]);
+			i++;
+			continue;
+		}
+		/* Teletext stuff */
+		if (strcmp (argv[i],"-tpage")==0 && i<argc-1)
+		{
+			tlt_config.page = atoi_hex(argv[i+1]);
+			tlt_config.user_page = tlt_config.page;
+			i++;
+			continue;
+		}
+
+		/* Red Hen/ UCLA Specific stuff */
+		if (strcmp (argv[i],"-UCLA")==0 || strcmp (argv[i],"-ucla")==0)
+		{
+			opt->ucla = 1;
+			opt->millis_separator = '.';
+			opt->enc_cfg.no_bom = 1;
+			if (!opt->transcript_settings.isFinal){
+				opt->transcript_settings.showStartTime = 1;
+				opt->transcript_settings.showEndTime = 1;
+				opt->transcript_settings.showCC = 1;
+				opt->transcript_settings.showMode = 1;
+				opt->transcript_settings.relativeTimestamp = 0;
+				opt->transcript_settings.isFinal = 1;
+			}
+			continue;
+		}
+        if (strcmp (argv[i],"-latrusmap")==0 )
+        {
+            tlt_config.latrusmap = 1;
+            continue;
+        }
+		if (strcmp (argv[i],"-tickertext")==0 || strcmp (argv[i],"-tickertape")==0)
+		{
+			opt->tickertext = 1;
+			continue;
+		}
+#endif
+		if (strcmp (argv[i],"-lf")==0 || strcmp (argv[i],"-LF")==0)
+		{
+			opt->enc_cfg.line_terminator_lf = 1;
+			continue;
+		}
+#ifndef MMCCXTR
+		if (strcmp (argv[i],"-noautotimeref")==0)
+		{
+			opt->noautotimeref = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-autodash")==0)
+		{
+			opt->enc_cfg.autodash = 1;
+			continue;
+		}
+		if (strcmp(argv[i], "-sem") == 0)
+		{
+			opt->enc_cfg.autodash = 1;
+			continue;
+		}
+		if (strcmp (argv[i],"-xmltv")==0)
+		{
+			if (i==argc-1 // Means no following argument
+					|| !isanumber (argv[i+1])) // Means is not a number
+			opt->xmltv = 1;
+			else
+			{
+				opt->xmltv=atoi_hex (argv[i+1]);
+				i++;
+			}
+			continue;
+		}
+
+		if (strcmp (argv[i],"-xmltvliveinterval")==0)
+		{
+			if (i==argc-1 // Means no following argument
+					|| !isanumber (argv[i+1])) // Means is not a number
+			opt->xmltvliveinterval = 10;
+			else
+			{
+				opt->xmltvliveinterval=atoi_hex (argv[i+1]);
+				i++;
+			}
+			continue;
+		}
+
+		if (strcmp (argv[i],"-xmltvoutputinterval")==0)
+		{
+			if (i==argc-1 // Means no following argument
+					|| !isanumber (argv[i+1])) // Means is not a number
+			opt->xmltvoutputinterval = 0;
+			else
+			{
+				opt->xmltvoutputinterval=atoi_hex (argv[i+1]);
+				i++;
+			}
+			continue;
+		}
+		if (strcmp (argv[i],"-xmltvonlycurrent")==0)
+		{
+			opt->xmltvonlycurrent=1;
+			i++;
+			continue;
+		}
+
+		if (strcmp (argv[i],"-unixts")==0 && i<argc-1)
+		{
+			uint64_t t = 0;
+			t = atoi_hex(argv[i + 1]);
+			if (t <= 0)
+			{
+				time_t now = time(NULL);
+				t = time(&now);
+			}
+			utc_refvalue = t;
+			i++;
+			opt->noautotimeref= 1; // If set by user don't attempt to fix
+			continue;
+		}
+#endif
+		if (strcmp (argv[i],"-sects")==0)
+		{
+			opt->date_format=ODF_SECONDS;
+			continue;
+		}
+		if (strcmp (argv[i],"-datets")==0)
+		{
+			opt->date_format=ODF_DATE;
+			continue;
+		}
+		if (strcmp (argv[i],"-teletext")==0)
+		{
+			opt->demux_cfg.codec = CCX_CODEC_TELETEXT;
+			continue;
+		}
+		if (strcmp (argv[i],"-noteletext")==0)
+		{
+			opt->demux_cfg.nocodec = CCX_CODEC_TELETEXT;
+			continue;
+		}
+		/* Custom transcript */
+		if (strcmp(argv[i], "-customtxt") == 0 && i<argc - 1){
+			char *format = argv[i + 1];
+			if (strlen(format) == 7){
+				if (opt->date_format == ODF_NONE)
+					opt->date_format = ODF_HHMMSSMS; // Necessary for displaying times, if any would be used.
+				if (!opt->transcript_settings.isFinal){
+					opt->transcript_settings.showStartTime = format[0] - '0';
+					opt->transcript_settings.showEndTime = format[1] - '0';
+					opt->transcript_settings.showMode = format[2] - '0';
+					opt->transcript_settings.showCC = format[3] - '0';
+					opt->transcript_settings.relativeTimestamp = format[4] - '0';
+					opt->transcript_settings.xds = format[5] - '0';
+					opt->transcript_settings.useColors = format[6] - '0';
+				} else {
+					// Throw exception
+					fatal(EXIT_INCOMPATIBLE_PARAMETERS, "customtxt cannot be set after -UCLA is used!");
+				}
+				i++;
+			}
+			else {
+				fatal(EXIT_MALFORMED_PARAMETER, "Custom TXT format not OK: %s, expected 7 bits string\n",
+						format);
+			}
+			continue;
+		}
+		/* Network stuff */
+		if (strcmp (argv[i],"-udp")==0 && i<argc-1)
+		{
+			char *at = strchr(argv[i + 1], '@');
+			char *colon = strchr(argv[i + 1], ':');
+			if (at && !colon)
+			{
+				fatal(EXIT_MALFORMED_PARAMETER, "If -udp contains an '@', it must also contain a ':'");
+			}
+			else if (at && colon)
+			{
+				*at = '\0';
+				*colon = '\0';
+				opt->udpsrc = argv[i + 1];
+				opt->udpaddr = at + 1;
+				opt->udpport = atoi_hex(colon + 1);
+			}
+			else if (colon)
+			{
+				*colon = '\0';
+				opt->udpaddr = argv[i + 1];
+				opt->udpport = atoi_hex(colon + 1);
+			}
+			else
+			{
+				opt->udpaddr = NULL;
+				opt->udpport = atoi_hex(argv[i + 1]);
+			}
+
+			opt->input_source = CCX_DS_NETWORK;
+			i++;
+			continue;
+		}
+
+		if (strcmp (argv[i],"-sendto")==0 && i<argc-1)
+		{
+			opt->send_to_srv = 1;
+
+			set_output_format(opt, "bin");
+
+			opt->xmltv = 2;
+			opt->xmltvliveinterval = 2;
+
+			char *addr = argv[i + 1];
+			if (*addr == '[')
+			{
+				addr++;
+
+				opt->srv_addr = addr;
+
+				char *br = strchr(addr, ']');
+				if (br == NULL)
+					fatal (EXIT_INCOMPATIBLE_PARAMETERS, "Wrong address format, for IPv6 use [address]:port\n");
+				*br = '\0';
+
+				br++; /* Colon */
+				if (*br != '\0')
+					opt->srv_port = br + 1;
+
+				i++;
+				continue;
+			}
+
+			opt->srv_addr = argv[i + 1];
+
+			char *colon = strchr(argv[i + 1], ':');
+			if (colon != NULL)
+			{
+				*colon = '\0';
+				opt->srv_port = colon + 1;
+			}
+
+			i++;
+			continue;
+		}
+
+		if (strcmp (argv[i],"-tcp")==0 && i<argc-1)
+		{
+			opt->tcpport = argv[i + 1];
+			opt->input_source = CCX_DS_TCP;
+
+			set_input_format(opt, "bin");
+
+			i++;
+			continue;
+		}
+
+		if (strcmp (argv[i],"-tcppassword")==0 && i<argc-1)
+		{
+			opt->tcp_password = argv[i + 1];
+
+			i++;
+			continue;
+		}
+
+		if (strcmp (argv[i],"-tcpdesc")==0 && i<argc-1)
+		{
+			opt->tcp_desc = argv[i + 1];
+
+			i++;
+			continue;
+		}
+
+		if (strcmp(argv[i], "-font") == 0 && i<argc - 1)
+		{
+			opt->enc_cfg.render_font = argv[i + 1];
+			i++;
+			continue;
+		}
+#ifdef WITH_LIBCURL
+		if (strcmp (argv[i],"-curlposturl")==0 && i<argc-1)
+		{
+			opt->curlposturl = argv[i + 1];
+			i++;
+			continue;
+		}
+#endif
+
+#ifdef ENABLE_SHARING
+		if (!strcmp(argv[i], "-enable-sharing")) {
+			opt->sharing_enabled = 1;
+			continue;
+		}
+		if (!strcmp(argv[i], "-sharing-url") && i < argc - 1) {
+			opt->sharing_url = argv[i + 1];
+			i++;
+			continue;
+		}
+		if (!strcmp(argv[i], "-translate") && i < argc - 1) {
+			opt->translate_enabled = 1;
+			opt->sharing_enabled = 1;
+			opt->translate_langs = argv[i + 1];
+			i++;
+			continue;
+		}
+		if (!strcmp(argv[i], "-translate-auth") && i < argc - 1) {
+			opt->translate_key = argv[i + 1];
+			i++;
+			continue;
+		}
+#endif //ENABLE_SHARING
+
+		fatal (EXIT_INCOMPATIBLE_PARAMETERS, "Error: Parameter %s not understood.\n", argv[i]);
+		// Unrecognized switches are silently ignored
+	}
+
+#ifndef MMCCXTR
+	if(opt->demux_cfg.auto_stream ==CCX_SM_MP4 && opt->input_source == CCX_DS_STDIN)
+	{
+		fatal (EXIT_INCOMPATIBLE_PARAMETERS, "MP4 requires an actual file, it's not possible to read from a stream, including stdin.\n");
+	}
+#endif
+
+	if(opt->extract_chapters)
+	{
+		mprint("Request to extract chapters recieved.\n");
+		mprint("Note that this must only be used with MP4 files,\n");
+		mprint("for other files it will simply generate subtitles file.\n\n");
+	}
+
+	if(opt->gui_mode_reports)
+	{
+		opt->no_progress_bar=1;
+		// Do it as soon as possible, because it something fails we might not have a chance
+		activity_report_version();
+	}
+
+	if(opt->enc_cfg.sentence_cap)
+	{
+		if(add_built_in_words())
+			fatal (EXIT_NOT_ENOUGH_MEMORY, "Not enough memory for word list");
+		if(opt->sentence_cap_file && process_cap_file (opt->sentence_cap_file))
+			fatal (EXIT_ERROR_IN_CAPITALIZATION_FILE, "There was an error processing the capitalization file.\n");
+
+		ccx_encoders_helpers_perform_shellsort_words();
+	}
+#ifndef MMCCXTR
+	if(opt->demux_cfg.ts_forced_program != -1)
+		opt->demux_cfg.ts_forced_program_selected = 1;
+
+	// Init telexcc redundant options
+	tlt_config.dolevdist = opt->dolevdist;
+	tlt_config.levdistmincnt = opt->levdistmincnt;
+	tlt_config.levdistmaxpct = opt->levdistmaxpct;
+	tlt_config.extraction_start = opt->extraction_start;
+	tlt_config.extraction_end = opt->extraction_end;
+	tlt_config.write_format = opt->write_format;
+	tlt_config.gui_mode_reports = opt->gui_mode_reports;
+	tlt_config.date_format = opt->date_format;
+	tlt_config.noautotimeref = opt->noautotimeref;
+	tlt_config.send_to_srv = opt->send_to_srv;
+	tlt_config.nofontcolor = opt->nofontcolor;
+	tlt_config.nohtmlescape = opt->nohtmlescape;
+	tlt_config.millis_separator = opt->millis_separator;
+
+	// teletext page number out of range
+	if ((tlt_config.page != 0) && ((tlt_config.page < 100) || (tlt_config.page > 899))) {
+		print_error(opt->gui_mode_reports, "Teletext page number could not be lower than 100 or higher than 899\n");
+		return EXIT_NOT_CLASSIFIED;
+	}
+#endif
+
+	if (opt->num_input_files == 0 && opt->input_source  == CCX_DS_FILE)
+	{
+		return EXIT_NO_INPUT_FILES;
+	}
+	if (opt->num_input_files > 1 && opt->live_stream)
+	{
+		print_error(opt->gui_mode_reports, "Live stream mode accepts only one input file.\n");
+		return EXIT_TOO_MANY_INPUT_FILES;
+	}
+	if (opt->num_input_files && opt->input_source == CCX_DS_NETWORK)
+	{
+		print_error(opt->gui_mode_reports, "UDP mode is not compatible with input files.\n");
+		return EXIT_TOO_MANY_INPUT_FILES;
+	}
+	if (opt->input_source == CCX_DS_NETWORK || opt->input_source == CCX_DS_TCP)
+	{
+		ccx_options.buffer_input = 1; // Mandatory, because each datagram must be read complete.
+	}
+	if (opt->num_input_files && opt->input_source == CCX_DS_TCP)
+	{
+		print_error(opt->gui_mode_reports, "TCP mode is not compatible with input files.\n");
+		return EXIT_TOO_MANY_INPUT_FILES;
+	}
+
+#ifndef MMCCXTR
+	if (opt->demux_cfg.auto_stream == CCX_SM_MCPOODLESRAW && opt->write_format==CCX_OF_RAW)
+	{
+		print_error(opt->gui_mode_reports, "-in=raw can only be used if the output is a subtitle file.\n");
+		return EXIT_INCOMPATIBLE_PARAMETERS;
+	}
+	if (opt->demux_cfg.auto_stream == CCX_SM_RCWT && opt->write_format==CCX_OF_RCWT && opt->output_filename == NULL)
+	{
+		print_error(opt->gui_mode_reports,
+			   "CCExtractor's binary format can only be used simultaneously for input and\noutput if the output file name is specified given with -o.\n");
+		return EXIT_INCOMPATIBLE_PARAMETERS;
+	}
+	if (opt->write_format != CCX_OF_DVDRAW && opt->cc_to_stdout && opt->extract==12)
+	{
+		print_error(opt->gui_mode_reports, "You can't extract both fields to stdout at the same time in broadcast mode.");
+		return EXIT_INCOMPATIBLE_PARAMETERS;
+	}
+	if (opt->write_format == CCX_OF_SPUPNG && opt->cc_to_stdout)
+	{
+		print_error(opt->gui_mode_reports, "You cannot use -out=spupng with -stdout.");
+		return EXIT_INCOMPATIBLE_PARAMETERS;
+	}
+
+	if (opt->write_format == CCX_OF_WEBVTT && opt->enc_cfg.encoding != CCX_ENC_UTF_8)
+	{
+		mprint("Note: Output format is WebVTT, forcing UTF-8");
+		opt->enc_cfg.encoding = CCX_ENC_UTF_8;
+	}
+#endif
+#ifdef WITH_LIBCURL
+	if (opt->write_format==CCX_OF_CURL && opt->curlposturl==NULL)
+	{
+		print_error(opt->gui_mode_reports, "You must pass a URL (-curlposturl) if output format is curl");
+		return EXIT_INCOMPATIBLE_PARAMETERS;
+	}
+	if (opt->write_format != CCX_OF_CURL && opt->curlposturl != NULL)
+	{
+		print_error(opt->gui_mode_reports, "-curlposturl requires that the format is curl");
+		return EXIT_INCOMPATIBLE_PARAMETERS;
+	}
+#endif
+	/* Initialize some Encoder Configuration */
+	opt->enc_cfg.extract = opt->extract;
+	if (opt->num_input_files > 0)
+	{
+		opt->enc_cfg.multiple_files = 1;
+		opt->enc_cfg.first_input_file = opt->inputfile[0];
+	}
+	opt->enc_cfg.cc_to_stdout = opt->cc_to_stdout;
+	opt->enc_cfg.write_format = opt->write_format;
+	opt->enc_cfg.send_to_srv = opt->send_to_srv;
+	opt->enc_cfg.date_format = opt->date_format;
+	opt->enc_cfg.transcript_settings = opt->transcript_settings;
+	opt->enc_cfg.millis_separator = opt->millis_separator;
+	opt->enc_cfg.no_font_color = opt->nofontcolor;
+	opt->enc_cfg.force_flush = opt->force_flush;
+	opt->enc_cfg.append_mode = opt->append_mode;
+	opt->enc_cfg.ucla = opt->ucla;
+	opt->enc_cfg.no_type_setting = opt->notypesetting;
+	opt->enc_cfg.subs_delay = opt->subs_delay;
+	opt->enc_cfg.gui_mode_reports = opt->gui_mode_reports;
+#ifndef MMCCXTR
+	if(opt->enc_cfg.render_font==NULL)
+		opt->enc_cfg.render_font = DEFAULT_FONT_PATH;
+#endif
+	if(opt->output_filename && opt->multiprogram == CCX_FALSE)
+		opt->enc_cfg.output_filename = strdup(opt->output_filename);
+	else
+		opt->enc_cfg.output_filename = NULL;
+#ifdef WITH_LIBCURL
+	opt->enc_cfg.curlposturl = opt->curlposturl;
+#endif
+	return EXIT_OK;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/params_dump.c Added

@@ -0,0 +1,422 @@
+#include "lib_ccx.h"
+#include "ccx_common_option.h"
+#ifndef MMCCXTR
+#include "teletext.h"
+
+#include "ccx_decoders_708.h"
+#endif
+
+void params_dump(struct lib_ccx_ctx *ctx)
+{
+	// Display parsed parameters
+	mprint ("Input: ");
+	switch (ccx_options.input_source)
+	{
+		case CCX_DS_FILE:
+			dbg_print(CCX_DMT_VERBOSE, "Files (%d): ", ctx->num_input_files);
+			for (int i=0;i<ctx->num_input_files;i++)
+				mprint ("%s%s",ctx->inputfile[i],i==(ctx->num_input_files-1)?"":", ");
+			break;
+		case CCX_DS_STDIN:
+			mprint ("stdin");
+			break;
+		case CCX_DS_NETWORK:
+			if (ccx_options.udpsrc != NULL)
+				mprint ("Network, %s@%s:%d", ccx_options.udpsrc, ccx_options.udpaddr, ccx_options.udpport);
+			else if (ccx_options.udpaddr == NULL)
+				mprint ("Network, UDP/%u",ccx_options.udpport);
+			else
+			{
+				mprint ("Network, %s:%d",ccx_options.udpaddr, ccx_options.udpport);
+			}
+			break;
+		case CCX_DS_TCP:
+			mprint("Network, TCP/%s", ccx_options.tcpport);
+			break;
+	}
+	mprint ("\n");
+	mprint ("[Extract: %d] ", ccx_options.extract);
+	mprint ("[Stream mode: ");
+
+	ctx->demux_ctx->print_cfg(ctx->demux_ctx);
+	mprint ("]\n");
+#ifndef MMCCXTR
+	mprint ("[Program : ");
+	if (ccx_options.demux_cfg.ts_forced_program_selected != 0)
+		mprint ("%u ]",ccx_options.demux_cfg.ts_forced_program);
+	else
+		mprint ("Auto ]");
+#endif
+	mprint (" [Hauppage mode: %s]",ccx_options.hauppauge_mode?"Yes":"No");
+
+	mprint (" [Use MythTV code: ");
+	switch (ccx_options.auto_myth)
+	{
+		case 0:
+			mprint ("Disabled");
+			break;
+		case 1:
+			mprint ("Forced - Overrides stream mode setting");
+			break;
+		case 2:
+			mprint ("Auto");
+			break;
+	}
+	mprint ("]");
+	mprint ("\n");
+
+	if (ccx_options.settings_dtvcc.enabled)
+	{
+		mprint ("[CEA-708: %d decoders active]\n", ccx_options.settings_dtvcc.active_services_count);
+		if (ccx_options.settings_dtvcc.active_services_count == CCX_DTVCC_MAX_SERVICES)
+		{
+			char *charset = ccx_options.enc_cfg.all_services_charset;
+			mprint ("[CEA-708: using charset \"%s\" for all services]\n", charset ? charset : "none");
+		}
+		else
+		{
+			for (int i = 0; i < CCX_DTVCC_MAX_SERVICES; i++)
+			{
+				if (ccx_options.settings_dtvcc.services_enabled[i])
+					mprint("[CEA-708: using charset \"%s\" for service %d]\n",
+						   ccx_options.enc_cfg.services_charsets[i] ?
+						   ccx_options.enc_cfg.services_charsets[i] : "none",
+						   i + 1);
+			}
+		}
+	}
+
+	if (ccx_options.wtvconvertfix)
+		mprint (" [Windows 7 wtv to dvr-ms conversion fix: Enabled]\n");
+
+	if (ccx_options.wtvmpeg2)
+		mprint (" [WTV use MPEG2 stream: Enabled]\n");
+
+	mprint ("[Timing mode: ");
+	switch (ccx_options.use_gop_as_pts)
+	{
+		case 1:
+			mprint ("GOP (forced)");
+			break;
+		case -1:
+			mprint ("PTS (forced)");
+			break;
+		case 0:
+			mprint ("Auto");
+			break;
+	}
+	mprint ("] ");
+	mprint ("[Debug: %s] ", (ccx_options.debug_mask & CCX_DMT_VERBOSE) ? "Yes": "No");
+	mprint ("[Buffer input: %s]\n", ccx_options.buffer_input ? "Yes": "No");
+	mprint ("[Use pic_order_cnt_lsb for H.264: %s] ", ccx_options.usepicorder ? "Yes": "No");
+	mprint("[Print CC decoder traces: %s]\n", (ccx_options.debug_mask & CCX_DMT_DECODER_608) ? "Yes" : "No");
+	mprint ("[Target format: %s] ",ctx->extension);
+	mprint ("[Encoding: ");
+	switch (ccx_options.enc_cfg.encoding)
+	{
+		case CCX_ENC_UNICODE:
+			mprint ("Unicode");
+			break;
+		case CCX_ENC_UTF_8:
+			mprint ("UTF-8");
+			break;
+		case CCX_ENC_LATIN_1:
+			mprint ("Latin-1");
+			break;
+	}
+	mprint ("] ");
+	mprint ("[Delay: %lld] ",ctx->subs_delay);
+
+	mprint ("[Trim lines: %s]\n",ccx_options.enc_cfg.trim_subs?"Yes":"No");
+	mprint ("[Add font color data: %s] ", ccx_options.nofontcolor? "No" : "Yes");
+	mprint ("[Add font typesetting: %s]\n", ccx_options.notypesetting? "No" : "Yes");
+	mprint ("[Convert case: ");
+	if (ccx_options.sentence_cap_file!=NULL)
+		mprint ("Yes, using %s", ccx_options.sentence_cap_file);
+	else
+	{
+		mprint ("%s",ccx_options.enc_cfg.sentence_cap?"Yes, but only built-in words":"No");
+	}
+	mprint ("]");
+	mprint (" [Video-edit join: %s]", ccx_options.binary_concat?"No":"Yes");
+	mprint ("\n[Extraction start time: ");
+	if (ccx_options.extraction_start.set==0)
+		mprint ("not set (from start)");
+	else
+		mprint ("%02d:%02d:%02d", ccx_options.extraction_start.hh,
+				ccx_options.extraction_start.mm,
+				ccx_options.extraction_start.ss);
+	mprint ("]\n");
+	mprint ("[Extraction end time: ");
+	if (ccx_options.extraction_end.set==0)
+		mprint ("not set (to end)");
+	else
+		mprint ("%02d:%02d:%02d", ccx_options.extraction_end.hh,
+				ccx_options.extraction_end.mm,
+				ccx_options.extraction_end.ss);
+	mprint ("]\n");
+	mprint ("[Live stream: ");
+	if (ccx_options.live_stream==0)
+		mprint ("No");
+	else
+	{
+		if (ccx_options.live_stream<1)
+			mprint ("Yes, no timeout");
+		else
+			mprint ("Yes, timeout: %d seconds",ccx_options.live_stream);
+	}
+	mprint ("] [Clock frequency: %d]\n",MPEG_CLOCK_FREQ);
+#ifndef MMCCXTR
+	mprint ("[Teletext page: ");
+	if (tlt_config.page)
+		mprint ("%d]\n",tlt_config.page);
+	else
+		mprint ("Autodetect]\n");
+#endif
+	mprint ("[Start credits text: %s]\n",
+			ccx_options.enc_cfg.start_credits_text?ccx_options.enc_cfg.start_credits_text:"None");
+	if (ccx_options.enc_cfg.start_credits_text)
+	{
+		mprint ("Start credits time: Insert between [%ld] and [%ld] seconds\n",
+				(long) (ccx_options.enc_cfg.startcreditsnotbefore.time_in_ms/1000),
+				(long) (ccx_options.enc_cfg.startcreditsnotafter.time_in_ms/1000)
+		       );
+		mprint ("                    Display for at least [%ld] and at most [%ld] seconds\n",
+				(long) (ccx_options.enc_cfg.startcreditsforatleast.time_in_ms/1000),
+				(long) (ccx_options.enc_cfg.startcreditsforatmost.time_in_ms/1000)
+		       );
+	}
+	if (ccx_options.enc_cfg.end_credits_text)
+	{
+		mprint ("End credits text: [%s]\n",
+				ccx_options.enc_cfg.end_credits_text?ccx_options.enc_cfg.end_credits_text:"None");
+		mprint ("                    Display for at least [%ld] and at most [%ld] seconds\n",
+				(long) (ccx_options.enc_cfg.endcreditsforatleast.time_in_ms/1000),
+				(long) (ccx_options.enc_cfg.endcreditsforatmost.time_in_ms/1000)
+		       );
+	}
+	// print quantisation mode used
+	mprint("[Quantisation-mode: ");
+	switch(ccx_options.ocr_quantmode)
+	{
+		case 0:
+			// when no quantisation
+			mprint("None]\n");
+			break;
+		case 1:
+			// default mode, CCExtractor's internal function
+			mprint("CCExtractor's internal function]\n");
+			break;
+		case 2:
+			// reduced color palette quantisation
+			mprint("Reduced color palette]\n");
+			break;
+	}
+}
+
+#define Y_N(cond) ((cond) ? "Yes" : "No")
+
+void print_cc_report(struct lib_ccx_ctx *ctx, struct cap_info* info)
+{
+	struct lib_cc_decode *dec_ctx = NULL;
+	dec_ctx = update_decoder_list_cinfo(ctx, info);
+	printf("EIA-608: %s\n", Y_N(dec_ctx->cc_stats[0] > 0 || dec_ctx->cc_stats[1] > 0));
+
+	if (dec_ctx->cc_stats[0] > 0 || dec_ctx->cc_stats[1] > 0)
+	{
+		printf("XDS: %s\n", Y_N(ctx->freport.data_from_608->xds));
+
+		printf("CC1: %s\n", Y_N(ctx->freport.data_from_608->cc_channels[0]));
+		printf("CC2: %s\n", Y_N(ctx->freport.data_from_608->cc_channels[1]));
+		printf("CC3: %s\n", Y_N(ctx->freport.data_from_608->cc_channels[2]));
+		printf("CC4: %s\n", Y_N(ctx->freport.data_from_608->cc_channels[3]));
+	}
+	printf("CEA-708: %s\n", Y_N(dec_ctx->cc_stats[2] > 0 || dec_ctx->cc_stats[3] > 0));
+
+	if (dec_ctx->cc_stats[2] > 0 || dec_ctx->cc_stats[3] > 0)
+	{
+		printf("Services: ");
+		for (int i = 0; i < CCX_DTVCC_MAX_SERVICES; i++)
+		{
+			if (ctx->freport.data_from_708->services[i] == 0)
+				continue;
+			printf("%d ", i);
+		}
+		printf("\n");
+
+		printf("Primary Language Present: %s\n", Y_N(ctx->freport.data_from_708->services[1]));
+
+		printf("Secondary Language Present: %s\n", Y_N(ctx->freport.data_from_708->services[2]));
+	}
+}
+
+void print_file_report(struct lib_ccx_ctx *ctx)
+{
+	struct lib_cc_decode *dec_ctx = NULL;	
+	struct ccx_demuxer *demux_ctx = ctx->demux_ctx;
+
+	printf("File: ");
+	switch (ccx_options.input_source)
+	{
+		case CCX_DS_FILE:
+			if (ctx->current_file < 0)
+			{
+				printf("file is not opened yet\n");
+				return;
+			}
+
+			printf("%s\n", ctx->inputfile[ctx->current_file]);
+			break;
+		case CCX_DS_STDIN:
+			printf("stdin\n");
+			break;
+		case CCX_DS_TCP:
+		case CCX_DS_NETWORK:
+			printf("network\n");
+			break;
+	}
+
+	struct cap_info* program;
+	printf("Stream Mode: ");
+	switch (demux_ctx->stream_mode)
+	{
+#ifndef MMCCXTR
+		case CCX_SM_TRANSPORT:
+			printf("Transport Stream\n");
+
+			printf("Program Count: %d\n", demux_ctx->freport.program_cnt);
+
+			printf("Program Numbers: ");
+
+			for (int i = 0; i < demux_ctx->nb_program; i++)
+				printf("%u ", demux_ctx->pinfo[i].program_number);
+
+			printf("\n");
+
+			for (int i = 0; i < 65536; i++)
+			{
+				if (demux_ctx->PIDs_programs[i] == 0)
+					continue;
+
+				printf("PID: %u, Program: %u, ", i, demux_ctx->PIDs_programs[i]->program_number);
+				int j;
+				for (j = 0; j < SUB_STREAMS_CNT; j++)
+				{
+					if (demux_ctx->freport.dvb_sub_pid[j] == i)
+					{
+						printf("DVB Subtitles\n");
+						break;
+					}
+					if (demux_ctx->freport.tlt_sub_pid[j] == i)
+					{
+						printf("Teletext Subtitles\n");
+						break;
+					}
+				}
+				if (j == SUB_STREAMS_CNT)
+					printf("%s\n", desc[demux_ctx->PIDs_programs[i]->printable_stream_type]);
+			}
+
+			break;
+		case CCX_SM_PROGRAM:
+			printf("Program Stream\n");
+			break;
+		case CCX_SM_ASF:
+			printf("ASF\n");
+			break;
+		case CCX_SM_WTV:
+			printf("WTV\n");
+			break;
+		case CCX_SM_ELEMENTARY_OR_NOT_FOUND:
+			printf("Not Found\n");
+			break;
+		case CCX_SM_MP4:
+			printf("MP4\n");
+			break;
+		case CCX_SM_MCPOODLESRAW:
+			printf("McPoodle's raw\n");
+			break;
+#endif
+		case CCX_SM_RCWT:
+			printf("BIN\n");
+			break;
+#ifdef WTV_DEBUG
+		case CCX_SM_HEX_DUMP:
+			printf("Hex\n");
+			break;
+#endif
+		default:
+			break;
+	}
+	if(list_empty(&demux_ctx->cinfo_tree.all_stream))
+	{
+		print_cc_report(ctx, NULL);
+	}
+#ifndef MMCCXTR
+	list_for_each_entry(program, &demux_ctx->cinfo_tree.pg_stream, pg_stream, struct cap_info)
+	{
+		struct cap_info* info = NULL;
+		printf("//////// Program #%u: ////////\n", program->program_number);
+
+		printf("DVB Subtitles: ");
+		info = get_sib_stream_by_type(program, CCX_CODEC_DVB);
+		if(info)
+			printf("Yes\n");
+		else
+			printf("No\n");
+
+		printf("Teletext: ");
+		info = get_sib_stream_by_type(program, CCX_CODEC_TELETEXT);
+		if(info)
+		{
+			printf("Yes\n");
+			dec_ctx = update_decoder_list_cinfo(ctx, info);
+			printf("Pages With Subtitles: ");
+			tlt_print_seen_pages(dec_ctx);
+
+				printf("\n");
+		}
+		else
+			printf("No\n");
+
+
+		printf("ATSC Closed Caption: ");
+		info = get_sib_stream_by_type(program, CCX_CODEC_ATSC_CC);
+		if(info)
+		{
+			printf("Yes\n");
+			print_cc_report(ctx, info);
+		}
+		else
+			printf("No\n");
+
+
+		info = get_best_sib_stream(program);
+		if(!info)
+			continue;
+
+		dec_ctx = update_decoder_list_cinfo(ctx, info);
+		if (dec_ctx->in_bufferdatatype == CCX_PES &&
+			(info->stream == CCX_SM_TRANSPORT ||
+			 info->stream == CCX_SM_PROGRAM ||
+			 info->stream == CCX_SM_ASF ||
+			 info->stream == CCX_SM_WTV))
+		{
+			printf("Width: %u\n", dec_ctx->current_hor_size);
+			printf("Height: %u\n", dec_ctx->current_vert_size);
+			printf("Aspect Ratio: %s\n", aspect_ratio_types[dec_ctx->current_aspect_ratio]);
+			printf("Frame Rate: %s\n", framerates_types[dec_ctx->current_frame_rate]);
+		}
+		printf("\n");
+	}
+
+	printf("MPEG-4 Timed Text: %s\n", Y_N(ctx->freport.mp4_cc_track_cnt));
+	if (ctx->freport.mp4_cc_track_cnt) {
+		printf("MPEG-4 Timed Text tracks count: %d\n", ctx->freport.mp4_cc_track_cnt);
+	}
+#endif
+
+	freep(&ctx->freport.data_from_608);
+	memset(&ctx->freport, 0, sizeof (struct file_report));
+#undef Y_N
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/sequencing.c Added

@@ -0,0 +1,143 @@
+#include "lib_ccx.h"
+#include "ccx_common_option.h"
+
+// Defined by the maximum number of B-Frames per anchor frame.
+//#define MAXBFRAMES 50 - from lib_ccx.h
+//  They can be (temporally) before or after the anchor. Reserve
+// enough space.
+//#define SORTBUF (2*MAXBFRAMES+1) - from lib_ccx.h
+// B-Frames can be (temporally) before or after the anchor
+
+void init_hdcc (struct lib_cc_decode *ctx)
+{
+	for (int j=0; j<SORTBUF; j++)
+	{
+		ctx->cc_data_count[j] = 0;
+		ctx->cc_fts[j] = 0;
+	}
+	memset(ctx->cc_data_pkts, 0, SORTBUF*(31*3+1));
+	ctx->has_ccdata_buffered = 0;
+}
+
+// Buffer caption blocks for later sorting/flushing.
+void store_hdcc(struct lib_cc_decode *ctx, unsigned char *cc_data, int cc_count, int sequence_number, LLONG current_fts_now, struct cc_subtitle *sub)
+{
+	//stream_mode = ctx->demux_ctx->get_stream_mode(ctx->demux_ctx);
+	// Uninitialized?
+	if (ctx->anchor_seq_number < 0)
+	{
+		anchor_hdcc( ctx, sequence_number);
+	}
+
+	int seq_index = sequence_number - ctx->anchor_seq_number + MAXBFRAMES;
+
+	if (seq_index < 0 || seq_index > 2*MAXBFRAMES)
+	{
+		// Maybe missing an anchor frame - try to recover
+		dbg_print(CCX_DMT_VERBOSE, "Too many B-frames, or missing anchor frame. Trying to recover ..\n");
+
+		process_hdcc(ctx, sub);
+		anchor_hdcc( ctx, sequence_number);
+		seq_index = sequence_number - ctx->anchor_seq_number + MAXBFRAMES;
+	}
+
+	ctx->has_ccdata_buffered = 1;
+
+	// In GOP mode the fts is set only once for the whole GOP. Recreate
+	// the right time according to the sequence number.
+	if (ccx_options.use_gop_as_pts==1)
+	{
+		current_fts_now += (LLONG) (sequence_number*1000.0/current_fps);
+	}
+
+	if (cc_count)
+	{
+		if (cc_data)
+		{
+			// Changed by CFS to concat, i.e. don't assume there's no data already for this seq_index.
+			// Needed at least for MP4 samples. // TODO: make sure we don't overflow
+			ctx->cc_fts[seq_index] = current_fts_now; // CFS: Maybe do even if there's no data?
+			//if (stream_mode!=CCX_SM_MP4) // CFS: Very ugly hack, but looks like overwriting is needed for at least some ES
+				ctx->cc_data_count[seq_index]  = 0;
+			memcpy(ctx->cc_data_pkts[seq_index] + ctx->cc_data_count[seq_index] * 3, cc_data, cc_count * 3 + 1);
+		}
+		ctx->cc_data_count[seq_index] += cc_count;
+	}
+	// DEBUG STUFF
+	/*
+	   printf("\nCC blocks, channel 0:\n");
+	   for ( int i=0; i < cc_count*3; i+=3)
+	   {
+	   printf("%s", debug_608_to_ASC( cc_data+i, 0) );
+	   }
+	   printf("\n");
+	 */
+}
+
+// Set a new anchor frame that new B-frames refer to.
+void anchor_hdcc(struct lib_cc_decode *ctx, int seq)
+{
+	// Re-init the index
+	ctx->anchor_seq_number = seq;
+}
+
+// Sort/flash caption block buffer
+void process_hdcc (struct lib_cc_decode *ctx, struct cc_subtitle *sub)
+{
+	// Remember the current value
+	LLONG store_fts_now = ctx->timing->fts_now;
+	int reset_cb = -1;
+
+	dbg_print(CCX_DMT_VERBOSE, "Flush HD caption blocks\n");
+
+	for (int seq=0; seq<SORTBUF; seq++)
+	{
+
+		// We rely on this.
+		if (ctx->in_bufferdatatype == CCX_H264)
+			reset_cb = 1;
+
+		// If fts_now is unchanged we rely on cc block counting,
+		// otherwise reset counters as they get changed by do_cb()
+		// below. This only happens when current_pts does not get
+		// updated, like it used do happen for elementary streams.
+		// Since use_gop_as_pts this is not needed anymore, but left
+		// here for posterity.
+		if (reset_cb < 0 && ctx->cc_fts[seq] && seq<SORTBUF-1 && ctx->cc_fts[seq+1])
+		{
+			if (ctx->cc_fts[seq] != ctx->cc_fts[seq+1])
+				reset_cb = 1;
+			else
+				reset_cb = 0;
+		}
+		if (reset_cb == 1)
+		{
+			cb_field1 = 0;
+			cb_field2 = 0;
+			cb_708 = 0;
+		}
+
+		// Skip sequence numbers without data
+		if (ctx->cc_data_count[seq] == 0)
+			continue;
+
+		if (ctx->cc_data_pkts[seq][ctx->cc_data_count[seq]*3]!=0xFF)
+		{
+			// This is not optional. Something is wrong.
+			dbg_print(CCX_DMT_VERBOSE, "Missing 0xFF marker at end\n");
+			// A "continue;" here would ignore this caption, but we
+			// process it.
+		}
+
+		// Re-create original time
+		ctx->timing->fts_now = ctx->cc_fts[seq];
+		process_cc_data( ctx, ctx->cc_data_pkts[seq], ctx->cc_data_count[seq], sub);
+
+	}
+
+	// Restore the value
+	ctx->timing->fts_now = store_fts_now;
+
+	// Now that we are done, clean up.
+	init_hdcc(ctx);
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/utility.c Added

@@ -0,0 +1,700 @@
+#include <stdio.h>
+#include <signal.h>
+#include <string.h>
+#include "lib_ccx.h"
+#include "ccx_common_platform.h"
+#include "ccx_common_option.h"
+#include "activity.h"
+#include "utility.h"
+
+int temp_debug = 0; // This is a convenience variable used to enable/disable debug on variable conditions. Find references to understand.
+volatile sig_atomic_t change_filename_requested = 0;
+
+
+static uint32_t crc32_table [] = {
+    0x00000000, 0x04c11db7, 0x09823b6e, 0x0d4326d9,
+    0x130476dc, 0x17c56b6b, 0x1a864db2, 0x1e475005,
+    0x2608edb8, 0x22c9f00f, 0x2f8ad6d6, 0x2b4bcb61,
+    0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
+    0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9,
+    0x5f15adac, 0x5bd4b01b, 0x569796c2, 0x52568b75,
+    0x6a1936c8, 0x6ed82b7f, 0x639b0da6, 0x675a1011,
+    0x791d4014, 0x7ddc5da3, 0x709f7b7a, 0x745e66cd,
+    0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
+    0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5,
+    0xbe2b5b58, 0xbaea46ef, 0xb7a96036, 0xb3687d81,
+    0xad2f2d84, 0xa9ee3033, 0xa4ad16ea, 0xa06c0b5d,
+    0xd4326d90, 0xd0f37027, 0xddb056fe, 0xd9714b49,
+    0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
+    0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1,
+    0xe13ef6f4, 0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d,
+    0x34867077, 0x30476dc0, 0x3d044b19, 0x39c556ae,
+    0x278206ab, 0x23431b1c, 0x2e003dc5, 0x2ac12072,
+    0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
+    0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca,
+    0x7897ab07, 0x7c56b6b0, 0x71159069, 0x75d48dde,
+    0x6b93dddb, 0x6f52c06c, 0x6211e6b5, 0x66d0fb02,
+    0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1, 0x53dc6066,
+    0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
+    0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e,
+    0xbfa1b04b, 0xbb60adfc, 0xb6238b25, 0xb2e29692,
+    0x8aad2b2f, 0x8e6c3698, 0x832f1041, 0x87ee0df6,
+    0x99a95df3, 0x9d684044, 0x902b669d, 0x94ea7b2a,
+    0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
+    0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2,
+    0xc6bcf05f, 0xc27dede8, 0xcf3ecb31, 0xcbffd686,
+    0xd5b88683, 0xd1799b34, 0xdc3abded, 0xd8fba05a,
+    0x690ce0ee, 0x6dcdfd59, 0x608edb80, 0x644fc637,
+    0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
+    0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f,
+    0x5c007b8a, 0x58c1663d, 0x558240e4, 0x51435d53,
+    0x251d3b9e, 0x21dc2629, 0x2c9f00f0, 0x285e1d47,
+    0x36194d42, 0x32d850f5, 0x3f9b762c, 0x3b5a6b9b,
+    0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
+    0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623,
+    0xf12f560e, 0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7,
+    0xe22b20d2, 0xe6ea3d65, 0xeba91bbc, 0xef68060b,
+    0xd727bbb6, 0xd3e6a601, 0xdea580d8, 0xda649d6f,
+    0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
+    0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7,
+    0xae3afba2, 0xaafbe615, 0xa7b8c0cc, 0xa379dd7b,
+    0x9b3660c6, 0x9ff77d71, 0x92b45ba8, 0x9675461f,
+    0x8832161a, 0x8cf30bad, 0x81b02d74, 0x857130c3,
+    0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
+    0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c,
+    0x7b827d21, 0x7f436096, 0x7200464f, 0x76c15bf8,
+    0x68860bfd, 0x6c47164a, 0x61043093, 0x65c52d24,
+    0x119b4be9, 0x155a565e, 0x18197087, 0x1cd86d30,
+    0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
+    0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088,
+    0x2497d08d, 0x2056cd3a, 0x2d15ebe3, 0x29d4f654,
+    0xc5a92679, 0xc1683bce, 0xcc2b1d17, 0xc8ea00a0,
+    0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb, 0xdbee767c,
+    0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
+    0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4,
+    0x89b8fd09, 0x8d79e0be, 0x803ac667, 0x84fbdbd0,
+    0x9abc8bd5, 0x9e7d9662, 0x933eb0bb, 0x97ffad0c,
+    0xafb010b1, 0xab710d06, 0xa6322bdf, 0xa2f33668,
+    0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
+};
+
+int verify_crc32(uint8_t *buf, int len)
+{
+	int i = 0;
+	int32_t crc = -1;
+	for (i = 0; i < len; i++)
+		crc = (crc << 8) ^ crc32_table[((crc >> 24) ^ (buf[i] & 0xff)) & 0xff];
+	return crc?CCX_FALSE:CCX_TRUE;
+}
+
+int stringztoms (const char *s, struct ccx_boundary_time *bt)
+{
+	unsigned ss=0, mm=0, hh=0;
+	int value=-1;
+	int colons=0;
+	const char *c=s;
+	while (*c)
+	{
+		if (*c==':')
+		{
+			if (value==-1) // : at the start, or ::, etc
+				return -1;
+			colons++;
+			if (colons>2) // Max 2, for HH:MM:SS
+				return -1;
+			hh=mm;
+			mm=ss;
+			ss=value;
+			value=-1;
+		}
+		else
+		{
+			if (!isdigit (*c)) // Only : or digits, so error
+				return -1;
+			if (value==-1)
+				value=*c-'0';
+			else
+				value=value*10+*c-'0';
+		}
+		c++;
+	}
+	hh = mm;
+	mm = ss;
+	ss = value;
+	if (mm > 59 || ss > 59)
+		return -1;
+	bt->set = 1;
+	bt->hh = hh;
+	bt->mm = mm;
+	bt->ss = ss;
+	LLONG secs = (hh * 3600 + mm * 60 + ss);
+	bt->time_in_ms = secs*1000;
+	return 0;
+}
+void timestamp_to_srttime(uint64_t timestamp, char *buffer)
+{
+	uint64_t p = timestamp;
+	uint8_t h = (uint8_t) (p / 3600000);
+	uint8_t m = (uint8_t) (p / 60000 - 60 * h);
+	uint8_t s = (uint8_t) (p / 1000 - 3600 * h - 60 * m);
+	uint16_t u = (uint16_t) (p - 3600000 * h - 60000 * m - 1000 * s);
+	sprintf(buffer, "%02"PRIu8":%02"PRIu8":%02"PRIu8",%03"PRIu16, h, m, s, u);
+}
+void timestamp_to_vtttime(uint64_t timestamp, char *buffer)
+{
+	uint64_t p = timestamp;
+	uint8_t h = (uint8_t)(p / 3600000);
+	uint8_t m = (uint8_t)(p / 60000 - 60 * h);
+	uint8_t s = (uint8_t)(p / 1000 - 3600 * h - 60 * m);
+	uint16_t u = (uint16_t)(p - 3600000 * h - 60000 * m - 1000 * s);
+	sprintf(buffer, "%02"PRIu8":%02"PRIu8":%02"PRIu8".%03"PRIu16, h, m, s, u);
+}
+
+#define MIN3(a, b, c) ((a) < (b) ? ((a) < (c) ? (a) : (c)) : ((b) < (c) ? (b) : (c)))
+
+int levenshtein_dist (const uint64_t *s1, const uint64_t *s2, unsigned s1len, unsigned s2len)
+{
+	unsigned int x, y, v, lastdiag, olddiag;
+	unsigned int *column = (unsigned *) malloc ((s1len+1)*sizeof (unsigned int));
+	for (y = 1; y <= s1len; y++)
+		column[y] = y;
+	for (x = 1; x <= s2len; x++)
+	{
+		column[0] = x;
+		for (y = 1, lastdiag = x-1; y <= s1len; y++)
+		{
+			olddiag = column[y];
+			column[y] = MIN3(column[y] + 1, column[y-1] + 1, lastdiag + (s1[y-1] == s2[x-1] ? 0 : 1));
+			lastdiag = olddiag;
+		}
+	}
+	v = column[s1len];
+	free (column);
+	return v;
+}
+
+int levenshtein_dist_char (const char *s1, const char *s2, unsigned s1len, unsigned s2len)
+{
+	unsigned int x, y, v, lastdiag, olddiag;
+	unsigned int *column = (unsigned *) malloc ((s1len+1)*sizeof (unsigned int));
+	for (y = 1; y <= s1len; y++)
+		column[y] = y;
+	for (x = 1; x <= s2len; x++)
+	{
+		column[0] = x;
+		for (y = 1, lastdiag = x-1; y <= s1len; y++)
+		{
+			olddiag = column[y];
+			column[y] = MIN3(column[y] + 1, column[y-1] + 1, lastdiag + (s1[y-1] == s2[x-1] ? 0 : 1));
+			lastdiag = olddiag;
+		}
+	}
+	v = column[s1len];
+	free (column);
+	return v;
+}
+
+void millis_to_date (uint64_t timestamp, char *buffer, enum ccx_output_date_format date_format, char millis_separator)
+{
+	time_t secs;
+	unsigned int millis;
+	char c_temp[80];
+	struct tm *time_struct=NULL;
+	switch (date_format)
+	{
+		case ODF_NONE:
+			buffer[0] = 0;
+			break;
+		case ODF_HHMMSS:
+			timestamp_to_srttime (timestamp, buffer);
+			buffer[8] = 0;
+			break;
+		case ODF_HHMMSSMS:
+			timestamp_to_srttime (timestamp, buffer);
+			break;
+		case ODF_SECONDS:
+			secs = (time_t) (timestamp/1000);
+			millis = (time_t) (timestamp%1000);
+			sprintf (buffer, "%lu%c%03u", (unsigned long) secs,
+					millis_separator, (unsigned) millis);
+			break;
+		case ODF_DATE:
+			secs = (time_t) (timestamp/1000);
+			millis = (unsigned int) (timestamp%1000);
+			time_struct = gmtime(&secs);
+			strftime(c_temp, sizeof(c_temp), "%Y%m%d%H%M%S", time_struct);
+			sprintf (buffer, "%s%c%03u", c_temp, millis_separator, millis);
+			break;
+
+		default:
+			fatal(CCX_COMMON_EXIT_BUG_BUG, "Invalid value for date_format in millis_to_date()\n");
+	}
+}
+
+bool_t in_array(uint16_t *array, uint16_t length, uint16_t element)
+{
+	bool_t r = NO;
+	for (uint16_t i = 0; i < length; i++)
+		if (array[i] == element)
+		{
+			r = YES;
+			break;
+		}
+	return r;
+}
+
+void print_error (int mode, const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	if (mode)
+		fprintf(stderr,"###MESSAGE#");
+	else
+		fprintf(stderr, "\rError: ");
+	vfprintf(stderr, fmt, args);
+	fprintf(stderr, "\n");
+	va_end(args);
+}
+/* Write formatted message to stderr and then exit. */
+void fatal(int exit_code, const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	if (ccx_options.gui_mode_reports)
+		fprintf(stderr,"###MESSAGE#");
+	else
+		fprintf(stderr, "\rError: ");
+	vfprintf(stderr, fmt, args);
+	fprintf(stderr, "\n");
+	print_end_msg();
+	va_end(args);
+	exit(exit_code);
+}
+
+/* General output, replacement for printf so we can control globally where messages go.
+   mprint => Message print */
+void mprint (const char *fmt, ...)
+{
+	va_list args;
+	if (!ccx_options.messages_target)
+		return;
+	activity_header(); // Brag about writing it :-)
+	va_start(args, fmt);
+	if (ccx_options.messages_target==CCX_MESSAGES_STDOUT)
+	{
+		vfprintf(stdout, fmt, args);
+		fflush (stdout);
+	}
+	else
+	{
+		vfprintf(stderr, fmt, args);
+		fflush (stderr);
+	}
+	va_end(args);
+}
+
+/* Shorten some debug output code. */
+void dbg_print(LLONG mask, const char *fmt, ...)
+{
+	va_list args;
+	LLONG t;
+	if (!ccx_options.messages_target)
+		return;
+	t = temp_debug ? (ccx_options.debug_mask_on_debug | ccx_options.debug_mask) : ccx_options.debug_mask; // Mask override?
+
+	if(mask & t)
+	{
+		va_start(args, fmt);
+		if (ccx_options.messages_target==CCX_MESSAGES_STDOUT)
+		{
+			vfprintf(stdout, fmt, args);
+			fflush (stdout);
+		}
+		else
+		{
+			vfprintf(stderr, fmt, args);
+			fflush (stderr);
+		}
+		va_end(args);
+	}
+}
+
+void dump (LLONG mask, unsigned char *start, int l, unsigned long abs_start, unsigned clear_high_bit)
+{
+	LLONG t=temp_debug ? (ccx_options.debug_mask_on_debug | ccx_options.debug_mask) : ccx_options.debug_mask; // Mask override?
+	if(! (mask & t))
+		return;
+
+	for (int x=0; x<l; x=x+16)
+	{
+		mprint ("%08ld | ",x+abs_start);
+		for (int j=0; j<16; j++)
+		{
+			if (x+j<l)
+				mprint ("%02X ",start[x+j]);
+			else
+				mprint ("   ");
+		}
+		mprint (" | ");
+		for (int j=0; j<16; j++)
+		{
+			if (x+j<l && start[x+j]>=' ')
+				mprint ("%c", start[x+j] & (clear_high_bit ? 0x7F : 0xFF)); // 0x7F < remove high bit, convenient for visual CC inspection
+			else
+				mprint (" ");
+		}
+		mprint ("\n");
+	}
+}
+
+void init_boundary_time (struct ccx_boundary_time *bt)
+{
+	bt->hh = 0;
+	bt->mm = 0;
+	bt->ss = 0;
+	bt->set = 0;
+	bt->time_in_ms = 0;
+}
+
+
+void sleep_secs (int secs)
+{
+#ifdef _WIN32
+	Sleep(secs * 1000);
+#else
+	sleep(secs);
+#endif
+}
+
+int hex_to_int (char high, char low)
+{
+	unsigned char h,l;
+	if (high >= '0' && high <= '9')
+		h = high-'0';
+	else if (high >= 'a' && high <= 'f')
+		h = high-'a'+10;
+	else
+		return -1;
+	if (low >= '0' && low <= '9')
+		l = low - '0';
+	else if (low >= 'a' && low <= 'f')
+		l = low - 'a'+10;
+	else
+		return -1;
+	return h * 16+l;
+}
+int hex_string_to_int(char* string, int len)
+{
+  int total_return = 0;
+  while(*string && len-- > 0 && total_return >= 0){
+    unsigned char c = *string;
+    if(c >= '0' && c <= '9')
+      total_return = total_return * 16 + (c - '0');
+    else if(*string >= 'a' && *string <= 'f')
+      total_return = total_return * 16 + (c - 'a' + 10);
+    else
+      total_return = -1;
+    string++;
+  }
+  return total_return;
+}
+
+#ifndef _WIN32
+void m_signal(int sig, void (*func)(int))
+{
+	struct sigaction act;
+	act.sa_handler = func;
+	sigemptyset(&act.sa_mask);
+	act.sa_flags = 0;
+
+	if (sigaction(sig, &act, NULL))
+		perror("sigaction() error");
+
+	return;
+}
+
+#endif
+
+#ifndef MMCCXTR
+struct encoder_ctx *change_filename(struct encoder_ctx *enc_ctx)
+{
+	if(change_filename_requested == 0)
+	{
+		return enc_ctx;
+	}
+	struct encoder_ctx *temp_encoder = malloc(sizeof(struct encoder_ctx));
+	*temp_encoder = *enc_ctx;
+	if (enc_ctx->out->fh != -1)
+	{
+		if (enc_ctx->out->fh > 0)
+			close(enc_ctx->out->fh);
+		enc_ctx->out->fh=-1;
+		int iter;
+		char str_number[15];
+		char *current_name = malloc(sizeof(char)*(strlen(enc_ctx->out->filename)+10));
+		strcpy(current_name,enc_ctx->out->filename);
+		mprint ("Creating %s\n", enc_ctx->out->filename);
+		if(enc_ctx->out->renaming_extension)
+		{
+			strcat(current_name,".");
+			sprintf(str_number, "%d", enc_ctx->out->renaming_extension);
+			strcat(current_name,str_number);
+		}
+		enc_ctx->out->renaming_extension++;
+		for (iter = enc_ctx->out->renaming_extension; iter >= 1; iter--)
+		{
+			int ret;
+			char new_extension[6];
+			sprintf(new_extension, ".%d", iter); 
+			char *newname = malloc(sizeof(char)*(strlen(enc_ctx->out->filename)+10));
+			strcpy(newname,enc_ctx->out->filename);
+			strcat(newname,new_extension);
+			ret = rename(current_name, newname);
+			if(ret)
+			{
+				mprint("Failed to rename the file\n");
+
+			}
+			mprint ("Creating %s\n", newname);
+			strcpy(current_name,enc_ctx->out->filename);
+			
+			if(iter-2>0)
+			{
+				strcat(current_name,".");
+				sprintf(str_number, "%d", iter-2);
+				strcat(current_name,str_number);
+			}
+			free(newname);
+		
+		}
+
+		enc_ctx->out->fh = open(enc_ctx->out->filename, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, S_IREAD | S_IWRITE);
+		free(current_name);
+		if (enc_ctx->out->fh == -1)
+		{
+			mprint("Failed to create a new rotation file\n");
+			return temp_encoder;
+		}
+		free(temp_encoder);		
+		change_filename_requested = 0;
+		return enc_ctx;
+		
+	}
+	return temp_encoder;
+}
+#endif
+
+char *get_basename(char *filename)
+{
+	char *c;
+	int len;
+	char *basefilename;
+
+	if(!filename)
+		return NULL;	
+
+	len = strlen(filename);
+	basefilename = (char *) malloc(len+1);
+	if (basefilename == NULL)
+	{
+		return NULL;
+	}
+
+	strcpy (basefilename, filename);
+
+	for (c = basefilename + len; c > basefilename && *c != '.'; c--)
+	{;} // Get last .
+	if (*c == '.')
+		*c = 0;
+
+	return basefilename;
+}
+
+char *get_file_extension(enum ccx_output_format write_format)
+{
+	switch (write_format)
+	{
+		case CCX_OF_RAW:
+			return strdup(".raw");
+		case CCX_OF_SRT:
+			return strdup(".srt");
+#ifndef MMCCXTR
+		case CCX_OF_SSA:
+			return strdup(".ass");
+		case CCX_OF_WEBVTT:
+			return strdup (".vtt");
+		case CCX_OF_SAMI:
+			return strdup(".smi");
+		case CCX_OF_SMPTETT:
+			return strdup(".ttml");
+		case CCX_OF_TRANSCRIPT:
+			return strdup(".txt");
+		case CCX_OF_RCWT:
+			return strdup(".bin");
+		case CCX_OF_SPUPNG:
+			return strdup(".xml");
+		case CCX_OF_DVDRAW:
+			return strdup(".dvdraw");
+		case CCX_OF_SIMPLE_XML:
+			return strdup(".xml");
+		case CCX_OF_G608:
+			return strdup(".g608");
+		case CCX_OF_NULL:
+			return NULL;
+		case CCX_OF_CURL:
+			return NULL;
+#endif
+		default:
+			fatal (CCX_COMMON_EXIT_BUG_BUG, "write_format doesn't have any legal value. Please report this bug on Github.com\n");
+			errno = EINVAL;
+			return NULL;
+	}
+	return 0;
+}
+
+char *create_outfilename(const char *basename, const char *suffix, const char *extension)
+{
+	char *ptr = NULL;
+	size_t blen, slen, elen;
+
+	if(basename)
+		blen = strlen(basename);
+	else
+		blen = 0;
+
+	if(suffix)
+		slen = strlen(suffix);
+	else
+		slen = 0;
+
+	if(extension)
+		elen = strlen(extension);
+	else
+		elen = 0;
+	if ( (elen + slen + blen) <= 0)
+		return NULL;
+
+	ptr = malloc(elen + slen + blen + 1);
+	if(!ptr)
+		return NULL;
+
+	ptr[0] = '\0';
+
+	if(basename)
+		strcat(ptr, basename);
+	if(suffix)
+		strcat(ptr, suffix);
+	if(extension)
+		strcat(ptr, extension);
+	return ptr;
+}
+
+#ifndef MMCCXTR
+size_t utf16_to_utf8(unsigned short utf16_char, unsigned char *out)
+{
+	if (utf16_char < 0x80) {
+		out[0] = (unsigned char)((utf16_char >> 0 & 0x7F) | 0x00);
+		return 1;
+	} else if (utf16_char < 0x0800) {
+		out[0] = (unsigned char)((utf16_char >> 6 & 0x1F) | 0xC0);
+		out[1] = (unsigned char)((utf16_char >> 0 & 0x3F) | 0x80);
+		return 2;
+	} else if (utf16_char < 0x010000) {
+		out[0] = (unsigned char)((utf16_char >> 12 & 0x0F) | 0xE0);
+		out[1] = (unsigned char)((utf16_char >> 6 & 0x3F) | 0x80);
+		out[2] = (unsigned char)((utf16_char >> 0 & 0x3F) | 0x80);
+		return 3;
+	} else if (utf16_char < 0x110000) {
+		out[0] = (unsigned char)((utf16_char >> 18 & 0x07) | 0xF0);
+		out[1] = (unsigned char)((utf16_char >> 12 & 0x3F) | 0x80);
+		out[2] = (unsigned char)((utf16_char >> 6 & 0x3F) | 0x80);
+		out[3] = (unsigned char)((utf16_char >> 0 & 0x3F) | 0x80);
+		return 4;
+	}
+	return 0;
+}
+#endif
+
+LLONG change_timebase(LLONG val, struct ccx_rational cur_tb, struct ccx_rational dest_tb)
+{
+	/* val = (value * current timebase) / destination timebase */
+	val = val * cur_tb.num * dest_tb.den;
+	val = val / ( cur_tb.den * dest_tb.num);
+	return val;
+}
+
+char *str_reallocncat(char *dst, char *src)
+{	
+	int nl = dst==NULL? (strlen (src)+1) : (strlen(dst) + strlen(src) + 1);
+	char *orig = dst;
+	dst = (char *)realloc(dst, nl);
+	if (!dst)
+		return NULL;
+	if (orig == NULL)
+		strcpy(dst, src);
+	else
+		strcat(dst, src);
+	return dst;
+}
+
+#if defined(_WIN32) && !defined(MMCCXTR)
+char *strndup(const char *s, size_t n)
+{
+	char *p;
+
+	p = (char *)malloc(n + 1);
+	if (p == NULL)
+		return NULL;
+	memcpy(p, s, n);
+	p[n] = '\0';
+	return p;
+}
+char *strtok_r(char *str, const char *delim, char **saveptr)
+{
+	return strtok_s(str, delim, saveptr);
+}
+#endif //_WIN32
+
+int vasprintf(char **strp, const char *fmt, va_list ap)
+{
+	int len, ret;
+	va_list tmp_va;
+
+	va_copy(tmp_va, ap);
+#if defined(_WIN32) && !defined(MMCCXTR)
+	len = _vscprintf(fmt, tmp_va);
+#else
+	len = vsnprintf(NULL, 0, fmt, tmp_va);
+#endif
+	va_end(tmp_va);
+	if (len == -1)
+		return -1;
+	size_t size = (size_t)len + 1;
+	*strp = malloc(size);
+	if (*strp == NULL)
+		return -1;
+
+#if defined(_WIN32) && !defined(MMCCXTR)
+	ret = vsprintf_s(*strp, size, fmt, ap);
+#else
+	ret = vsnprintf(*strp, size, fmt, ap);
+#endif
+	if (ret == -1) {
+		free(*strp);
+		return -1;
+	}
+
+	return ret;
+}
+
+int asprintf(char **strp, const char *fmt, ...)
+{
+	int ret;
+	va_list ap;
+
+	va_start(ap, fmt);
+	ret = vasprintf(strp, fmt, ap);
+	va_end(ap);
+
+	return ret;
+}

makemkv-oss-1.16.2.tar.gz/mmccextr/lib_ccx/utility.h Added

@@ -0,0 +1,47 @@
+#ifndef CC_UTILITY_H
+#define CC_UTILITY_H
+#include <signal.h>
+#ifndef _WIN32
+	#include <arpa/inet.h>
+#endif
+
+#define RL32(x) (*(unsigned int *)(x))
+#define RB32(x) (ntohl(*(unsigned int *)(x)))
+#define RL16(x) (*(unsigned short int*)(x))
+#define RB16(x) (ntohs(*(unsigned short int*)(x)))
+
+#define RB24(x) (  ((unsigned char*)(x))[0] << 16 | ((unsigned char*)(x))[1] << 8 | ((unsigned char*)(x))[2]  )
+
+#define CCX_NOPTS	((int64_t)UINT64_C(0x8000000000000000))
+
+struct ccx_rational
+{
+	int num;
+	int den;
+};
+extern int temp_debug;
+volatile extern sig_atomic_t change_filename_requested;
+
+int levenshtein_dist_char (const char *s1, const char *s2, unsigned s1len, unsigned s2len);
+void init_boundary_time (struct ccx_boundary_time *bt);
+void print_error (int mode, const char *fmt, ...);
+int stringztoms (const char *s, struct ccx_boundary_time *bt);
+char *get_basename(char *filename);
+char *get_file_extension(enum ccx_output_format write_format);
+char *create_outfilename(const char *basename, const char *suffix, const char *extension);
+int verify_crc32(uint8_t *buf, int len);
+size_t utf16_to_utf8(unsigned short utf16_char, unsigned char *out);
+LLONG change_timebase(LLONG val, struct ccx_rational cur_tb, struct ccx_rational dest_tb);
+char *str_reallocncat(char *dst, char *src);
+
+void dump (LLONG mask, unsigned char *start, int l, unsigned long abs_start, unsigned clear_high_bit);
+LLONG change_timebase(LLONG val, struct ccx_rational cur_tb, struct ccx_rational dest_tb);
+void timestamp_to_vtttime(uint64_t timestamp, char *buffer);
+int vasprintf(char **strp, const char *fmt, va_list ap);
+int asprintf(char **strp, const char *fmt, ...);
+#ifdef _WIN32
+char *strndup(const char *s, size_t n);
+char *strtok_r(char *str, const char *delim, char **saveptr);
+#endif //_WIN32
+
+#endif //CC_UTILITY_H

makemkv-oss-1.16.2.tar.gz/mmccextr/mmccextr.mak Added

@@ -0,0 +1,54 @@
+
+MMCCEXTR_DEF=\
+  -DMMCCXTR=1 \
+
+
+MMCCEXTR_SRC=\
+    ccextractor.c \
+    lib_ccx/activity.c \
+    lib_ccx/ccx_common_char_encoding.c \
+    lib_ccx/ccx_common_common.c \
+    lib_ccx/ccx_common_constants.c \
+    lib_ccx/ccx_common_option.c \
+    lib_ccx/ccx_common_timing.c \
+    lib_ccx/ccx_decoders_608.c \
+    lib_ccx/ccx_decoders_common.c \
+    lib_ccx/ccx_demuxer.c \
+    lib_ccx/ccx_encoders_common.c \
+    lib_ccx/ccx_encoders_helpers.c \
+    lib_ccx/ccx_encoders_srt.c \
+    lib_ccx/file_functions.c \
+    lib_ccx/general_loop.c \
+    lib_ccx/lib_ccx.c \
+    lib_ccx/output.c \
+    lib_ccx/params.c \
+    lib_ccx/params_dump.c \
+    lib_ccx/sequencing.c \
+    lib_ccx/utility.c \
+
+MMCCEXTR_HDR=\
+    ccextractor.h \
+    lib_ccx/activity.h \
+    lib_ccx/bitstream.h \
+    lib_ccx/ccx_common_char_encoding.h \
+    lib_ccx/ccx_common_common.h \
+    lib_ccx/ccx_common_constants.h \
+    lib_ccx/ccx_common_option.h \
+    lib_ccx/ccx_common_platform.h \
+    lib_ccx/ccx_common_structs.h \
+    lib_ccx/ccx_common_timing.h \
+    lib_ccx/ccx_decoders_608.h \
+    lib_ccx/ccx_decoders_708.h \
+    lib_ccx/ccx_decoders_common.h \
+    lib_ccx/ccx_decoders_structs.h \
+    lib_ccx/ccx_demuxer.h \
+    lib_ccx/ccx_encoders_common.h \
+    lib_ccx/ccx_encoders_helpers.h \
+    lib_ccx/ccx_encoders_structs.h \
+    lib_ccx/compile_info.h \
+    lib_ccx/compile_info_real.h \
+    lib_ccx/file_buffer.h \
+    lib_ccx/lib_ccx.h \
+    lib_ccx/list.h \
+    lib_ccx/utility.h \
+

Build Results
RPM Lint

Refresh

Comments for request 5366 0

Request History

manfred.h created request over 3 years ago

- Update to version 1.16.2
* Bug fixes:
- Mac OS: Program produced random errors when running on OS X
10.11 El Captain or earlier versions
- Linux: ccextractor is now part of OSS package

manfred.h accepted request over 3 years ago

Accepted