Request 5586 (accepted)

Overview

Request 5586 (accepted)

- Update to version 1.17.0
* Improved handling for discs with mastering errors
* A new, rewritten DVD engine - much better handling for discs
with structure protection
* Many internal improvements and small bugfixes
* Notable Bug fixes:
- Program failed to recognize some exotic USB drives
- Program failed on some DVD streams recorded from satellite
feed (TiVO DVD)
- Program could hang if internet connection wasn't available
- Add silence-return-type.patch

Created by manfred.h over 2 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

silence-return-type.patch Added

@@ -0,0 +1,44 @@
+diff -rup makemkv-oss-1.17.0.orig/mmgpl/dvdnav/vm/vmget.c makemkv-oss-1.17.0/mmgpl/dvdnav/vm/vmget.c
+--- makemkv-oss-1.17.0.orig/mmgpl/dvdnav/vm/vmget.c	2022-06-28 10:12:22.384481339 +0200
++++ makemkv-oss-1.17.0/mmgpl/dvdnav/vm/vmget.c	2022-06-28 10:16:08.024416824 +0200
+@@ -311,6 +311,8 @@ int vm_get_video_scale_permission(vm_t *
+ }
+ 
+ video_attr_t vm_get_video_attr(vm_t *vm) {
++  static video_attr_t not_actually_used = { 0 };
++
+   switch ((vm->state).domain) {
+   case DVD_DOMAIN_VTSTitle:
+     return vm->vtsi->vtsi_mat->vts_video_attr;
+@@ -322,9 +324,12 @@ video_attr_t vm_get_video_attr(vm_t *vm)
+   default:
+     vassert(0);
+   }
++  return not_actually_used; /* NOT REACHED */
+ }
+ 
+ audio_attr_t vm_get_audio_attr(vm_t *vm, int streamN) {
++  static audio_attr_t not_actually_used = { 0 };
++
+   switch ((vm->state).domain) {
+   case DVD_DOMAIN_VTSTitle:
+     return vm->vtsi->vtsi_mat->vts_audio_attrstreamN;
+@@ -336,9 +341,12 @@ audio_attr_t vm_get_audio_attr(vm_t *vm,
+   default:
+     vassert(0);
+   }
++  return not_actually_used; /* NOT REACHED */
+ }
+ 
+ subp_attr_t vm_get_subp_attr(vm_t *vm, int streamN) {
++  static subp_attr_t not_actually_used = { 0 };
++
+   switch ((vm->state).domain) {
+   case DVD_DOMAIN_VTSTitle:
+     return vm->vtsi->vtsi_mat->vts_subp_attrstreamN;
+@@ -350,4 +358,5 @@ subp_attr_t vm_get_subp_attr(vm_t *vm, i
+   default:
+     vassert(0);
+   }
++  return not_actually_used; /* NOT REACHED */
+ }

makemkv-bin-1.16.7.tar.gz/bin/amd64/makemkvcon -> makemkv-bin-1.17.0.tar.gz/bin/amd64/makemkvcon Changed

makemkv-bin-1.16.7.tar.gz/bin/arm64/makemkvcon -> makemkv-bin-1.17.0.tar.gz/bin/arm64/makemkvcon Changed

makemkv-bin-1.16.7.tar.gz/bin/armel/makemkvcon -> makemkv-bin-1.17.0.tar.gz/bin/armel/makemkvcon Changed

makemkv-bin-1.16.7.tar.gz/bin/i386/makemkvcon -> makemkv-bin-1.17.0.tar.gz/bin/i386/makemkvcon Changed

makemkv-bin-1.16.7.tar.gz/src/share/appdata.tar -> makemkv-bin-1.17.0.tar.gz/src/share/appdata.tar Changed

makemkv-bin-1.16.7.tar.gz/src/share/blues.jar -> makemkv-bin-1.17.0.tar.gz/src/share/blues.jar Changed

makemkv-oss-1.16.7.tar.gz/Makefile.in -> makemkv-oss-1.17.0.tar.gz/Makefile.in Changed

@@ -44,13 +44,13 @@
 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 out/mmccextr
+all: out/libdriveio.so.0 out/libmakemkv.so.1 $(OUT_GUI) out/libmmbd.so.0 out/mmccextr out/mmgplsrv
 	@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 out/mmccextr
+install: out/libdriveio.so.0 out/libmakemkv.so.1 $(OUT_GUI) out/libmmbd.so.0 out/mmccextr out/mmgplsrv
 	$(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
@@ -68,6 +68,7 @@
 	$(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
+	$(INSTALL) -D -m 755 out/mmgplsrv $(DESTDIR)$(bindir)/mmgplsrv
 
 out/%: out/%.full
 	$(OBJCOPY) $(STRIP_FLAGS) $< $@
@@ -115,6 +116,12 @@
 	$(GCC) $(CFLAGS) $(MMCCEXTR_DEF) -DHAVE_BUILDINFO_H -Itmp -D_GNU_SOURCE -o$@ $(MMCCX_SRC) -lc \
 	-ffunction-sections -Wl,--gc-sections -Wl,-z,defs
 
+out/mmgplsrv.full: $(MMGPL_SRC)
+	mkdir -p out
+	$(GCC) $(CFLAGS) $(INCF)$(MMGPL_INC) $(INCF)$(DVDNAV_INC) $(INCF)$(DVDREAD_INC) $(INCF)$(MAKEMKVGUI_INC) $(INCF)$(LIBMAKEMKV_INC) \
+	$(INCF)$(LIBDRIVEIO_INC) $(INCF)$(LIBABI_INC) $(MMGPL_DEF) -D_GNU_SOURCE -Dstl=std -o$@ $(MMGPL_SRC) $(MMGPL_SRC_LINUX) -lc -lstdc++ \
+	-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.7.tar.gz/libdriveio/inc/driveio/driveio.h -> makemkv-oss-1.17.0.tar.gz/libdriveio/inc/driveio/driveio.h Changed

makemkv-oss-1.16.7.tar.gz/libdriveio/inc/driveio/scsihlp.h -> makemkv-oss-1.17.0.tar.gz/libdriveio/inc/driveio/scsihlp.h Changed

makemkv-oss-1.16.7.tar.gz/libdriveio/inc/lgpl/byteorder.h -> makemkv-oss-1.17.0.tar.gz/libdriveio/inc/lgpl/byteorder.h Changed

makemkv-oss-1.17.0.tar.gz/libdriveio/inc/lgpl/posixio.h Added

@@ -0,0 +1,131 @@
+/*
+    libDriveIo - MMC drive interrogation library
+
+    Copyright (C) 2007-2022 GuinpinSoft inc <libdriveio@makemkv.com>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library 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
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+*/
+#ifndef LGPL_POSIXIO_H_INCLUDED
+#define LGPL_POSIXIO_H_INCLUDED
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <stdio.h>
+
+#if defined(_WIN32)
+
+#include <io.h>
+#include <process.h>
+
+#define lseek64 _lseeki64
+#define lseek   _lseek
+#define O_LARGEFILE 0
+
+#define open        _open
+#define close       _close
+#define read        _read
+#define unlink      _unlink
+#define write       _write
+#define fileno      _fileno
+#define dup         _dup
+#define stat64      _stat64
+#define fstat64     _fstat64
+
+#ifndef S_IFBLK
+#define	S_IFBLK 0060000	/* Block device.  */
+#endif
+#ifndef S_IFLNK
+#define	S_IFLNK 0120000	/* Symbolic link.  */
+#endif
+#ifndef S_IFSOCK
+#define	S_IFSOCK 0140000	/* Socket.  */
+#endif
+
+#ifndef STDIN_FILENO
+#define	STDIN_FILENO	0
+#define	STDOUT_FILENO	1
+#define	STDERR_FILENO	2
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int     open_utf8(const char * _Filename, int _Openflag, int _PermissionMode);
+int     stat64_utf8(const char * _Name, struct stat64 * _Stat);
+FILE*   fopen_utf8(const char * _Filename, const char * _Mode);
+int     unlink_utf8(const char * _Filename);
+int     rmdir_utf8(const char * _Path);
+int     mkdir_utf8(const char * _Path,unsigned int _Mode);
+int     rename_utf8(const char * _OldPath, const char * _NewPath);
+int     pread64(int fd,void* buf,size_t count,uint64_t offset);
+int     pwrite64(int fd,const void* buf,size_t count,uint64_t offset);
+int     ftruncate64(int fd,uint64_t offset);
+int     fsync(int fd);
+
+#ifdef __cplusplus
+};
+#endif
+
+#elif defined(_darwin_)
+
+#include <sys/param.h>
+#include <sys/mount.h>
+
+#ifndef _DARWIN_FEATURE_64_BIT_INODE
+#error "_DARWIN_FEATURE_64_BIT_INODE not defined"
+#endif
+
+#undef  stat64
+#define stat64 stat
+
+#define O_LARGEFILE 0
+#define O_BINARY    0
+#define lseek64     lseek
+#define pread64     pread
+#define pwrite64    pwrite
+#define ftruncate64 ftruncate
+
+#define open_utf8   open
+#define stat64_utf8 stat
+#define lstat64_utf8 lstat
+#define fstat64     fstat
+#define fopen_utf8  fopen
+#define unlink_utf8 unlink
+#define rmdir_utf8  rmdir
+#define mkdir_utf8  mkdir
+#define rename_utf8 rename
+
+#elif defined(_linux_)
+
+#define O_BINARY 0
+
+#define open_utf8   open
+#define stat64_utf8 stat64
+#define lstat64_utf8 lstat64
+#define fopen_utf8  fopen
+#define unlink_utf8 unlink
+#define rmdir_utf8  rmdir
+#define mkdir_utf8  mkdir
+#define rename_utf8 rename
+
+#endif
+
+#endif // LGPL_POSIXIO_H_INCLUDED
+

makemkv-oss-1.16.7.tar.gz/libdriveio/src/scsihlp.cpp -> makemkv-oss-1.17.0.tar.gz/libdriveio/src/scsihlp.cpp Changed

@@ -286,7 +286,7 @@
     return 0;
 }
 
-int LibDriveIo::QueryInquiryInfo(ISimpleScsiTarget* ScsiTarget,uint8_t Evpd,uint8_t *Buffer,unsigned int *BufferSize)
+int LibDriveIo::QueryInquiryInfo(ISimpleScsiTarget* ScsiTarget,uint8_t *Buffer,unsigned int *BufferSize)
 {
     int err;
     unsigned int len,slen;
@@ -295,43 +295,27 @@
 
     memset(cdb_inquiry,0,sizeof(cdb_inquiry));
     cdb_inquiry0=0x12;
-    if (Evpd!=0)
-    {
-        cdb_inquiry1=1;
-        cdb_inquiry2=Evpd;
-    }
 
-    err=ExecuteReadScsiCommand(ScsiTarget,cdb_inquiry,6,Buffer,254,&res);
+    err=ExecuteReadScsiCommand(ScsiTarget,cdb_inquiry,6,Buffer,0x60,&res);
     if (err) return err;
     len = res.Transferred;
 
-    if (Evpd==0)
+    if (res.Status != 0) return DRIVEIO_ERR_SCSI_STATUS(res.Status);
+    slen = ((unsigned int)Buffer4) + 5;
+    if (slen > len)
     {
-        if (res.Status!=0) return DRIVEIO_ERR_SCSI_STATUS(res.Status);
-        slen = ((unsigned int)Buffer4)+5;
-        if (slen>len)
-        {
-            if (len>=35)
-            {
-                //
-                // Some drives return incomplete inquiry data, accept it
-                // as long as mandatory portion is present
-                //
-                memset(Buffer+len,0,slen-len);
-            } else {
-                return DRIVEIO_ERROR_BAD_DATA;
-            }
-        }
-    } else {
-        *BufferSize=0;
-        if (res.Status!=0)
+        if (len >= 35)
         {
-            return 0;
+            //
+            // Some drives return incomplete inquiry data, accept it
+            // as long as mandatory portion is present
+            //
+            memset(Buffer + len, 0, slen - len);
+        } else {
+            return DRIVEIO_ERROR_BAD_DATA;
         }
-        slen = ((unsigned int)Buffer3)+4;
-        if (slen>len) return 0;
-        if (Buffer1!=Evpd) return 0;
     }
+
     *BufferSize = slen;
     return 0;
 }
@@ -349,7 +333,7 @@
         AddInquiryData(InquiryData,(const uint8_t*)item.Data);
     } else {
         // no drive info, query all data manually
-        if (0!=(err=QueryInquiryInfo(ScsiTarget,0,buf,&len))) return err;
+        if (0!=(err=QueryInquiryInfo(ScsiTarget,buf,&len))) return err;
         AddInquiryData(InquiryData,buf);
 
         if ((buf0&0x1f)!=5) return DRIVEIO_ERROR_BAD_DATA; // not a MMC drive

makemkv-oss-1.16.7.tar.gz/libdriveio/src/stdquery.cpp -> makemkv-oss-1.17.0.tar.gz/libdriveio/src/stdquery.cpp Changed

@@ -31,7 +31,7 @@
 //
 // Queries all standard drive info
 //
-static int QueryDriveInfo(ISimpleScsiTarget* ScsiTarget,DIO_INFOLIST List,bool Total)
+static int QueryDriveInfo(ISimpleScsiTarget* ScsiTarget,DIO_INFOLIST List)
 {
     int err;
     unsigned int len,slen;
@@ -40,36 +40,17 @@
     //
     // Inquiry
     //
-    err=QueryInquiryInfo(ScsiTarget,0,data_buffer,&slen);
+    err=QueryInquiryInfo(ScsiTarget,data_buffer,&slen);
     if (err) return err;
     if (DriveInfoList_AddItem(List,diid_InquiryData,data_buffer,slen)) return DRIVEIO_ERR_NO_MEMORY;
     if ((data_buffer0&0x1f)!=5) return DRIVEIO_ERROR_BAD_DATA; // not a MMC drive
 
-    if (Total)
-    {
-        uint8_t inqdata34;
-        memcpy(inqdata,data_buffer,34);
-
-        for (unsigned int evpd=1;evpd<256;evpd++)
-        {
-            err=QueryInquiryInfo(ScsiTarget,(uint8_t)evpd,data_buffer,&slen);
-            if (err) return err;
-            if (slen>=34)
-            {
-                if (0==memcmp(inqdata,data_buffer,34)) slen=0;
-            }
-            if (slen==0) continue;
-            if (DriveInfoList_AddItem(List,(DriveInfoId)(diid_InquiryData+evpd),data_buffer,slen)) return DRIVEIO_ERR_NO_MEMORY;
-        }
-    }
-
     //
     // All feature descriptors
     //
-    unsigned int current_feature = 0;
+    unsigned int current_feature = 0, first_feature;
     while(current_feature<0x10000)
     {
-        bool first_feature;
         uint8_t cdb_get_configuration10;
         ScsiCmdResponse res;
 
@@ -94,28 +75,23 @@
 
         if (slen < 12) return DRIVEIO_ERROR_BAD_DATA;
 
-        first_feature = true;
-
         const uint8_t *dptr=data_buffer+8;
         slen-=8;
 
+        first_feature = current_feature;
+
         while(slen>=4)
         {
             unsigned int feature_code, feature_len;
 
             feature_code = rd16be(dptr);
 
-            if (first_feature && (feature_code<current_feature))
+            if ((feature_code < first_feature) ||
+                ((current_feature !=0) && (feature_code == 0)))
             {
                 // drive is supposed to return empty feature header
-                // but returned the last feature descriptor
-                unsigned int diff = current_feature - feature_code;
-                if (diff<3)
-                {
-                    current_feature++;
-                } else {
-                    current_feature = 0x10000;
-                }
+                // but returned the last feature descriptor (or garbage)
+                current_feature = 0x10000;
                 break;
             }
 
@@ -123,20 +99,13 @@
 
             if (feature_len > slen)
             {
-                if (first_feature)
-                {
-                    // feature is bigger than max buffer size, skip it
-                    current_feature = feature_code+1;
-                    break;
-                } else {
-                    break;
-                }
+                if (feature_code >= current_feature) current_feature = (feature_code + 1);
+                break;
             }
 
             if (DriveInfoList_AddItem(List,(DriveInfoId)(diid_FeatureDescriptor + feature_code),dptr,feature_len)) return DRIVEIO_ERR_NO_MEMORY;
 
-            first_feature = false;
-            current_feature = feature_code+1;
+            if (feature_code >= current_feature) current_feature = (feature_code + 1);
             dptr += feature_len;
             slen -= feature_len;
         }
@@ -419,11 +388,11 @@
     switch(QueryType)
     {
     case diq_QueryAllInfo:
-        if (0!=(err = QueryDriveInfo(ScsiTarget,list,false))) break;
+        if (0!=(err = QueryDriveInfo(ScsiTarget,list))) break;
         if (0!=(err = QueryDiscInfo(ScsiTarget,list,false))) break;
         break;
     case diq_QueryDriveInfo:
-        err = QueryDriveInfo(ScsiTarget,list,false);
+        err = QueryDriveInfo(ScsiTarget,list);
         break;
     case diq_QueryDiscInfo:
         err = QueryDiscInfo(ScsiTarget,list,true);

makemkv-oss-1.16.7.tar.gz/libffabi/src/audio_convert.c -> makemkv-oss-1.17.0.tar.gz/libffabi/src/audio_convert.c Changed

makemkv-oss-1.16.7.tar.gz/libffabi/src/audio_mix.c -> makemkv-oss-1.17.0.tar.gz/libffabi/src/audio_mix.c Changed

makemkv-oss-1.16.7.tar.gz/libffabi/src/mlp.c -> makemkv-oss-1.17.0.tar.gz/libffabi/src/mlp.c Changed

makemkv-oss-1.16.7.tar.gz/libmakemkv/inc/lgpl/stl.h -> makemkv-oss-1.17.0.tar.gz/libmakemkv/inc/lgpl/stl.h Changed

makemkv-oss-1.16.7.tar.gz/makefile.common -> makemkv-oss-1.17.0.tar.gz/makefile.common Changed

makemkv-oss-1.16.7.tar.gz/makemkvgui/inc/ver_num.h -> makemkv-oss-1.17.0.tar.gz/makemkvgui/inc/ver_num.h Changed

makemkv-oss-1.16.7.tar.gz/makemkvgui/src/backupdlg.cpp -> makemkv-oss-1.17.0.tar.gz/makemkvgui/src/backupdlg.cpp Changed

@@ -17,7 +17,7 @@
 #include "mainwnd.h"
 #include <lgpl/sstring.h>
 
-CBackupDialog::CBackupDialog(CApClient* ap_client,QIcon* icon,QWidget *parent) : QDialog(parent)
+CBackupDialog::CBackupDialog(CApClient* ap_client,bool ForceDecrypted,QIcon* icon,QWidget *parent) : QDialog(parent)
 {
     setWindowIcon(*icon);
     setWindowTitle(UI_QSTRING(APP_BACKUPDLG_TITLE));
@@ -30,7 +30,7 @@
     labelText->setWordWrap(true);
     labelText->setText(UI_QSTRING(APP_IFACE_BACKUPDLG_TEXT));
 
-    backupDir = new CDirSelectBox(ap_client,CDirSelectBox::DirBoxOutDirBackup,UI_QSTRING(APP_IFACE_BACKUPDLG_FOLDER));
+    backupDir = new CDirSelectBox(ap_client, CDirSelectBox::DirBoxOutDirBackup, UI_QSTRING(APP_IFACE_BACKUPDLG_FOLDER));
     buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel , Qt::Horizontal);
 
     QGroupBox* box = new QGroupBox(UI_QSTRING(APP_IFACE_BACKUPDLG_TEXT_CAPTION));
@@ -45,6 +45,12 @@
     oblay->addWidget(check_Decrypt);
     obox->setLayout(oblay);
 
+    if (ForceDecrypted)
+    {
+        check_Decrypt->setChecked(true);
+        check_Decrypt->setEnabled(false);
+    }
+
     QBoxLayout *lay = new QVBoxLayout();
     lay->addWidget(box);
     lay->addWidget(obox);
@@ -61,7 +67,7 @@
 void CBackupDialog::SlotAccepted()
 {
     int newDecrypt = check_Decrypt->isChecked()?1:0;
-    if (backupDecrypt!=newDecrypt)
+    if ( (backupDecrypt!=newDecrypt) && (check_Decrypt->isEnabled()))
     {
         client->SetSettingInt(apset_app_BackupDecrypted,newDecrypt);
         client->SaveSettings();

makemkv-oss-1.16.7.tar.gz/makemkvgui/src/backupdlg.h -> makemkv-oss-1.17.0.tar.gz/makemkvgui/src/backupdlg.h Changed

makemkv-oss-1.16.7.tar.gz/makemkvgui/src/clt_pipe.cpp -> makemkv-oss-1.17.0.tar.gz/makemkvgui/src/clt_pipe.cpp Changed

makemkv-oss-1.16.7.tar.gz/makemkvgui/src/mainwnd.cpp -> makemkv-oss-1.17.0.tar.gz/makemkvgui/src/mainwnd.cpp Changed

makemkv-oss-1.16.7.tar.gz/makemkvgui/src/settingdlg.cpp -> makemkv-oss-1.17.0.tar.gz/makemkvgui/src/settingdlg.cpp Changed

@@ -28,15 +28,15 @@
     tabWidget->setUsesScrollButtons(false);
     buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::Apply , Qt::Horizontal);
 
+    // dvd
+    dvdTab = new CDVDTab(client);
+    tabWidget->addTab(dvdTab, UI_QSTRING(APP_TTREE_VIDEO));
+
     // general
     generalTab = new CGeneralTab();
     tabWidget->addTab(generalTab,UI_QSTRING(APP_IFACE_SETTINGS_TAB_GENERAL));
     check(connect(generalTab->check_ExpertMode, &QCheckBox::stateChanged, this, &CSettingDialog::SlotExpertStateChanged));
 
-    // dvd
-    dvdTab = new CDVDTab(client);
-    tabWidget->addTab(dvdTab,UI_QSTRING(APP_TTREE_VIDEO));
-
     // IO
     ioTab = new CIOTab();
     tabWidget->addTab(ioTab,UI_QSTRING(APP_IFACE_SETTINGS_TAB_IO));
@@ -384,6 +384,7 @@
     comboBoxSpRemoveMethod->addItem(UI_QSTRING(APP_IFACE_SETTINGS_DVD_AUTO));
     comboBoxSpRemoveMethod->addItem(QLatin1String("CellWalk"));
     comboBoxSpRemoveMethod->addItem(QLatin1String("CellTrim"));
+    comboBoxSpRemoveMethod->addItem(QLatin1String("CellFull"));
 
     QGridLayout *b_lay = new QGridLayout();
     b_lay->setColumnStretch(0,2);

makemkv-oss-1.16.7.tar.gz/makemkvgui/src/uisync.cpp -> makemkv-oss-1.17.0.tar.gz/makemkvgui/src/uisync.cpp Changed

makemkv-oss-1.17.0.tar.gz/mmgpl Added

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav Added

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/dvd_types.h Added

@@ -0,0 +1,273 @@
+/*
+ * Copyright (C) 2000, 2001 Björn Englund, Håkan Hjort
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is a modified
+ * file originally part of the Ogle DVD player project.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * Various useful structs and enums for DVDs.
+ */
+
+#ifndef LIBDVDNAV_DVD_TYPES_H
+#define LIBDVDNAV_DVD_TYPES_H
+
+#include <stdint.h>
+
+/*
+ * DVD Menu ID
+ * (see dvdnav_menu_call())
+ */
+typedef enum {
+  /* When used in VTS domain, DVD_MENU_Escape behaves like DVD_MENU_Root,
+   * but from within a menu domain, DVD_MENU_Escape resumes playback. */
+  DVD_MENU_Escape     = 0,
+  DVD_MENU_Title      = 2,
+  DVD_MENU_Root       = 3,
+  DVD_MENU_Subpicture = 4,
+  DVD_MENU_Audio      = 5,
+  DVD_MENU_Angle      = 6,
+  DVD_MENU_Part       = 7
+} DVDMenuID_t;
+
+/* Domain */
+typedef enum {
+  DVD_DOMAIN_FirstPlay = 1,  /* First Play Domain */
+  DVD_DOMAIN_VTSTitle  = 2,  /* Video Title Set Domain */
+  DVD_DOMAIN_VMGM      = 4,  /* Video Manager Domain */
+  DVD_DOMAIN_VTSMenu   = 8   /* Video Title Set Menu Domain */
+} DVDDomain_t;
+
+/*
+ * Structure containing info on highlight areas
+ * (see dvdnav_get_highlight_area())
+ */
+typedef struct {
+  uint32_t palette;     /* The CLUT entries for the highlight palette
+                           (4-bits per entry -> 4 entries) */
+  uint16_t sx,sy,ex,ey; /* The start/end x,y positions */
+  uint32_t pts;         /* Highlight PTS to match with SPU */
+
+  /* button number for the SPU decoder/overlaying engine */
+  uint32_t buttonN;
+} dvdnav_highlight_area_t;
+
+/* The audio format */
+typedef enum {
+  DVD_AUDIO_FORMAT_AC3        = 0,
+  DVD_AUDIO_FORMAT_UNKNOWN_1  = 1,
+  DVD_AUDIO_FORMAT_MPEG       = 2,
+  DVD_AUDIO_FORMAT_MPEG2_EXT  = 3,
+  DVD_AUDIO_FORMAT_LPCM       = 4,
+  DVD_AUDIO_FORMAT_UNKNOWN_5  = 5,
+  DVD_AUDIO_FORMAT_DTS        = 6,
+  DVD_AUDIO_FORMAT_SDDS       = 7
+} DVDAudioFormat_t;
+
+/* the following types are currently unused */
+
+#if 0
+
+/* User operation permissions */
+typedef enum {
+  UOP_FLAG_TitleOrTimePlay            = 0x00000001,
+  UOP_FLAG_ChapterSearchOrPlay        = 0x00000002,
+  UOP_FLAG_TitlePlay                  = 0x00000004,
+  UOP_FLAG_Stop                       = 0x00000008,
+  UOP_FLAG_GoUp                       = 0x00000010,
+  UOP_FLAG_TimeOrChapterSearch        = 0x00000020,
+  UOP_FLAG_PrevOrTopPGSearch          = 0x00000040,
+  UOP_FLAG_NextPGSearch               = 0x00000080,
+  UOP_FLAG_ForwardScan                = 0x00000100,
+  UOP_FLAG_BackwardScan               = 0x00000200,
+  UOP_FLAG_TitleMenuCall              = 0x00000400,
+  UOP_FLAG_RootMenuCall               = 0x00000800,
+  UOP_FLAG_SubPicMenuCall             = 0x00001000,
+  UOP_FLAG_AudioMenuCall              = 0x00002000,
+  UOP_FLAG_AngleMenuCall              = 0x00004000,
+  UOP_FLAG_ChapterMenuCall            = 0x00008000,
+  UOP_FLAG_Resume                     = 0x00010000,
+  UOP_FLAG_ButtonSelectOrActivate     = 0x00020000,
+  UOP_FLAG_StillOff                   = 0x00040000,
+  UOP_FLAG_PauseOn                    = 0x00080000,
+  UOP_FLAG_AudioStreamChange          = 0x00100000,
+  UOP_FLAG_SubPicStreamChange         = 0x00200000,
+  UOP_FLAG_AngleChange                = 0x00400000,
+  UOP_FLAG_KaraokeAudioPresModeChange = 0x00800000,
+  UOP_FLAG_VideoPresModeChange        = 0x01000000
+} DVDUOP_t;
+
+/* Parental Level */
+typedef enum {
+  DVD_PARENTAL_LEVEL_1 = 1,
+  DVD_PARENTAL_LEVEL_2 = 2,
+  DVD_PARENTAL_LEVEL_3 = 3,
+  DVD_PARENTAL_LEVEL_4 = 4,
+  DVD_PARENTAL_LEVEL_5 = 5,
+  DVD_PARENTAL_LEVEL_6 = 6,
+  DVD_PARENTAL_LEVEL_7 = 7,
+  DVD_PARENTAL_LEVEL_8 = 8,
+  DVD_PARENTAL_LEVEL_None = 15
+} DVDParentalLevel_t;
+
+/* Language ID (ISO-639 language code) */
+typedef uint16_t DVDLangID_t;
+
+/* Country ID (ISO-3166 country code) */
+typedef uint16_t DVDCountryID_t;
+
+/* Register */
+typedef uint16_t DVDRegister_t;
+typedef enum {
+  DVDFalse = 0,
+  DVDTrue = 1
+} DVDBool_t;
+typedef DVDRegister_t DVDGPRMArray_t16;
+typedef DVDRegister_t DVDSPRMArray_t24;
+
+/* Navigation */
+typedef int DVDStream_t;
+typedef int DVDPTT_t;
+typedef int DVDTitle_t;
+
+/* Angle number (1-9 or default?) */
+typedef int DVDAngle_t;
+
+/* Timecode */
+typedef struct {
+  uint8_t Hours;
+  uint8_t Minutes;
+  uint8_t Seconds;
+  uint8_t Frames;
+} DVDTimecode_t;
+
+/* Subpicture stream number (0-31,62,63) */
+typedef int DVDSubpictureStream_t;
+
+/* Audio stream number (0-7, 15(none)) */
+typedef int DVDAudioStream_t;
+
+/* The audio application mode */
+typedef enum {
+  DVD_AUDIO_APP_MODE_None     = 0,
+  DVD_AUDIO_APP_MODE_Karaoke  = 1,
+  DVD_AUDIO_APP_MODE_Surround = 2,
+  DVD_AUDIO_APP_MODE_Other    = 3
+} DVDAudioAppMode_t;
+
+/* Audio language extension */
+typedef enum {
+  DVD_AUDIO_LANG_EXT_NotSpecified       = 0,
+  DVD_AUDIO_LANG_EXT_NormalCaptions     = 1,
+  DVD_AUDIO_LANG_EXT_VisuallyImpaired   = 2,
+  DVD_AUDIO_LANG_EXT_DirectorsComments1 = 3,
+  DVD_AUDIO_LANG_EXT_DirectorsComments2 = 4
+} DVDAudioLangExt_t;
+
+/* Subpicture language extension */
+typedef enum {
+  DVD_SUBPICTURE_LANG_EXT_NotSpecified  = 0,
+  DVD_SUBPICTURE_LANG_EXT_NormalCaptions  = 1,
+  DVD_SUBPICTURE_LANG_EXT_BigCaptions  = 2,
+  DVD_SUBPICTURE_LANG_EXT_ChildrensCaptions  = 3,
+  DVD_SUBPICTURE_LANG_EXT_NormalCC  = 5,
+  DVD_SUBPICTURE_LANG_EXT_BigCC  = 6,
+  DVD_SUBPICTURE_LANG_EXT_ChildrensCC  = 7,
+  DVD_SUBPICTURE_LANG_EXT_Forced  = 9,
+  DVD_SUBPICTURE_LANG_EXT_NormalDirectorsComments  = 13,
+  DVD_SUBPICTURE_LANG_EXT_BigDirectorsComments  = 14,
+  DVD_SUBPICTURE_LANG_EXT_ChildrensDirectorsComments  = 15,
+} DVDSubpictureLangExt_t;
+
+/* Karaoke Downmix mode */
+typedef enum {
+  DVD_KARAOKE_DOWNMIX_0to0 = 0x0001,
+  DVD_KARAOKE_DOWNMIX_1to0 = 0x0002,
+  DVD_KARAOKE_DOWNMIX_2to0 = 0x0004,
+  DVD_KARAOKE_DOWNMIX_3to0 = 0x0008,
+  DVD_KARAOKE_DOWNMIX_4to0 = 0x0010,
+  DVD_KARAOKE_DOWNMIX_Lto0 = 0x0020,
+  DVD_KARAOKE_DOWNMIX_Rto0 = 0x0040,
+  DVD_KARAOKE_DOWNMIX_0to1 = 0x0100,
+  DVD_KARAOKE_DOWNMIX_1to1 = 0x0200,
+  DVD_KARAOKE_DOWNMIX_2to1 = 0x0400,
+  DVD_KARAOKE_DOWNMIX_3to1 = 0x0800,
+  DVD_KARAOKE_DOWNMIX_4to1 = 0x1000,
+  DVD_KARAOKE_DOWNMIX_Lto1 = 0x2000,
+  DVD_KARAOKE_DOWNMIX_Rto1 = 0x4000
+} DVDKaraokeDownmix_t;
+typedef int DVDKaraokeDownmixMask_t;
+
+/* Display mode */
+typedef enum {
+  DVD_DISPLAY_MODE_ContentDefault = 0,
+  DVD_DISPLAY_MODE_16x9 = 1,
+  DVD_DISPLAY_MODE_4x3PanScan = 2,
+  DVD_DISPLAY_MODE_4x3Letterboxed = 3
+} DVDDisplayMode_t;
+
+/* Audio attributes */
+typedef struct {
+  DVDAudioAppMode_t     AppMode;
+  DVDAudioFormat_t      AudioFormat;
+  DVDLangID_t           Language;
+  DVDAudioLangExt_t     LanguageExtension;
+  DVDBool_t             HasMultichannelInfo;
+  DVDAudioSampleFreq_t  SampleFrequency;
+  DVDAudioSampleQuant_t SampleQuantization;
+  DVDChannelNumber_t    NumberOfChannels;
+} DVDAudioAttributes_t;
+typedef int DVDAudioSampleFreq_t;
+typedef int DVDAudioSampleQuant_t;
+typedef int DVDChannelNumber_t;
+
+/* Subpicture attributes */
+typedef enum {
+  DVD_SUBPICTURE_TYPE_NotSpecified = 0,
+  DVD_SUBPICTURE_TYPE_Language     = 1,
+  DVD_SUBPICTURE_TYPE_Other        = 2
+} DVDSubpictureType_t;
+typedef enum {
+  DVD_SUBPICTURE_CODING_RunLength = 0,
+  DVD_SUBPICTURE_CODING_Extended  = 1,
+  DVD_SUBPICTURE_CODING_Other     = 2
+} DVDSubpictureCoding_t;
+typedef struct {
+  DVDSubpictureType_t    Type;
+  DVDSubpictureCoding_t  CodingMode;
+  DVDLangID_t            Language;
+  DVDSubpictureLangExt_t LanguageExtension;
+} DVDSubpictureAttributes_t;
+
+/* Video attributes */
+typedef struct {
+  DVDBool_t PanscanPermitted;
+  DVDBool_t LetterboxPermitted;
+  int AspectX;
+  int AspectY;
+  int FrameRate;
+  int FrameHeight;
+  DVDVideoCompression_t Compression;
+  DVDBool_t Line21Field1InGop;
+  DVDBool_t Line21Field2InGop;
+  int more_to_come;
+} DVDVideoAttributes_t;
+typedef int DVDVideoCompression_t;
+
+#endif
+
+#endif /* LIBDVDNAV_DVD_TYPES_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/dvdnav.c Added

@@ -0,0 +1,1496 @@
+/*
+ * Copyright (C) 2000 Rich Wareham <richwareham@users.sourceforge.net>
+ *
+ * This file is part of libdvdnav, a DVD navigation library.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+/* Un-comment the following to enable additional Log3() function calls.
+ * Do not forget to #define TRACE in src/vm/vm.h (required) */
+/*
+#define LOG_DEBUG
+*/
+
+#include <inttypes.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <limits.h>
+#include <string.h>
+#include "dvdnav/dvdnav.h"
+#include <dvdread/dvd_reader.h>
+#include <dvdread/nav_types.h>
+#include <dvdread/ifo_types.h> /* For vm_cmd_t */
+#include "vm/decoder.h"
+#include "vm/vm.h"
+#include "vm/getset.h"
+#include "dvdnav_internal.h"
+#include "logger.h"
+#ifndef DVDNAV_NO_CACHE
+#include "read_cache.h"
+#endif
+#include <dvdread/nav_read.h>
+
+static dvdnav_status_t dvdnav_clear(dvdnav_t * this) {
+  /* clear everything except file, vm, mutex, readahead */
+
+  pthread_mutex_lock(&this->vm_lock);
+  if (this->file) DVDCloseFile(this->file);
+  this->file = NULL;
+
+  memset(&this->position_current,0,sizeof(this->position_current));
+  memset(&this->pci,0,sizeof(this->pci));
+  memset(&this->dsi,0,sizeof(this->dsi));
+  this->last_cmd_nav_lbn = SRI_END_OF_CELL;
+
+  /* Set initial values of flags */
+  this->skip_still = 0;
+  this->sync_wait = 0;
+  this->sync_wait_skip = 0;
+  this->spu_clut_changed = 0;
+  this->started = 0;
+  this->nav_only = 0;
+  this->cur_cell_time = 0;
+
+#ifndef DVDNAV_NO_CACHE
+  dvdnav_read_cache_clear(this->cache);
+#endif
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_dup(dvdnav_t **dest, dvdnav_t *src) {
+  dvdnav_t *this;
+
+  (*dest) = NULL;
+  this = (dvdnav_t*)malloc(sizeof(dvdnav_t));
+  if (!this)
+    return DVDNAV_STATUS_ERR;
+
+  memcpy(this, src, sizeof(dvdnav_t));
+  this->file = NULL;
+  this->vm = NULL;
+  this->path = NULL;
+#ifndef DVDNAV_NO_CACHE
+  this->cache = NULL;
+#endif
+
+  pthread_mutex_init(&this->vm_lock, NULL);
+
+  this->vm = vm_new_copy(src->vm);
+  if (!this->vm)
+    goto fail;
+
+  if (src->path) {
+      this->path = strdup(src->path);
+      if (!this->path)
+          goto fail;
+  }
+
+#ifndef DVDNAV_NO_CACHE
+  /* Start the read-ahead cache. */
+  this->cache = dvdnav_read_cache_new(this);
+  if (!this->cache)
+    goto fail;
+#endif
+
+  (*dest) = this;
+  return DVDNAV_STATUS_OK;
+
+fail:
+    printerr("Error initialising the DVD VM.");
+    pthread_mutex_destroy(&this->vm_lock);
+    vm_free_vm(this->vm);
+    free(this->path);
+    free(this);
+    return DVDNAV_STATUS_ERR;
+}
+
+dvdnav_status_t dvdnav_free_dup(dvdnav_t *this) {
+
+#ifdef LOG_DEBUG
+  Log3(this, "free_dup:called");
+#endif
+
+  if (this->file) {
+    pthread_mutex_lock(&this->vm_lock);
+    DVDCloseFile(this->file);
+#ifdef LOG_DEBUG
+    Log3(this, "close:file closing");
+#endif
+    this->file = NULL;
+    pthread_mutex_unlock(&this->vm_lock);
+  }
+
+  /* Free the VM */
+  if(this->vm)
+    vm_free_copy(this->vm);
+
+  pthread_mutex_destroy(&this->vm_lock);
+
+  free(this->path);
+
+#ifndef DVDNAV_NO_CACHE
+  /* We leave the final freeing of the entire structure to the cache,
+   * because we don't know, if there are still buffers out in the wild,
+   * that must return first. */
+  if(this->cache)
+    dvdnav_read_cache_free(this->cache);
+  else
+    free(this);
+#else
+  free(this);
+#endif
+
+  return DVDNAV_STATUS_OK;
+}
+
+static dvdnav_status_t dvdnav_open_common(dvdnav_t** dest,
+                                          void *priv, const dvdnav_logger_cb *logcb,
+                                          const char *path,
+                                          dvdnav_stream_cb *stream_cb) {
+  dvdnav_t *this;
+
+  /* Create a new structure */
+  (*dest) = NULL;
+  this = (dvdnav_t*)calloc(1, sizeof(dvdnav_t));
+  if(!this)
+    return DVDNAV_STATUS_ERR;
+
+  this->priv = priv;
+  if(logcb)
+    this->logcb = *logcb;
+
+  pthread_mutex_init(&this->vm_lock, NULL);
+  /* Initialise the error string */
+  printerr("");
+
+  /* Initialise the VM */
+  this->vm = vm_new_vm(priv, logcb);
+  if(!this->vm) {
+    goto fail;
+  }
+  if(!vm_reset(this->vm, path, priv, stream_cb)) {
+    goto fail;
+  }
+
+  /* Set the path. */
+  if(path != NULL)
+  {
+    this->path = strdup(path);
+    if(!this->path)
+      goto fail;
+  }
+
+  /* Pre-open and close a file so that the CSS-keys are cached. */
+  this->file = DVDOpenFile(vm_get_dvd_reader(this->vm), 0, DVD_READ_MENU_VOBS);
+
+#ifndef DVDNAV_NO_CACHE
+  /* Start the read-ahead cache. */
+  this->cache = dvdnav_read_cache_new(this);
+  if(!this->cache)
+    goto fail;
+#endif
+
+  dvdnav_clear(this);
+
+  (*dest) = this;
+  return DVDNAV_STATUS_OK;
+
+fail:
+  pthread_mutex_destroy(&this->vm_lock);
+  vm_free_vm(this->vm);
+  free(this->path);
+  free(this);
+  return DVDNAV_STATUS_ERR;
+}
+
+dvdnav_status_t dvdnav_open(dvdnav_t** dest, const char *path) {
+  return dvdnav_open_common(dest, NULL, NULL, path, NULL);
+}
+
+dvdnav_status_t dvdnav_open2(dvdnav_t** dest,
+                             void *priv,const dvdnav_logger_cb *logcb,
+                             const char *path) {
+  return dvdnav_open_common(dest, priv, logcb, path, NULL);
+}
+
+dvdnav_status_t dvdnav_open_stream(dvdnav_t** dest,
+                                   void *priv, dvdnav_stream_cb *stream_cb) {
+  return dvdnav_open_common(dest, priv, NULL, NULL, stream_cb);
+}
+
+dvdnav_status_t dvdnav_open_stream2(dvdnav_t** dest,
+                                    void *priv,const dvdnav_logger_cb *logcb,
+                                    dvdnav_stream_cb *stream_cb) {
+  return dvdnav_open_common(dest, priv, logcb, NULL, stream_cb);
+}
+
+dvdnav_status_t dvdnav_close(dvdnav_t *this) {
+
+#ifdef LOG_DEBUG
+  Log3(this, "close:called");
+#endif
+
+  if (this->file) {
+    pthread_mutex_lock(&this->vm_lock);
+    DVDCloseFile(this->file);
+#ifdef LOG_DEBUG
+    Log3(this, "close:file closing");
+#endif
+    this->file = NULL;
+    pthread_mutex_unlock(&this->vm_lock);
+  }
+
+  /* Free the VM */
+  if(this->vm)
+    vm_free_vm(this->vm);
+
+  pthread_mutex_destroy(&this->vm_lock);
+
+  free(this->path);
+
+#ifndef DVDNAV_NO_CACHE
+  /* We leave the final freeing of the entire structure to the cache,
+   * because we don't know, if there are still buffers out in the wild,
+   * that must return first. */
+  if(this->cache)
+    dvdnav_read_cache_free(this->cache);
+  else
+    free(this);
+#else
+  free(this);
+#endif
+
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_reset(dvdnav_t *this) {
+  dvdnav_status_t result;
+
+#ifdef LOG_DEBUG
+  Log3(this, "reset:called");
+#endif
+
+  pthread_mutex_lock(&this->vm_lock);
+
+#ifdef LOG_DEBUG
+  Log3(this, "reseting vm");
+#endif
+  if(!vm_reset(this->vm, NULL, NULL, NULL)) {
+    printerr("Error restarting the VM.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+#ifdef LOG_DEBUG
+  Log3(this, "clearing dvdnav");
+#endif
+  pthread_mutex_unlock(&this->vm_lock);
+  result = dvdnav_clear(this);
+
+  return result;
+}
+
+dvdnav_status_t dvdnav_path(dvdnav_t *this, const char** path) {
+  (*path) = this->path;
+
+  return DVDNAV_STATUS_OK;
+}
+
+const char* dvdnav_err_to_string(dvdnav_t *this) {
+
+#ifndef DVDNAV_NO_ERRSTR
+    if(!this)
+    return "Hey! You gave me a NULL pointer you naughty person!";
+
+  return this->err_str;
+#else
+    return "";
+#endif
+
+}
+
+/* converts a dvd_time_t to PTS ticks */
+int64_t dvdnav_convert_time(dvd_time_t *time) {
+  int64_t result;
+  int64_t frames;
+
+  result  = ((int64_t)(time->hour    >> 4  )) * 10 * 60 * 60 * 90000;
+  result += ((int64_t)(time->hour    & 0x0f))      * 60 * 60 * 90000;
+  result += ((int64_t)(time->minute  >> 4  ))      * 10 * 60 * 90000;
+  result += ((int64_t)(time->minute  & 0x0f))           * 60 * 90000;
+  result += ((int64_t)(time->second  >> 4  ))           * 10 * 90000;
+  result += ((int64_t)(time->second  & 0x0f))                * 90000;
+
+  frames  = ((time->frame_u & 0x30) >> 4) * 10;
+  frames += ((time->frame_u & 0x0f)     )     ;
+
+  if (time->frame_u & 0x80)
+    result += frames * 3000;
+  else
+    result += frames * 3600;
+
+  return result;
+}
+
+/*
+ * Returns 1 if block contains NAV packet, 0 otherwise.
+ * Processes said NAV packet if present.
+ *
+ * Most of the code in here is copied from xine's MPEG demuxer
+ * so any bugs which are found in that should be corrected here also.
+ */
+static int32_t dvdnav_decode_packet(dvdnav_t *this, uint8_t *p,
+                                    dsi_t *nav_dsi, pci_t *nav_pci) {
+  int32_t        bMpeg1 = 0;
+  uint32_t       nHeaderLen;
+  uint32_t       nPacketLen;
+  uint32_t       nStreamID;
+
+  if (p3 == 0xBA) { /* program stream pack header */
+    int32_t nStuffingBytes;
+
+    bMpeg1 = (p4 & 0x40) == 0;
+
+    if (bMpeg1) {
+      p += 12;
+    } else { /* mpeg2 */
+      nStuffingBytes = p0xD & 0x07;
+      p += 14 + nStuffingBytes;
+    }
+  }
+
+  if (p3 == 0xbb) { /* program stream system header */
+    nHeaderLen = (p4 << 8) | p5;
+    p += 6 + nHeaderLen;
+  }
+
+  /* we should now have a PES packet here */
+  if (p0 || p1 || (p2 != 1)) {
+    Log1(this, "demux error! %02x %02x %02x (should be 0x000001)",p0,p1,p2);
+    return 0;
+  }
+
+  nPacketLen = p4 << 8 | p5;
+  nStreamID  = p3;
+
+  nHeaderLen = 6;
+  p += nHeaderLen;
+
+  if (nStreamID == 0xbf) { /* Private stream 2 */
+#if 0
+    char buffer80 * 3 + 1;
+    int32_t i;
+    for(i=0;i<80;i++)
+      sprintf(&bufferi*3, "%02x ",pi-6);
+    Log3(this, "nav packet=%u %s",p-p_start-6, buffer);
+#endif
+
+    if(p0 == 0x00) {
+      navRead_PCI(nav_pci, p+1);
+    }
+
+    p += nPacketLen;
+
+    /* We should now have a DSI packet. */
+    if(p6 == 0x01) {
+      nPacketLen = p4 << 8 | p5;
+      p += 6;
+      navRead_DSI(nav_dsi, p+1);
+    }
+    return 1;
+  }
+  return 0;
+}
+
+/* DSI is used for most angle stuff.
+ * PCI is used for only non-seemless angle stuff
+ */
+static int32_t dvdnav_get_vobu(dvdnav_t *this, dsi_t *nav_dsi, pci_t *nav_pci, dvdnav_vobu_t *vobu) {
+  uint32_t next;
+  int32_t angle, num_angle;
+
+  vobu->vobu_start = nav_dsi->dsi_gi.nv_pck_lbn; /* Absolute offset from start of disk */
+  vobu->vobu_length = nav_dsi->dsi_gi.vobu_ea; /* Relative offset from vobu_start */
+
+  /*
+   * If we're not at the end of this cell, we can determine the next
+   * VOBU to display using the VOBU_SRI information section of the
+   * DSI.  Using this value correctly follows the current angle,
+   * avoiding the doubled scenes in The Matrix, and makes our life
+   * really happy.
+   *
+   * vobu_next is an offset value, 0x3fffffff = SRI_END_OF_CELL
+   * DVDs are about 6 Gigs, which is only up to 0x300000 blocks
+   * Should really assert if bit 31 != 1
+   */
+
+#if 0
+  /* Old code -- may still be useful one day */
+  if(nav_dsi->vobu_sri.next_vobu != SRI_END_OF_CELL ) {
+    vobu->vobu_next = ( nav_dsi->vobu_sri.next_vobu & 0x3fffffff );
+  } else {
+    vobu->vobu_next = vobu->vobu_length;
+  }
+#else
+  /* Relative offset from vobu_start */
+  vobu->vobu_next = ( nav_dsi->vobu_sri.next_vobu & 0x3fffffff );
+#endif
+
+  vm_get_angle_info(this->vm, &angle, &num_angle);
+
+  /* FIMXE: The angle reset doesn't work for some reason for the moment */
+#if 0
+  if((num_angle < angle) && (angle != 1)) {
+    Log3(this, "angle ends!");
+
+    /* This is to switch back to angle one when we
+     * finish with angles. */
+    dvdnav_angle_change(this, 1);
+  }
+#endif
+  /* only use ILVU information if we are at the last vobunit in ILVU */
+  /* otherwise we will miss nav packets from vobunits inbetween */
+  if(num_angle != 0 && (nav_dsi->sml_pbi.category & DSI_ILVU_MASK) == (DSI_ILVU_BLOCK | DSI_ILVU_LAST)) {
+
+    if((next = nav_pci->nsml_agli.nsml_agl_dstaangle-1) != 0) {
+      if((next & 0x3fffffff) != 0) {
+        if(next & 0x80000000)
+          vobu->vobu_next = - (int32_t)(next & 0x3fffffff);
+        else
+          vobu->vobu_next = + (int32_t)(next & 0x3fffffff);
+      }
+    } else if((next = nav_dsi->sml_agli.dataangle-1.address) != 0) {
+      vobu->vobu_length = nav_dsi->sml_pbi.ilvu_ea;
+
+      if((next & 0x80000000) && (next != 0x7fffffff))
+        vobu->vobu_next =  - (int32_t)(next & 0x3fffffff);
+      else
+        vobu->vobu_next =  + (int32_t)(next & 0x3fffffff);
+    }
+  }
+
+  return 1;
+}
+
+/*
+ * These are the main get_next_block function which actually get the media stream video and audio etc.
+ *
+ * There are two versions: The second one is using the zero-copy read ahead cache and therefore
+ * hands out pointers targetting directly into the cache.
+ * The first one uses a memcopy to fill this cache block into the application provided memory.
+ * The benefit of this first one is that no special memory management is needed. The application is
+ * the only one responsible of allocating and freeing the memory associated with the pointer.
+ * The drawback is the additional memcopy.
+ */
+
+dvdnav_status_t dvdnav_get_next_block(dvdnav_t *this, uint8_t *buf,
+                                      int32_t *event, int32_t *len) {
+  unsigned char *block;
+  dvdnav_status_t status;
+
+  block = buf;
+  status = dvdnav_get_next_cache_block(this, &block, event, len);
+  if (status == DVDNAV_STATUS_OK && block != buf) {
+    /* we received a block from the cache, copy it, so we can give it back */
+    if (this->nav_only == 0) {
+      memcpy(buf, block, DVD_VIDEO_LB_LEN);
+    } else {
+      *len = 0;
+    }
+#ifndef DVDNAV_NO_CACHE
+    dvdnav_free_cache_block(this, block);
+#endif
+  }
+  return status;
+}
+
+int64_t dvdnav_get_current_time(dvdnav_t *this) {
+  int i;
+  int64_t tm=0;
+  dvd_state_t *state = &this->vm->state;
+
+  if(! state->pgc)
+    return 0;
+
+  for(i=0; i<state->cellN-1; i++) {
+    if(!
+        (state->pgc->cell_playbacki.block_type == BLOCK_TYPE_ANGLE_BLOCK &&
+         state->pgc->cell_playbacki.block_mode != BLOCK_MODE_FIRST_CELL)
+    )
+      tm += dvdnav_convert_time(&state->pgc->cell_playbacki.playback_time);
+  }
+  tm += this->cur_cell_time;
+
+  return tm;
+}
+
+uint64_t dvdnav_get_absolute_time(dvdnav_t *self)
+{
+    dvd_state_t *state = &self->vm->state;
+
+    return (((uint64_t)state->registers.time_counter) << 9);
+}
+
+uint32_t dvdnav_get_prm(dvdnav_t *self, uint8_t type, uint8_t reg)
+{
+    dvd_state_t *state = &self->vm->state;
+    uint32_t r;
+
+    switch (type)
+    {
+    case 0: r = state->registers.GPRMreg; break;
+    case 1: r = state->registers.SPRMreg; break;
+    case 2: r = state->registers.GPRM_mode; break;
+    case 3: r = state->registers.SPRM_flags; break;
+    default: r = 0; break;
+    }
+    return r;
+}
+
+static dvdnav_status_t dvdnav_check_vobu(dvdnav_t *this,uint32_t vobu)
+{
+    uint8_t bufDVD_VIDEO_LB_LEN;
+    uint8_t* data;
+    pci_t pci;
+    dsi_t dsi;
+
+#ifndef DVDNAV_NO_CACHE
+    data = buf;
+    if (dvdnav_read_cache_block(this->cache, vobu, 1, &data) <= 0) data = NULL;
+#else
+    data = (uint8_t*) DVDReadBlock(this->file, vobu, buf);
+#endif
+
+    if (NULL == data) {
+        printerr("Error reading NAV packet.");
+        return DVDNAV_STATUS_ERR;
+    }
+
+    /* Decode nav into pci and dsi. */
+    if (!dvdnav_decode_packet(this, data, &dsi, &pci)) {
+        printerr("Expected NAV packet but none found.");
+        return DVDNAV_STATUS_ERR;
+    }
+
+    if (pci.pci_gi.nv_pck_lbn != vobu) {
+        printerr("Fake NAV packet.");
+        return DVDNAV_STATUS_ERR;
+    }
+
+    return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_get_next_cache_block(dvdnav_t *this, uint8_t **buf,
+                                            int32_t *event, int32_t *len) {
+  dvd_state_t *state;
+  int32_t result;
+
+  if(!this)
+      return DVDNAV_STATUS_ERR;
+
+  pthread_mutex_lock(&this->vm_lock);
+
+  if(!this->started) {
+    /* Start the VM */
+    if (!vm_start(this->vm)) {
+      printerr("Encrypted or faulty DVD");
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_ERR;
+    }
+    this->started = 1;
+  }
+
+  if (!this->vm->state.pgc) {
+      printerr("No current PGC.");
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_ERR;
+  }
+
+  state = &(this->vm->state);
+  (*event) = DVDNAV_NOP;
+  (*len) = 0;
+
+  /* Check the STOP flag */
+  if(this->vm->stopped) {
+    vm_stop(this->vm);
+    (*event) = DVDNAV_STOP;
+    this->started = 0;
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  vm_position_get(this->vm, &this->position_next);
+
+#ifdef LOG_DEBUG
+  Log3(this->vm, "POS-NEXT ");
+  vm_position_print(this->vm, &this->position_next);
+  Log3(this->vm, "POS-CUR  ");
+  vm_position_print(this->vm, &this->position_current);
+#endif
+
+  /* did we hop? */
+  if(this->position_current.hop_channel != this->position_next.hop_channel) {
+    (*event) = DVDNAV_HOP_CHANNEL;
+#ifdef LOG_DEBUG
+    Log3(this->vm, "HOP_CHANNEL");
+#endif
+    if (this->position_next.hop_channel - this->position_current.hop_channel >= HOP_SEEK) {
+      int32_t num_angles = 0, current;
+
+      /* we seeked -> check for multiple angles */
+      vm_get_angle_info(this->vm, &current, &num_angles);
+      if (num_angles > 1) {
+        int32_t result, block;
+        /* we have to skip the first VOBU when seeking in a multiangle feature,
+         * because it might belong to the wrong angle */
+        block = this->position_next.cell_start + this->position_next.block;
+#ifndef DVDNAV_NO_CACHE
+        result = dvdnav_read_cache_block(this->cache, block, 1, buf);
+#else
+        *buf = (uint8_t*) DVDReadBlock(this->file, block, *buf);
+        result = (NULL == *buf) ? -1 : DVD_VIDEO_LB_LEN;
+#endif
+        if(result <= 0) {
+          printerr("Error reading NAV packet.");
+          pthread_mutex_unlock(&this->vm_lock);
+          return DVDNAV_STATUS_ERR;
+        }
+        /* Decode nav into pci and dsi. Then get next VOBU info. */
+        if(!dvdnav_decode_packet(this, *buf, &this->dsi, &this->pci)) {
+          printerr("Expected NAV packet but none found.");
+          pthread_mutex_unlock(&this->vm_lock);
+          return DVDNAV_STATUS_ERR;
+        }
+        dvdnav_get_vobu(this, &this->dsi, &this->pci, &this->vobu);
+        /* skip to next, if there is a next */
+        if (this->vobu.vobu_next != SRI_END_OF_CELL) {
+          this->vobu.vobu_start += this->vobu.vobu_next;
+          this->vobu.vobu_next   = 0;
+        }
+        /* update VM state */
+        this->vm->state.blockN = this->vobu.vobu_start - this->position_next.cell_start;
+      }
+    }
+    this->position_current.hop_channel = this->position_next.hop_channel;
+    /* update VOBU info */
+    this->vobu.vobu_start  = this->position_next.cell_start + this->position_next.block;
+    this->vobu.vobu_next   = 0;
+    /* Make blockN == vobu_length to do expected_nav */
+    this->vobu.vobu_length = 0;
+    this->vobu.blockN      = 0;
+    this->sync_wait        = 0;
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  /* Check the HIGHLIGHT flag */
+  if(this->position_current.button != this->position_next.button) {
+    dvdnav_highlight_event_t *hevent = (dvdnav_highlight_event_t *)*buf;
+
+    (*event) = DVDNAV_HIGHLIGHT;
+#ifdef LOG_DEBUG
+    Log3(this, "HIGHLIGHT");
+#endif
+    (*len) = sizeof(dvdnav_highlight_event_t);
+    hevent->display = 1;
+    hevent->buttonN = this->position_next.button;
+    this->position_current.button = this->position_next.button;
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  /* Check the WAIT flag */
+  if(this->sync_wait) {
+    (*event) = DVDNAV_WAIT;
+#ifdef LOG_DEBUG
+    Log3(this, "WAIT");
+#endif
+    (*len) = 0;
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  /* Check to see if we need to change the currently opened VOB or open
+   * a new one because we don't currently have an opened VOB. */
+  if((this->file == NULL) ||
+     (this->position_current.vts != this->position_next.vts) ||
+     (this->position_current.domain != this->position_next.domain)) {
+    dvd_read_domain_t domain;
+    int32_t vtsN;
+    dvdnav_vts_change_event_t *vts_event = (dvdnav_vts_change_event_t *)*buf;
+
+    if(this->file) {
+      DVDCloseFile(this->file);
+      this->file = NULL;
+    }
+
+    vts_event->old_vtsN = this->position_current.vts;
+    vts_event->old_domain = this->position_current.domain;
+
+    /* Use the DOMAIN to find whether to open menu or title VOBs */
+    switch(this->position_next.domain) {
+    case DVD_DOMAIN_FirstPlay:
+    case DVD_DOMAIN_VMGM:
+      domain = DVD_READ_MENU_VOBS;
+      vtsN = 0;
+      break;
+    case DVD_DOMAIN_VTSMenu:
+      domain = DVD_READ_MENU_VOBS;
+      vtsN = this->position_next.vts;
+      break;
+    case DVD_DOMAIN_VTSTitle:
+      domain = DVD_READ_TITLE_VOBS;
+      vtsN = this->position_next.vts;
+      break;
+    default:
+      printerr("Unknown domain when changing VTS.");
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_ERR;
+    }
+
+    this->position_current.vts = this->position_next.vts;
+    this->position_current.domain = this->position_next.domain;
+#ifndef DVDNAV_NO_CACHE
+    dvdnav_read_cache_clear(this->cache);
+#endif
+    this->file = DVDOpenFile(vm_get_dvd_reader(this->vm), vtsN, domain);
+    vts_event->new_vtsN = this->position_next.vts;
+    vts_event->new_domain = this->position_next.domain;
+
+    /* If couldn't open the file for some reason, moan */
+    if(this->file == NULL) {
+      printerrf("Error opening vtsN=%i, domain=%i.", vtsN, domain);
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_ERR;
+    }
+
+    /* File opened successfully so return a VTS change event */
+    (*event) = DVDNAV_VTS_CHANGE;
+#ifdef LOG_DEBUG
+    Log3(this, "VTS_CHANGE");
+#endif
+    (*len) = sizeof(dvdnav_vts_change_event_t);
+
+    this->spu_clut_changed = 1;
+    this->position_current.cell = -1; /* Force an update */
+    this->position_current.spu_channel = -1; /* Force an update */
+    this->position_current.audio_channel = -1; /* Force an update */;
+
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  /* Check if the cell changed */
+  if( (this->position_current.cell != this->position_next.cell) ||
+      (this->position_current.cell_restart != this->position_next.cell_restart) ||
+      (this->position_current.cell_start != this->position_next.cell_start) ) {
+    dvdnav_cell_change_event_t *cell_event = (dvdnav_cell_change_event_t *)*buf;
+    int32_t first_cell_nr, last_cell_nr, i;
+    dvd_state_t *state = &this->vm->state;
+
+    this->cur_cell_time = 0;
+    (*event) = DVDNAV_CELL_CHANGE;
+#ifdef LOG_DEBUG
+    Log3(this, "CELL_CHANGE");
+#endif
+    (*len) = sizeof(dvdnav_cell_change_event_t);
+
+    cell_event->cellN = state->cellN;
+    cell_event->pgN   = state->pgN;
+    cell_event->cell_length =
+        (state->pgc->cell_playbackstate->cellN - 1.last_sector + 1);
+
+    cell_event->pg_length = 0;
+    /* Find start cell of program. */
+    first_cell_nr = state->pgc->program_mapstate->pgN-1;
+    /* Find end cell of program */
+    if(state->pgN < state->pgc->nr_of_programs)
+      last_cell_nr = state->pgc->program_mapstate->pgN - 1;
+    else
+      last_cell_nr = state->pgc->nr_of_cells;
+    for (i = first_cell_nr; i <= last_cell_nr; i++)
+      cell_event->pg_length +=
+        (state->pgc->cell_playbacki - 1.last_sector + 1);
+
+    cell_event->pgc_length = dvdnav_convert_time(&state->pgc->playback_time);
+
+    cell_event->cell_start = 0;
+    for (i = 1; i < state->cellN; i++)
+      cell_event->cell_start +=
+          (state->pgc->cell_playbacki - 1.last_sector + 1);
+
+    cell_event->pg_start = 0;
+    for (i = 1; i < state->pgc->program_mapstate->pgN-1; i++)
+      cell_event->pg_start +=
+        (state->pgc->cell_playbacki - 1.last_sector + 1);
+
+    this->position_current.cell         = this->position_next.cell;
+    this->position_current.cell_restart = this->position_next.cell_restart;
+    this->position_current.cell_start   = this->position_next.cell_start;
+    this->position_current.block        = this->position_next.block;
+
+    /* vobu info is used for mid cell resumes */
+    this->vobu.vobu_start               = this->position_next.cell_start + this->position_next.block;
+    this->vobu.vobu_next                = 0;
+    /* Make blockN == vobu_length to do expected_nav */
+    this->vobu.vobu_length = 0;
+    this->vobu.blockN      = 0;
+
+    /* update the spu palette at least on PGC changes */
+    this->spu_clut_changed = 1;
+    this->position_current.spu_channel = -1; /* Force an update */
+    this->position_current.audio_channel = -1; /* Force an update */
+
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  /* has the CLUT changed? */
+  if(this->spu_clut_changed) {
+    (*event) = DVDNAV_SPU_CLUT_CHANGE;
+#ifdef LOG_DEBUG
+    Log3(this, "SPU_CLUT_CHANGE");
+#endif
+    (*len) = 16 * sizeof(uint32_t);
+    memcpy(*buf, state->pgc->palette, sizeof(state->pgc->palette));
+    this->spu_clut_changed = 0;
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  /* has the SPU channel changed? */
+  if(this->position_current.spu_channel != this->position_next.spu_channel) {
+    dvdnav_spu_stream_change_event_t *stream_change = (dvdnav_spu_stream_change_event_t *)*buf;
+
+    (*event) = DVDNAV_SPU_STREAM_CHANGE;
+#ifdef LOG_DEBUG
+    Log3(this, "SPU_STREAM_CHANGE");
+#endif
+    (*len) = sizeof(dvdnav_spu_stream_change_event_t);
+    stream_change->physical_wide      = vm_get_subp_active_stream(this->vm, 0);
+    stream_change->physical_letterbox = vm_get_subp_active_stream(this->vm, 1);
+    stream_change->physical_pan_scan  = vm_get_subp_active_stream(this->vm, 2);
+    this->position_current.spu_channel = this->position_next.spu_channel;
+#ifdef LOG_DEBUG
+    Log3(this, "SPU_STREAM_CHANGE stream_id_wide=%d",stream_change->physical_wide);
+    Log3(this, "SPU_STREAM_CHANGE stream_id_letterbox=%d",stream_change->physical_letterbox);
+    Log3(this, "SPU_STREAM_CHANGE stream_id_pan_scan=%d",stream_change->physical_pan_scan);
+    Log3(this, "SPU_STREAM_CHANGE returning DVDNAV_STATUS_OK");
+#endif
+    /* This is not realy the right place to do this. FOSL_BTNN should set the register
+     * at HLI_S_PTM rather than when we enter the SPU. As well we should activate FOAC_BTNN
+     * at HLI_E_PTM
+     */
+    if (this->pci.hli.hl_gi.fosl_btnn != 0) {
+      set_HL_BTN(this->vm, this->pci.hli.hl_gi.fosl_btnn);
+    }
+
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  /* has the audio channel changed? */
+  if(this->position_current.audio_channel != this->position_next.audio_channel) {
+    dvdnav_audio_stream_change_event_t *stream_change = (dvdnav_audio_stream_change_event_t *)*buf;
+
+    (*event) = DVDNAV_AUDIO_STREAM_CHANGE;
+#ifdef LOG_DEBUG
+    Log3(this, "AUDIO_STREAM_CHANGE");
+#endif
+    (*len) = sizeof(dvdnav_audio_stream_change_event_t);
+    stream_change->physical = vm_get_audio_active_stream( this->vm );
+    stream_change->logical = this->position_next.audio_channel;
+    this->position_current.audio_channel = this->position_next.audio_channel;
+#ifdef LOG_DEBUG
+    Log3(this, "AUDIO_STREAM_CHANGE stream_id=%d returning DVDNAV_STATUS_OK",stream_change->physical);
+#endif
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  /* Check the STILLFRAME flag */
+  if(this->position_current.still != 0) {
+    dvdnav_still_event_t *still_event = (dvdnav_still_event_t *)*buf;
+
+    (*event) = DVDNAV_STILL_FRAME;
+#ifdef LOG_DEBUG
+    Log3(this, "STILL_FRAME");
+#endif
+    (*len) = sizeof(dvdnav_still_event_t);
+    still_event->length = this->position_current.still;
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  /* Have we reached the end of a VOBU? */
+  if (this->vobu.blockN >= this->vobu.vobu_length) {
+
+    /* Have we reached the end of a cell? */
+    if(this->vobu.vobu_next == SRI_END_OF_CELL) {
+      /* End of Cell from NAV DSI info */
+#ifdef LOG_DEBUG
+      Log3(this, "Still set to %x", this->position_next.still);
+#endif
+      this->position_current.still = this->position_next.still;
+
+      /* we are about to leave a cell, so a lot of state changes could occur;
+       * under certain conditions, the application should get in sync with us before this,
+       * otherwise it might show stills or menus too shortly */
+      if ((this->position_current.still || this->pci.hli.hl_gi.hli_ss) && !this->sync_wait_skip)
+        this->sync_wait = 1;
+
+      if(!this->position_current.still || this->skip_still ) {
+        /* no active cell still -> get us to the next cell */
+        vm_get_next_cell(this->vm);
+        this->position_current.still = 0; /* still gets activated at end of cell */
+        this->skip_still = 0;
+        this->sync_wait_skip = 0;
+      }
+      /* handle related state changes in next iteration */
+      (*event) = DVDNAV_NOP;
+      (*len) = 0;
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_OK;
+    }
+
+    /* at the start of the next VOBU -> expecting NAV packet */
+#ifndef DVDNAV_NO_CACHE
+    result = dvdnav_read_cache_block(this->cache, this->vobu.vobu_start + this->vobu.vobu_next, 1, buf);
+#else
+    *buf = (uint8_t*)DVDReadBlock(this->file, this->vobu.vobu_start + this->vobu.vobu_next, *buf);
+    result = (NULL == *buf) ? -1 : DVD_VIDEO_LB_LEN;
+#endif
+
+    if(result <= 0) {
+      printerr("Error reading NAV packet.");
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_ERR;
+    }
+    /* Decode nav into pci and dsi. Then get next VOBU info. */
+    if(!dvdnav_decode_packet(this, *buf, &this->dsi, &this->pci)) {
+      printerr("Expected NAV packet but none found.");
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_ERR;
+    }
+    /* We need to update the vm state->blockN with which VOBU we are in.
+     * This is so RSM resumes to the VOBU level and not just the CELL level.
+     */
+    this->vm->state.blockN = this->vobu.vobu_start - this->position_current.cell_start;
+
+    dvdnav_get_vobu(this, &this->dsi, &this->pci, &this->vobu);
+    this->vobu.blockN = 0;
+
+#ifndef DVDNAV_NO_CACHE
+    /* Give the cache a hint about the size of next VOBU.
+     * This improves pre-caching, because the VOBU will almost certainly be read entirely.
+     */
+    dvdnav_pre_cache_blocks(this->cache, this->vobu.vobu_start+1, this->vobu.vobu_length+1);
+#endif
+
+    /* release NAV menu filter, when we reach the same NAV packet again */
+    if (this->last_cmd_nav_lbn == this->pci.pci_gi.nv_pck_lbn)
+      this->last_cmd_nav_lbn = SRI_END_OF_CELL;
+
+    /* Successfully got a NAV packet */
+    (*event) = DVDNAV_NAV_PACKET;
+#ifdef LOG_DEBUG
+    Log3(this, "NAV_PACKET");
+#endif
+    (*len) = 2048;
+
+    {
+        uint32_t new_cell_time = (uint32_t)dvdnav_convert_time(&this->dsi.dsi_gi.c_eltm);
+        if (0 == this->cur_cell_time) {
+            if (new_cell_time < (2 * 90000)) {
+                this->vm->state.registers.time_counter += (new_cell_time>>9);
+            }
+            if (0 == new_cell_time) {
+                new_cell_time = 1;
+            }
+        } else {
+            uint32_t cur_cell_time = this->cur_cell_time;
+            if ((new_cell_time > cur_cell_time) &&
+                ((new_cell_time - cur_cell_time) < (260*60*90000))) {
+                this->vm->state.registers.time_counter += ((new_cell_time - cur_cell_time)>>9);
+            }
+        }
+        this->cur_cell_time = new_cell_time;
+        if (this->vobu.vobu_next < 0) {
+            this->vm->state.registers.time_counter += 88;
+        }
+
+    }
+
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+
+  /* If we've got here, it must just be a normal block. */
+  if(!this->file) {
+    printerr("Attempting to read without opening file.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+
+  if (this->nav_only) {
+      pgc_t* pgc = this->vm->state.pgc;
+
+      if ((NULL != pgc) && (0==pgc->pg_playback_mode) && (this->vm->state.domain == DVD_DOMAIN_VTSTitle)) {
+
+          uint32_t fwda = 0;
+          cell_playback_t* cell = &pgc->cell_playbackthis->vm->state.cellN - 1;
+
+          if ( (this->pci.pci_gi.nv_pck_lbn == this->vobu.vobu_start) &&
+              (this->pci.hli.hl_gi.hli_ss != 0) )
+          {
+              fwda = 1;
+          }
+
+          if ((0 == fwda) && (0 == cell->playback_mode)) {
+              if ((BLOCK_TYPE_NONE == cell->block_type) &&
+                  (BLOCK_MODE_NOT_IN_BLOCK == cell->block_mode) &&
+                  (0 == cell->interleaved) &&
+                  (0 == cell->seamless_angle) &&
+                  (cell->last_vobu_start_sector < cell->last_sector) &&
+                  (cell->last_vobu_start_sector > cell->first_sector) &&
+                  (cell->first_sector < cell->last_sector) &&
+                  (this->vobu.vobu_start >= cell->first_sector) &&
+                  (this->vobu.vobu_start < cell->last_vobu_start_sector))
+              {
+                  fwda = cell->last_vobu_start_sector - this->vobu.vobu_start;
+                  if ((fwda < 0x1000) || (DVDNAV_STATUS_ERR == dvdnav_check_vobu(this, cell->last_vobu_start_sector))) {
+                      fwda = 0;
+                  }
+              }
+
+              if ((0 == fwda) && (this->dsi.dsi_gi.nv_pck_lbn == this->vobu.vobu_start)) {
+                  vobu_sri_t* sri = &this->dsi.vobu_sri;
+                  unsigned int i;
+
+                  for (i = 0; i < 16; i++)
+                  {
+                      if ((sri->fwdai & 0x3fffffff) >= 0x20000) continue;
+
+                      fwda = sri->fwdai & 0x3fffffff;
+                      break;
+                  }
+              }
+          }
+          if ((fwda > 0x20) && (DVDNAV_STATUS_ERR != dvdnav_check_vobu(this, this->vobu.vobu_start + fwda))) {
+              this->vobu.vobu_next = fwda;
+          }
+      }
+      this->vobu.blockN = this->vobu.vobu_length;
+
+      (*event) = DVDNAV_BLOCK_OK;
+      (*len) = 0;
+  } else {
+    this->vobu.blockN++;
+
+#ifndef DVDNAV_NO_CACHE
+    result = dvdnav_read_cache_block(this->cache, this->vobu.vobu_start + this->vobu.blockN, 1, buf);
+#else
+    *buf = (uint8_t*)DVDReadBlock(this->file, this->vobu.vobu_start + this->vobu.blockN, *buf);
+    result = (NULL == *buf) ? -1 : DVD_VIDEO_LB_LEN;
+#endif
+
+    if(result <= 0) {
+      printerr("Error reading from DVD.");
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_ERR;
+    }
+    (*event) = DVDNAV_BLOCK_OK;
+    (*len) = 2048;
+  }
+
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_OK;
+}
+
+#ifndef DVDNAV_NO_TXTDT
+dvdnav_status_t dvdnav_get_title_string(dvdnav_t *this, const char **title_str) {
+  (*title_str) = this->vm->dvd_name;
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_get_serial_string(dvdnav_t *this, const char **serial_str) {
+  (*serial_str) = this->vm->dvd_serial;
+  return DVDNAV_STATUS_OK;
+}
+#endif
+
+uint8_t dvdnav_get_video_aspect(dvdnav_t *this) {
+  uint8_t         retval;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  retval = (uint8_t)vm_get_video_aspect(this->vm);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return retval;
+}
+dvdnav_status_t dvdnav_get_video_resolution(dvdnav_t *this, uint32_t *width, uint32_t *height) {
+  int w, h;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return DVDNAV_STATUS_ERR;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  vm_get_video_res(this->vm, &w, &h);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  *width  = w;
+  *height = h;
+  return DVDNAV_STATUS_OK;
+}
+
+uint8_t dvdnav_get_video_scale_permission(dvdnav_t *this) {
+  uint8_t         retval;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  retval = (uint8_t)vm_get_video_scale_permission(this->vm);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return retval;
+}
+
+uint16_t dvdnav_audio_stream_to_lang(dvdnav_t *this, uint8_t stream) {
+  audio_attr_t  attr;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  attr = vm_get_audio_attr(this->vm, stream);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  if(attr.lang_type != 1)
+    return 0xffff;
+
+  return attr.lang_code;
+}
+
+uint16_t dvdnav_audio_stream_format(dvdnav_t *this, uint8_t stream) {
+  audio_attr_t  attr;
+  uint16_t format;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1; /* 0xffff */
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  attr = vm_get_audio_attr(this->vm, stream);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  switch(attr.audio_format) {
+  case 0:
+    format = DVD_AUDIO_FORMAT_AC3;
+    break;
+  case 2: /* MPEG-1 or MPEG-2 without extension bitstream. */
+  case 3: /* MPEG-2 with extension bitstream. */
+    format = DVD_AUDIO_FORMAT_MPEG2_EXT;
+    break;
+  case 4:
+    format = DVD_AUDIO_FORMAT_LPCM;
+    break;
+  case 6:
+    format = DVD_AUDIO_FORMAT_DTS;
+    break;
+  case 7:
+    format = DVD_AUDIO_FORMAT_SDDS;
+    break;
+  default:
+    format = 0xffff;
+    break;
+  }
+
+  return format;
+}
+
+uint16_t dvdnav_audio_stream_channels(dvdnav_t *this, uint8_t stream) {
+  audio_attr_t  attr;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1; /* 0xffff */
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  attr = vm_get_audio_attr(this->vm, stream);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return attr.channels + 1;
+}
+
+uint16_t dvdnav_spu_stream_to_lang(dvdnav_t *this, uint8_t stream) {
+  subp_attr_t  attr;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  attr = vm_get_subp_attr(this->vm, stream);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  if(attr.type != 1)
+    return 0xffff;
+
+  return attr.lang_code;
+}
+
+int8_t dvdnav_get_audio_logical_stream(dvdnav_t *this, uint8_t audio_num) {
+  int8_t       retval;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return -1;
+  }
+  retval = vm_get_audio_stream(this->vm, audio_num);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return retval;
+}
+
+dvdnav_status_t dvdnav_get_audio_attr(dvdnav_t *this, uint8_t audio_num, audio_attr_t *audio_attr) {
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return DVDNAV_STATUS_ERR;
+  }
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  *audio_attr=vm_get_audio_attr(this->vm, audio_num);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return DVDNAV_STATUS_OK;
+}
+
+int8_t dvdnav_get_spu_logical_stream(dvdnav_t *this, uint8_t subp_num) {
+  int8_t       retval;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return -1;
+  }
+  retval = vm_get_subp_stream(this->vm, subp_num, 0);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return retval;
+}
+
+dvdnav_status_t dvdnav_get_spu_attr(dvdnav_t *this, uint8_t audio_num, subp_attr_t *subp_attr) {
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return DVDNAV_STATUS_ERR;
+  }
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  *subp_attr=vm_get_subp_attr(this->vm, audio_num);
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_OK;
+}
+
+int8_t dvdnav_get_active_audio_stream(dvdnav_t *this) {
+  int8_t        retval;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return -1;
+  }
+  retval = vm_get_audio_active_stream(this->vm);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return retval;
+}
+
+int8_t dvdnav_get_active_spu_stream(dvdnav_t *this) {
+  int8_t        retval;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return -1;
+  }
+  retval = vm_get_subp_active_stream(this->vm, 0);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return retval;
+}
+
+static int8_t dvdnav_is_domain(dvdnav_t *this, DVDDomain_t domain) {
+  int8_t        retval;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return -1;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  retval = (this->vm->state.domain == domain);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return retval;
+}
+
+/* First Play domain. (Menu) */
+int8_t dvdnav_is_domain_fp(dvdnav_t *this) {
+  return dvdnav_is_domain(this, DVD_DOMAIN_FirstPlay);
+}
+/* Video management Menu domain. (Menu) */
+int8_t dvdnav_is_domain_vmgm(dvdnav_t *this) {
+  return dvdnav_is_domain(this, DVD_DOMAIN_VMGM);
+}
+/* Video Title Menu domain (Menu) */
+int8_t dvdnav_is_domain_vtsm(dvdnav_t *this) {
+  return dvdnav_is_domain(this, DVD_DOMAIN_VTSMenu);
+}
+/* Video Title domain (playing movie). */
+int8_t dvdnav_is_domain_vts(dvdnav_t *this) {
+  return dvdnav_is_domain(this, DVD_DOMAIN_VTSTitle);
+}
+
+/* Generally delegate angle information handling to VM */
+dvdnav_status_t dvdnav_angle_change(dvdnav_t *this, int32_t angle) {
+  int32_t num, current;
+
+  pthread_mutex_lock(&this->vm_lock);
+  vm_get_angle_info(this->vm, &current, &num);
+  /* Set angle SPRM if valid */
+  if((angle > 0) && (angle <= num)) {
+    this->vm->state.AGL_REG = angle;
+  } else {
+    printerr("Passed an invalid angle number.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_get_angle_info(dvdnav_t *this, int32_t *current_angle,
+                                      int32_t *number_of_angles) {
+  pthread_mutex_lock(&this->vm_lock);
+  vm_get_angle_info(this->vm, current_angle, number_of_angles);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return DVDNAV_STATUS_OK;
+}
+
+pci_t* dvdnav_get_current_nav_pci(dvdnav_t *this) {
+  if(!this) return 0;
+  return &this->pci;
+}
+
+dsi_t* dvdnav_get_current_nav_dsi(dvdnav_t *this) {
+  if(!this) return 0;
+  return &this->dsi;
+}
+
+uint32_t dvdnav_get_next_still_flag(dvdnav_t *this) {
+  if(!this) return -1;
+  return this->position_next.still;
+}
+
+user_ops_t dvdnav_get_restrictions(dvdnav_t* this) {
+  /*
+   * user_ops_t is a structure of 32 bits.  We want to compute
+   * the union of two of those bitfields so to make this quicker
+   * than performing 32 ORs, we will access them as 32bits words.
+   */
+  union {
+    user_ops_t ops_struct;
+    uint32_t   ops_int;
+  } ops, tmp;
+
+  ops.ops_int = 0;
+
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return ops.ops_struct;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  ops.ops_struct = this->pci.pci_gi.vobu_uop_ctl;
+
+  if(this->vm && this->vm->state.pgc) {
+    tmp.ops_struct = this->vm->state.pgc->prohibited_ops;
+    ops.ops_int |= tmp.ops_int;
+  }
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return ops.ops_struct;
+}
+
+const char* dvdnav_version(void) {
+    return DVDNAV_VERSION_STRING;
+}

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/dvdnav.h Added

@@ -0,0 +1,741 @@
+/*
+ * Copyright (C) 2001 Rich Wareham <richwareham@users.sourceforge.net>
+ *
+ * This file is part of libdvdnav, a DVD navigation library.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * This is the main header file applications should include if they want
+ * to access dvdnav functionality.
+ */
+
+#ifndef LIBDVDNAV_DVDNAV_H
+#define LIBDVDNAV_DVDNAV_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "version.h"
+#include <dvdnav/dvd_types.h>
+#include <dvdread/dvd_reader.h>
+#include <dvdread/nav_types.h>
+#include <dvdread/ifo_types.h> /* For vm_cmd_t */
+#include <dvdnav/dvdnav_events.h>
+
+#include <stdarg.h>
+
+/*********************************************************************
+ * dvdnav data types                                                 *
+ *********************************************************************/
+
+/*
+ * Opaque data-type can be viewed as a 'DVD handle'. You should get
+ * a pointer to a dvdnav_t from the dvdnav_open() function.
+ * Never call free() on the pointer, you have to give it back with
+ * dvdnav_close().
+ */
+typedef struct dvdnav_s dvdnav_t;
+
+/* Status as reported by most of libdvdnav's functions */
+typedef int32_t dvdnav_status_t;
+
+typedef dvd_reader_stream_cb dvdnav_stream_cb;
+
+/*
+ * Unless otherwise stated, all functions return DVDNAV_STATUS_OK if
+ * they succeeded, otherwise DVDNAV_STATUS_ERR is returned and the error may
+ * be obtained by calling dvdnav_err_to_string().
+ */
+#define DVDNAV_STATUS_ERR 0
+#define DVDNAV_STATUS_OK  1
+
+/*********************************************************************
+ * initialisation & housekeeping functions                           *
+ *********************************************************************/
+
+/*
+ * Logger callback definition
+ */
+typedef enum
+{
+    DVDNAV_LOGGER_LEVEL_INFO,
+    DVDNAV_LOGGER_LEVEL_ERROR,
+    DVDNAV_LOGGER_LEVEL_WARN,
+    DVDNAV_LOGGER_LEVEL_DEBUG,
+} dvdnav_logger_level_t;
+
+typedef struct
+{
+  void ( *pf_log )  ( void *, dvdnav_logger_level_t, const char *, va_list );
+} dvdnav_logger_cb;
+
+/*
+ * These functions allow you to open a DVD device and associate it
+ * with a dvdnav_t.
+ */
+
+/*
+ * Attempts to open the DVD drive at the specified path or using external
+ * seek/read functions (dvdnav_open_stream) and pre-cache the CSS-keys.
+ * libdvdread is used to access the DVD, so any source supported by libdvdread
+ * can be given with "path" or "stream_cb".  Currently, using dvdnav_open,
+ * libdvdread can access : DVD drives, DVD image files, DVD file-by-file
+ * copies. Using dvdnav_open_stream, libdvdread can access any kind of DVD
+ * storage via custom implementation of seek/read functions.
+ *
+ * The resulting dvdnav_t handle will be written to *dest.
+ */
+dvdnav_status_t dvdnav_open(dvdnav_t **dest, const char *path);
+dvdnav_status_t
+dvdnav_open_stream(dvdnav_t **dest, void *priv, dvdnav_stream_cb *stream_cb);
+
+dvdnav_status_t dvdnav_open2(dvdnav_t **dest,
+                             void *, const dvdnav_logger_cb *,
+                             const char *path);
+dvdnav_status_t dvdnav_open_stream2(dvdnav_t **dest,
+                                    void *priv, const dvdnav_logger_cb *,
+                                    dvdnav_stream_cb *stream_cb);
+
+dvdnav_status_t dvdnav_dup(dvdnav_t **dest, dvdnav_t *src);
+dvdnav_status_t dvdnav_free_dup(dvdnav_t * _this);
+
+/*
+ * Closes a dvdnav_t previously opened with dvdnav_open(), freeing any
+ * memory associated with it.
+ */
+dvdnav_status_t dvdnav_close(dvdnav_t *self);
+
+/*
+ * Resets the DVD virtual machine and cache buffers.
+ */
+dvdnav_status_t dvdnav_reset(dvdnav_t *self);
+
+/*
+ * Fills a pointer with a value pointing to a string describing
+ * the path associated with an open dvdnav_t. It assigns *path to NULL
+ * on error.
+ */
+dvdnav_status_t dvdnav_path(dvdnav_t *self, const char **path);
+
+/*
+ * Returns a human-readable string describing the last error.
+ */
+const char* dvdnav_err_to_string(dvdnav_t *self);
+
+const char* dvdnav_version(void);
+
+/*********************************************************************
+ * changing and reading DVD player characteristics                   *
+ *********************************************************************/
+
+/*
+ * These functions allow you to manipulate the various global characteristics
+ * of the DVD playback engine.
+ */
+
+/*
+ * Sets the region mask (bit 0 set implies region 1, bit 1 set implies
+ * region 2, etc) of the virtual machine. Generally you will only need to set
+ * this if you are playing RCE discs which query the virtual machine as to its
+ * region setting.
+ *
+ * This has _nothing_ to do with the region setting of the DVD drive.
+ */
+dvdnav_status_t dvdnav_set_region_mask(dvdnav_t *self, int32_t region_mask);
+
+/*
+ * Returns the region mask (bit 0 set implies region 1, bit 1 set implies
+ * region 2, etc) of the virtual machine.
+ *
+ * This has _nothing_ to do with the region setting of the DVD drive.
+ */
+dvdnav_status_t dvdnav_get_region_mask(dvdnav_t *self, int32_t *region_mask);
+
+/*
+ * Specify whether read-ahead caching should be used. You may not want this if your
+ * decoding engine does its own buffering.
+ *
+ * The default read-ahead cache does not use an additional thread for the reading
+ * (see read_cache.c for a threaded cache, but note that this code is currently
+ * unmaintained). It prebuffers on VOBU level by reading ahead several buffers
+ * on every read request. The speed of this prebuffering has been optimized to
+ * also work on slow DVD drives.
+ *
+ * If in addition you want to prevent memcpy's to improve performance, have a look
+ * at dvdnav_get_next_cache_block().
+ */
+dvdnav_status_t dvdnav_set_readahead_flag(dvdnav_t *self, int32_t read_ahead_flag);
+
+/*
+ * Query whether read-ahead caching/buffering will be used.
+ */
+dvdnav_status_t dvdnav_get_readahead_flag(dvdnav_t *self, int32_t *read_ahead_flag);
+
+/*
+ * Specify whether the positioning works PGC or PG based.
+ * Programs (PGs) on DVDs are similar to Chapters and a program chain (PGC)
+ * usually covers a whole feature. This affects the behaviour of the
+ * functions dvdnav_get_position() and dvdnav_sector_search(). See there.
+ * Default is PG based positioning.
+ */
+dvdnav_status_t dvdnav_set_PGC_positioning_flag(dvdnav_t *self, int32_t pgc_based_flag);
+
+/*
+ * Query whether positioning is PG or PGC based.
+ */
+dvdnav_status_t dvdnav_get_PGC_positioning_flag(dvdnav_t *self, int32_t *pgc_based_flag);
+
+
+dvdnav_status_t dvdnav_set_nav_only_flag(dvdnav_t *self, int32_t nav_only);
+
+/*********************************************************************
+ * reading data                                                      *
+ *********************************************************************/
+
+/*
+ * These functions are used to poll the playback engine and actually get data
+ * off the DVD.
+ */
+
+/*
+ * Attempts to get the next block off the DVD and copies it into the buffer 'buf'.
+ * If there is any special actions that may need to be performed, the value
+ * pointed to by 'event' gets set accordingly.
+ *
+ * If 'event' is DVDNAV_BLOCK_OK then 'buf' is filled with the next block
+ * (note that means it has to be at /least/ 2048 bytes big). 'len' is
+ * then set to 2048.
+ *
+ * Otherwise, buf is filled with an appropriate event structure and
+ * len is set to the length of that structure.
+ *
+ * See the dvdnav_events.h header for information on the various events.
+ */
+dvdnav_status_t dvdnav_get_next_block(dvdnav_t *self, uint8_t *buf,
+                                      int32_t *event, int32_t *len);
+
+/*
+ * This basically does the same as dvdnav_get_next_block. The only difference is
+ * that it avoids a memcopy, when the requested block was found in the cache.
+ * In such a case (cache hit) this function will return a different pointer than
+ * the one handed in, pointing directly into the relevant block in the cache.
+ * Those pointers must _never_ be freed but instead returned to the library via
+ * dvdnav_free_cache_block().
+ */
+dvdnav_status_t dvdnav_get_next_cache_block(dvdnav_t *self, uint8_t **buf,
+                                            int32_t *event, int32_t *len);
+
+/*
+ * All buffers which came from the internal cache (when dvdnav_get_next_cache_block()
+ * returned a buffer different from the one handed in) have to be freed with this
+ * function. Although handing in other buffers not from the cache doesn't cause any harm.
+ */
+dvdnav_status_t dvdnav_free_cache_block(dvdnav_t *self, unsigned char *buf);
+
+/*
+ * If we are currently in a still-frame this function skips it.
+ *
+ * See also the DVDNAV_STILL_FRAME event.
+ */
+dvdnav_status_t dvdnav_still_skip(dvdnav_t *self);
+
+/*
+ * If we are currently in WAIT state, that is: the application is required to
+ * wait for its fifos to become empty, calling this signals libdvdnav that this
+ * is achieved and that it can continue.
+ *
+ * See also the DVDNAV_WAIT event.
+ */
+dvdnav_status_t dvdnav_wait_skip(dvdnav_t *self);
+
+/*
+ * Returns the still time from the currently playing cell.
+ * The still time is given in seconds with 0xff meaning an indefinite still.
+ *
+ * This function can be used to detect still frames before they are reached.
+ * Some players might need this to prepare for a frame to be shown for a
+ * longer time than usual.
+ */
+uint32_t dvdnav_get_next_still_flag(dvdnav_t *self);
+
+/*
+ * Stops playback. The next event obtained with one of the get_next_block
+ * functions will be a DVDNAV_STOP event.
+ *
+ * It is not required to call this before dvdnav_close().
+ */
+dvdnav_status_t dvdnav_stop(dvdnav_t *self);
+
+
+/*********************************************************************
+ * title/part navigation                                             *
+ *********************************************************************/
+
+/*
+ * Returns the number of titles on the disk.
+ */
+dvdnav_status_t dvdnav_get_number_of_titles(dvdnav_t *self, int32_t *titles);
+
+/*
+ * Returns the number of parts within the given title.
+ */
+dvdnav_status_t dvdnav_get_number_of_parts(dvdnav_t *self, int32_t title, int32_t *parts);
+
+/*
+ * Returns the number of angles for the given title.
+ */
+dvdnav_status_t dvdnav_get_number_of_angles(dvdnav_t *self, int32_t title, int32_t *angles);
+
+/*
+ * Plays the specified title of the DVD from its beginning (that is: part 1).
+ */
+dvdnav_status_t dvdnav_title_play(dvdnav_t *self, int32_t title);
+
+/*
+ * Plays the specified title, starting from the specified part.
+ */
+dvdnav_status_t dvdnav_part_play(dvdnav_t *self, int32_t title, int32_t part);
+
+/*
+ * Plays the specified title, starting from the specified program
+ */
+dvdnav_status_t dvdnav_program_play(dvdnav_t *self, int32_t title, int32_t pgcn, int32_t pgn);
+
+/*
+ * Stores in *times an array (that the application *must* free) of
+ * dvdtimes corresponding to the chapter times for the chosen title.
+ * *duration will have the duration of the title
+ * The number of entries in *times is the result of the function.
+ * On error *times is NULL and the output is 0
+ */
+uint32_t dvdnav_describe_title_chapters(dvdnav_t *self, int32_t title, uint64_t **times, uint64_t *duration);
+
+/*
+ * Play the specified amount of parts of the specified title of
+ * the DVD then STOP.
+ *
+ * Currently unimplemented!
+ */
+dvdnav_status_t dvdnav_part_play_auto_stop(dvdnav_t *self, int32_t title,
+                                           int32_t part, int32_t parts_to_play);
+
+/*
+ * Play the specified title starting from the specified time.
+ *
+ * Currently unimplemented!
+ */
+dvdnav_status_t dvdnav_time_play(dvdnav_t *self, int32_t title,
+                                 uint64_t time);
+
+/*
+ * Stop playing the current position and jump to the specified menu.
+ *
+ * See also DVDMenuID_t from libdvdread
+ */
+dvdnav_status_t dvdnav_menu_call(dvdnav_t *self, DVDMenuID_t menu);
+
+/*
+ * Return the title number and part currently being played.
+ * A title of 0 indicates we are in a menu. In this case, part
+ * is set to the current menu's ID.
+ */
+dvdnav_status_t dvdnav_current_title_info(dvdnav_t *self, int32_t *title,
+                                          int32_t *part);
+
+/*
+ * Return the title number, pgcn and pgn currently being played.
+ * A title of 0 indicates, we are in a menu.
+ */
+dvdnav_status_t dvdnav_current_title_program2(dvdnav_t *self, int32_t *title, int32_t* vtsn,
+                                          int32_t *pgcn, int32_t *pgn,int32_t* celln);
+
+/*
+ * Return the current position (in blocks) within the current
+ * title and the length (in blocks) of said title.
+ *
+ * Current implementation is wrong and likely to behave unpredictably!
+ * Use is discouraged!
+ */
+dvdnav_status_t dvdnav_get_position_in_title(dvdnav_t *self,
+                                             uint32_t *pos,
+                                             uint32_t *len);
+
+/*
+ * This function is only available for compatibility reasons.
+ *
+ * Stop playing the current position and start playback of the current title
+ * from the specified part.
+ */
+dvdnav_status_t dvdnav_part_search(dvdnav_t *self, int32_t part);
+
+
+/*********************************************************************
+ * program chain/program navigation                                  *
+ *********************************************************************/
+
+/*
+ * Stop playing the current position and start playback from the last
+ * VOBU boundary before the given sector. The sector number is not
+ * meant to be an absolute physical DVD sector, but a relative sector
+ * in the current program. This function cannot leave the current
+ * program and will fail if asked to do so.
+ *
+ * If program chain based positioning is enabled
+ * (see dvdnav_set_PGC_positioning_flag()), this will seek to the relative
+ * sector inside the current program chain.
+ *
+ * 'origin' can be one of SEEK_SET, SEEK_CUR, SEEK_END as defined in
+ * fcntl.h.
+ */
+dvdnav_status_t dvdnav_sector_search(dvdnav_t *self,
+                                     int64_t offset, int32_t origin);
+
+/*
+ returns the current stream time in PTS ticks as reported by the IFO structures
+ divide it by 90000 to get the current play time in seconds
+ */
+int64_t dvdnav_get_current_time(dvdnav_t *self);
+
+uint64_t dvdnav_get_absolute_time(dvdnav_t *self);
+
+uint32_t dvdnav_get_prm(dvdnav_t *self, uint8_t type, uint8_t reg);
+
+/*
+ * Stop playing the current position and start playback of the title
+ * from the specified timecode.
+ *
+ * Currently implemented using interpolation. That interpolation is slightly
+ * inaccurate.
+ */
+dvdnav_status_t dvdnav_time_search(dvdnav_t *self,
+                                   uint64_t time);
+
+/*
+ * Stop playing current position and play the "GoUp"-program chain.
+ * (which generally leads to the title menu or a higher-level menu).
+ */
+dvdnav_status_t dvdnav_go_up(dvdnav_t *self);
+
+/*
+ * Stop playing the current position and start playback at the
+ * previous program (if it exists).
+ */
+dvdnav_status_t dvdnav_prev_pg_search(dvdnav_t *self);
+
+/*
+ * Stop playing the current position and start playback at the
+ * first program.
+ */
+dvdnav_status_t dvdnav_top_pg_search(dvdnav_t *self);
+
+/*
+ * Stop playing the current position and start playback at the
+ * next program (if it exists).
+ */
+dvdnav_status_t dvdnav_next_pg_search(dvdnav_t *self);
+
+/*
+ * Return the current position (in blocks) within the current
+ * program and the length (in blocks) of current program.
+ *
+ * If program chain based positioning is enabled
+ * (see dvdnav_set_PGC_positioning_flag()), this will return the
+ * relative position in and the length of the current program chain.
+ */
+dvdnav_status_t dvdnav_get_position(dvdnav_t *self, uint32_t *pos,
+                                    uint32_t *len);
+
+
+/*********************************************************************
+ * menu highlights                                                   *
+ *********************************************************************/
+
+/*
+ * Most functions related to highlights take a NAV PCI packet as a parameter.
+ * While you can get such a packet from libdvdnav, this will result in
+ * errors for players with internal FIFOs because due to the FIFO length,
+ * libdvdnav will be ahead in the stream compared to what the user is
+ * seeing on screen.  Therefore, player applications who have a NAV
+ * packet available, which is better in sync with the actual playback,
+ * should always pass this one to these functions.
+ */
+
+/*
+ * Get the currently highlighted button
+ * number (1..36) or 0 if no button is highlighted.
+ */
+dvdnav_status_t dvdnav_get_current_highlight(dvdnav_t *self, int32_t *button);
+
+/*
+ * Returns the Presentation Control Information (PCI) structure associated
+ * with the current position.
+ *
+ * Read the general notes above.
+ * See also libdvdreads nav_types.h for definition of pci_t.
+ */
+pci_t* dvdnav_get_current_nav_pci(dvdnav_t *self);
+
+/*
+ * Returns the DSI (data search information) structure associated
+ * with the current position.
+ *
+ * Read the general notes above.
+ * See also libdvdreads nav_types.h for definition of dsi_t.
+ */
+dsi_t* dvdnav_get_current_nav_dsi(dvdnav_t *self);
+
+/*
+ * Get the area associated with a certain button.
+ */
+dvdnav_status_t dvdnav_get_highlight_area(pci_t *nav_pci , int32_t button, int32_t mode,
+                                          dvdnav_highlight_area_t *highlight);
+
+/*
+ * Move button highlight around as suggested by function name (e.g. with arrow keys).
+ */
+dvdnav_status_t dvdnav_upper_button_select(dvdnav_t *self, pci_t *pci);
+dvdnav_status_t dvdnav_lower_button_select(dvdnav_t *self, pci_t *pci);
+dvdnav_status_t dvdnav_right_button_select(dvdnav_t *self, pci_t *pci);
+dvdnav_status_t dvdnav_left_button_select(dvdnav_t *self, pci_t *pci);
+
+/*
+ * Activate ("press") the currently highlighted button.
+ */
+dvdnav_status_t dvdnav_button_activate(dvdnav_t *self, pci_t *pci);
+
+/*
+ * Highlight a specific button.
+ */
+dvdnav_status_t dvdnav_button_select(dvdnav_t *self, pci_t *pci, int32_t button);
+
+/*
+ * Activate ("press") specified button.
+ */
+dvdnav_status_t dvdnav_button_select_and_activate(dvdnav_t *self, pci_t *pci, int32_t button);
+
+/*
+ * Activate ("press") a button and execute specified command.
+ */
+dvdnav_status_t dvdnav_button_activate_cmd(dvdnav_t *self, int32_t button, vm_cmd_t *cmd);
+
+/*
+ * Select button at specified video frame coordinates.
+ */
+dvdnav_status_t dvdnav_mouse_select(dvdnav_t *self, pci_t *pci, int32_t x, int32_t y);
+
+/*
+ * Activate ("press") button at specified video frame coordinates.
+ */
+dvdnav_status_t dvdnav_mouse_activate(dvdnav_t *self, pci_t *pci, int32_t x, int32_t y);
+
+
+/*********************************************************************
+ * languages                                                         *
+ *********************************************************************/
+
+/*
+ * The language codes expected by these functions are two character
+ * codes as defined in ISO639.
+ */
+
+/*
+ * Set which menu language we should use per default.
+ */
+dvdnav_status_t dvdnav_menu_language_select(dvdnav_t *self,
+                                           char *code);
+
+/*
+ * Set which audio language we should use per default.
+ */
+dvdnav_status_t dvdnav_audio_language_select(dvdnav_t *self,
+                                            char *code);
+
+/*
+ * Set which spu language we should use per default.
+ */
+dvdnav_status_t dvdnav_spu_language_select(dvdnav_t *self,
+                                          char *code);
+
+
+/*********************************************************************
+ * obtaining stream attributes                                       *
+ *********************************************************************/
+
+/*
+ * Return a string describing the title of the DVD.
+ * This is an ID string encoded on the disc by the author. In many cases
+ * this is a descriptive string such as `THE_MATRIX' but sometimes is singularly
+ * uninformative such as `PDVD-011421'. Some DVD authors even forget to set this,
+ * so you may also read the default of the authoring software they used, like
+ * `DVDVolume'.
+ */
+dvdnav_status_t dvdnav_get_title_string(dvdnav_t *self, const char **title_str);
+
+/*
+ * Returns a string containing the serial number of the DVD.
+ * This has a max of 15 characters and should be more unique than the
+ * title string.
+ */
+dvdnav_status_t dvdnav_get_serial_string(dvdnav_t *self, const char **serial_str);
+
+/*
+ * Get video aspect code.
+ * The aspect code does only change on VTS boundaries.
+ * See the DVDNAV_VTS_CHANGE event.
+ *
+ * 0 -- 4:3, 2 -- 16:9
+ */
+uint8_t dvdnav_get_video_aspect(dvdnav_t *self);
+
+/*
+ * Get video resolution.
+ */
+dvdnav_status_t dvdnav_get_video_resolution(dvdnav_t *self, uint32_t *width, uint32_t *height);
+
+/*
+ * Get video scaling permissions.
+ * The scaling permission does only change on VTS boundaries.
+ * See the DVDNAV_VTS_CHANGE event.
+ *
+ * bit0 set = deny letterboxing, bit1 set = deny pan&scan
+ */
+uint8_t dvdnav_get_video_scale_permission(dvdnav_t *self);
+
+/*
+ * Converts a *logical* audio stream id into language code
+ * (returns 0xffff if no such stream).
+ */
+uint16_t dvdnav_audio_stream_to_lang(dvdnav_t *self, uint8_t stream);
+
+/*
+ * Returns the format of *logical* audio stream 'stream'
+ * (returns 0xffff if no such stream).
+ */
+uint16_t dvdnav_audio_stream_format(dvdnav_t *self, uint8_t stream);
+
+/*
+ * Returns number of channels in *logical* audio stream 'stream'
+ * (returns 0xffff if no such stream).
+ */
+uint16_t dvdnav_audio_stream_channels(dvdnav_t *self, uint8_t stream);
+
+/*
+ * Converts a *logical* subpicture stream id into country code
+ * (returns 0xffff if no such stream).
+ */
+uint16_t dvdnav_spu_stream_to_lang(dvdnav_t *self, uint8_t stream);
+
+/*
+ * Converts a *physical* (MPEG) audio stream id into a logical stream number.
+ */
+int8_t dvdnav_get_audio_logical_stream(dvdnav_t *self, uint8_t audio_num);
+
+#define HAVE_GET_AUDIO_ATTR
+/*
+ * Get audio attr
+ */
+dvdnav_status_t dvdnav_get_audio_attr(dvdnav_t *self, uint8_t audio_mum, audio_attr_t *audio_attr);
+
+/*
+ * Converts a *physical* (MPEG) subpicture stream id into a logical stream number.
+ */
+int8_t dvdnav_get_spu_logical_stream(dvdnav_t *self, uint8_t subp_num);
+
+#define HAVE_GET_SPU_ATTR
+/*
+ * Get spu attr
+ */
+dvdnav_status_t dvdnav_get_spu_attr(dvdnav_t *self, uint8_t audio_mum, subp_attr_t *subp_attr);
+
+/*
+ * Get active audio stream.
+ */
+int8_t dvdnav_get_active_audio_stream(dvdnav_t *self);
+
+/*
+ * Get active spu stream.
+ */
+int8_t dvdnav_get_active_spu_stream(dvdnav_t *self);
+
+/*
+ * Get the set of user operations that are currently prohibited.
+ * There are potentially new restrictions right after
+ * DVDNAV_CHANNEL_HOP and DVDNAV_NAV_PACKET.
+ */
+user_ops_t dvdnav_get_restrictions(dvdnav_t *self);
+
+
+/*********************************************************************
+ * multiple angles                                                   *
+ *********************************************************************/
+
+/*
+ * The libdvdnav library abstracts away the difference between seamless and
+ * non-seamless angles. From the point of view of the programmer you just set the
+ * angle number and all is well in the world. You will always see only the
+ * selected angle coming from the get_next_block functions.
+ *
+ * Note:
+ * It is quite possible that some tremendously strange DVD feature might change the
+ * angle number from under you. Generally you should always view the results from
+ * dvdnav_get_angle_info() as definitive only up to the next time you call
+ * dvdnav_get_next_block().
+ */
+
+/*
+ * Sets the current angle. If you try to follow a non existent angle
+ * the call fails.
+ */
+dvdnav_status_t dvdnav_angle_change(dvdnav_t *self, int32_t angle);
+
+/*
+ * Returns the current angle and number of angles present.
+ */
+dvdnav_status_t dvdnav_get_angle_info(dvdnav_t *self, int32_t *current_angle,
+                                      int32_t *number_of_angles);
+
+/*********************************************************************
+ * domain queries                                                    *
+ *********************************************************************/
+
+/*
+ * Are we in the First Play domain?
+ */
+int8_t dvdnav_is_domain_fp(dvdnav_t *self);
+
+/*
+ * Are we in the Video management Menu domain?
+ */
+int8_t dvdnav_is_domain_vmgm(dvdnav_t *self);
+
+/*
+ * Are we in the Video Title Menu domain?
+ */
+int8_t dvdnav_is_domain_vtsm(dvdnav_t *self);
+
+/*
+ * Are we in the Video Title Set domain?
+ */
+int8_t dvdnav_is_domain_vts(dvdnav_t *self);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBDVDNAV_DVDNAV_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/dvdnav_events.h Added

@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2001 Rich Wareham <richwareham@users.sourceforge.net>
+ *
+ * This file is part of libdvdnav, a DVD navigation library.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/*
+ * This header defines events and event types
+ */
+
+#ifndef LIBDVDNAV_DVDNAV_EVENTS_H
+#define LIBDVDNAV_DVDNAV_EVENTS_H
+
+/*
+ * DVDNAV_BLOCK_OK
+ *
+ * A regular data block from the DVD has been returned.
+ * This one should be demuxed and decoded for playback.
+ */
+#define DVDNAV_BLOCK_OK                         0
+
+
+/*
+ * DVDNAV_NOP
+ *
+ * Just ignore this.
+ */
+#define DVDNAV_NOP                         1
+
+
+/*
+ * DVDNAV_STILL_FRAME
+ *
+ * We have reached a still frame. The player application should wait
+ * the amount of time specified by the still's length while still handling
+ * user input to make menus and other interactive stills work.
+ * The last delivered frame should be kept showing.
+ * Once the still has timed out, call dvdnav_skip_still().
+ * A length of 0xff means an infinite still which has to be skipped
+ * indirectly by some user interaction.
+ */
+#define DVDNAV_STILL_FRAME                 2
+
+typedef struct {
+  /* The length (in seconds) the still frame should be displayed for,
+   * or 0xff if infinite. */
+  int length;
+} dvdnav_still_event_t;
+
+
+/*
+ * DVDNAV_SPU_STREAM_CHANGE
+ *
+ * Inform the SPU decoding/overlaying engine to switch SPU channels.
+ */
+#define DVDNAV_SPU_STREAM_CHANGE         3
+
+typedef struct {
+  /* The physical (MPEG) stream number for widescreen SPU display.
+   * Use this, if you blend the SPU on an anamorphic image before
+   * unsqueezing it. */
+  int physical_wide;
+
+  /* The physical (MPEG) stream number for letterboxed display.
+   * Use this, if you blend the SPU on an anamorphic image after
+   * unsqueezing it. */
+  int physical_letterbox;
+
+  /* The physical (MPEG) stream number for pan&scan display.
+   * Use this, if you blend the SPU on an anamorphic image after
+   * unsqueezing it the pan&scan way. */
+  int physical_pan_scan;
+
+  /* The logical (DVD) stream number. */
+  int logical;
+} dvdnav_spu_stream_change_event_t;
+
+
+/*
+ * DVDNAV_AUDIO_STREAM_CHANGE
+ *
+ * Inform the audio decoder to switch channels.
+ */
+#define DVDNAV_AUDIO_STREAM_CHANGE         4
+
+typedef struct {
+  /* The physical (MPEG) stream number. */
+  int physical;
+
+  /* The logical (DVD) stream number. */
+  int logical;
+} dvdnav_audio_stream_change_event_t;
+
+
+/*
+ * DVDNAV_VTS_CHANGE
+ *
+ * Some status information like video aspect and video scale permissions do
+ * not change inside a VTS. Therefore this event can be used to query such
+ * information only when necessary and update the decoding/displaying
+ * accordingly.
+ */
+#define DVDNAV_VTS_CHANGE                 5
+
+typedef struct {
+  int old_vtsN;                 /* the old VTS number */
+  DVDDomain_t old_domain;       /* the old domain */
+  int new_vtsN;                 /* the new VTS number */
+  DVDDomain_t new_domain;       /* the new domain */
+} dvdnav_vts_change_event_t;
+
+
+/*
+ * DVDNAV_CELL_CHANGE
+ *
+ * Some status information like the current Title and Part numbers do not
+ * change inside a cell. Therefore this event can be used to query such
+ * information only when necessary and update the decoding/displaying
+ * accordingly.
+ * Some useful information for accurate time display is also reported
+ * together with this event.
+ */
+#define DVDNAV_CELL_CHANGE                 6
+
+typedef struct {
+  int     cellN;       /* the new cell number */
+  int     pgN;         /* the current program number */
+  int64_t cell_length; /* the length of the current cell in sectors */
+  int64_t pg_length;   /* the length of the current program in sectors */
+  int64_t pgc_length;  /* the length of the current program chain in PTS ticks */
+  int64_t cell_start;  /* the start offset of the current cell relatively to the PGC in sectors */
+  int64_t pg_start;    /* the start offset of the current PG relatively to the PGC in sectors */
+} dvdnav_cell_change_event_t;
+
+
+/*
+ * DVDNAV_NAV_PACKET
+ *
+ * NAV packets are useful for various purposes. They define the button
+ * highlight areas and VM commands of DVD menus, so they should in any
+ * case be sent to the SPU decoder/overlaying engine for the menus to work.
+ * NAV packets also provide a way to detect PTS discontinuities, because
+ * they carry the start and end PTS values for the current VOBU.
+ * (pci.vobu_s_ptm and pci.vobu_e_ptm) Whenever the start PTS of the
+ * current NAV does not match the end PTS of the previous NAV, a PTS
+ * discontinuity has occured.
+ * NAV packets can also be used for time display, because they are
+ * timestamped relatively to the current Cell.
+ */
+#define DVDNAV_NAV_PACKET                 7
+
+
+/*
+ * DVDNAV_STOP
+ *
+ * Applications should end playback here. A subsequent dvdnav_get_next_block()
+ * call will restart the VM from the beginning of the DVD.
+ */
+#define DVDNAV_STOP                         8
+
+
+/*
+ * DVDNAV_HIGHLIGHT
+ *
+ * The current button highlight changed. Inform the overlaying engine to
+ * highlight a different button. Please note, that at the moment only mode 1
+ * highlights are reported this way. That means, when the button highlight
+ * has been moved around by some function call, you will receive an event
+ * telling you the new button. But when a button gets activated, you have
+ * to handle the mode 2 highlighting (that is some different colour the
+ * button turns to on activation) in your application.
+ */
+#define DVDNAV_HIGHLIGHT                 9
+
+typedef struct {
+  /* highlight mode: 0 - hide, 1 - show, 2 - activate, currently always 1 */
+  int display;
+
+  /* FIXME: these fields are currently not set */
+  uint32_t palette;     /* The CLUT entries for the highlight palette
+                           (4-bits per entry -> 4 entries) */
+  uint16_t sx,sy,ex,ey; /* The start/end x,y positions */
+  uint32_t pts;         /* Highlight PTS to match with SPU */
+
+  /* button number for the SPU decoder/overlaying engine */
+  uint32_t buttonN;
+} dvdnav_highlight_event_t;
+
+
+/*
+ * DVDNAV_SPU_CLUT_CHANGE
+ *
+ * Inform the SPU decoder/overlaying engine to update its colour lookup table.
+ * The CLUT is given as 16 uint32_t's in the buffer.
+ */
+#define DVDNAV_SPU_CLUT_CHANGE                10
+
+
+/*
+ * DVDNAV_HOP_CHANNEL
+ *
+ * A non-seamless operation has been performed. Applications can drop all
+ * their internal fifo's content, which will speed up the response.
+ */
+#define DVDNAV_HOP_CHANNEL                12
+
+
+/*
+ * DVDNAV_WAIT
+ *
+ * We have reached a point in DVD playback, where timing is critical.
+ * Player application with internal fifos can introduce state
+ * inconsistencies, because libdvdnav is always the fifo's length
+ * ahead in the stream compared to what the application sees.
+ * Such applications should wait until their fifos are empty
+ * when they receive this type of event.
+ * Once this is achieved, call dvdnav_skip_wait().
+ */
+#define DVDNAV_WAIT                        13
+
+
+#endif /* LIBDVDNAV_DVDNAV_EVENTS_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/dvdnav_internal.h Added

@@ -0,0 +1,276 @@
+/*
+ * Copyright (C) 2001-2004 Rich Wareham <richwareham@users.sourceforge.net>
+ *
+ * This file is part of libdvdnav, a DVD navigation library.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDNAV_DVDNAV_INTERNAL_H
+#define LIBDVDNAV_DVDNAV_INTERNAL_H
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef _WIN32
+
+#ifndef DVDNAV_NO_LOCKING
+/* pthread_mutex_* wrapper for win32 */
+#include <windows.h>
+#include <process.h>
+typedef CRITICAL_SECTION pthread_mutex_t;
+#define pthread_mutex_init(a, b) InitializeCriticalSection(a)
+#define pthread_mutex_lock(a)    EnterCriticalSection(a)
+#define pthread_mutex_unlock(a)  LeaveCriticalSection(a)
+#define pthread_mutex_destroy(a) DeleteCriticalSection(a)
+#endif
+
+#include <io.h> /* read() */
+#define lseek64 _lseeki64
+
+#else
+
+#ifndef DVDNAV_NO_LOCKING
+#include <pthread.h>
+#endif
+
+#endif /* _WIN32 */
+
+#ifdef DVDNAV_NO_LOCKING
+#define pthread_mutex_init(a, b) (0)
+#define pthread_mutex_lock(a)    (0)
+#define pthread_mutex_unlock(a)  (0)
+#define pthread_mutex_destroy(a) (0)
+#endif
+
+#ifdef __ANDROID__
+# undef  lseek
+# define lseek lseek64
+# undef  off_t
+# define off_t off64_t
+#endif
+
+/* where should libdvdnav write its messages (stdout/stderr) */
+#define MSG_OUT stderr
+
+/* Maximum length of an error string */
+#define MAX_ERR_LEN 255
+
+#ifndef DVD_VIDEO_LB_LEN
+#define DVD_VIDEO_LB_LEN 2048
+#endif
+
+typedef enum {
+  DSI_ILVU_PRE   = 1 << 15, /* set during the last 3 VOBU preceeding an interleaved block. */
+  DSI_ILVU_BLOCK = 1 << 14, /* set for all VOBU in an interleaved block */
+  DSI_ILVU_FIRST = 1 << 13, /* set for the first VOBU for a given angle or scene within a ILVU, or the first VOBU in the preparation (PREU) sequence */
+  DSI_ILVU_LAST  = 1 << 12, /* set for the last VOBU for a given angle or scene within a ILVU, or the last VOBU in the preparation (PREU) sequence */
+  DSI_ILVU_MASK  = 0xf000
+} DSI_ILVU;
+
+typedef struct read_cache_s read_cache_t;
+
+/*
+ * These are defined here because they are
+ * not in ifo_types.h, they maybe one day
+ */
+#if PRAGMA_PACK
+#pragma pack(push)
+#pragma pack(1)
+#endif
+
+#ifndef audio_status_t
+typedef struct {
+#ifdef WORDS_BIGENDIAN
+  unsigned int available     : 1;
+  unsigned int zero1         : 4;
+  unsigned int stream_number : 3;
+  uint8_t zero2;
+#else
+  uint8_t zero2;
+  unsigned int stream_number : 3;
+  unsigned int zero1         : 4;
+  unsigned int available     : 1;
+#endif
+} ATTRIBUTE_PACKED audio_status_t;
+#endif
+
+#ifndef spu_status_t
+typedef struct {
+#ifdef WORDS_BIGENDIAN
+  unsigned int available               : 1;
+  unsigned int zero1                   : 2;
+  unsigned int stream_number_4_3       : 5;
+  unsigned int zero2                   : 3;
+  unsigned int stream_number_wide      : 5;
+  unsigned int zero3                   : 3;
+  unsigned int stream_number_letterbox : 5;
+  unsigned int zero4                   : 3;
+  unsigned int stream_number_pan_scan  : 5;
+#else
+  unsigned int stream_number_pan_scan  : 5;
+  unsigned int zero4                   : 3;
+  unsigned int stream_number_letterbox : 5;
+  unsigned int zero3                   : 3;
+  unsigned int stream_number_wide      : 5;
+  unsigned int zero2                   : 3;
+  unsigned int stream_number_4_3       : 5;
+  unsigned int zero1                   : 2;
+  unsigned int available               : 1;
+#endif
+} ATTRIBUTE_PACKED spu_status_t;
+#endif
+
+#if PRAGMA_PACK
+#pragma pack(pop)
+#endif
+
+/*
+ * Describes a given time, and the closest sector, vobu and tmap index
+ */
+typedef struct {
+  uint64_t            time;
+  uint32_t            sector;
+  uint32_t            vobu_idx;
+  int32_t             tmap_idx;
+} dvdnav_pos_data_t;
+
+/*
+ * Encapsulates cell data
+ */
+typedef struct {
+  int32_t             idx;
+  dvdnav_pos_data_t   *bgn;
+  dvdnav_pos_data_t   *end;
+} dvdnav_cell_data_t;
+
+/*
+ * Encapsulates common variables used by internal functions of jump_to_time
+ */
+typedef struct {
+  vobu_admap_t        *admap;
+  int32_t             admap_len;
+  vts_tmap_t          *tmap;
+  int32_t             tmap_len;
+  int32_t             tmap_interval;
+} dvdnav_jump_args_t;
+
+/*
+ * Utility constants for jump_to_time
+ */
+#define TMAP_IDX_EDGE_BGN  -1
+#define TMAP_IDX_EDGE_END  -2
+#define JUMP_MODE_TIME_AFTER 1
+#define JUMP_MODE_TIME_DEFAULT 0
+#define JUMP_MODE_TIME_BEFORE -1
+
+typedef struct dvdnav_vobu_s {
+  int32_t vobu_start;  /* Logical Absolute. MAX needed is 0x300000 */
+  int32_t vobu_length;
+  int32_t blockN;      /* Relative offset */
+  int32_t vobu_next;   /* Relative offset */
+} dvdnav_vobu_t;
+
+/** The main DVDNAV type **/
+
+struct dvdnav_s {
+  /* General data */
+  char       *path;               /* Path to DVD device/dir */
+  dvd_file_t *file;               /* Currently opened file */
+
+  /* Position data */
+  vm_position_t position_next;
+  vm_position_t position_current;
+  dvdnav_vobu_t vobu;
+
+  /* NAV data */
+  pci_t pci;
+  dsi_t dsi;
+  uint32_t last_cmd_nav_lbn;      /* detects when a command is issued on an already left NAV */
+
+  /* Flags */
+  int skip_still;                 /* Set when skipping a still */
+  int sync_wait;                  /* applications should wait till they are in sync with us */
+  int sync_wait_skip;             /* Set when skipping wait state */
+  int spu_clut_changed;           /* The SPU CLUT changed */
+  int started;                    /* vm_start has been called? */
+  int use_read_ahead;             /* 1 - use read-ahead cache, 0 - don't */
+  int pgc_based;                  /* positioning works PGC based instead of PG based */
+  int nav_only;                   /* do navigation only */
+  uint32_t cur_cell_time;         /* time expired since the beginning of the current cell, read from the dsi */
+
+  /* VM */
+  vm_t *vm;
+
+#ifndef DVDNAV_NO_LOCKING
+  pthread_mutex_t vm_lock;
+#endif
+
+  /* private context and logger*/
+  void *priv;
+  dvdnav_logger_cb logcb;
+
+#ifndef DVDNAV_NO_CACHE
+  /* Read-ahead cache */
+  read_cache_t *cache;
+#endif
+
+#ifndef DVDNAV_NO_ERRSTR
+  /* Errors */
+  char err_strMAX_ERR_LEN;
+#endif
+};
+
+/** HELPER FUNCTIONS **/
+
+/* converts a dvd_time_t to PTS ticks */
+int64_t dvdnav_convert_time(dvd_time_t *time);
+
+/** USEFUL MACROS **/
+
+#ifndef DVDNAV_NO_ERRSTR
+
+#ifdef __GNUC__
+#define printerrf(format, args...) \
+    do { if (this) snprintf(this->err_str, MAX_ERR_LEN, format, ## args); } while (0)
+#else
+#ifdef _MSC_VER
+#define printerrf(str) \
+    do { if (this) snprintf(this->err_str, MAX_ERR_LEN, str); } while (0)
+#else
+#define printerrf(...) \
+    do { if (this) snprintf(this->err_str, MAX_ERR_LEN, __VA_ARGS__); } while (0)
+#endif /* _MSC_VER */
+#endif
+
+#define printerr(str) \
+    do { if (this) strncpy(this->err_str, str, MAX_ERR_LEN - 1); } while (0)
+
+#else
+
+#include "logger.h"
+
+#define printerr(str) do { if (this) Log0(this,"ERROR: %s",str); } while (0)
+
+#ifdef _MSC_VER
+#define printerrf(fmt,...) do { if (this) Log0(this,"ERROR: " fmt,__VA_ARGS__); } while (0)
+#else
+#define printerrf(fmt, args...) do { if (this) Log0(this,"ERROR: " fmt, ## args); } while (0)
+#endif
+
+#endif
+
+#endif /* LIBDVDNAV_DVDNAV_INTERNAL_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/highlight.c Added

@@ -0,0 +1,514 @@
+/*
+ * Copyright (C) 2000 Rich Wareham <richwareham@users.sourceforge.net>
+ *
+ * This file is part of libdvdnav, a DVD navigation library.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <inttypes.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <limits.h>
+#include <string.h>
+#include <dvdread/nav_types.h>
+#include "dvdnav/dvdnav.h"
+#include "vm/decoder.h"
+#include "vm/vm.h"
+#include "vm/vmcmd.h"
+#include "dvdnav_internal.h"
+
+/*
+#define BUTTON_TESTING
+*/
+
+#ifdef BUTTON_TESTING
+
+#include <dvdread/nav_print.h>
+
+static void print_time(dvd_time_t *dtime) {
+  const char *rate;
+
+#if 0
+  assert((dtime->hour>>4) < 0xa && (dtime->hour&0xf) < 0xa);
+  assert((dtime->minute>>4) < 0x7 && (dtime->minute&0xf) < 0xa);
+  assert((dtime->second>>4) < 0x7 && (dtime->second&0xf) < 0xa);
+  assert((dtime->frame_u&0xf) < 0xa);
+#endif
+
+  fprintf(MSG_OUT,"%02x:%02x:%02x.%02x",
+         dtime->hour,
+         dtime->minute,
+         dtime->second,
+         dtime->frame_u & 0x3f);
+  switch((dtime->frame_u & 0xc0) >> 6) {
+  case 1:
+    rate = "25.00";
+    break;
+  case 3:
+    rate = "29.97";
+    break;
+  default:
+    rate = "(please send a bug report)";
+    break;
+  }
+  fprintf(MSG_OUT," @ %s fps", rate);
+}
+
+static void nav_print_PCI_GI(pci_gi_t *pci_gi) {
+  int32_t i;
+
+  fprintf(MSG_OUT,"libdvdnav: pci_gi:\n");
+  fprintf(MSG_OUT,"libdvdnav: nv_pck_lbn    0x%08x\n", pci_gi->nv_pck_lbn);
+  fprintf(MSG_OUT,"libdvdnav: vobu_cat      0x%04x\n", pci_gi->vobu_cat);
+  fprintf(MSG_OUT,"libdvdnav: vobu_uop_ctl  0x%08x\n", *(uint32_t*)&pci_gi->vobu_uop_ctl);
+  fprintf(MSG_OUT,"libdvdnav: vobu_s_ptm    0x%08x\n", pci_gi->vobu_s_ptm);
+  fprintf(MSG_OUT,"libdvdnav: vobu_e_ptm    0x%08x\n", pci_gi->vobu_e_ptm);
+  fprintf(MSG_OUT,"libdvdnav: vobu_se_e_ptm 0x%08x\n", pci_gi->vobu_se_e_ptm);
+  fprintf(MSG_OUT,"libdvdnav: e_eltm        ");
+  print_time(&pci_gi->e_eltm);
+  fprintf(MSG_OUT,"\n");
+
+  fprintf(MSG_OUT,"libdvdnav: vobu_isrc     \"");
+  for(i = 0; i < 32; i++) {
+    char c = pci_gi->vobu_isrci;
+    if((c >= ' ') && (c <= '~'))
+      fprintf(MSG_OUT,"%c", c);
+    else
+      fprintf(MSG_OUT,".");
+  }
+  fprintf(MSG_OUT,"\"\n");
+}
+
+static void nav_print_NSML_AGLI(nsml_agli_t *nsml_agli) {
+  int32_t i, j = 0;
+
+  for(i = 0; i < 9; i++)
+    j |= nsml_agli->nsml_agl_dstai;
+  if(j == 0)
+    return;
+
+  fprintf(MSG_OUT,"libdvdnav: nsml_agli:\n");
+  for(i = 0; i < 9; i++)
+    if(nsml_agli->nsml_agl_dstai)
+      fprintf(MSG_OUT,"libdvdnav: nsml_agl_c%d_dsta  0x%08x\n", i + 1,
+             nsml_agli->nsml_agl_dstai);
+}
+
+static void nav_print_HL_GI(hl_gi_t *hl_gi, int32_t *btngr_ns, int32_t *btn_ns) {
+
+  if((hl_gi->hli_ss & 0x03) == 0)
+    return;
+
+  fprintf(MSG_OUT,"libdvdnav: hl_gi:\n");
+  fprintf(MSG_OUT,"libdvdnav: hli_ss        0x%01x\n", hl_gi->hli_ss & 0x03);
+  fprintf(MSG_OUT,"libdvdnav: hli_s_ptm     0x%08x\n", hl_gi->hli_s_ptm);
+  fprintf(MSG_OUT,"libdvdnav: hli_e_ptm     0x%08x\n", hl_gi->hli_e_ptm);
+  fprintf(MSG_OUT,"libdvdnav: btn_se_e_ptm  0x%08x\n", hl_gi->btn_se_e_ptm);
+
+  *btngr_ns = hl_gi->btngr_ns;
+  fprintf(MSG_OUT,"libdvdnav: btngr_ns      %d\n",  hl_gi->btngr_ns);
+  fprintf(MSG_OUT,"libdvdnav: btngr%d_dsp_ty    0x%02x\n", 1, hl_gi->btngr1_dsp_ty);
+  fprintf(MSG_OUT,"libdvdnav: btngr%d_dsp_ty    0x%02x\n", 2, hl_gi->btngr2_dsp_ty);
+  fprintf(MSG_OUT,"libdvdnav: btngr%d_dsp_ty    0x%02x\n", 3, hl_gi->btngr3_dsp_ty);
+
+  fprintf(MSG_OUT,"libdvdnav: btn_ofn       %d\n", hl_gi->btn_ofn);
+  *btn_ns = hl_gi->btn_ns;
+  fprintf(MSG_OUT,"libdvdnav: btn_ns        %d\n", hl_gi->btn_ns);
+  fprintf(MSG_OUT,"libdvdnav: nsl_btn_ns    %d\n", hl_gi->nsl_btn_ns);
+  fprintf(MSG_OUT,"libdvdnav: fosl_btnn     %d\n", hl_gi->fosl_btnn);
+  fprintf(MSG_OUT,"libdvdnav: foac_btnn     %d\n", hl_gi->foac_btnn);
+}
+
+static void nav_print_BTN_COLIT(btn_colit_t *btn_colit) {
+  int32_t i, j;
+
+  j = 0;
+  for(i = 0; i < 6; i++)
+    j |= btn_colit->btn_colii/2i&1;
+  if(j == 0)
+    return;
+
+  fprintf(MSG_OUT,"libdvdnav: btn_colit:\n");
+  for(i = 0; i < 3; i++)
+    for(j = 0; j < 2; j++)
+      fprintf(MSG_OUT,"libdvdnav: btn_cqoli %d  %s_coli:  %08x\n",
+             i, (j == 0) ? "sl" : "ac",
+             btn_colit->btn_coliij);
+}
+
+static void nav_print_BTNIT(btni_t *btni_table, int32_t btngr_ns, int32_t btn_ns) {
+  int32_t i, j, k;
+
+  fprintf(MSG_OUT,"libdvdnav: btnit:\n");
+  fprintf(MSG_OUT,"libdvdnav: btngr_ns: %i\n", btngr_ns);
+  fprintf(MSG_OUT,"libdvdnav: btn_ns: %i\n", btn_ns);
+
+  if(btngr_ns == 0)
+    return;
+
+  for(i = 0; i < btngr_ns; i++) {
+    for(j = 0; j < (36 / btngr_ns); j++) {
+      if(j < btn_ns) {
+        btni_t *btni = &btni_table(36 / btngr_ns) * i + j;
+
+        fprintf(MSG_OUT,"libdvdnav: group %d btni %d:  ", i+1, j+1);
+        fprintf(MSG_OUT,"btn_coln %d, auto_action_mode %d\n",
+               btni->btn_coln, btni->auto_action_mode);
+        fprintf(MSG_OUT,"libdvdnav: coords   (%d, %d) .. (%d, %d)\n",
+               btni->x_start, btni->y_start, btni->x_end, btni->y_end);
+
+        fprintf(MSG_OUT,"libdvdnav: up %d, ", btni->up);
+        fprintf(MSG_OUT,"down %d, ", btni->down);
+        fprintf(MSG_OUT,"left %d, ", btni->left);
+        fprintf(MSG_OUT,"right %d\n", btni->right);
+        for(k = 0; k < 8; k++) {
+          fprintf(MSG_OUT, "libdvdnav: %02x ", btni->cmd.bytesk);
+        }
+        fprintf(MSG_OUT, "| ");
+#ifdef TRACE
+        vm_print_mnemonic(&btni->cmd);
+#endif
+        fprintf(MSG_OUT, "\n");
+      }
+    }
+  }
+}
+
+static void nav_print_HLI(hli_t *hli) {
+  int32_t btngr_ns = 0, btn_ns = 0;
+
+  fprintf(MSG_OUT,"libdvdnav: hli:\n");
+  nav_print_HL_GI(&hli->hl_gi, & btngr_ns, & btn_ns);
+  nav_print_BTN_COLIT(&hli->btn_colit);
+  nav_print_BTNIT(hli->btnit, btngr_ns, btn_ns);
+}
+
+void nav_print_PCI(pci_t *pci) {
+  fprintf(MSG_OUT,"libdvdnav: pci packet:\n");
+  nav_print_PCI_GI(&pci->pci_gi);
+  nav_print_NSML_AGLI(&pci->nsml_agli);
+  nav_print_HLI(&pci->hli);
+}
+
+#endif
+
+
+/* Highlighting API calls */
+
+dvdnav_status_t dvdnav_get_current_highlight(dvdnav_t *this, int32_t *button) {
+  /* Simply return the appropriate value based on the SPRM */
+  if(((*button) = this->position_current.button) == -1)
+    (*button) = this->vm->state.HL_BTNN_REG >> 10;
+
+  return DVDNAV_STATUS_OK;
+}
+
+static btni_t *get_current_button(dvdnav_t *this, pci_t *pci) {
+  int32_t button = 0;
+
+  if(!pci->hli.hl_gi.hli_ss) {
+    printerr("Not in a menu.");
+    return NULL;
+  }
+  if(this->last_cmd_nav_lbn == pci->pci_gi.nv_pck_lbn) {
+    printerr("This NAV has already been left.");
+    return NULL;
+  }
+
+  button = this->vm->state.HL_BTNN_REG >> 10;
+#ifdef BUTTON_TESTING
+  nav_print_PCI(pci);
+#endif
+
+  return &(pci->hli.btnitbutton-1);
+}
+
+static dvdnav_status_t button_auto_action(dvdnav_t *this, pci_t *pci) {
+  btni_t *button_ptr;
+  if ((button_ptr = get_current_button(this, pci)) == NULL)
+      return DVDNAV_STATUS_ERR;
+
+  if (button_ptr->auto_action_mode)
+    return dvdnav_button_activate(this, pci);
+
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_upper_button_select(dvdnav_t *this, pci_t *pci) {
+  btni_t *button_ptr;
+
+  if(!(button_ptr = get_current_button(this, pci)))
+    return DVDNAV_STATUS_ERR;
+
+  dvdnav_button_select(this, pci, button_ptr->up);
+  return button_auto_action(this, pci);
+}
+
+dvdnav_status_t dvdnav_lower_button_select(dvdnav_t *this, pci_t *pci) {
+  btni_t *button_ptr;
+
+  if(!(button_ptr = get_current_button(this, pci)))
+    return DVDNAV_STATUS_ERR;
+
+  dvdnav_button_select(this, pci, button_ptr->down);
+  return button_auto_action(this, pci);
+}
+
+dvdnav_status_t dvdnav_right_button_select(dvdnav_t *this, pci_t *pci) {
+  btni_t *button_ptr;
+
+  if(!(button_ptr = get_current_button(this, pci)))
+    return DVDNAV_STATUS_ERR;
+
+  dvdnav_button_select(this, pci, button_ptr->right);
+  return button_auto_action(this, pci);
+}
+
+dvdnav_status_t dvdnav_left_button_select(dvdnav_t *this, pci_t *pci) {
+  btni_t *button_ptr;
+
+  if(!(button_ptr = get_current_button(this, pci)))
+    return DVDNAV_STATUS_ERR;
+
+  dvdnav_button_select(this, pci, button_ptr->left);
+  return button_auto_action(this, pci);
+}
+
+dvdnav_status_t dvdnav_get_highlight_area(pci_t *nav_pci , int32_t button, int32_t mode,
+                                          dvdnav_highlight_area_t *highlight) {
+  btni_t *button_ptr;
+
+#ifdef BUTTON_TESTING
+  fprintf(MSG_OUT, "libdvdnav: Button get_highlight_area %i\n", button);
+#endif
+
+  if(!nav_pci->hli.hl_gi.hli_ss)
+    return DVDNAV_STATUS_ERR;
+  if((button <= 0) || (button > nav_pci->hli.hl_gi.btn_ns))
+    return DVDNAV_STATUS_ERR;
+
+
+  button_ptr = &nav_pci->hli.btnitbutton-1;
+
+  highlight->sx = button_ptr->x_start;
+  highlight->sy = button_ptr->y_start;
+  highlight->ex = button_ptr->x_end;
+  highlight->ey = button_ptr->y_end;
+  if(button_ptr->btn_coln != 0) {
+    highlight->palette = nav_pci->hli.btn_colit.btn_colibutton_ptr->btn_coln-1mode;
+  } else {
+    highlight->palette = 0;
+  }
+  highlight->pts = nav_pci->hli.hl_gi.hli_s_ptm;
+  highlight->buttonN = button;
+#ifdef BUTTON_TESTING
+  fprintf(MSG_OUT, "libdvdnav: highlight: Highlight area is (%u,%u)-(%u,%u), display = %i, button = %u\n",
+               button_ptr->x_start, button_ptr->y_start,
+               button_ptr->x_end, button_ptr->y_end,
+               1,
+               button);
+#endif
+
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_button_activate(dvdnav_t *this, pci_t *pci) {
+  int32_t button;
+  btni_t *button_ptr = NULL;
+
+  if(!pci->hli.hl_gi.hli_ss) {
+    printerr("Not in a menu.");
+    return DVDNAV_STATUS_ERR;
+  }
+  if(this->last_cmd_nav_lbn == pci->pci_gi.nv_pck_lbn) {
+    printerr("This NAV has already been left.");
+    return DVDNAV_STATUS_ERR;
+  }
+  pthread_mutex_lock(&this->vm_lock);
+
+  if(!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+
+  button = this->vm->state.HL_BTNN_REG >> 10;
+
+  if((button <= 0) || (button > pci->hli.hl_gi.btn_ns)) {
+    /* Special code to handle still menus with no buttons.
+     * The navigation is expected to report to the application that a STILL is
+     * underway. In turn, the application is supposed to report to the user
+     * that the playback is paused. The user is then expected to undo the pause,
+     * ie: hit play. At that point, the navigation should release the still and
+     * go to the next Cell.
+     * Explanation by Mathieu Lacage <mathieu_lacage@realmagic.fr>
+     * Code added by jcdutton.
+     */
+    if (this->position_current.still != 0) {
+      /* In still, but no buttons. */
+      vm_get_next_cell(this->vm);
+      this->position_current.still = 0;
+      this->sync_wait = 0;
+      this->last_cmd_nav_lbn = pci->pci_gi.nv_pck_lbn;
+      pthread_mutex_unlock(&this->vm_lock);
+      /* clear error message */
+      printerr("");
+      return DVDNAV_STATUS_OK;
+    }
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+
+  if ((button_ptr = get_current_button(this, pci)) == NULL) {
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+
+  /* Finally, make the VM execute the appropriate code and probably
+   * schedule a jump */
+#ifdef BUTTON_TESTING
+  fprintf(MSG_OUT, "libdvdnav: Evaluating Button Activation commands.\n");
+#endif
+  if(vm_exec_cmd(this->vm, &(button_ptr->cmd)) == 1) {
+    /* Command caused a jump */
+    this->vm->hop_channel++;
+    this->position_current.still = 0;
+    this->last_cmd_nav_lbn = pci->pci_gi.nv_pck_lbn;
+  }
+
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_button_activate_cmd(dvdnav_t *this, int32_t button, vm_cmd_t *cmd)
+{
+  pthread_mutex_lock(&this->vm_lock);
+
+  if(!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+
+  /* make the VM execute the appropriate code and probably
+   * schedule a jump */
+#ifdef BUTTON_TESTING
+  fprintf(MSG_OUT, "libdvdnav: dvdnav_button_activate_cmd: Evaluating Button Activation commands.\n");
+#endif
+  if(button > 0) {
+    this->vm->state.HL_BTNN_REG = (button << 10);
+    if(vm_exec_cmd(this->vm, cmd) == 1) {
+      /* Command caused a jump */
+      this->vm->hop_channel++;
+    }
+  }
+  /* Always remove still, because some still menus have no buttons. */
+  this->position_current.still = 0;
+  this->sync_wait = 0;
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_button_select(dvdnav_t *this, pci_t *pci, int32_t button) {
+  if(!pci->hli.hl_gi.hli_ss) {
+    printerr("Not in a menu.");
+    return DVDNAV_STATUS_ERR;
+  }
+  if(this->last_cmd_nav_lbn == pci->pci_gi.nv_pck_lbn) {
+    printerr("This NAV has already been left.");
+    return DVDNAV_STATUS_ERR;
+  }
+
+#ifdef BUTTON_TESTING
+  fprintf(MSG_OUT, "libdvdnav: Button select %i\n", button);
+#endif
+
+  if((button <= 0) || (button > pci->hli.hl_gi.btn_ns)) {
+    printerr("Button does not exist.");
+    return DVDNAV_STATUS_ERR;
+  }
+
+  this->vm->state.HL_BTNN_REG = (button << 10);
+  this->position_current.button = -1; /* Force Highlight change */
+
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_button_select_and_activate(dvdnav_t *this, pci_t *pci,
+                                                  int32_t button) {
+  /* A trivial function */
+  if(dvdnav_button_select(this, pci, button) != DVDNAV_STATUS_ERR)
+    return dvdnav_button_activate(this, pci);
+  return DVDNAV_STATUS_ERR;
+}
+
+dvdnav_status_t dvdnav_mouse_select(dvdnav_t *this, pci_t *pci, int32_t x, int32_t y) {
+  int32_t button, cur_button;
+  int32_t best,dist,d;
+  int32_t mx,my,dx,dy;
+
+  if(!pci->hli.hl_gi.hli_ss) {
+    printerr("Not in a menu.");
+    return DVDNAV_STATUS_ERR;
+  }
+  if(this->last_cmd_nav_lbn == pci->pci_gi.nv_pck_lbn) {
+    printerr("This NAV has already been left.");
+    return DVDNAV_STATUS_ERR;
+  }
+
+  cur_button = this->vm->state.HL_BTNN_REG >> 10;
+
+  best = 0;
+  dist = 0x08000000; /* >> than  (720*720)+(567*567); */
+
+  /* Loop through all buttons */
+  for(button = 1; button <= pci->hli.hl_gi.btn_ns; button++) {
+    btni_t *button_ptr = &(pci->hli.btnitbutton-1);
+
+    if((x >= button_ptr->x_start) && (x <= button_ptr->x_end) &&
+       (y >= button_ptr->y_start) && (y <= button_ptr->y_end)) {
+      mx = (button_ptr->x_start + button_ptr->x_end)/2;
+      my = (button_ptr->y_start + button_ptr->y_end)/2;
+      dx = mx - x;
+      dy = my - y;
+      d = (dx*dx) + (dy*dy);
+      /* If the mouse is within the button and the mouse is closer
+       * to the center of this button then it is the best choice. */
+      if(d < dist) {
+        dist = d;
+        best = button;
+      }
+    }
+  }
+  /* As an efficiency measure, only re-select the button
+   * if it is different to the previously selected one. */
+  if (best != 0 && best != cur_button)
+    dvdnav_button_select(this, pci, best);
+
+  /* return DVDNAV_STATUS_OK only if we actually found a matching button */
+  return best ? DVDNAV_STATUS_OK : DVDNAV_STATUS_ERR;
+}
+
+dvdnav_status_t dvdnav_mouse_activate(dvdnav_t *this, pci_t *pci, int32_t x, int32_t y) {
+  /* A trivial function */
+  if(dvdnav_mouse_select(this, pci, x,y) != DVDNAV_STATUS_ERR)
+    return dvdnav_button_activate(this, pci);
+  return DVDNAV_STATUS_ERR;
+}

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/logger.c Added

@@ -0,0 +1,54 @@
+/*
+* This file is part of libdvdnav, a DVD navigation library.
+*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "dvdnav/dvdnav.h"
+#include "logger.h"
+
+void dvdnav_log( void *priv, const dvdnav_logger_cb *logcb,
+                 dvdnav_logger_level_t level, const char *fmt, ... )
+{
+    va_list list;
+    va_start(list, fmt);
+    if(logcb && logcb->pf_log)
+        logcb->pf_log(priv, level, fmt, list);
+#if 0
+    else
+    {
+        FILE *stream = (level == DVDNAV_LOGGER_LEVEL_ERROR) ? stderr : stdout;
+        fprintf(stream, "libdvdnav: ");
+        vfprintf(stream, fmt, list);
+        fprintf(stream, "\n");
+    }
+#endif
+    va_end(list);
+}
+
+int dvdnav_assert_worker(void *priv, const dvdnav_logger_cb *logcb, const char* expression)
+{
+    dvdnav_log(priv, logcb, DVDNAV_LOGGER_LEVEL_ERROR, "libdvdnav assertion failure: %s\n", expression);
+    dvdnav_critical_failure();
+    return 0;
+}
+
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/logger.h Added

@@ -0,0 +1,39 @@
+/*
+* This file is part of libdvdnav, a DVD navigation library.
+*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+*/
+
+#ifndef LIBDVDNAV_LOGGER_H
+#define LIBDVDNAV_LOGGER_H
+
+void dvdnav_log( void *priv, const dvdnav_logger_cb *logcb,
+                 dvdnav_logger_level_t level, const char *fmt, ... );
+
+#define LOG(ctx, level, ...) \
+  dvdnav_log(ctx->priv, &ctx->logcb, level, __VA_ARGS__)
+#define Log0(ctx, ...) LOG(ctx, DVDNAV_LOGGER_LEVEL_ERROR, __VA_ARGS__)
+#define Log1(ctx, ...) LOG(ctx, DVDNAV_LOGGER_LEVEL_WARN,  __VA_ARGS__)
+#define Log2(ctx, ...) LOG(ctx, DVDNAV_LOGGER_LEVEL_INFO,  __VA_ARGS__)
+#define Log3(ctx, ...) LOG(ctx, DVDNAV_LOGGER_LEVEL_DEBUG, __VA_ARGS__)
+
+void dvdnav_critical_failure(void);
+int dvdnav_assert_worker(void *priv, const dvdnav_logger_cb *logcb, const char* expression);
+
+#define vassert(_Expression_) (void)((!!(_Expression_)) || (dvdnav_assert_worker(vm->priv, &vm->logcb, #_Expression_)))
+#define dassert(_Expression_) (void)((!!(_Expression_)) || (dvdnav_assert_worker(NULL, NULL, #_Expression_)))
+
+
+#endif

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/mmdvdnav.h Added

@@ -0,0 +1,107 @@
+/*
+    GPL is cancer. A hacky and otherwise useless glue code to comply with GPL licensing.
+
+    Copyright (C) 2007-2022 GuinpinSoft inc <mmgpl@makemkv.com>
+
+    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.
+
+*/
+#ifndef LGPL_MMDVDNAV_H_INCLUDED
+#define LGPL_MMDVDNAV_H_INCLUDED
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef enum _dvdnav_event_type_t
+{
+    dvdnav_evt_error=0,
+    dvdnav_evt_libdvdnav = 1,
+    dvdnav_evt_read = 2,
+    dvdnav_evt_status = 3,
+} dvdnav_event_type_t;
+
+typedef enum _dvdnav_cmd_type_t
+{
+    dvdnav_cmd_add_ifo = 0,
+    dvdnav_cmd_set_ifo = 1,
+    dvdnav_cmd_add_vob = 2,
+    dvdnav_cmd_set_param = 3,
+    dvdnav_cmd_run = 4,
+    dvdnav_cmd_clone = 5,
+    dvdnav_cmd_die = 6,
+    dvdnav_cmd_log = 7,
+} dvdnav_cmd_type_t;
+
+typedef struct _dvdnav_event_t
+{
+    dvdnav_event_type_t type;
+    uint32_t            code;
+    uint32_t            time;
+    uint32_t            vobu;
+    uint32_t            sprm_flags;
+    uint16_t            title_id;
+    uint16_t            pgc_id;
+    uint8_t             vtsn;
+    uint8_t             cell_id;
+    uint8_t             still_time;
+    uint8_t             highlight;
+} dvdnav_event_t;
+
+typedef enum _dvdnav_lib_code_t
+{
+    dvdnav_lib_block_ok = 0,
+    dvdnav_lib_nop = 1,
+    dvdnav_lib_still_frame = 2,
+    dvdnav_lib_spu_change = 3,
+    dvdnav_lib_audio_change = 4,
+    dvdnav_lib_vts_change = 5,
+    dvdnav_lib_cell_change = 6,
+    dvdnav_lib_nav_packet = 7,
+    dvdnav_lib_stop = 8,
+    dvdnav_lib_highlight = 9,
+    dvdnav_lib_clut = 10,
+    dvdnav_lib_hop = 12,
+    dvdnav_lib_wait = 13,
+} dvdnav_lib_code_t;
+
+typedef enum _dvdnav_param_t
+{
+    dvdnav_region_mask = 0,
+    dvdnav_menu_language = 1,
+    dvdnav_audio_language = 2,
+    dvdnav_spu_language = 3,
+    dvdnav_angle = 4,
+    dvdnav_button = 5,
+    dvdnav_title = 6,
+    dvdnav_program = 7,
+    dvdnav_highlight = 8,
+} dvdnav_param_t;
+
+typedef struct dvdnav_s dvdnav_t;
+
+#define FLAG_MENU_VOB 0x100
+#define VTS_ID_MASK   0x0ff
+
+bool DvdNavAddIfo(unsigned int id,unsigned int size, uint32_t tvob_offset, const uint8_t* data,unsigned int data_size);
+bool DvdNavSetIfo(unsigned int id,unsigned int offset,const uint8_t* data,unsigned int data_size);
+bool DvdNavAddVob(unsigned int id, uint32_t sector, const uint8_t* data);
+void DvdNavStat(uint32_t* p_read, uint32_t* p_access);
+bool DvdNavSetParam(dvdnav_t* ctx, int id, uint32_t value);
+bool DvdNavRun(dvdnav_t* ctx, dvdnav_event_t* p_event);
+
+bool DvdNavRunServer(uint64_t pipein, uint64_t pipeout);
+
+#endif // LGPL_MMDVDNAV_H_INCLUDED
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/navbase.h Added

@@ -0,0 +1,42 @@
+/*
+    GPL is cancer. A hacky and otherwise useless glue code to comply with GPL licensing.
+
+    Copyright (C) 2007-2022 GuinpinSoft inc <mmgpl@makemkv.com>
+
+    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.
+
+*/
+#ifndef DVDNAVBASE_H_INCLUDED
+#define DVDNAVBASE_H_INCLUDED
+
+#include <dvdnav/dvdnav.h>
+
+class IDvdNavBase
+{
+public:
+    virtual void DvdNavLog(dvdnav_logger_level_t level, const char *str, va_list lst) = 0;
+    virtual bool DvdNavReadVob(unsigned int id, uint32_t sector, uint8_t* data) = 0;
+public:
+    dvdnav_t* DvdNavOpen(bool EnableLog);
+public:
+    static void CbLog(void *ctx, dvdnav_logger_level_t level, const char *str, va_list lst);
+    static int CbRead(void *p_stream, void* buffer, int i_read);
+    static IDvdNavBase* GetBase(void* ctx, const dvdnav_stream_cb* strcb);
+public:
+    void Log(const char* fmt, ...);
+};
+
+
+#endif // DVDNAVBASE_H_INCLUDED

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/navigation.c Added

@@ -0,0 +1,305 @@
+/*
+ * Copyright (C) 2000 Rich Wareham <richwareham@users.sourceforge.net>
+ *
+ * This file is part of libdvdnav, a DVD navigation library.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <inttypes.h>
+#include <limits.h>
+#include <string.h>
+#include "dvdnav/dvdnav.h"
+#include <dvdread/nav_types.h>
+#include <dvdread/ifo_types.h>
+#include "vm/decoder.h"
+#include "vm/vm.h"
+#include "dvdnav_internal.h"
+
+/* Navigation API calls */
+
+dvdnav_status_t dvdnav_still_skip(dvdnav_t *this) {
+  pthread_mutex_lock(&this->vm_lock);
+  this->vm->state.registers.time_counter += ((((uint32_t)this->position_current.still & 0xff) * 5625) >> 5);
+  this->position_current.still = 0;
+
+  pthread_mutex_unlock(&this->vm_lock);
+  this->skip_still = 1;
+  this->sync_wait = 0;
+  this->sync_wait_skip = 1;
+
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_wait_skip(dvdnav_t *this) {
+  this->sync_wait = 0;
+  this->sync_wait_skip = 1;
+
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_get_number_of_titles(dvdnav_t *this, int32_t *titles) {
+  if (!this->vm->vmgi) {
+    printerr("Bad VM state.");
+    return DVDNAV_STATUS_ERR;
+  }
+
+  (*titles) = vm_get_vmgi(this->vm)->tt_srpt->nr_of_srpts;
+
+  return DVDNAV_STATUS_OK;
+}
+
+static dvdnav_status_t get_title_by_number(dvdnav_t *this, int32_t title,
+                                           title_info_t **pp_title)
+{
+    int32_t titlescount;
+    dvdnav_status_t status = dvdnav_get_number_of_titles(this, &titlescount);
+    if(status == DVDNAV_STATUS_OK)
+    {
+        if ((title < 1) || (title > titlescount)) {
+          printerr("Passed a title number out of range.");
+          status = DVDNAV_STATUS_ERR;
+        }
+        else {
+            *pp_title = &vm_get_vmgi(this->vm)->tt_srpt->titletitle-1;
+        }
+    }
+    return status;
+}
+
+dvdnav_status_t dvdnav_get_number_of_parts(dvdnav_t *this, int32_t title, int32_t *parts) {
+  title_info_t *info;
+  dvdnav_status_t status = get_title_by_number(this, title, &info);
+  if(status == DVDNAV_STATUS_OK)
+      (*parts) = info->nr_of_ptts;
+  return status;
+}
+
+dvdnav_status_t dvdnav_get_number_of_angles(dvdnav_t *this, int32_t title, int32_t *angles) {
+    title_info_t *info;
+    dvdnav_status_t status = get_title_by_number(this, title, &info);
+    if(status == DVDNAV_STATUS_OK)
+        (*angles) = info->nr_of_angles;
+    return status;
+}
+
+dvdnav_status_t dvdnav_current_title_info(dvdnav_t *this, int32_t *title, int32_t *part) {
+  int32_t retval;
+
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->vtsi || !this->vm->vmgi) {
+    printerr("Bad VM state.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if (!this->started) {
+    printerr("Virtual DVD machine not started.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if ( (this->vm->state.domain == DVD_DOMAIN_VTSMenu)
+      || (this->vm->state.domain == DVD_DOMAIN_VMGM) ) {
+    /* Get current Menu ID: into *part. */
+    if(! vm_get_current_menu(this->vm, part)) {
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_ERR;
+    }
+    if (*part > -1) {
+      *title = 0;
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_OK;
+    }
+  }
+  if (this->vm->state.domain == DVD_DOMAIN_VTSTitle) {
+    retval = vm_get_current_title_part(this->vm, title, part);
+    pthread_mutex_unlock(&this->vm_lock);
+    return retval ? DVDNAV_STATUS_OK : DVDNAV_STATUS_ERR;
+  }
+  printerr("Not in a title or menu.");
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_ERR;
+}
+
+dvdnav_status_t dvdnav_current_title_program2(dvdnav_t *this, int32_t *title, int32_t *vtsn, int32_t *pgcn, int32_t *pgn, int32_t *celln) {
+  int32_t retval;
+  int32_t part;
+
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->vtsi && !this->vm->vmgi) {
+    printerr("Bad VM state.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if (!this->started) {
+    printerr("Virtual DVD machine not started.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if ( (this->vm->state.domain == DVD_DOMAIN_VTSMenu)
+      || (this->vm->state.domain == DVD_DOMAIN_VMGM) ) {
+    /* Get current Menu ID: into *part. */
+    if(! vm_get_current_menu(this->vm, &part)) {
+      part = -1;
+    }
+    *title = 0;
+    *vtsn = (this->vm->state.domain == DVD_DOMAIN_VTSMenu) ? this->vm->state.vtsN : 0;
+    *pgcn = this->vm->state.pgcN;
+    *pgn = this->vm->state.pgN;
+    *celln = this->vm->state.cellN;
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+  if (this->vm->state.domain == DVD_DOMAIN_VTSTitle) {
+    if (0 == vm_get_current_title_part(this->vm, title, &part)) {
+        *title = -1;
+    }
+    *vtsn = this->vm->state.vtsN;
+    *pgcn = this->vm->state.pgcN;
+    *pgn = this->vm->state.pgN;
+    *celln = this->vm->state.cellN;
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_OK;
+  }
+  printerr("Not in a title or menu.");
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_ERR;
+}
+
+dvdnav_status_t dvdnav_title_play(dvdnav_t *this, int32_t title) {
+  return dvdnav_part_play(this, title, 1);
+}
+
+dvdnav_status_t dvdnav_program_play(dvdnav_t *this, int32_t title, int32_t pgcn, int32_t pgn) {
+  int32_t retval;
+
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->vmgi) {
+    printerr("Bad VM state.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if (!this->started) {
+    /* don't report an error but be nice */
+    vm_start(this->vm);
+    this->started = 1;
+  }
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if((title < 1) || (title > this->vm->vmgi->tt_srpt->nr_of_srpts)) {
+    printerr("Title out of range.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+
+  retval = vm_jump_title_program(this->vm, title, pgcn, pgn);
+  if (retval)
+    this->vm->hop_channel++;
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return retval ? DVDNAV_STATUS_OK : DVDNAV_STATUS_ERR;
+}
+
+dvdnav_status_t dvdnav_part_play(dvdnav_t *this, int32_t title, int32_t part) {
+  int32_t retval;
+
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->vmgi) {
+    printerr("Bad VM state.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if (!this->started) {
+    /* don't report an error but be nice */
+    vm_start(this->vm);
+    this->started = 1;
+  }
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if((title < 1) || (title > this->vm->vmgi->tt_srpt->nr_of_srpts)) {
+    printerr("Title out of range.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  if((part < 1) || (part > this->vm->vmgi->tt_srpt->titletitle-1.nr_of_ptts)) {
+    printerr("Part out of range.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+
+  retval = vm_jump_title_part(this->vm, title, part);
+  if (retval)
+    this->vm->hop_channel++;
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return retval ? DVDNAV_STATUS_OK : DVDNAV_STATUS_ERR;
+}
+
+dvdnav_status_t dvdnav_part_play_auto_stop(dvdnav_t *this, int32_t title,
+                                           int32_t part, int32_t parts_to_play) {
+  /* FIXME: Implement auto-stop */
+ if (dvdnav_part_play(this, title, part) == DVDNAV_STATUS_OK)
+   printerr("Not implemented yet.");
+ return DVDNAV_STATUS_ERR;
+}
+
+dvdnav_status_t dvdnav_time_play(dvdnav_t *this, int32_t title,
+                                 uint64_t time) {
+  /* FIXME: Implement */
+  printerr("Not implemented yet.");
+  return DVDNAV_STATUS_ERR;
+}
+
+dvdnav_status_t dvdnav_stop(dvdnav_t *this) {
+  pthread_mutex_lock(&this->vm_lock);
+  this->vm->stopped = 1;
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_go_up(dvdnav_t *this) {
+  /* A nice easy function... delegate to the VM */
+  int retval;
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm->state.pgc) {
+    printerr("No current PGC.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+
+  retval = vm_jump_up(this->vm);
+  pthread_mutex_unlock(&this->vm_lock);
+
+  return retval ? DVDNAV_STATUS_OK : DVDNAV_STATUS_ERR;
+}

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/settings.c Added

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2000 Rich Wareham <richwareham@users.sourceforge.net>
+ *
+ * This file is part of libdvdnav, a DVD navigation library.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <inttypes.h>
+#include <limits.h>
+#include <string.h>
+#include "dvdnav/dvdnav.h"
+#include <dvdread/nav_types.h>
+#include <dvdread/ifo_types.h>
+#include "vm/decoder.h"
+#include "vm/vm.h"
+#include "dvdnav_internal.h"
+
+/* Characteristics/setting API calls */
+
+dvdnav_status_t dvdnav_get_region_mask(dvdnav_t *this, int32_t *region) {
+  (*region) = this->vm->state.registers.SPRM20;
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_set_region_mask(dvdnav_t *this, int32_t mask) {
+  pthread_mutex_lock(&this->vm_lock);
+  this->vm->state.registers.SPRM20 = (mask & 0xff);
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_set_readahead_flag(dvdnav_t *this, int32_t use_readahead) {
+  this->use_read_ahead = use_readahead;
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_get_readahead_flag(dvdnav_t *this, int32_t *flag) {
+  (*flag) = this->use_read_ahead;
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_set_nav_only_flag(dvdnav_t *this, int32_t nav_only) {
+    this->nav_only = nav_only;
+    return DVDNAV_STATUS_OK;
+}
+
+static dvdnav_status_t set_language_register(dvdnav_t *this, char *code, int reg) {
+  if(!code0 || !code1) {
+    printerr("Passed illegal language code.");
+    return DVDNAV_STATUS_ERR;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  this->vm->state.registers.SPRMreg = (code0 << 8) | code1;
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_menu_language_select(dvdnav_t *this, char *code) {
+  return set_language_register(this, code, 0);
+}
+
+dvdnav_status_t dvdnav_audio_language_select(dvdnav_t *this, char *code) {
+  return set_language_register(this, code, 16);
+}
+
+dvdnav_status_t dvdnav_spu_language_select(dvdnav_t *this, char *code) {
+  return set_language_register(this, code, 18);
+}
+
+dvdnav_status_t dvdnav_set_PGC_positioning_flag(dvdnav_t *this, int32_t pgc) {
+  this->pgc_based = pgc;
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_get_PGC_positioning_flag(dvdnav_t *this, int32_t *flag) {
+  (*flag) = this->pgc_based;
+  return DVDNAV_STATUS_OK;
+}

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/version.h Added

@@ -0,0 +1,35 @@
+/*
+* This file is part of libdvdnav, a DVD navigation library.
+*
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+*/
+#ifndef LIBDVDNAV_VERSION_H
+#define LIBDVDNAV_VERSION_H
+
+#define DVDNAV_VERSION_CODE(major, minor, micro) \
+     (((major) * 10000) +                         \
+      ((minor) *   100) +                         \
+      ((micro) *     1))
+
+#define DVDNAV_VERSION_MAJOR 6
+#define DVDNAV_VERSION_MINOR 1
+#define DVDNAV_VERSION_MICRO 1
+
+#define DVDNAV_VERSION_STRING "6.1.1"
+
+#define DVDNAV_VERSION \
+    DVDNAV_VERSION_CODE(DVDNAV_VERSION_MAJOR, DVDNAV_VERSION_MINOR, DVDNAV_VERSION_MICRO)
+
+#endif

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm Added

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/decoder.c Added

@@ -0,0 +1,857 @@
+/*
+ * Copyright (C) 2000, 2001 Martin Norbäck, Håkan Hjort
+ *               2002-2004 the dvdnav project
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <string.h>  /* For memset */
+#include <stdarg.h>
+
+#include <dvdread/nav_types.h>
+#include <dvdread/ifo_types.h> /* vm_cmd_t */
+
+#include "dvdnav/dvdnav.h"
+#include "decoder.h"
+#include "vm.h"
+#include "vmcmd.h"
+#include "../dvdnav_internal.h"
+
+uint32_t vm_getbits(command_t *command, int32_t start, int32_t count) {
+  uint64_t result = 0;
+  uint64_t bit_mask = 0;
+  uint64_t examining = 0;
+  int32_t  bits;
+
+  if (count == 0) return 0;
+
+  if ( ((start - count) < -1) ||
+       (count > 32) ||
+       (start > 63) ||
+       (count < 0) ||
+       (start < 0) ) {
+    fprintf(MSG_OUT, "libdvdnav: Bad call to vm_getbits. Parameter out of range\n");
+    abort();
+  }
+  /* all ones, please */
+  bit_mask = ~bit_mask;
+  bit_mask >>= 63 - start;
+  bits = start + 1 - count;
+  examining = ((bit_mask >> bits) << bits );
+  command->examined |= examining;
+  result = (command->instruction & bit_mask) >> bits;
+  return (uint32_t) result;
+}
+
+static uint16_t get_GPRM(registers_t* registers, uint8_t reg) {
+  if (0!=(registers->GPRM_mode&(1<<reg))) {
+    uint16_t result;
+    /* Counter mode */
+    /* fprintf(MSG_OUT, "libdvdnav: Getting counter %d\n",reg);*/
+    result = (uint16_t)(((registers->time_counter - registers->GPRM_timereg)*32) / 5625);
+    registers->GPRMreg=result;
+    return result;
+
+  } else {
+    /* Register mode */
+    return registers->GPRMreg;
+  }
+
+}
+
+static void set_GPRM(registers_t* registers, uint8_t reg, uint16_t value) {
+  if (0!=(registers->GPRM_mode&(1<<reg))) {
+    /* Counter mode */
+    /* fprintf(MSG_OUT, "libdvdnav: Setting counter %d\n",reg); */
+    registers->GPRM_timereg = registers->time_counter;
+  }
+  registers->GPRMreg = value;
+}
+
+/* Eval register code, can either be system or general register.
+   SXXX_XXXX, where S is 1 if it is system register. */
+static uint16_t eval_reg(command_t* command, uint8_t reg) {
+  if(reg & 0x80) {
+    reg &= 0x1f;
+    if (reg == 20) {
+      fprintf(MSG_OUT, "libdvdnav: Suspected RCE Region Protection!!!\n");
+    }
+    command->registers->SPRM_flags |= (1 << reg);
+    if (reg >= 24) return 0;
+    return command->registers->SPRMreg;
+  } else {
+    return get_GPRM(command->registers, reg & 0x0f) ;
+  }
+}
+
+// GPL is cancer
+//#undef MSG_OUT
+//#undef fprintf
+#define tfprintf vm_debug_print
+#define tMSG_OUT log
+
+
+#ifdef TRACE
+
+static char *linkcmd2str(link_cmd_t cmd) {
+  switch(cmd) {
+  case LinkNoLink:
+    return "LinkNoLink";
+  case LinkTopC:
+    return "LinkTopC";
+  case LinkNextC:
+    return "LinkNextC";
+  case LinkPrevC:
+    return "LinkPrevC";
+  case LinkTopPG:
+    return "LinkTopPG";
+  case LinkNextPG:
+    return "LinkNextPG";
+  case LinkPrevPG:
+    return "LinkPrevPG";
+  case LinkTopPGC:
+    return "LinkTopPGC";
+  case LinkNextPGC:
+    return "LinkNextPGC";
+  case LinkPrevPGC:
+    return "LinkPrevPGC";
+  case LinkGoUpPGC:
+    return "LinkGoUpPGC";
+  case LinkTailPGC:
+    return "LinkTailPGC";
+  case LinkRSM:
+    return "LinkRSM";
+  case LinkPGCN:
+    return "LinkPGCN";
+  case LinkPTTN:
+    return "LinkPTTN";
+  case LinkPGN:
+    return "LinkPGN";
+  case LinkCN:
+    return "LinkCN";
+  case Exit:
+    return "Exit";
+  case JumpTT:
+    return "JumpTT";
+  case JumpVTS_TT:
+    return "JumpVTS_TT";
+  case JumpVTS_PTT:
+    return "JumpVTS_PTT";
+  case JumpSS_FP:
+    return "JumpSS_FP";
+  case JumpSS_VMGM_MENU:
+    return "JumpSS_VMGM_MENU";
+  case JumpSS_VTSM:
+    return "JumpSS_VTSM";
+  case JumpSS_VMGM_PGC:
+    return "JumpSS_VMGM_PGC";
+  case CallSS_FP:
+    return "CallSS_FP";
+  case CallSS_VMGM_MENU:
+    return "CallSS_VMGM_MENU";
+  case CallSS_VTSM:
+    return "CallSS_VTSM";
+  case CallSS_VMGM_PGC:
+    return "CallSS_VMGM_PGC";
+  case PlayThis:
+    return "PlayThis";
+  }
+  return "*** (bug)";
+}
+
+void vm_print_link(const trace_log_t* log, const link_t* value) {
+  char *cmd = linkcmd2str(value->command);
+
+  switch(value->command) {
+  case LinkNoLink:
+  case LinkTopC:
+  case LinkNextC:
+  case LinkPrevC:
+  case LinkTopPG:
+  case LinkNextPG:
+  case LinkPrevPG:
+  case LinkTopPGC:
+  case LinkNextPGC:
+  case LinkPrevPGC:
+  case LinkGoUpPGC:
+  case LinkTailPGC:
+  case LinkRSM:
+    tfprintf(tMSG_OUT, "libdvdnav: %s (button %d)\n", cmd, value->data1);
+    break;
+  case LinkPGCN:
+  case JumpTT:
+  case JumpVTS_TT:
+  case JumpSS_VMGM_MENU: /*  == 2 -> Title Menu */
+  case JumpSS_VMGM_PGC:
+    tfprintf(tMSG_OUT, "libdvdnav: %s %d\n", cmd, value->data1);
+    break;
+  case LinkPTTN:
+  case LinkPGN:
+  case LinkCN:
+    tfprintf(tMSG_OUT, "libdvdnav: %s %d (button %d)\n", cmd, value->data1, value->data2);
+    break;
+  case Exit:
+  case JumpSS_FP:
+  case PlayThis: /*  Humm.. should we have this at all.. */
+    tfprintf(tMSG_OUT, "libdvdnav: %s\n", cmd);
+    break;
+  case JumpVTS_PTT:
+    tfprintf(tMSG_OUT, "libdvdnav: %s %d:%d\n", cmd, value->data1, value->data2);
+    break;
+  case JumpSS_VTSM:
+    tfprintf(tMSG_OUT, "libdvdnav: %s vts %d title %d menu %d\n",
+            cmd, value->data1, value->data2, value->data3);
+    break;
+  case CallSS_FP:
+    tfprintf(tMSG_OUT, "libdvdnav: %s resume cell %d\n", cmd, value->data1);
+    break;
+  case CallSS_VMGM_MENU: /*  == 2 -> Title Menu */
+  case CallSS_VTSM:
+    tfprintf(tMSG_OUT, "libdvdnav: %s %d resume cell %d\n", cmd, value->data1, value->data2);
+    break;
+  case CallSS_VMGM_PGC:
+    tfprintf(tMSG_OUT, "libdvdnav: %s %d resume cell %d\n", cmd, value->data1, value->data2);
+    break;
+  }
+ }
+
+void vm_print_registers(const trace_log_t* log, registers_t *registers ) {
+  int32_t i;
+  tfprintf(tMSG_OUT, "libdvdnav:    #   ");
+  for(i = 0; i < 24; i++)
+    tfprintf(tMSG_OUT, " %2d |", i);
+  tfprintf(tMSG_OUT, "\nlibdvdnav: SRPMS: ");
+  for(i = 0; i < 24; i++)
+    tfprintf(tMSG_OUT, "%04x|", registers->SPRMi);
+  tfprintf(tMSG_OUT, "\nlibdvdnav: GRPMS: ");
+  for(i = 0; i < 16; i++)
+    tfprintf(tMSG_OUT, "%04x|", get_GPRM(registers, i) );
+  tfprintf(tMSG_OUT, "\nlibdvdnav: Gmode: ");
+  for(i = 0; i < 16; i++)
+    tfprintf(tMSG_OUT, "%04x|", (0!=(registers->GPRM_mode&(1<<i)))?1:0 );
+  tfprintf(tMSG_OUT, "\nlibdvdnav: Gtime: ");
+  for(i = 0; i < 16; i++)
+    tfprintf(tMSG_OUT, "%04lx|", ((registers->GPRM_timei<<5)/5625) & 0xffff);
+  tfprintf(tMSG_OUT, "\n");
+}
+
+#endif
+
+/* Eval register or immediate data.
+   AAAA_AAAA BBBB_BBBB, if immediate use all 16 bits for data else use
+   lower eight bits for the system or general purpose register. */
+static uint16_t eval_reg_or_data(command_t* command, int32_t imm, int32_t start) {
+  if(imm) { /*  immediate */
+    return vm_getbits(command, start, 16);
+  } else {
+    return eval_reg(command, vm_getbits(command, (start - 8), 8));
+  }
+}
+
+/* Eval register or immediate data.
+   xBBB_BBBB, if immediate use all 7 bits for data else use
+   lower four bits for the general purpose register number. */
+/* Evaluates gprm or data depending on bit, data is in byte n */
+static uint16_t eval_reg_or_data_2(command_t* command,
+                                   int32_t imm, int32_t start) {
+  if(imm) /* immediate */
+    return vm_getbits(command, (start - 1), 7);
+  else
+    return get_GPRM(command->registers, (vm_getbits(command, (start - 4), 4)) );
+}
+
+
+/* Compare data using operation, return result from comparison.
+   Helper function for the different if functions. */
+static int32_t eval_compare(uint8_t operation, uint16_t data1, uint16_t data2) {
+  switch(operation) {
+    case 1:
+      return data1 & data2;
+    case 2:
+      return data1 == data2;
+    case 3:
+      return data1 != data2;
+    case 4:
+      return data1 >= data2;
+    case 5:
+      return data1 >  data2;
+    case 6:
+      return data1 <= data2;
+    case 7:
+      return data1 <  data2;
+  }
+  fprintf(MSG_OUT, "libdvdnav: eval_compare: Invalid comparison code\n");
+  return 0;
+}
+
+
+/* Evaluate if version 1.
+   Has comparison data in byte 3 and 4-5 (immediate or register) */
+static int32_t eval_if_version_1(command_t* command) {
+  uint8_t op = vm_getbits(command, 54, 3);
+  if(op) {
+    return eval_compare(op, eval_reg(command, vm_getbits(command, 39, 8)),
+                            eval_reg_or_data(command, vm_getbits(command, 55, 1), 31));
+  }
+  return 1;
+}
+
+/* Evaluate if version 2.
+   This version only compares register which are in byte 6 and 7 */
+static int32_t eval_if_version_2(command_t* command) {
+  uint8_t op = vm_getbits(command, 54, 3);
+  if(op) {
+    return eval_compare(op, eval_reg(command, vm_getbits(command, 15, 8)),
+                            eval_reg(command, vm_getbits(command, 7, 8)));
+  }
+  return 1;
+}
+
+/* Evaluate if version 3.
+   Has comparison data in byte 2 and 6-7 (immediate or register) */
+static int32_t eval_if_version_3(command_t* command) {
+  uint8_t op = vm_getbits(command, 54, 3);
+  if(op) {
+    return eval_compare(op, eval_reg(command, vm_getbits(command, 47, 8)),
+                            eval_reg_or_data(command, vm_getbits(command, 55, 1), 15));
+  }
+  return 1;
+}
+
+/* Evaluate if version 4.
+   Has comparison data in byte 1 and 4-5 (immediate or register)
+   The register in byte 1 is only the lowe nibble (4 bits) */
+static int32_t eval_if_version_4(command_t* command) {
+  uint8_t op = vm_getbits(command, 54, 3);
+  if(op) {
+    return eval_compare(op, eval_reg(command, vm_getbits(command, 51, 4)),
+                            eval_reg_or_data(command, vm_getbits(command, 55, 1), 31));
+  }
+  return 1;
+}
+
+/* Evaluate special instruction.... returns the new row/line number,
+   0 if no new row and 256 if Break. */
+static int32_t eval_special_instruction(command_t* command, int32_t cond) {
+  int32_t line, level;
+
+  switch(vm_getbits(command, 51, 4)) {
+    case 0: /*  NOP */
+      line = 0;
+      return cond ? line : 0;
+    case 1: /*  Goto line */
+      line = vm_getbits(command, 7, 8);
+      return cond ? line : 0;
+    case 2: /*  Break */
+      /*  max number of rows < 256, so we will end this set */
+      line = 256;
+      return cond ? 256 : 0;
+    case 3: /*  Set temporary parental level and goto */
+      line = vm_getbits(command, 7, 8);
+      level = vm_getbits(command, 11, 4);
+      if(cond) {
+        /*  This always succeeds now, if we want real parental protection */
+        /*  we need to ask the user and have passwords and stuff. */
+        command->registers->SPRM13 = level;
+      }
+      return cond ? line : 0;
+  }
+  return 0;
+}
+
+/* Evaluate link by subinstruction.
+   Return 1 if link, or 0 if no link
+   Actual link instruction is in return_values parameter */
+static int32_t eval_link_subins(command_t* command, int32_t cond, link_t *return_values) {
+  uint16_t button = vm_getbits(command, 15, 6);
+  uint8_t  linkop = vm_getbits(command, 4, 5);
+
+  if(linkop > 0x10)
+    return 0;    /*  Unknown Link by Sub-Instruction command */
+
+  /*  Assumes that the link_cmd_t enum has the same values as the LinkSIns codes */
+  return_values->command = linkop;
+  return_values->data1 = button;
+  return cond;
+}
+
+
+/* Evaluate link instruction.
+   Return 1 if link, or 0 if no link
+   Actual link instruction is in return_values parameter */
+static int32_t eval_link_instruction(command_t* command, int32_t cond, link_t *return_values) {
+  uint8_t op = vm_getbits(command, 51, 4);
+
+  switch(op) {
+    case 1:
+        return eval_link_subins(command, cond, return_values);
+    case 4:
+        return_values->command = LinkPGCN;
+        return_values->data1   = vm_getbits(command, 14, 15);
+        return cond;
+    case 5:
+        return_values->command = LinkPTTN;
+        return_values->data1 = vm_getbits(command, 9, 10);
+        return_values->data2 = vm_getbits(command, 15, 6);
+        return cond;
+    case 6:
+        return_values->command = LinkPGN;
+        return_values->data1 = vm_getbits(command, 6, 7);
+        return_values->data2 = vm_getbits(command, 15, 6);
+        return cond;
+    case 7:
+        return_values->command = LinkCN;
+        return_values->data1 = vm_getbits(command, 7, 8);
+        return_values->data2 = vm_getbits(command, 15, 6);
+        return cond;
+  }
+  return 0;
+}
+
+
+/* Evaluate a jump instruction.
+   returns 1 if jump or 0 if no jump
+   actual jump instruction is in return_values parameter */
+static int32_t eval_jump_instruction(command_t* command, int32_t cond, link_t *return_values) {
+
+  switch(vm_getbits(command, 51, 4)) {
+    case 1:
+      return_values->command = Exit;
+      return cond;
+    case 2:
+      return_values->command = JumpTT;
+      return_values->data1 = vm_getbits(command, 22, 7);
+      return cond;
+    case 3:
+      return_values->command = JumpVTS_TT;
+      return_values->data1 = vm_getbits(command, 22, 7);
+      return cond;
+    case 5:
+      return_values->command = JumpVTS_PTT;
+      return_values->data1 = vm_getbits(command, 22, 7);
+      return_values->data2 = vm_getbits(command, 41, 10);
+      return cond;
+    case 6:
+      switch(vm_getbits(command, 23, 2)) {
+        case 0:
+          return_values->command = JumpSS_FP;
+          return cond;
+        case 1:
+          return_values->command = JumpSS_VMGM_MENU;
+          return_values->data1 =  vm_getbits(command, 19, 4);
+          return cond;
+        case 2:
+          return_values->command = JumpSS_VTSM;
+          return_values->data1 =  vm_getbits(command, 31, 8);
+          return_values->data2 =  vm_getbits(command, 39, 8);
+          return_values->data3 =  vm_getbits(command, 19, 4);
+          return cond;
+        case 3:
+          return_values->command = JumpSS_VMGM_PGC;
+          return_values->data1 =  vm_getbits(command, 46, 15);
+          return cond;
+        }
+      break;
+    case 8:
+      switch(vm_getbits(command, 23, 2)) {
+        case 0:
+          return_values->command = CallSS_FP;
+          return_values->data1 = vm_getbits(command, 31, 8);
+          return cond;
+        case 1:
+          return_values->command = CallSS_VMGM_MENU;
+          return_values->data1 = vm_getbits(command, 19, 4);
+          return_values->data2 = vm_getbits(command, 31, 8);
+          return cond;
+        case 2:
+          return_values->command = CallSS_VTSM;
+          return_values->data1 = vm_getbits(command, 19, 4);
+          return_values->data2 = vm_getbits(command, 31, 8);
+          return cond;
+        case 3:
+          return_values->command = CallSS_VMGM_PGC;
+          return_values->data1 = vm_getbits(command, 46, 15);
+          return_values->data2 = vm_getbits(command, 31, 8);
+          return cond;
+      }
+      break;
+  }
+  return 0;
+}
+
+/* Evaluate a set sytem register instruction
+   May contain a link so return the same as eval_link */
+static int32_t eval_system_set(command_t* command, int32_t cond, link_t *return_values) {
+  int32_t i;
+  uint16_t data, data2;
+
+  switch(vm_getbits(command, 59, 4)) {
+    case 1: /*  Set system reg 1 &| 2 &| 3 (Audio, Subp. Angle) */
+      for(i = 1; i <= 3; i++) {
+        if(vm_getbits(command, 63 - ((2 + i)*8), 1)) {
+          data = eval_reg_or_data_2(command, vm_getbits(command, 60, 1), (47 - (i*8)));
+          if(cond) {
+            command->registers->SPRMi = data;
+          }
+        }
+      }
+      break;
+    case 2: /*  Set system reg 9 & 10 (Navigation timer, Title PGC number) */
+      data = eval_reg_or_data(command, vm_getbits(command, 60, 1), 47);
+      data2 = vm_getbits(command, 23, 8); /*  ?? size */
+      if(cond) {
+        command->registers->SPRM9 = data; /*  time */
+        command->registers->SPRM10 = data2; /*  pgcN */
+      }
+      break;
+    case 3: /*  Mode: Counter / Register + Set */
+      data = eval_reg_or_data(command, vm_getbits(command, 60, 1), 47);
+      data2 = vm_getbits(command, 19, 4);
+      if(vm_getbits(command, 23, 1)) {
+        command->registers->GPRM_mode |= (1 << data2); /* Set bit n */
+      } else {
+        command->registers->GPRM_mode &= ~(1 << data2);/* Reset bit n */
+      }
+      if(cond) {
+        set_GPRM(command->registers, data2, data);
+      }
+      break;
+    case 6: /*  Set system reg 8 (Highlighted button) */
+      data = eval_reg_or_data(command, vm_getbits(command, 60, 1), 31); /*  Not system reg!! */
+      if(cond) {
+        command->registers->SPRM8 = data & 0xfc00;
+      }
+      break;
+  }
+  if(vm_getbits(command, 51, 4)) {
+    return eval_link_instruction(command, cond, return_values);
+  }
+  return 0;
+}
+
+
+/* Evaluate set operation
+   Sets the register given to the value indicated by op and data.
+   For the swap case the contents of reg is stored in reg2.
+*/
+static void eval_set_op(command_t* command, int32_t op, int32_t reg, int32_t reg2, int32_t data) {
+  static const int32_t shortmax = 0xffff;
+  int32_t     tmp;
+  switch(op) {
+    case 1:
+      set_GPRM(command->registers, reg, data);
+      break;
+    case 2: /* SPECIAL CASE - SWAP! */
+      set_GPRM(command->registers, reg2, get_GPRM(command->registers, reg));
+      set_GPRM(command->registers, reg, data);
+      break;
+    case 3:
+      tmp = get_GPRM(command->registers, reg) + data;
+      if(tmp > shortmax) tmp = shortmax;
+      set_GPRM(command->registers, reg, (uint16_t)tmp);
+      break;
+    case 4:
+      tmp = get_GPRM(command->registers, reg) - data;
+      if(tmp < 0) tmp = 0;
+      set_GPRM(command->registers, reg, (uint16_t)tmp);
+      break;
+    case 5:
+      tmp = get_GPRM(command->registers, reg) * data;
+      if(tmp > shortmax) tmp = shortmax;
+      set_GPRM(command->registers, reg, (uint16_t)tmp);
+      break;
+    case 6:
+      if (data != 0) {
+        set_GPRM(command->registers, reg, (get_GPRM(command->registers, reg) / data) );
+      } else {
+        set_GPRM(command->registers, reg, 0xffff); /* Avoid that divide by zero! */
+      }
+      break;
+    case 7:
+      if (data != 0) {
+        set_GPRM(command->registers, reg, (get_GPRM(command->registers, reg) % data) );
+      } else {
+        set_GPRM(command->registers, reg, 0xffff); /* Avoid that divide by zero! */
+      }
+      break;
+    case 8: /* SPECIAL CASE - RND! Return numbers between 1 and data. */
+      set_GPRM(command->registers, reg, 1 + ((uint16_t) ((float) data * rand()/(RAND_MAX+1.0))) );
+      break;
+    case 9:
+      set_GPRM(command->registers, reg, (get_GPRM(command->registers, reg) & data) );
+      break;
+    case 10:
+      set_GPRM(command->registers, reg, (get_GPRM(command->registers, reg) | data) );
+      break;
+    case 11:
+      set_GPRM(command->registers, reg, (get_GPRM(command->registers, reg) ^ data) );
+      break;
+  }
+}
+
+/* Evaluate set instruction, combined with either Link or Compare. */
+static void eval_set_version_1(command_t* command, int32_t cond) {
+  uint8_t  op   = vm_getbits(command, 59, 4);
+  uint8_t  reg  = vm_getbits(command, 35, 4); /* FIXME: This is different from vmcmd.c!!! */
+  uint8_t  reg2 = vm_getbits(command, 19, 4);
+  uint16_t data = eval_reg_or_data(command, vm_getbits(command, 60, 1), 31);
+
+  if(cond) {
+    eval_set_op(command, op, reg, reg2, data);
+  }
+}
+
+
+/* Evaluate set instruction, combined with both Link and Compare. */
+static void eval_set_version_2(command_t* command, int32_t cond) {
+  uint8_t  op   = vm_getbits(command, 59, 4);
+  uint8_t  reg  = vm_getbits(command, 51, 4);
+  uint8_t  reg2 = vm_getbits(command, 35, 4); /* FIXME: This is different from vmcmd.c!!! */
+  uint16_t data = eval_reg_or_data(command, vm_getbits(command, 60, 1), 47);
+
+  if(cond) {
+    eval_set_op(command, op, reg, reg2, data);
+  }
+}
+
+
+/* Evaluate a command
+   returns row number of goto, 0 if no goto, -1 if link.
+   Link command in return_values */
+static int32_t eval_command(uint8_t *bytes, registers_t* registers, link_t *return_values) {
+  int32_t cond, res = 0;
+  command_t command;
+  command.instruction =( (uint64_t) bytes0 << 56 ) |
+        ( (uint64_t) bytes1 << 48 ) |
+        ( (uint64_t) bytes2 << 40 ) |
+        ( (uint64_t) bytes3 << 32 ) |
+        ( (uint64_t) bytes4 << 24 ) |
+        ( (uint64_t) bytes5 << 16 ) |
+        ( (uint64_t) bytes6 <<  8 ) |
+          (uint64_t) bytes7 ;
+  command.examined = 0;
+  command.registers = registers;
+  memset(return_values, 0, sizeof(link_t));
+
+  switch(vm_getbits(&command, 63, 3)) { /* three first old_bits */
+    case 0: /*  Special instructions */
+      cond = eval_if_version_1(&command);
+      res = eval_special_instruction(&command, cond);
+      if(res == -1) {
+        fprintf(MSG_OUT, "libdvdnav: Unknown Instruction!\n");
+        dassert(0);
+      }
+      break;
+    case 1: /*  Link/jump instructions */
+      if(vm_getbits(&command, 60, 1)) {
+        cond = eval_if_version_2(&command);
+        res = eval_jump_instruction(&command, cond, return_values);
+      } else {
+        cond = eval_if_version_1(&command);
+        res = eval_link_instruction(&command, cond, return_values);
+      }
+      if(res)
+        res = -1;
+      break;
+    case 2: /*  System set instructions */
+      cond = eval_if_version_2(&command);
+      res = eval_system_set(&command, cond, return_values);
+      if(res)
+        res = -1;
+      break;
+    case 3: /*  Set instructions, either Compare or Link may be used */
+      cond = eval_if_version_3(&command);
+      eval_set_version_1(&command, cond);
+      if(vm_getbits(&command, 51, 4)) {
+        res = eval_link_instruction(&command, cond, return_values);
+      }
+      if(res)
+        res = -1;
+      break;
+    case 4: /*  Set, Compare -> Link Sub-Instruction */
+      eval_set_version_2(&command, /*True*/ 1);
+      cond = eval_if_version_4(&command);
+      res = eval_link_subins(&command, cond, return_values);
+      if(res)
+        res = -1;
+      break;
+    case 5: /*  Compare -> (Set and Link Sub-Instruction) */
+      /* FIXME: These are wrong. Need to be updated from vmcmd.c */
+      cond = eval_if_version_4(&command);
+      eval_set_version_2(&command, cond);
+      res = eval_link_subins(&command, cond, return_values);
+      if(res)
+        res = -1;
+      break;
+    case 6: /*  Compare -> Set, allways Link Sub-Instruction */
+      /* FIXME: These are wrong. Need to be updated from vmcmd.c */
+      cond = eval_if_version_4(&command);
+      eval_set_version_2(&command, cond);
+      res = eval_link_subins(&command, /*True*/ 1, return_values);
+      if(res)
+        res = -1;
+      break;
+    default: /* Unknown command type */
+      fprintf(MSG_OUT, "libdvdnav: WARNING: Unknown Command Type=%x\n", vm_getbits(&command, 63, 3));
+  }
+  /*  Check if there are bits not yet examined */
+
+  if(command.instruction & ~ command.examined) {
+    fprintf(MSG_OUT, "libdvdnav: decoder.c: WARNING, unknown bits:");
+    fprintf(MSG_OUT, " %08"PRIx64, (command.instruction & ~ command.examined) );
+    fprintf(MSG_OUT, "\n");
+  }
+
+  return res;
+}
+
+/* Evaluate a set of commands in the given register set (which is modified) */
+int32_t vmEval_CMD(const trace_log_t* log, vm_cmd_t commands, int32_t num_commands,
+               registers_t *registers, link_t *return_values) {
+  int32_t i = 0;
+  int32_t total = 0;
+
+#ifdef TRACE
+  if ((NULL != log) && (NULL != log->logcb.pf_log)) {
+      /*  DEBUG */
+      tfprintf(tMSG_OUT, "libdvdnav: Registers before transaction\n");
+      vm_print_registers(log, registers);
+      tfprintf(tMSG_OUT, "libdvdnav: Full list of commands to execute\n");
+      for (i = 0; i < num_commands; i++)
+          vm_print_cmd(log, i, &commandsi);
+      tfprintf(tMSG_OUT, "libdvdnav: --------------------------------------------\n");
+      tfprintf(tMSG_OUT, "libdvdnav: Single stepping commands\n");
+  }
+#endif
+
+  i = 0;
+  while(i < num_commands && total < 100000) {
+    int32_t line;
+
+#ifdef TRACE
+    if ((NULL != log) && (NULL != log->logcb.pf_log)) {
+        vm_print_cmd(log, i, &commandsi);
+    }
+#endif
+
+    line = eval_command(&commandsi.bytes0, registers, return_values);
+
+    if (line < 0) { /*  Link command */
+#ifdef TRACE
+        if ((NULL != log) && (NULL != log->logcb.pf_log)) {
+            tfprintf(tMSG_OUT, "libdvdnav: Registers after transaction\n");
+            vm_print_registers(log, registers);
+            tfprintf(tMSG_OUT, "libdvdnav: eval: Doing Link/Jump/Call\n");
+        }
+#endif
+      return 1;
+    }
+
+    if (line > 0) /*  Goto command */
+      i = line - 1;
+    else /*  Just continue on the next line */
+      i++;
+
+    total++;
+  }
+
+  memset(return_values, 0, sizeof(link_t));
+#ifdef TRACE
+  if ((NULL != log) && (NULL != log->logcb.pf_log)) {
+      tfprintf(tMSG_OUT, "libdvdnav: Registers after transaction\n");
+      vm_print_registers(log, registers);
+  }
+#endif
+  return 0;
+}
+
+#define MaxLogLineSize 255
+
+static char g_log_lineMaxLogLineSize+1;
+static unsigned int g_log_size = 0;
+
+static void vm_debug_println(const trace_log_t* log, const char* str)
+{
+    va_list lst;
+
+    memset(&lst,0,sizeof(lst));
+
+    (*log->logcb.pf_log)(log->priv, DVDNAV_LOGGER_LEVEL_INFO, g_log_line, lst);
+}
+
+void vm_debug_print(const trace_log_t* log, const char* fmt, ...)
+{
+    unsigned int log_have,sz;
+    va_list lst;
+
+    if (NULL == log) return;
+    if (NULL == log->logcb.pf_log) return;
+
+    log_have = MaxLogLineSize - g_log_size;
+
+    if (log_have < 2)
+    {
+        g_log_lineg_log_size = 0;
+        vm_debug_println(log,g_log_line);
+        g_log_size = 0;
+        log_have = MaxLogLineSize;
+    }
+
+    va_start(lst, fmt);
+    sz = vsnprintf(g_log_line + g_log_size, log_have, fmt, lst);
+    va_end(lst);
+
+    if (sz >= log_have)
+    {
+        sz = log_have;
+    }
+    g_log_size += sz;
+
+    g_log_lineg_log_size = 0;
+
+    while (g_log_size!=0)
+    {
+        char* p;
+
+        p = strchr(g_log_line, '\n');
+        if (NULL == p) break;
+
+        *p = 0;
+        vm_debug_println(log,g_log_line);
+
+        log_have = (unsigned int)((p + 1) - g_log_line);
+
+        if (log_have <= g_log_size)
+        {
+            g_log_size -= log_have;
+            memmove(g_log_line, g_log_line + log_have, g_log_size);
+        } else {
+            g_log_size = 0;
+        }
+        g_log_lineg_log_size = 0;
+    };
+}
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/decoder.h Added

@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2000, 2001 Martin Norbäck, Håkan Hjort
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDNAV_DECODER_H
+#define LIBDVDNAV_DECODER_H
+
+/* link command types */
+typedef enum {
+  LinkNoLink  = 0,
+
+  LinkTopC    = 1,
+  LinkNextC   = 2,
+  LinkPrevC   = 3,
+
+  LinkTopPG   = 5,
+  LinkNextPG  = 6,
+  LinkPrevPG  = 7,
+
+  LinkTopPGC  = 9,
+  LinkNextPGC = 10,
+  LinkPrevPGC = 11,
+  LinkGoUpPGC = 12,
+  LinkTailPGC = 13,
+
+  LinkRSM     = 16,
+
+  LinkPGCN,
+  LinkPTTN,
+  LinkPGN,
+  LinkCN,
+
+  Exit,
+
+  JumpTT, /* 22 */
+  JumpVTS_TT,
+  JumpVTS_PTT,
+
+  JumpSS_FP,
+  JumpSS_VMGM_MENU,
+  JumpSS_VTSM,
+  JumpSS_VMGM_PGC,
+
+  CallSS_FP, /* 29 */
+  CallSS_VMGM_MENU,
+  CallSS_VTSM,
+  CallSS_VMGM_PGC,
+
+  PlayThis
+} link_cmd_t;
+
+/* a link's data set */
+typedef struct {
+  link_cmd_t command;
+  uint16_t   data1;
+  uint16_t   data2;
+  uint16_t   data3;
+} link_t;
+
+/* the VM registers */
+typedef struct {
+  uint16_t SPRM24;
+  uint16_t GPRM16;
+  uint16_t GPRM_mode;  /* Need to have some thing to indicate normal/counter mode for every GPRM */
+  uint32_t GPRM_time16;  /* For counter mode */
+  uint32_t SPRM_flags;
+  uint32_t time_counter;
+} registers_t;
+
+/* a VM command data set */
+typedef struct {
+  uint64_t instruction;
+  uint64_t examined;
+  registers_t *registers;
+} command_t;
+
+/* identical layout to vm_t. GPL is cancer. */
+typedef struct {
+    void *priv;
+    dvdnav_logger_cb logcb;
+} trace_log_t;
+
+void vm_debug_print(const trace_log_t* log, const char* fmt, ...);
+
+
+/* the big VM function, executing the given commands and writing
+ * the link where to continue, the return value indicates if a jump
+ * has been performed */
+int32_t vmEval_CMD(const trace_log_t* log, vm_cmd_t commands, int32_t num_commands,
+               registers_t *registers, link_t *return_values);
+
+/* extracts some bits from the command */
+uint32_t vm_getbits(command_t* command, int32_t start, int32_t count);
+
+#ifdef TRACE
+/* for debugging: prints a link in readable form */
+void vm_print_link(const trace_log_t* log,const link_t* value);
+
+/* for debugging: dumps VM registers */
+void vm_print_registers(const trace_log_t* log, registers_t *registers );
+#endif
+
+#endif /* LIBDVDNAV_DECODER_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/getset.c Added

@@ -0,0 +1,375 @@
+/*
+ * Copyright (C) 2000, 2001 Håkan Hjort
+ * Copyright (C) 2001 Rich Wareham <richwareham@users.sourceforge.net>
+ *               2002-2004 the dvdnav project
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+#include <dvdread/nav_types.h>
+#include <dvdread/ifo_types.h>
+#include <dvdread/ifo_read.h>
+#include "dvdnav/dvdnav.h"
+
+#include "decoder.h"
+#include "vm.h"
+#include "getset.h"
+#include "../dvdnav_internal.h"
+#include "../logger.h"
+
+#include "getset.h"
+/* Set functions */
+
+int set_TT(vm_t *vm, int tt) {
+  return set_PTT(vm, tt, 1);
+}
+
+int set_PTT(vm_t *vm, int tt, int ptt) {
+  vassert(tt <= vm->vmgi->tt_srpt->nr_of_srpts);
+  return set_VTS_PTT(vm, vm->vmgi->tt_srpt->titlett - 1.title_set_nr,
+                     vm->vmgi->tt_srpt->titlett - 1.vts_ttn, ptt);
+}
+
+int set_VTS_TT(vm_t *vm, int vtsN, int vts_ttn) {
+  return set_VTS_PTT(vm, vtsN, vts_ttn, 1);
+}
+
+int set_VTS_PTT(vm_t *vm, int vtsN, int vts_ttn, int part) {
+  int pgcN, pgN, res;
+
+  (vm->state).domain = DVD_DOMAIN_VTSTitle;
+
+  if (vtsN != (vm->state).vtsN)
+    if (!ifoOpenNewVTSI(vm, vm->dvd, vtsN))  /* Also sets (vm->state).vtsN */
+      return 0;
+
+  if ((vts_ttn < 1) || (vts_ttn > vm->vtsi->vts_ptt_srpt->nr_of_srpts) ||
+      (part < 1) || (part > vm->vtsi->vts_ptt_srpt->titlevts_ttn - 1.nr_of_ptts) ) {
+    return 0;
+  }
+
+  pgcN = vm->vtsi->vts_ptt_srpt->titlevts_ttn - 1.pttpart - 1.pgcn;
+  pgN = vm->vtsi->vts_ptt_srpt->titlevts_ttn - 1.pttpart - 1.pgn;
+
+  (vm->state).TT_PGCN_REG = pgcN;
+  (vm->state).PTTN_REG    = part;
+  (vm->state).TTN_REG     = get_TT(vm, vtsN, vts_ttn);
+  if( (vm->state.TTN_REG) == 0 )
+    return 0;
+
+  (vm->state).VTS_TTN_REG = vts_ttn;
+  (vm->state).vtsN        = vtsN;  /* Not sure about this one. We can get to it easily from TTN_REG */
+  /* Any other registers? */
+
+  res = set_PGCN(vm, pgcN);   /* This clobber's state.pgN (sets it to 1), but we don't want clobbering here. */
+  (vm->state).pgN = pgN;
+  return res;
+}
+
+int set_PROG(vm_t *vm, int tt, int pgcn, int pgn) {
+  vassert(tt <= vm->vmgi->tt_srpt->nr_of_srpts);
+  return set_VTS_PROG(vm, vm->vmgi->tt_srpt->titlett - 1.title_set_nr,
+                     vm->vmgi->tt_srpt->titlett - 1.vts_ttn, pgcn, pgn);
+}
+
+int set_VTS_PROG(vm_t *vm, int vtsN, int vts_ttn, int pgcn, int pgn) {
+  int pgcN, pgN, res, title, part = 0;
+
+  (vm->state).domain = DVD_DOMAIN_VTSTitle;
+
+  if (vtsN != (vm->state).vtsN)
+    if (!ifoOpenNewVTSI(vm, vm->dvd, vtsN))  /* Also sets (vm->state).vtsN */
+      return 0;
+
+  if ((vts_ttn < 1) || (vts_ttn > vm->vtsi->vts_ptt_srpt->nr_of_srpts)) {
+    return 0;
+  }
+
+  pgcN = pgcn;
+  pgN = pgn;
+
+  (vm->state).TT_PGCN_REG = pgcN;
+  (vm->state).TTN_REG     = get_TT(vm, vtsN, vts_ttn);
+  vassert( (vm->state.TTN_REG) != 0 );
+  (vm->state).VTS_TTN_REG = vts_ttn;
+  (vm->state).vtsN        = vtsN;  /* Not sure about this one. We can get to it easily from TTN_REG */
+  /* Any other registers? */
+
+  res = set_PGCN(vm, pgcN);   /* This clobber's state.pgN (sets it to 1), but we don't want clobbering here. */
+  (vm->state).pgN = pgN;
+  vm_get_current_title_part(vm, &title, &part);
+  (vm->state).PTTN_REG    = part;
+  return res;
+}
+
+int set_FP_PGC(vm_t *vm) {
+  if (!vm || !vm->vmgi)
+      return 1;
+  (vm->state).domain = DVD_DOMAIN_FirstPlay;
+  if (!vm->vmgi->first_play_pgc) {
+    return set_PGCN(vm, 1);
+  }
+  (vm->state).pgc = vm->vmgi->first_play_pgc;
+  (vm->state).pgcN = vm->vmgi->vmgi_mat->first_play_pgc;
+  return 1;
+}
+
+
+int set_MENU(vm_t *vm, int menu) {
+  vassert((vm->state).domain == DVD_DOMAIN_VMGM || (vm->state).domain == DVD_DOMAIN_VTSMenu);
+  return set_PGCN(vm, get_ID(vm, menu));
+}
+
+int set_PGCN(vm_t *vm, int pgcN) {
+  pgcit_t *pgcit;
+
+  pgcit = get_PGCIT(vm);
+  if (pgcit == NULL)
+    return 0;
+
+  if(pgcN < 1 || pgcN > pgcit->nr_of_pgci_srp) {
+#ifdef TRACE
+    Log3(vm, "** No such pgcN = %d", pgcN);
+#endif
+    return 0;
+  }
+
+  (vm->state).pgc = pgcit->pgci_srppgcN - 1.pgc;
+  (vm->state).pgcN = pgcN;
+  (vm->state).pgN = 1;
+
+  if((vm->state).domain == DVD_DOMAIN_VTSTitle)
+    (vm->state).TT_PGCN_REG = pgcN;
+
+  return 1;
+}
+
+/* Figure out the correct pgN from the cell */
+int get_PGN(vm_t *vm) {
+  int new_pgN = 0;
+
+  vassert((vm->state).pgc != NULL);
+
+  while(new_pgN < (vm->state).pgc->nr_of_programs
+        && (vm->state).cellN >= (vm->state).pgc->program_mapnew_pgN)
+    new_pgN++;
+
+  return new_pgN;
+}
+
+/* Update (vm->state). */
+int set_PGN(vm_t *vm, int pgN) {
+  int dummy, part = 0;
+
+  if ((vm->state).pgc == NULL)
+    return 0;
+
+  (vm->state).pgN = pgN;
+
+  if((vm->state).domain == DVD_DOMAIN_VTSTitle) {
+    if((vm->state).TTN_REG > vm->vmgi->tt_srpt->nr_of_srpts)
+      return 0; /* ?? */
+
+    vm_get_current_title_part(vm, &dummy, &part);
+    (vm->state).PTTN_REG = part;
+  }
+  return 1;
+}
+
+/* Must be called before domain is changed (set_PGCN()) */
+void set_RSMinfo(vm_t *vm, int cellN, int blockN) {
+  int i;
+
+  if(cellN) {
+    (vm->state).rsm_cellN = cellN;
+    (vm->state).rsm_blockN = blockN;
+  } else {
+    (vm->state).rsm_cellN = (vm->state).cellN;
+    (vm->state).rsm_blockN = blockN;
+  }
+  (vm->state).rsm_vtsN = (vm->state).vtsN;
+  (vm->state).rsm_pgcN = get_PGCN(vm);
+
+  /* assert((vm->state).rsm_pgcN == (vm->state).TT_PGCN_REG);  for DVD_DOMAIN_VTSTitle */
+
+  for(i = 0; i < 5; i++) {
+    (vm->state).rsm_regsi = (vm->state).registers.SPRM4 + i;
+  }
+}
+
+
+/* Force the highlight button number register */
+void set_HL_BTN(vm_t *vm, int btnn)
+{
+    (vm->state).HL_BTNN_REG = btnn << 10;
+}
+
+/* Get functions */
+
+/* Searches the TT tables, to find the current TT.
+ * returns the current TT.
+ * returns 0 if not found.
+ */
+int get_TT(vm_t *vm, int vtsN, int vts_ttn) {
+  int i;
+  int tt=0;
+
+  for(i = 1; i <= vm->vmgi->tt_srpt->nr_of_srpts; i++) {
+    if( vm->vmgi->tt_srpt->titlei - 1.title_set_nr == vtsN &&
+        vm->vmgi->tt_srpt->titlei - 1.vts_ttn == vts_ttn) {
+      tt=i;
+      break;
+    }
+  }
+  return tt;
+}
+
+/* Search for entry_id match of the PGC Category in the current VTS PGCIT table.
+ * Return pgcN based on entry_id match.
+ */
+int get_ID(vm_t *vm, int id) {
+  int pgcN, i;
+  pgcit_t *pgcit;
+
+  /* Relies on state to get the correct pgcit. */
+  pgcit = get_PGCIT(vm);
+  if(pgcit == NULL) {
+    Log1(vm, "PGCIT null!");
+    return 0;
+  }
+#ifdef TRACE
+  Log3(vm, "** Searching for menu (0x%x) entry PGC", id);
+#endif
+
+  /* Force high bit set. */
+  id |=0x80;
+
+  /* Get menu/title */
+  for(i = 0; i < pgcit->nr_of_pgci_srp; i++) {
+    if( (pgcit->pgci_srpi.entry_id) == id) {
+      pgcN = i + 1;
+#ifdef TRACE
+      Log3(vm, "Found menu.");
+#endif
+      return pgcN;
+    }
+  }
+#ifdef TRACE
+  Log3(vm, "** No such id/menu (0x%02x) entry PGC", id & 0x7f);
+  for(i = 0; i < pgcit->nr_of_pgci_srp; i++) {
+    if ( (pgcit->pgci_srpi.entry_id & 0x80) == 0x80) {
+      Log3(vm, "Available menus: 0x%x",
+                     pgcit->pgci_srpi.entry_id & 0x7f);
+    }
+  }
+#endif
+  return 0; /*  error */
+}
+
+/* FIXME: we have a pgcN member in the vm's state now, so this should be obsolete */
+int get_PGCN(vm_t *vm) {
+  pgcit_t *pgcit;
+  int pgcN = 1;
+
+  if ((vm->state).pgc == NULL) {
+    return 0; /* error */
+  }
+
+  pgcit = get_PGCIT(vm);
+
+  if (pgcit) {
+    while(pgcN <= pgcit->nr_of_pgci_srp) {
+      if(pgcit->pgci_srppgcN - 1.pgc == (vm->state).pgc) {
+        vassert((vm->state).pgcN == pgcN);
+        return pgcN;
+      }
+      pgcN++;
+    }
+  }
+  Log0(vm, "get_PGCN failed. Was trying to find pgcN in domain %d",
+         (vm->state).domain);
+  return 0; /*  error */
+}
+
+pgcit_t* get_MENU_PGCIT(vm_t *vm, ifo_handle_t *h, uint16_t lang) {
+  int i;
+
+  if(h == NULL || h->pgci_ut == NULL) {
+    Log0(vm, "*** pgci_ut handle is NULL ***");
+    return NULL; /*  error? */
+  }
+
+  i = 0;
+  while(i < h->pgci_ut->nr_of_lus
+        && h->pgci_ut->lui.lang_code != lang)
+    i++;
+  if(i == h->pgci_ut->nr_of_lus) {
+    Log1(vm, "Language '%c%c' not found, using '%c%c' instead",
+            (char)(lang >> 8), (char)(lang & 0xff),
+             (char)(h->pgci_ut->lu0.lang_code >> 8),
+            (char)(h->pgci_ut->lu0.lang_code & 0xff));
+    char *buffer = malloc(3 * h->pgci_ut->nr_of_lus + 1);
+    if(buffer)
+    {
+        buffer3 * h->pgci_ut->nr_of_lus = 0;
+        for(i = 0; i < h->pgci_ut->nr_of_lus; i++) {
+        sprintf(&buffer3*i, "%c%c ",
+                 (char)(h->pgci_ut->lui.lang_code >> 8),
+                (char)(h->pgci_ut->lui.lang_code & 0xff));
+        }
+        Log2(vm, "Menu Languages available: %s", buffer);
+        free(buffer);
+    }
+    i = 0; /*  error? */
+  }
+
+  return h->pgci_ut->lui.pgcit;
+}
+
+/* Uses state to decide what to return */
+pgcit_t* get_PGCIT(vm_t *vm) {
+  pgcit_t *pgcit = NULL;
+
+  switch ((vm->state).domain) {
+  case DVD_DOMAIN_VTSTitle:
+    if(!vm->vtsi) return NULL;
+    pgcit = vm->vtsi->vts_pgcit;
+    break;
+  case DVD_DOMAIN_VTSMenu:
+    if(!vm->vtsi) return NULL;
+    pgcit = get_MENU_PGCIT(vm, vm->vtsi, (vm->state).registers.SPRM0);
+    break;
+  case DVD_DOMAIN_VMGM:
+  case DVD_DOMAIN_FirstPlay:
+    pgcit = get_MENU_PGCIT(vm, vm->vmgi, (vm->state).registers.SPRM0);
+    break;
+  default:
+    abort();
+  }
+
+  return pgcit;
+}
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/getset.h Added

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2000, 2001 Håkan Hjort
+ * Copyright (C) 2001 Rich Wareham <richwareham@users.sourceforge.net>
+ *               2002-2004 the dvdnav project
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* get_XYZ returns a value.
+ * set_XYZ sets state using passed parameters.
+ *         returns success/failure.
+ */
+
+/* Set */
+int  set_TT(vm_t *vm, int tt);
+int  set_PTT(vm_t *vm, int tt, int ptt);
+int  set_VTS_TT(vm_t *vm, int vtsN, int vts_ttn);
+int  set_VTS_PTT(vm_t *vm, int vtsN, int vts_ttn, int part);
+int  set_PROG(vm_t *vm, int tt, int pgcn, int pgn);
+int  set_VTS_PROG(vm_t *vm, int vtsN, int vts_ttn, int pgcn, int pgn);
+int  set_FP_PGC(vm_t *vm);
+int  set_MENU(vm_t *vm, int menu);
+int  set_PGCN(vm_t *vm, int pgcN);
+int  set_PGN(vm_t *vm, int pgN);
+void set_RSMinfo(vm_t *vm, int cellN, int blockN);
+void set_HL_BTN(vm_t *vm, int btnn);
+
+/* Get */
+int get_TT(vm_t *vm, int vtsN, int vts_ttn);
+int get_ID(vm_t *vm, int id);
+int get_PGCN(vm_t *vm);
+int get_PGN(vm_t *vm); /* Get PGN based on (vm->state).CellN */
+
+pgcit_t* get_MENU_PGCIT(vm_t *vm, ifo_handle_t *h, uint16_t lang);
+pgcit_t* get_PGCIT(vm_t *vm);
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/play.c Added

@@ -0,0 +1,374 @@
+/*
+ * Copyright (C) 2000, 2001 Håkan Hjort
+ * Copyright (C) 2001 Rich Wareham <richwareham@users.sourceforge.net>
+ *               2002-2004 the dvdnav project
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <dvdread/nav_types.h>
+#include <dvdread/ifo_types.h>
+#include <dvdread/ifo_read.h>
+#include "dvdnav/dvdnav.h"
+
+#include "decoder.h"
+#include "vm.h"
+#include "play.h"
+#include "getset.h"
+#include "rand.h"
+
+#include "../dvdnav_internal.h"
+#include "../logger.h"
+
+/* Playback control */
+
+link_t play_PGC(vm_t *vm) {
+  link_t link_values;
+
+#ifdef TRACE
+  if((vm->state).domain != DVD_DOMAIN_FirstPlay) {
+    Log3(vm, "play_PGC: (vm->state).pgcN (%i)", get_PGCN(vm));
+  } else {
+    Log3(vm, "play_PGC: first_play_pgc");
+  }
+#endif
+
+  /* This must be set before the pre-commands are executed because they
+   * might contain a CallSS that will save resume state */
+
+  /* FIXME: This may be only a temporary fix for something... */
+  (vm->state).pgN = 1;
+  (vm->state).cellN = 0;
+  (vm->state).blockN = 0;
+
+  /* Handle random playback mode by choosing our initial program
+   * number randomly - some discs end up jumping to nowhere if you
+   * always choose the first cell.
+   */
+  if ((vm->state).pgc->pg_playback_mode!=0) {
+    rand_next(&vm->state.rnd);
+    (vm->state).pgN_step = 0;
+    (vm->state).pgN = 1 + rand_shuffle(&vm->state.rnd, (vm->state).pgc->nr_of_programs, (vm->state).pgN_step);
+  }
+
+  /* eval -> updates the state and returns either
+     - some kind of jump (Jump(TT/SS/VTS_TTN/CallSS/link C/PG/PGC/PTTN)
+     - just play video i.e first PG
+       (This is what happens if you fall of the end of the pre_cmds)
+     - or an error (are there more cases?) */
+  if((vm->state).pgc->command_tbl && (vm->state).pgc->command_tbl->nr_of_pre) {
+    if(vmEval_CMD((trace_log_t*)vm, (vm->state).pgc->command_tbl->pre_cmds,
+                  (vm->state).pgc->command_tbl->nr_of_pre,
+                  &(vm->state).registers, &link_values)) {
+      /*  link_values contains the 'jump' return value */
+      return link_values;
+    } else {
+#ifdef TRACE
+      Log3(vm, "PGC pre commands didn't do a Jump, Link or Call");
+#endif
+    }
+  }
+  return play_PG(vm);
+}
+
+link_t play_PGC_PG(vm_t *vm, int pgN) {
+  link_t link_values;
+
+#ifdef TRACE
+  if((vm->state).domain != DVD_DOMAIN_FirstPlay) {
+    Log3(vm, "play_PGC_PG: (vm->state).pgcN (%i)", get_PGCN(vm));
+  } else {
+    Log3(vm, "play_PGC_PG: first_play_pgc");
+  }
+#endif
+
+  /*  This must be set before the pre-commands are executed because they
+   *  might contain a CallSS that will save resume state */
+
+  /* FIXME: This may be only a temporary fix for something... */
+  (vm->state).pgN = pgN;
+  (vm->state).cellN = 0;
+  (vm->state).blockN = 0;
+
+  /* eval -> updates the state and returns either
+     - some kind of jump (Jump(TT/SS/VTS_TTN/CallSS/link C/PG/PGC/PTTN)
+     - just play video i.e first PG
+       (This is what happens if you fall of the end of the pre_cmds)
+     - or an error (are there more cases?) */
+  if((vm->state).pgc->command_tbl && (vm->state).pgc->command_tbl->nr_of_pre) {
+    if(vmEval_CMD((trace_log_t*)vm, (vm->state).pgc->command_tbl->pre_cmds,
+                  (vm->state).pgc->command_tbl->nr_of_pre,
+                  &(vm->state).registers, &link_values)) {
+      /*  link_values contains the 'jump' return value */
+      return link_values;
+    } else {
+#ifdef TRACE
+      Log3(vm, "PGC pre commands didn't do a Jump, Link or Call");
+#endif
+    }
+  }
+  return play_PG(vm);
+}
+
+link_t play_PGC_post(vm_t *vm) {
+  link_t link_values = { LinkNoLink, 0, 0, 0 };
+
+#ifdef TRACE
+  Log3(vm, "play_PGC_post:");
+#endif
+
+  /* eval -> updates the state and returns either
+     - some kind of jump (Jump(TT/SS/VTS_TTN/CallSS/link C/PG/PGC/PTTN)
+     - just go to next PGC
+       (This is what happens if you fall of the end of the post_cmds)
+     - or an error (are there more cases?) */
+  if((vm->state).pgc->command_tbl && (vm->state).pgc->command_tbl->nr_of_post &&
+     vmEval_CMD((trace_log_t*)vm, (vm->state).pgc->command_tbl->post_cmds,
+                (vm->state).pgc->command_tbl->nr_of_post,
+                &(vm->state).registers, &link_values)) {
+    return link_values;
+  }
+
+#ifdef TRACE
+  Log3(vm, "** Fell of the end of the pgc, continuing in NextPGC");
+#endif
+  /* Should end up in the STOP_DOMAIN if next_pgc is 0. */
+  if(!set_PGCN(vm, (vm->state).pgc->next_pgc_nr)) {
+    link_values.command = Exit;
+    return link_values;
+  }
+  return play_PGC(vm);
+}
+
+link_t play_PG(vm_t *vm) {
+#ifdef TRACE
+  Log3(vm, "play_PG: (vm->state).pgN (%i)", (vm->state).pgN);
+#endif
+
+  vassert((vm->state).pgN > 0);
+  if((vm->state).pgN > (vm->state).pgc->nr_of_programs) {
+#ifdef TRACE
+    Log3(vm, "play_PG: (vm->state).pgN (%i) > pgc->nr_of_programs (%i)",
+            (vm->state).pgN, (vm->state).pgc->nr_of_programs );
+#endif
+    vassert((vm->state).pgN == (vm->state).pgc->nr_of_programs + 1);
+    return play_PGC_post(vm);
+  }
+
+  (vm->state).cellN = (vm->state).pgc->program_map(vm->state).pgN - 1;
+
+  return play_Cell(vm);
+}
+
+link_t play_Cell(vm_t *vm) {
+  static const link_t play_this = {PlayThis, /* Block in Cell */ 0, 0, 0};
+
+#ifdef TRACE
+  Log3(vm, "play_Cell: (vm->state).cellN (%i)", (vm->state).cellN);
+#endif
+
+  vassert((vm->state).cellN > 0);
+  if((vm->state).cellN > (vm->state).pgc->nr_of_cells) {
+#ifdef TRACE
+    Log3(vm, "(vm->state).cellN (%i) > pgc->nr_of_cells (%i)",
+            (vm->state).cellN, (vm->state).pgc->nr_of_cells );
+#endif
+    vassert((vm->state).cellN == (vm->state).pgc->nr_of_cells + 1);
+    return play_PGC_post(vm);
+  }
+
+  /* Multi angle/Interleaved */
+  switch((vm->state).pgc->cell_playback(vm->state).cellN - 1.block_mode) {
+  case 0: /*  Normal */
+    vassert((vm->state).pgc->cell_playback(vm->state).cellN - 1.block_type == 0);
+    break;
+  case 1: /*  The first cell in the block */
+    switch((vm->state).pgc->cell_playback(vm->state).cellN - 1.block_type) {
+    case 0: /*  Not part of a block */
+      vassert(0);
+      break;
+    case 1: /*  Angle block */
+      /* Loop and check each cell instead? So we don't get outside the block? */
+      (vm->state).cellN += (vm->state).AGL_REG - 1;
+#ifdef DVDNAV_STRICT
+      vassert((vm->state).cellN <= (vm->state).pgc->nr_of_cells);
+      vassert((vm->state).pgc->cell_playback(vm->state).cellN - 1.block_mode != 0);
+      vassert((vm->state).pgc->cell_playback(vm->state).cellN - 1.block_type == 1);
+#else
+      if (!((vm->state).cellN <= (vm->state).pgc->nr_of_cells) ||
+          !((vm->state).pgc->cell_playback(vm->state).cellN - 1.block_mode != 0) ||
+          !((vm->state).pgc->cell_playback(vm->state).cellN - 1.block_type == 1)) {
+        Log1(vm, "Invalid angle block");
+        (vm->state).cellN -= (vm->state).AGL_REG - 1;
+      }
+#endif
+      break;
+    case 2: /*  reserved */
+    case 3: /*  reserved */
+    default:
+      Log1(vm, "Invalid? Cell block_mode (%d), block_type (%d)",
+              (vm->state).pgc->cell_playback(vm->state).cellN - 1.block_mode,
+              (vm->state).pgc->cell_playback(vm->state).cellN - 1.block_type);
+      vassert(0);
+    }
+    break;
+  case 2: /*  Cell in the block */
+  case 3: /*  Last cell in the block */
+  /* These might perhaps happen for RSM or LinkC commands? */
+  default:
+    Log1(vm, "Cell is in block but did not enter at first cell!");
+  }
+
+  /* Updates (vm->state).pgN and PTTN_REG */
+  if(!set_PGN(vm,get_PGN(vm))) {
+    /* Should not happen */
+    vassert(0);
+    return play_PGC_post(vm);
+  }
+  (vm->state).cell_restart++;
+  (vm->state).blockN = 0;
+#ifdef TRACE
+  Log3(vm, "Cell should restart here");
+#endif
+  return play_this;
+}
+
+link_t play_Cell_post(vm_t *vm) {
+  cell_playback_t *cell;
+
+#ifdef TRACE
+  Log3(vm, "play_Cell_post: (vm->state).cellN (%i)", (vm->state).cellN);
+#endif
+
+  cell = &(vm->state).pgc->cell_playback(vm->state).cellN - 1;
+
+  /* Still time is already taken care of before we get called. */
+
+  /* Deal with a Cell command, if any */
+  if(cell->cell_cmd_nr != 0) {
+    link_t link_values;
+
+    if ((vm->state).pgc->command_tbl != NULL &&
+        (vm->state).pgc->command_tbl->nr_of_cell >= cell->cell_cmd_nr) {
+#ifdef TRACE
+      Log3(vm, "Cell command present, executing");
+#endif
+      if(vmEval_CMD((trace_log_t*)vm, &(vm->state).pgc->command_tbl->cell_cmdscell->cell_cmd_nr - 1, 1,
+                    &(vm->state).registers, &link_values)) {
+        if (link_values.command != LinkNoLink) {
+          return link_values;
+        } else {
+#ifdef TRACE
+            Log3(vm, "Cell command did a Cheesy Link");
+#endif
+        }
+      } else {
+#ifdef TRACE
+        Log3(vm, "Cell command didn't do a Jump, Link or Call");
+#endif
+      }
+    } else {
+#ifdef TRACE
+      Log3(vm, "Invalid Cell command");
+#endif
+    }
+  }
+
+  /* Where to continue after playing the cell... */
+  /* Multi angle/Interleaved */
+  switch((vm->state).pgc->cell_playback(vm->state).cellN - 1.block_mode) {
+  case 0: /*  Normal */
+    vassert((vm->state).pgc->cell_playback(vm->state).cellN - 1.block_type == 0);
+    (vm->state).cellN++;
+    break;
+  case 1: /*  The first cell in the block */
+  case 2: /*  A cell in the block */
+  case 3: /*  The last cell in the block */
+  default:
+    switch((vm->state).pgc->cell_playback(vm->state).cellN - 1.block_type) {
+    case 0: /*  Not part of a block */
+      vassert(0);
+      break;
+    case 1: /*  Angle block */
+      /* Skip the 'other' angles */
+      (vm->state).cellN++;
+      while((vm->state).cellN <= (vm->state).pgc->nr_of_cells &&
+            (vm->state).pgc->cell_playback(vm->state).cellN - 1.block_mode >= 2) {
+        (vm->state).cellN++;
+      }
+      break;
+    case 2: /*  reserved */
+    case 3: /*  reserved */
+    default:
+      Log1(vm, "Invalid? Cell block_mode (%d), block_type (%d)",
+              (vm->state).pgc->cell_playback(vm->state).cellN - 1.block_mode,
+              (vm->state).pgc->cell_playback(vm->state).cellN - 1.block_type);
+      vassert(0);
+    }
+    break;
+  }
+
+  return play_PGN(vm);
+}
+
+/* Figure out the correct pgN for the new cell */
+link_t play_PGN(vm_t *vm) {
+  int new_pgN;
+  int last_pg;
+
+  vassert((vm->state).pgc != NULL);
+
+  last_pg = 0;
+  new_pgN = get_PGN(vm);
+
+  if (0 != (vm->state).pgc->pg_playback_mode) {
+      if (new_pgN != (vm->state).pgN) {
+        unsigned int pgCnt = ((vm->state).pgc->pg_playback_mode & 0x7f) + 1;
+
+        (vm->state).pgN_step++;
+        if ((vm->state).pgN_step >= pgCnt) {
+            last_pg = 1;
+        } else {
+          new_pgN = 1 + rand_shuffle(&vm->state.rnd, (vm->state).pgc->nr_of_programs, (vm->state).pgN_step);
+          (vm->state).cellN = (vm->state).pgc->program_mapnew_pgN - 1;
+        }
+      }
+  } else {
+      if (new_pgN == (vm->state).pgc->nr_of_programs) /* We are at the last program */
+          if ((vm->state).cellN > (vm->state).pgc->nr_of_cells)
+              last_pg = 1;
+  }
+
+  if (last_pg) {
+#ifdef TRACE
+      Log3(vm, "last cell in this PGC");
+#endif
+      return play_PGC_post(vm);
+  }
+
+  set_PGN(vm, new_pgN);
+  return play_Cell(vm);
+}
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/play.h Added

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2000, 2001 Håkan Hjort
+ * Copyright (C) 2001 Rich Wareham <richwareham@users.sourceforge.net>
+ *               2002-2004 the dvdnav project
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+/* Play */
+link_t play_PGC(vm_t *vm);
+link_t play_PGC_PG(vm_t *vm, int pgN);
+link_t play_PGC_post(vm_t *vm);
+link_t play_PG(vm_t *vm);
+link_t play_PGN(vm_t *vm);
+
+link_t play_Cell(vm_t *vm);
+link_t play_Cell_post(vm_t *vm);
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/rand.cpp Added

@@ -0,0 +1,114 @@
+/*
+    Copyright (C) 2007-2022 GuinpinSoft inc <mmgpl@makemkv.com>
+
+    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.
+
+*/
+#include <stdint.h>
+#include <string.h>
+#include <strings.h>
+
+#include "rand.h"
+
+static const unsigned int NUM_WORDS = 9;
+static const unsigned int MAX_BOUND = NUM_WORDS * 32;
+static_assert(MAX_BOUND > 257, "Max PG count per PGC");
+
+uint32_t rand_next(uint32_t *rand)
+{
+    uint64_t product = ((uint64_t)(*rand)) * 48271;
+    uint32_t x = (uint32_t)( (product & 0x7fffffff) + (product >> 31) );
+
+    x = (x & 0x7fffffff) + (x >> 31);
+    *rand = x;
+    return x;
+}
+
+void rand_seed(uint32_t* rand, uint32_t value)
+{
+    uint32_t ns = (*rand + value);
+    ns |= 0x8000;
+    ns &= 0x7fffffff;
+    *rand = rand_next(&ns);
+}
+
+inline static uint32_t peek_next(uint32_t rand)
+{
+    uint32_t r = rand;
+    return rand_next(&r);
+}
+
+inline static bool getbit(uint32_t* bits, unsigned int index)
+{
+    unsigned int n = index / 32;
+    unsigned int s = index % 32;
+    return (0 != (bitsn & (1 << s)));
+}
+
+inline static void setbit(uint32_t* bits, unsigned int index)
+{
+    unsigned int n = index / 32;
+    unsigned int s = index % 32;
+    bitsn |= (1 << s);
+}
+
+unsigned int rand_shuffle(uint32_t* rand, unsigned int bound, unsigned int step)
+{
+    uint32_t bitsNUM_WORDS;
+    uint32_t r = *rand;
+
+    bzero(bits, sizeof(bits));
+
+    if (bound >= MAX_BOUND) return 0;
+
+    while (step >= bound)
+    {
+        step -= bound;
+        rand_next(&r);
+    }
+
+    if (bound >= 4)
+    {
+        while (0 == (peek_next(r) % bound))
+        {
+            rand_next(&r);
+        }
+    }
+
+    unsigned int n,v;
+    for (unsigned int s = 0; s <= step; s++)
+    {
+        n = (rand_next(&r) % (bound-s));
+        v = 0;
+
+        while (getbit(bits, v))
+        {
+            v++;
+        }
+
+        for (unsigned int i = 0; i < n; i++)
+        {
+            v++;
+            while (getbit(bits, v))
+            {
+                v++;
+            }
+        }
+        setbit(bits, v);
+    }
+
+    return v;
+}
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/rand.h Added

@@ -0,0 +1,35 @@
+/*
+    Copyright (C) 2007-2022 GuinpinSoft inc <mmgpl@makemkv.com>
+
+    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.
+
+*/
+#ifndef LIBDVDNAV_RAND_H
+#define LIBDVDNAV_RAND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void     rand_seed(uint32_t* rand,uint32_t value);
+uint32_t rand_next(uint32_t* rand);
+
+unsigned int rand_shuffle(uint32_t* rand, unsigned int bound, unsigned int step);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* LIBDVDNAV_RAND_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/vm.c Added

@@ -0,0 +1,1202 @@
+/*
+ * Copyright (C) 2000, 2001 Håkan Hjort
+ * Copyright (C) 2001 Rich Wareham <richwareham@users.sourceforge.net>
+ *               2002-2004 the dvdnav project
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <limits.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <ctype.h>
+
+#include <dvdread/nav_types.h>
+#include <dvdread/ifo_types.h>
+#include <dvdread/ifo_read.h>
+#include "dvdnav/dvdnav.h"
+
+#include "decoder.h"
+#include "vm.h"
+#include "play.h"
+#include "getset.h"
+#include "rand.h"
+#include "../dvdnav_internal.h"
+#include "../logger.h"
+
+#ifdef _MSC_VER
+#include <io.h>   /* read() */
+#endif /* _MSC_VER */
+
+#ifdef __OS2__
+#define INCL_DOS
+#include <os2safe.h>
+#include <os2.h>
+#include <io.h>     /* setmode() */
+#include <fcntl.h>  /* O_BINARY  */
+#endif
+
+#if DVDREAD_VERSION >= DVDREAD_VERSION_CODE(6,1,0)
+static void dvd_reader_logger_handler( void *priv, dvd_logger_level_t level,
+                                       const char *fmt, va_list list )
+{
+    vm_t *vm = priv;
+    if(vm->logcb.pf_log)
+        vm->logcb.pf_log(vm->priv, (dvdnav_logger_level_t) level, fmt, list );
+}
+#endif
+
+static int dvd_reader_seek_handler(void *priv, uint64_t pos)
+{
+    vm_t *vm = priv;
+    if(vm->streamcb.pf_seek)
+        return vm->streamcb.pf_seek(vm->priv, pos);
+    return 1;
+}
+
+static int dvd_reader_read_handler(void *priv, void *buffer, int count)
+{
+    vm_t *vm = priv;
+    if(vm->streamcb.pf_read)
+        return vm->streamcb.pf_read(vm->priv, buffer, count);
+    return 1;
+}
+
+static int dvd_reader_readv_handler(void *priv, void *iovec, int count)
+{
+    vm_t *vm = priv;
+    if(vm->streamcb.pf_readv)
+        return vm->streamcb.pf_readv(vm->priv, iovec, count);
+    return 1;
+}
+
+/*
+#define DVDNAV_STRICT
+*/
+
+/* Local prototypes */
+
+/* Process link - returns 1 if a hop has been performed */
+static int process_command(vm_t *vm,link_t link_values);
+
+/* Helper functions */
+static void vm_close(vm_t *vm);
+
+/* Debug functions */
+
+#ifdef TRACE
+void vm_position_print(vm_t *vm, vm_position_t *position) {
+  Log3(vm, "But=%x Spu=%x Aud=%x Ang=%x Hop=%x vts=%x dom=%x cell=%x cell_restart=%x cell_start=%x still=%x block=%x",
+  position->button,
+  position->spu_channel,
+  position->audio_channel,
+  position->angle_channel,
+  position->hop_channel,
+  position->vts,
+  position->domain,
+  position->cell,
+  position->cell_restart,
+  position->cell_start,
+  position->still,
+  position->block);
+}
+
+static void vm_print_current_domain_state(vm_t *vm) {
+  const char *domain;
+
+  switch(vm->state.domain) {
+    case DVD_DOMAIN_VTSTitle:  domain = "Video Title";        break;
+    case DVD_DOMAIN_VTSMenu: domain = "Video Title Menu";   break;
+    case DVD_DOMAIN_VMGM: domain = "Video Manager Menu"; break;
+    case DVD_DOMAIN_FirstPlay:   domain = "First Play";         break;
+    default:          domain = "Unknown";            break;
+  }
+  Log3(vm, "%s Domain: VTS:%d PGC:%d PG:%u CELL:%u BLOCK:%u VTS_TTN:%u TTN:%u TT_PGCN:%u",
+                   domain,
+                   vm->state.vtsN,
+                   get_PGCN(vm),
+                   vm->state.pgN,
+                   vm->state.cellN,
+                   vm->state.blockN,
+                   vm->state.VTS_TTN_REG,
+                   vm->state.TTN_REG,
+                   vm->state.TT_PGCN_REG);
+}
+#endif
+
+#ifdef __OS2__
+#define open os2_open
+
+static int os2_open(const char *name, int oflag)
+{
+  HFILE hfile;
+  ULONG ulAction;
+  ULONG rc;
+
+  rc = DosOpenL(name, &hfile, &ulAction, 0, FILE_NORMAL,
+                OPEN_ACTION_OPEN_IF_EXISTS | OPEN_ACTION_FAIL_IF_NEW,
+                OPEN_ACCESS_READONLY | OPEN_SHARE_DENYNONE | OPEN_FLAGS_DASD,
+                NULL);
+
+  if(rc)
+    return -1;
+
+  setmode(hfile, O_BINARY);
+
+  return (int)hfile;
+}
+#endif
+
+#ifndef DVDNAV_NO_TXTDT
+static void escaped_strcpy(char *dst, const char *src, size_t len)
+{
+    for(size_t i=0; i < len; i++ )
+    {
+      if(srci == 0)
+      {
+          dsti = 0;
+          break;
+      }
+      else if(isprint(srci))
+      {
+        dsti = srci;
+      } else {
+        dsti = ' ';
+      }
+    }
+}
+
+static int dvd_read_name(const vm_t *vm, char *name, char *serial, const char *device) {
+  /* Because we are compiling with _FILE_OFFSET_BITS=64
+   * all off_t are 64bit.
+   */
+  off_t off;
+  ssize_t read_size = 0;
+  int fd = -1;
+  uint8_t dataDVD_VIDEO_LB_LEN;
+
+  /* Read DVD name */
+  if (device == NULL) {
+    Log0(vm, "Device name string NULL");
+    goto fail;
+  }
+  if ((fd = open(device, O_RDONLY)) == -1) {
+    Log0(vm, "Unable to open device file %s.", device);
+    goto fail;
+  }
+
+  if ((off = lseek( fd, 32 * (off_t) DVD_VIDEO_LB_LEN, SEEK_SET )) == (off_t) - 1) {
+    Log0(vm, "Unable to seek to the title block %u.", 32);
+    goto fail;
+  }
+
+  if( off != ( 32 * (off_t) DVD_VIDEO_LB_LEN ) ) {
+    Log0(vm, "Can't seek to block %u", 32 );
+    goto fail;
+  }
+
+  if ((read_size = read( fd, data, DVD_VIDEO_LB_LEN )) == -1) {
+    Log0(vm, "Can't read name block. Probably not a DVD-ROM device.");
+    goto fail;
+  }
+
+  close(fd);
+  fd = -1;
+  if (read_size != DVD_VIDEO_LB_LEN) {
+    Log0(vm, "Can't read name block. Probably not a DVD-ROM device.");
+    goto fail;
+  }
+
+  char buffer49 = {0};
+  strncpy(name, (const char*) &data25, 48);
+  name48 = 0;
+  escaped_strcpy(buffer, name, 48);
+  Log2(vm, "DVD Title: %s", buffer);
+
+  strncpy(serial, (const char*) &data73, 14);
+  serial14 = 0;
+  escaped_strcpy(buffer, serial, 14);
+  Log2(vm, "DVD Serial Number: %s", buffer);
+
+  escaped_strcpy(buffer, (const char *) &data89, 128 - 89);
+  Log2(vm, "DVD Title (Alternative): %s", buffer);
+
+  return 1;
+
+fail:
+  if (fd >= 0)
+    close(fd);
+
+  return 0;
+}
+#endif
+
+int ifoOpenNewVTSI(vm_t *vm, dvd_reader_t *dvd, int vtsN) {
+  if(vm->state.vtsN == vtsN) {
+    return 1; /*  We alread have it */
+  }
+
+  if (vm->vtsi != NULL)
+      ifoClose(vm->vtsi);
+
+  vm->vtsi = ifoOpenVTSI(dvd, vtsN);
+  if(vm->vtsi == NULL) {
+    Log0(vm, "ifoOpenVTSI failed");
+    return 0;
+  }
+  if(!ifoRead_VTS_PTT_SRPT(vm->vtsi)) {
+    Log0(vm, "ifoRead_VTS_PTT_SRPT failed");
+    return 0;
+  }
+  if(!ifoRead_PGCIT(vm->vtsi)) {
+    Log0(vm, "ifoRead_PGCIT failed");
+    return 0;
+  }
+  if(!ifoRead_PGCI_UT(vm->vtsi)) {
+    Log0(vm, "ifoRead_PGCI_UT failed");
+    return 0;
+  }
+  if(!ifoRead_VOBU_ADMAP(vm->vtsi)) {
+    Log0(vm, "ifoRead_VOBU_ADMAP vtsi failed");
+    return 0;
+  }
+  if(!ifoRead_TITLE_VOBU_ADMAP(vm->vtsi)) {
+    Log0(vm, "ifoRead_TITLE_VOBU_ADMAP vtsi failed");
+    return 0;
+  }
+  vm->state.vtsN = vtsN;
+
+  return 1;
+}
+
+
+/* Initialisation & Destruction */
+
+vm_t* vm_new_vm(void *priv, const dvdnav_logger_cb *logcb) {
+  vm_t *vm = calloc(1, sizeof(vm_t));
+  if(vm)
+  {
+    vm->priv = priv;
+    if(logcb)
+        vm->logcb = *logcb;
+  }
+  return vm;
+}
+
+void vm_free_vm(vm_t *vm) {
+  vm_close(vm);
+  free(vm);
+}
+
+
+/* IFO Access */
+
+ifo_handle_t *vm_get_vmgi(vm_t *vm) {
+  return vm->vmgi;
+}
+
+ifo_handle_t *vm_get_vtsi(vm_t *vm) {
+  return vm->vtsi;
+}
+
+
+/* Reader Access */
+
+dvd_reader_t *vm_get_dvd_reader(vm_t *vm) {
+  return vm->dvd;
+}
+
+
+/* Basic Handling */
+
+int vm_start(vm_t *vm) {
+  if (vm->stopped) {
+    if (!vm_reset(vm, NULL, NULL, NULL))
+      return 0;
+
+    vm->stopped = 0;
+  }
+  /* Set pgc to FP (First Play) pgc */
+  set_FP_PGC(vm);
+  process_command(vm, play_PGC(vm));
+  return !vm->stopped;
+}
+
+void vm_stop(vm_t *vm) {
+  vm->stopped = 1;
+}
+
+static void vm_close(vm_t *vm) {
+  if(!vm)
+    return;
+  if(vm->vmgi) {
+    ifoClose(vm->vmgi);
+    vm->vmgi=NULL;
+  }
+  if(vm->vtsi) {
+    ifoClose(vm->vtsi);
+    vm->vtsi=NULL;
+  }
+  if(vm->dvd) {
+    DVDClose(vm->dvd);
+    vm->dvd=NULL;
+  }
+  vm->stopped = 1;
+}
+
+int vm_reset(vm_t *vm, const char *dvdroot,
+             void *priv, dvdnav_stream_cb *stream_cb) {
+  /*  Setup State */
+  memset(vm->state.registers.SPRM, 0, sizeof(vm->state.registers.SPRM));
+  memset(vm->state.registers.GPRM, 0, sizeof(vm->state.registers.GPRM));
+  memset(vm->state.registers.GPRM_time, 0, sizeof(vm->state.registers.GPRM_time));
+  vm->state.registers.GPRM_mode = 0;
+  vm->state.registers.SPRM_flags = 0;
+  vm->state.registers.time_counter = 0;
+  vm->state.registers.SPRM0  = ('e'<<8)|'n'; /* Player Menu Languange code */
+  vm->state.AST_REG            = 15;           /* 15 why? */
+  vm->state.SPST_REG           = 62;           /* 62 why? */
+  vm->state.AGL_REG            = 1;
+  vm->state.TTN_REG            = 1;
+  vm->state.VTS_TTN_REG        = 1;
+  /* vm->state.TT_PGCN_REG        = 0 */
+  vm->state.PTTN_REG           = 1;
+  vm->state.HL_BTNN_REG        = 1 << 10;
+  vm->state.PTL_REG            = 15;           /* Parental Level */
+  vm->state.registers.SPRM12 = ('U'<<8)|'S'; /* Parental Management Country Code */
+  vm->state.registers.SPRM16 = ('e'<<8)|'n'; /* Initial Language Code for Audio */
+  vm->state.registers.SPRM18 = ('e'<<8)|'n'; /* Initial Language Code for Spu */
+  vm->state.registers.SPRM20 = 0x1;          /* Player Regional Code Mask. Region free! */
+  vm->state.registers.SPRM14 = 0x100;        /* Try Pan&Scan */
+  vm->state.registers.SPRM15 = 0x7CFC;       /* Audio capabilities - All defined audio types */
+
+  vm->state.pgN                = 0;
+  vm->state.cellN              = 0;
+  vm->state.cell_restart       = 0;
+
+  vm->state.domain             = DVD_DOMAIN_FirstPlay;
+  vm->state.rsm_vtsN           = 0;
+  vm->state.rsm_cellN          = 0;
+  vm->state.rsm_blockN         = 0;
+
+  vm->state.vtsN               = -1;
+
+  vm->hop_channel                = 0;
+
+  /* save target callbacks */
+  if(stream_cb)
+      vm->streamcb = *stream_cb;
+  else
+      vm->streamcb = (dvdnav_stream_cb) { NULL, NULL, NULL };
+
+  /* bind local callbacks */
+  vm->dvdstreamcb.pf_seek = vm->streamcb.pf_seek ? dvd_reader_seek_handler : NULL;
+  vm->dvdstreamcb.pf_read = vm->streamcb.pf_read ? dvd_reader_read_handler : NULL;
+  vm->dvdstreamcb.pf_readv = vm->streamcb.pf_readv ? dvd_reader_readv_handler : NULL;
+
+  if (vm->dvd && (dvdroot || (priv && stream_cb))) {
+    /* a new dvd device has been requested */
+    vm_close(vm);
+  }
+  if (!vm->dvd) {
+    /* dvdread stream callback handlers for redirection */
+#if DVDREAD_VERSION >= DVDREAD_VERSION_CODE(6,1,0)
+    dvd_logger_cb dvdread_logcb = { .pf_log = dvd_reader_logger_handler };
+    /* Only install log handler if we have one ourself */
+    dvd_logger_cb *p_dvdread_logcb = vm->logcb.pf_log ? &dvdread_logcb : NULL;
+    if(dvdroot)
+        vm->dvd = DVDOpen2(vm, p_dvdread_logcb, dvdroot);
+    else if(vm->priv && vm->dvdstreamcb.pf_read)
+        vm->dvd = DVDOpenStream2(vm, p_dvdread_logcb, &vm->dvdstreamcb);
+#else
+      if(dvdroot)
+          vm->dvd = DVDOpen(dvdroot);
+      else if(vm->priv && vm->dvdstreamcb.pf_read)
+          vm->dvd = DVDOpenStream(vm, &vm->dvdstreamcb);
+#endif
+    if(!vm->dvd) {
+      Log0(vm, "vm: failed to open/read the DVD");
+      return 0;
+    }
+    vm->vmgi = ifoOpenVMGI(vm->dvd);
+    if(!vm->vmgi) {
+      Log0(vm, "vm: vm: failed to read VIDEO_TS.IFO");
+      return 0;
+    }
+    if(!ifoRead_FP_PGC(vm->vmgi)) {
+      Log0(vm, "vm: vm: ifoRead_FP_PGC failed");
+      return 0;
+    }
+    if(!ifoRead_TT_SRPT(vm->vmgi)) {
+      Log0(vm, "vm: vm: ifoRead_TT_SRPT failed");
+      return 0;
+    }
+    if(!ifoRead_PGCI_UT(vm->vmgi)) {
+      Log0(vm, "vm: vm: ifoRead_PGCI_UT failed");
+      return 0;
+    }
+    if(!ifoRead_PTL_MAIT(vm->vmgi)) {
+      Log0(vm, "vm: ifoRead_PTL_MAIT failed");
+      /* return 0; Not really used for now.. */
+    }
+    if(!ifoRead_VTS_ATRT(vm->vmgi)) {
+      Log0(vm, "vm: ifoRead_VTS_ATRT failed");
+      /* return 0; Not really used for now.. */
+    }
+    if(!ifoRead_VOBU_ADMAP(vm->vmgi)) {
+      Log0(vm, "vm: ifoRead_VOBU_ADMAP vgmi failed");
+      /* return 0; Not really used for now.. */
+    }
+#ifndef DVDNAV_NO_TXTDT
+    /* ifoRead_TXTDT_MGI(vmgi); Not implemented yet */
+    if(dvd_read_name(vm, vm->dvd_name, vm->dvd_serial, dvdroot) != 1) {
+      Log1(vm, "vm: dvd_read_name failed");
+    }
+#endif
+  }
+  if (vm->vmgi) {
+    int i, mask;
+    char buffer8 * 3 + 1;
+    char *p = buffer;
+    for (i = 1, mask = 1; i <= 8; i++, mask <<= 1)
+    {
+      if (((vm->vmgi->vmgi_mat->vmg_category >> 16) & mask) == 0)
+      {
+        sprintf(p, " %02d", i);
+        p +=3;
+      }
+    }
+    *p = 0;
+    Log2(vm, "DVD disk reports itself with Region mask 0x%08x. Regions:%s",
+      vm->vmgi->vmgi_mat->vmg_category, buffer);
+  }
+
+  vm->state.rnd = 0;
+  rand_seed(&vm->state.rnd, vm->vmgi->vmgi_mat->vmg_last_sector);
+  rand_seed(&vm->state.rnd, vm->vmgi->vmgi_mat->vmgi_last_sector);
+  rand_seed(&vm->state.rnd, vm->vmgi->vmgi_mat->vmgm_vobu_admap);
+
+  return 1;
+}
+
+
+/* copying and merging */
+
+vm_t *vm_new_copy(vm_t *source) {
+  vm_t *target = vm_new_vm(source->priv, &source->logcb);
+
+  if (target == NULL)
+    goto fail;
+
+  memcpy(target, source, sizeof(vm_t));
+
+  /* open a new vtsi handle, because the copy might switch to another VTS */
+
+  /* GPL is cancer */
+  if (NULL != target->vmgi) {
+      ifoAddRef(target->vmgi);
+  }
+  if (NULL != target->vtsi) {
+      ifoAddRef(target->vtsi);
+  }
+
+  return target;
+
+fail:
+  if (target != NULL)
+    vm_free_vm(target);
+
+  return NULL;
+}
+
+void vm_merge(vm_t *target, vm_t *source) {
+  if(target->vtsi)
+    ifoClose(target->vtsi);
+  memcpy(target, source, sizeof(vm_t));
+  memset(source, 0, sizeof(vm_t));
+}
+
+void vm_free_copy(vm_t *vm) {
+  if(vm->vtsi)
+    ifoClose(vm->vtsi);
+  free(vm);
+}
+
+
+/* regular playback */
+
+void vm_position_get(vm_t *vm, vm_position_t *position) {
+  position->button = vm->state.HL_BTNN_REG >> 10;
+  position->vts = vm->state.vtsN;
+  position->domain = vm->state.domain;
+  position->spu_channel = vm->state.SPST_REG;
+  position->audio_channel = vm->state.AST_REG;
+  position->angle_channel = vm->state.AGL_REG;
+  position->hop_channel = vm->hop_channel; /* Increases by one on each hop */
+  position->cell = vm->state.cellN;
+  position->cell_restart = vm->state.cell_restart;
+  position->cell_start = vm->state.pgc->cell_playbackvm->state.cellN - 1.first_sector;
+  position->still = vm->state.pgc->cell_playbackvm->state.cellN - 1.still_time;
+  position->block = vm->state.blockN;
+
+  /* handle PGC stills at PGC end */
+  if (vm->state.cellN == vm->state.pgc->nr_of_cells)
+    position->still += vm->state.pgc->still_time;
+  /* still already determined */
+  if (position->still)
+    return;
+  /* This is a rough fix for some strange still situations on some strange DVDs.
+   * There are discs (like the German "Back to the Future" RC2) where the only
+   * indication of a still is a cell playback time higher than the time the frames
+   * in this cell actually take to play (like 1 frame with 1 minute playback time).
+   * On the said BTTF disc, for these cells last_sector and last_vobu_start_sector
+   * are equal and the cells are very short, so we abuse these conditions to
+   * detect such discs. I consider these discs broken, so the fix is somewhat
+   * broken, too. */
+  if ((vm->state.pgc->cell_playbackvm->state.cellN - 1.last_sector ==
+       vm->state.pgc->cell_playbackvm->state.cellN - 1.last_vobu_start_sector) &&
+      (vm->state.pgc->cell_playbackvm->state.cellN - 1.last_sector -
+       vm->state.pgc->cell_playbackvm->state.cellN - 1.first_sector < 1024)) {
+    int time;
+    int size = vm->state.pgc->cell_playbackvm->state.cellN - 1.last_sector -
+               vm->state.pgc->cell_playbackvm->state.cellN - 1.first_sector;
+    time  = (vm->state.pgc->cell_playbackvm->state.cellN - 1.playback_time.hour   >> 4  ) * 36000;
+    time += (vm->state.pgc->cell_playbackvm->state.cellN - 1.playback_time.hour   & 0x0f) * 3600;
+    time += (vm->state.pgc->cell_playbackvm->state.cellN - 1.playback_time.minute >> 4  ) * 600;
+    time += (vm->state.pgc->cell_playbackvm->state.cellN - 1.playback_time.minute & 0x0f) * 60;
+    time += (vm->state.pgc->cell_playbackvm->state.cellN - 1.playback_time.second >> 4  ) * 10;
+    time += (vm->state.pgc->cell_playbackvm->state.cellN - 1.playback_time.second & 0x0f) * 1;
+    if (!time || size / time > 30)
+      /* datarate is too high, it might be a very short, but regular cell */
+      return;
+    if (time > 0xff) time = 0xff;
+    position->still = time;
+  }
+}
+
+void vm_get_next_cell(vm_t *vm) {
+  process_command(vm, play_Cell_post(vm));
+}
+
+
+/* Jumping */
+
+int vm_jump_pg(vm_t *vm, int pg) {
+  vm->state.pgN = pg;
+  process_command(vm, play_PG(vm));
+  return 1;
+}
+
+int vm_jump_cell_block(vm_t *vm, int cell, int block) {
+  vm->state.cellN = cell;
+  process_command(vm, play_Cell(vm));
+  /* play_Cell can jump to a different cell in case of angles */
+  if (vm->state.cellN == cell)
+    vm->state.blockN = block;
+  return 1;
+}
+
+int vm_jump_title_program(vm_t *vm, int title, int pgcn, int pgn) {
+  link_t link;
+
+  if(!set_PROG(vm, title, pgcn, pgn))
+    return 0;
+  /* Some DVDs do not want us to jump directly into a title and have
+   * PGC pre commands taking us back to some menu. Since we do not like that,
+   * we do not execute PGC pre commands that would do a jump. */
+  /* process_command(vm, play_PGC_PG(vm, vm->state.pgN)); */
+  link = play_PGC_PG(vm, vm->state.pgN);
+  if (link.command != PlayThis)
+    /* jump occured -> ignore it and play the PG anyway */
+    process_command(vm, play_PG(vm));
+  else
+    process_command(vm, link);
+  return 1;
+}
+
+int vm_jump_title_part(vm_t *vm, int title, int part) {
+  link_t link;
+
+  if(!set_PTT(vm, title, part))
+    return 0;
+#if 1
+  process_command(vm, play_PGC_PG(vm, vm->state.pgN));
+#else
+  /* Some DVDs do not want us to jump directly into a title and have
+   * PGC pre commands taking us back to some menu. Since we do not like that,
+   * we do not execute PGC pre commands that would do a jump. */
+  link = play_PGC_PG(vm, vm->state.pgN);
+  if (link.command != PlayThis)
+    /* jump occured -> ignore it and play the PG anyway */
+    process_command(vm, play_PG(vm));
+  else
+    process_command(vm, link);
+#endif
+  return 1;
+}
+
+int vm_jump_top_pg(vm_t *vm) {
+  process_command(vm, play_PG(vm));
+  return 1;
+}
+
+int vm_jump_next_pg(vm_t *vm) {
+  if(vm->state.pgN >= vm->state.pgc->nr_of_programs) {
+    /* last program -> move to TailPGC */
+    process_command(vm, play_PGC_post(vm));
+    return 1;
+  } else {
+    vm_jump_pg(vm, vm->state.pgN + 1);
+    return 1;
+  }
+}
+
+int vm_jump_prev_pg(vm_t *vm) {
+  if (vm->state.pgN <= 1) {
+    /* first program -> move to last program of previous PGC */
+    if (vm->state.pgc->prev_pgc_nr && set_PGCN(vm, vm->state.pgc->prev_pgc_nr)) {
+      process_command(vm, play_PGC(vm));
+      vm_jump_pg(vm, vm->state.pgc->nr_of_programs);
+      return 1;
+    }
+    return 0;
+  } else {
+    vm_jump_pg(vm, vm->state.pgN - 1);
+    return 1;
+  }
+}
+
+int vm_jump_up(vm_t *vm) {
+  if(vm->state.pgc->goup_pgc_nr && set_PGCN(vm, vm->state.pgc->goup_pgc_nr)) {
+    process_command(vm, play_PGC(vm));
+    return 1;
+  }
+  return 0;
+}
+
+int vm_jump_menu(vm_t *vm, DVDMenuID_t menuid) {
+  DVDDomain_t old_domain = vm->state.domain;
+
+  switch (vm->state.domain) {
+  case DVD_DOMAIN_FirstPlay: /* FIXME XXX $$$ What should we do here? */
+    break;
+  case DVD_DOMAIN_VTSTitle:
+    set_RSMinfo(vm, 0, vm->state.blockN);
+    /* FALL THROUGH */
+  case DVD_DOMAIN_VTSMenu:
+  case DVD_DOMAIN_VMGM:
+    switch(menuid) {
+    case DVD_MENU_Title:
+    case DVD_MENU_Escape:
+      if(vm->vmgi == NULL || vm->vmgi->pgci_ut == NULL)
+        return 0;
+      vm->state.domain = DVD_DOMAIN_VMGM;
+      break;
+    case DVD_MENU_Root:
+    case DVD_MENU_Subpicture:
+    case DVD_MENU_Audio:
+    case DVD_MENU_Angle:
+    case DVD_MENU_Part:
+      if(vm->vtsi == NULL || vm->vtsi->pgci_ut == NULL)
+        return 0;
+      vm->state.domain = DVD_DOMAIN_VTSMenu;
+      break;
+    }
+    if(get_PGCIT(vm) && set_MENU(vm, menuid)) {
+      process_command(vm, play_PGC(vm));
+      return 1;  /* Jump */
+    } else
+      vm->state.domain = old_domain;
+    break;
+  }
+
+  return 0;
+}
+
+int vm_jump_resume(vm_t *vm) {
+  link_t link_values = { LinkRSM, 0, 0, 0 };
+
+  if (!vm->state.rsm_vtsN) /* Do we have resume info? */
+    return 0;
+  return !!process_command(vm, link_values);
+}
+
+int vm_exec_cmd(vm_t *vm, vm_cmd_t *cmd) {
+  link_t link_values;
+
+  if(vmEval_CMD((trace_log_t*)vm, cmd, 1, &vm->state.registers, &link_values))
+    return process_command(vm, link_values);
+  else
+    return 0; /*  It updated some state thats all... */
+}
+
+/* link processing */
+
+static int process_command(vm_t *vm, link_t link_values) {
+
+  while(link_values.command != PlayThis) {
+
+#ifdef TRACE
+    if ((NULL!=vm->priv) && (NULL!=vm->logcb.pf_log)) {
+      Log3(vm, "Before printout starts:");
+      vm_print_link((const trace_log_t*)vm, &link_values);
+      Log3(vm, "Link values %i %i %i %i", link_values.command,
+              link_values.data1, link_values.data2, link_values.data3);
+      vm_print_current_domain_state(vm);
+      Log3(vm, "Before printout ends.");
+    }
+#endif
+
+    switch(link_values.command) {
+
+    case LinkNoLink:
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      return 0;  /* no actual jump */
+
+    case LinkTopC:
+      /* Restart playing from the beginning of the current Cell. */
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      link_values = play_Cell(vm);
+      break;
+
+    case LinkNextC:
+      /* Link to Next Cell */
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      vm->state.cellN += 1;
+      link_values = play_Cell(vm);
+      break;
+
+    case LinkPrevC:
+      /* Link to Previous Cell */
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      vassert(vm->state.cellN > 1);
+      vm->state.cellN -= 1;
+      link_values = play_Cell(vm);
+      break;
+
+    case LinkTopPG:
+      /* Link to Top of current Program */
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      link_values = play_PG(vm);
+      break;
+
+    case LinkNextPG:
+      /* Link to Next Program */
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      vm->state.pgN += 1;
+      link_values = play_PG(vm);
+      break;
+
+    case LinkPrevPG:
+      /* Link to Previous Program */
+      /* BUTTON number:data1 */
+      if ((1 == vm->state.pgN) || (0 != vm->state.pgc->pg_playback_mode)) {
+
+
+
+          goto do_LinkPrevPGC;
+      }
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      vassert(vm->state.pgN > 1);
+      vm->state.pgN -= 1;
+      link_values = play_PG(vm);
+      break;
+
+    case LinkTopPGC:
+      /* Restart playing from beginning of current Program Chain */
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      link_values = play_PGC(vm);
+      break;
+
+    case LinkNextPGC:
+      /* Link to Next Program Chain */
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      vassert(vm->state.pgc->next_pgc_nr != 0);
+      if(set_PGCN(vm, vm->state.pgc->next_pgc_nr))
+        link_values = play_PGC(vm);
+      else
+        link_values.command = Exit;
+      break;
+
+    case LinkPrevPGC:
+    do_LinkPrevPGC:
+      /* Link to Previous Program Chain */
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      vassert(vm->state.pgc->prev_pgc_nr != 0);
+      if(set_PGCN(vm, vm->state.pgc->prev_pgc_nr))
+        link_values = play_PGC(vm);
+      else
+        link_values.command = Exit;
+      break;
+
+    case LinkGoUpPGC:
+      /* Link to GoUp Program Chain */
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      vassert(vm->state.pgc->goup_pgc_nr != 0);
+      if(set_PGCN(vm, vm->state.pgc->goup_pgc_nr))
+        link_values = play_PGC(vm);
+      else
+        link_values.command = Exit;
+      break;
+
+    case LinkTailPGC:
+      /* Link to Tail of Program Chain */
+      /* BUTTON number:data1 */
+      if(link_values.data1 != 0)
+        vm->state.HL_BTNN_REG = link_values.data1 << 10;
+      link_values = play_PGC_post(vm);
+    break;
+
+    case LinkRSM:
+        /* Check and see if there is any rsm info!! */
+        if (!vm->state.rsm_vtsN) {
+          Log2(vm, "trying to resume without any resume info set");
+          link_values.command = Exit;
+          break;
+        }
+
+        vm->state.domain = DVD_DOMAIN_VTSTitle;
+        if (!ifoOpenNewVTSI(vm, vm->dvd, vm->state.rsm_vtsN))
+          vassert(0);
+        set_PGCN(vm, vm->state.rsm_pgcN);
+
+        /* These should never be set in SystemSpace and/or MenuSpace */
+        /* vm->state.TTN_REG = rsm_tt; ?? */
+        /* vm->state.TT_PGCN_REG = vm->state.rsm_pgcN; ?? */
+        int i;
+        for(i = 0; i < 5; i++) {
+          vm->state.registers.SPRM4 + i = vm->state.rsm_regsi;
+        }
+
+        if(link_values.data1 != 0)
+          vm->state.HL_BTNN_REG = link_values.data1 << 10;
+
+        if(vm->state.rsm_cellN == 0) {
+          vassert(vm->state.cellN); /*  Checking if this ever happens */
+          vm->state.pgN = 1;
+          link_values = play_PG(vm);
+        } else {
+          /* vm->state.pgN = ?? this gets the right value in set_PGN() below */
+          vm->state.cellN = vm->state.rsm_cellN;
+          link_values.command = PlayThis;
+          link_values.data1 = vm->state.rsm_blockN & 0xffff;
+          link_values.data2 = vm->state.rsm_blockN >> 16;
+          if(!set_PGN(vm,get_PGN(vm))) {
+            /* Were at the end of the PGC, should not happen for a RSM */
+            vassert(0);
+            link_values.command = LinkTailPGC;
+            link_values.data1 = 0;  /* No button */
+          }
+        }
+      break;
+
+    case LinkPGCN:
+      /* Link to Program Chain Number:data1 */
+      if(!set_PGCN(vm, link_values.data1))
+        vassert(0);
+      link_values = play_PGC(vm);
+      break;
+
+    case LinkPTTN:
+      /* Link to Part of current Title Number:data1 */
+      /* BUTTON number:data2 */
+      /* PGC Pre-Commands are not executed */
+      vassert(vm->state.domain == DVD_DOMAIN_VTSTitle);
+      if(link_values.data2 != 0)
+        vm->state.HL_BTNN_REG = link_values.data2 << 10;
+      if (!set_VTS_PTT(vm, vm->state.vtsN, vm->state.VTS_TTN_REG, link_values.data1)) {
+          link_values.command = Exit;
+      } else {
+
+
+          if ((vm->state).pgc->pg_playback_mode != 0) {
+              rand_next(&vm->state.rnd);
+              (vm->state).pgN_step = 0;
+              (vm->state).pgN = 1 + rand_shuffle(&vm->state.rnd, (vm->state).pgc->nr_of_programs, (vm->state).pgN_step);
+          }
+          link_values = play_PG(vm);
+      }
+      break;
+
+    case LinkPGN:
+      /* Link to Program Number:data1 */
+      /* BUTTON number:data2 */
+
+      if(link_values.data2 != 0)
+        vm->state.HL_BTNN_REG = link_values.data2 << 10;
+      /* Update any other state, PTTN perhaps? */
+      vm->state.pgN = link_values.data1;
+      link_values = play_PG(vm);
+      break;
+
+    case LinkCN:
+      /* Link to Cell Number:data1 */
+      /* BUTTON number:data2 */
+
+      if(link_values.data2 != 0)
+        vm->state.HL_BTNN_REG = link_values.data2 << 10;
+      /* Update any other state, pgN, PTTN perhaps? */
+      vm->state.cellN = link_values.data1;
+      link_values = play_Cell(vm);
+      break;
+
+    case Exit:
+      vm->stopped = 1;
+      return 0;
+
+    case JumpTT:
+      /* Jump to VTS Title Domain */
+      /* Only allowed from the First Play domain(PGC) */
+      /* or the Video Manager domain (VMG) */
+      /* Stop SPRM9 Timer */
+      /* Set SPRM1 and SPRM2 */
+      vassert(vm->state.domain == DVD_DOMAIN_VMGM || vm->state.domain == DVD_DOMAIN_FirstPlay); /* ?? */
+      if(set_TT(vm, link_values.data1))
+        link_values = play_PGC(vm);
+      else
+        link_values.command = Exit;
+      break;
+
+    case JumpVTS_TT:
+      /* Jump to Title:data1 in same VTS Title Domain */
+      /* Only allowed from the VTS Menu Domain(VTSM) */
+      /* or the Video Title Set Domain(VTS) */
+      /* Stop SPRM9 Timer */
+      /* Set SPRM1 and SPRM2 */
+      vassert(vm->state.domain == DVD_DOMAIN_VTSMenu || vm->state.domain == DVD_DOMAIN_VTSTitle); /* ?? */
+      if(!set_VTS_TT(vm, vm->state.vtsN, link_values.data1))
+        link_values.command = Exit;
+      else
+        link_values = play_PGC(vm);
+      break;
+
+    case JumpVTS_PTT:
+      /* Jump to Part:data2 of Title:data1 in same VTS Title Domain */
+      /* Only allowed from the VTS Menu Domain(VTSM) */
+      /* or the Video Title Set Domain(VTS) */
+      /* Stop SPRM9 Timer */
+      /* Set SPRM1 and SPRM2 */
+      vassert(vm->state.domain == DVD_DOMAIN_VTSMenu || vm->state.domain == DVD_DOMAIN_VTSTitle); /* ?? */
+      if(!set_VTS_PTT(vm, vm->state.vtsN, link_values.data1, link_values.data2))
+        link_values.command = Exit;
+      else
+        link_values = play_PGC_PG(vm, vm->state.pgN);
+      break;
+
+    case JumpSS_FP:
+      /* Jump to First Play Domain */
+      /* Only allowed from the VTS Menu Domain(VTSM) */
+      /* or the Video Manager domain (VMG) */
+      /* Stop SPRM9 Timer and any GPRM counters */
+      vassert(vm->state.domain == DVD_DOMAIN_VMGM || vm->state.domain == DVD_DOMAIN_VTSMenu); /* ?? */
+      if (!set_FP_PGC(vm))
+        vassert(0);
+      link_values = play_PGC(vm);
+      break;
+
+    case JumpSS_VMGM_MENU:
+      /* Jump to Video Manager domain - Title Menu:data1 or any PGC in VMG */
+      /* Allowed from anywhere except the VTS Title domain */
+      /* Stop SPRM9 Timer and any GPRM counters */
+      vassert(vm->state.domain != DVD_DOMAIN_VTSTitle); /* ?? */
+      if(vm->vmgi == NULL || vm->vmgi->pgci_ut == NULL) {
+        link_values.command = Exit;
+        break;
+      }
+      vm->state.domain = DVD_DOMAIN_VMGM;
+      if(!set_MENU(vm, link_values.data1))
+        vassert(0);
+      link_values = play_PGC(vm);
+      break;
+
+    case JumpSS_VTSM:
+      /* Jump to a menu in Video Title domain, */
+      /* or to a Menu is the current VTS */
+      /* Stop SPRM9 Timer and any GPRM counters */
+      /* ifoOpenNewVTSI:data1 */
+      /* VTS_TTN_REG:data2 */
+      /* get_MENU:data3 */
+      if(link_values.data1 != 0) {
+          vassert(vm->state.domain == DVD_DOMAIN_VTSMenu ||
+                  vm->state.domain == DVD_DOMAIN_VMGM || vm->state.domain == DVD_DOMAIN_FirstPlay); /* ?? */
+        if (link_values.data1 != vm->state.vtsN) {
+          /* the normal case */
+          vassert(vm->state.domain != DVD_DOMAIN_VTSMenu);
+          if (!ifoOpenNewVTSI(vm, vm->dvd, link_values.data1))  /* Also sets vm->state.vtsN */
+            vm->vtsi = NULL;
+        } else {
+          /* This happens on some discs like "Captain Scarlet & the Mysterons" or
+           * the German RC2 of "Anatomie" in VTSM. */
+        }
+
+        if(vm->vtsi == NULL || vm->vtsi->pgci_ut == NULL) {
+          link_values.command = Exit;
+          break;
+        }
+        vm->state.domain = DVD_DOMAIN_VTSMenu;
+      } else {
+        /*  This happens on 'The Fifth Element' region 2. */
+        vassert(vm->state.domain == DVD_DOMAIN_VTSMenu);
+      }
+      /*  I don't know what title is supposed to be used for. */
+      /*  Alien or Aliens has this != 1, I think. */
+      /* assert(link_values.data2 == 1); */
+      vm->state.VTS_TTN_REG = link_values.data2;
+      /* TTN_REG (SPRM4), VTS_TTN_REG (SPRM5), TT_PGCN_REG (SPRM6) are linked, */
+      /* so if one changes, the others must change to match it. */
+      vm->state.TTN_REG     = get_TT(vm, vm->state.vtsN, vm->state.VTS_TTN_REG);
+      if(!set_MENU(vm, link_values.data3))
+        vassert(0);
+      link_values = play_PGC(vm);
+      break;
+
+    case JumpSS_VMGM_PGC:
+      /* set_PGCN:data1 */
+      /* Stop SPRM9 Timer and any GPRM counters */
+      vassert(vm->state.domain != DVD_DOMAIN_VTSTitle); /* ?? */
+      if(vm->vmgi == NULL || vm->vmgi->pgci_ut == NULL) {
+        link_values.command = Exit;
+        break;
+      }
+      vm->state.domain = DVD_DOMAIN_VMGM;
+      if(!set_PGCN(vm, link_values.data1))
+        vassert(0);
+      link_values = play_PGC(vm);
+      break;
+
+    case CallSS_FP:
+      /* set_RSMinfo:data1 */
+      vassert(vm->state.domain == DVD_DOMAIN_VTSTitle); /* ?? */
+      /* Must be called before domain is changed */
+      set_RSMinfo(vm, link_values.data1, /* We dont have block info */ 0);
+      set_FP_PGC(vm);
+      link_values = play_PGC(vm);
+      break;
+
+    case CallSS_VMGM_MENU:
+      /* set_MENU:data1 */
+      /* set_RSMinfo:data2 */
+      vassert(vm->state.domain == DVD_DOMAIN_VTSTitle); /* ?? */
+      /* Must be called before domain is changed */
+      if(vm->vmgi == NULL || vm->vmgi->pgci_ut == NULL) {
+        link_values.command = Exit;
+        break;
+      }
+      set_RSMinfo(vm, link_values.data2, /* We dont have block info */ 0);
+      vm->state.domain = DVD_DOMAIN_VMGM;
+      if(!set_MENU(vm, link_values.data1))
+        vassert(0);
+      link_values = play_PGC(vm);
+      break;
+
+    case CallSS_VTSM:
+      /* set_MENU:data1 */
+      /* set_RSMinfo:data2 */
+      vassert(vm->state.domain == DVD_DOMAIN_VTSTitle); /* ?? */
+      /* Must be called before domain is changed */
+      if(vm->vtsi == NULL || vm->vtsi->pgci_ut == NULL) {
+        link_values.command = Exit;
+        break;
+      }
+      set_RSMinfo(vm, link_values.data2, /* We dont have block info */ 0);
+      vm->state.domain = DVD_DOMAIN_VTSMenu;
+      if(!set_MENU(vm, link_values.data1))
+        vassert(0);
+      link_values = play_PGC(vm);
+      break;
+
+    case CallSS_VMGM_PGC:
+      /* set_PGC:data1 */
+      /* set_RSMinfo:data2 */
+      vassert(vm->state.domain == DVD_DOMAIN_VTSTitle); /* ?? */
+      /* Must be called before domain is changed */
+      if(vm->vmgi == NULL || vm->vmgi->pgci_ut == NULL) {
+        link_values.command = Exit;
+        break;
+      }
+      set_RSMinfo(vm, link_values.data2, /* We dont have block info */ 0);
+      vm->state.domain = DVD_DOMAIN_VMGM;
+      if(!set_PGCN(vm, link_values.data1))
+        vassert(0);
+      link_values = play_PGC(vm);
+      break;
+
+    case PlayThis:
+      /* Should never happen. */
+      vassert(0);
+      break;
+    }
+
+#ifdef TRACE
+    Log3(vm, "After printout starts:");
+    vm_print_current_domain_state(vm);
+    Log3(vm, "After printout ends.");
+#endif
+
+  }
+
+  vm->state.blockN = link_values.data1 | (link_values.data2 << 16);
+  return 1;
+}
+
+//return the ifo_handle_t describing required title, used to
+//identify chapters
+ifo_handle_t *vm_get_title_ifo(vm_t *vm, uint32_t title)
+{
+  uint8_t titleset_nr;
+  if((title < 1) || (title > vm->vmgi->tt_srpt->nr_of_srpts))
+    return NULL;
+  titleset_nr = vm->vmgi->tt_srpt->titletitle-1.title_set_nr;
+  return ifoOpen(vm->dvd, titleset_nr);
+}
+
+void vm_ifo_close(ifo_handle_t *ifo)
+{
+  ifoClose(ifo);
+}

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/vm.h Added

@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2000, 2001 Håkan Hjort
+ * Copyright (C) 2001 Rich Wareham <richwareham@users.sourceforge.net>
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDNAV_VM_H
+#define LIBDVDNAV_VM_H
+
+/**
+ * State: SPRM, GPRM, Domain, pgc, pgN, cellN, ?
+ */
+typedef struct {
+  registers_t registers;
+
+  DVDDomain_t  domain;
+  int       vtsN;         /* 0 is vmgm? */
+  pgc_t    *pgc;          /* either this or 'int pgcN' is enough? */
+  int       pgcN;         /* but provide pgcN for quick lookup */
+  int       pgN;          /* is this needed? can allways fid pgN from cellN? */
+  int       pgN_step;
+  int       cellN;
+  int32_t   cell_restart; /* get cell to restart */
+  int       blockN;
+  uint32_t  rnd;          /* random state */
+
+  /* Resume info */
+  int      rsm_vtsN;
+  int      rsm_blockN;    /* of nav_packet */
+  uint16_t rsm_regs5;   /* system registers 4-8 */
+  int      rsm_pgcN;
+  int      rsm_cellN;
+} dvd_state_t;
+
+typedef struct vm_position_s {
+  int16_t  button;        /* Button highlighted */
+  int32_t  vts;           /* vts number to use */
+  DVDDomain_t domain;     /* domain to use */
+  int32_t  spu_channel;   /* spu channel to use */
+  int32_t  angle_channel; /* angle channel to use */
+  int32_t  audio_channel; /* audio channel to use */
+  int32_t  hop_channel;   /* channel hopping. E.g menu button pressed */
+#if 0
+  /* currently unused */
+  int32_t  title;         /* title number */
+  int32_t  chapter;       /* chapter number */
+#endif
+  int32_t  cell;          /* cell number */
+  int32_t  cell_restart;  /* get cell to restart */
+  int32_t  cell_start;    /* sector number of start of current cell in use */
+  int32_t  still;         /* is cell still */
+  int32_t  block;         /* block number within cell in use */
+} vm_position_t;
+
+typedef struct {
+  void *priv;
+  dvdnav_logger_cb logcb;
+  dvdnav_stream_cb streamcb;
+  dvd_reader_t *dvd;
+  dvd_reader_stream_cb dvdstreamcb;
+  ifo_handle_t *vmgi;
+  ifo_handle_t *vtsi;
+  dvd_state_t   state;
+  int32_t       hop_channel;
+#ifndef DVDNAV_NO_TXTDT
+  char          dvd_name50;
+  char          dvd_serial15;
+#endif
+  int           stopped;
+} vm_t;
+
+/* magic number for seeking hops */
+#define HOP_SEEK 0x1000
+
+
+/*  Audio stream number */
+#define AST_REG      registers.SPRM1
+/*  Subpicture stream number */
+#define SPST_REG     registers.SPRM2
+/*  Angle number */
+#define AGL_REG      registers.SPRM3
+/*  Title Track Number */
+#define TTN_REG      registers.SPRM4
+/*  VTS Title Track Number */
+#define VTS_TTN_REG  registers.SPRM5
+/*  PGC Number for this Title Track */
+#define TT_PGCN_REG  registers.SPRM6
+/*  Current Part of Title (PTT) number for (One_Sequential_PGC_Title) */
+#define PTTN_REG     registers.SPRM7
+/*  Highlighted Button Number (btn nr 1 == value 1024) */
+#define HL_BTNN_REG  registers.SPRM8
+/*  Parental Level */
+#define PTL_REG      registers.SPRM13
+
+/* Initialisation & destruction */
+vm_t *vm_new_vm(void *, const dvdnav_logger_cb *);
+void  vm_free_vm(vm_t *vm);
+
+/* IFO access */
+ifo_handle_t *vm_get_vmgi(vm_t *vm);
+ifo_handle_t *vm_get_vtsi(vm_t *vm);
+
+/* Reader Access */
+dvd_reader_t *vm_get_dvd_reader(vm_t *vm);
+
+/* Basic Handling */
+int  vm_start(vm_t *vm);
+void vm_stop(vm_t *vm);
+int  vm_reset(vm_t *vm, const char *dvdroot, void *priv,
+              dvdnav_stream_cb *stream_cb);
+
+/* copying and merging  - useful for try-running an operation */
+vm_t *vm_new_copy(vm_t *vm);
+void  vm_merge(vm_t *target, vm_t *source);
+void  vm_free_copy(vm_t *vm);
+
+/* regular playback */
+void vm_position_get(vm_t *vm, vm_position_t *position);
+void vm_get_next_cell(vm_t *vm);
+
+/* Jumping - all these return 1, if a hop has been performed */
+int vm_jump_pg(vm_t *vm, int pg);
+int vm_jump_cell_block(vm_t *vm, int cell, int block);
+int vm_jump_title_part(vm_t *vm, int title, int part);
+int vm_jump_title_program(vm_t *vm, int title, int pgcn, int pgn);
+int vm_jump_top_pg(vm_t *vm);
+int vm_jump_next_pg(vm_t *vm);
+int vm_jump_prev_pg(vm_t *vm);
+int vm_jump_up(vm_t *vm);
+int vm_jump_menu(vm_t *vm, DVDMenuID_t menuid);
+int vm_jump_resume(vm_t *vm);
+int vm_exec_cmd(vm_t *vm, vm_cmd_t *cmd);
+
+/* getting information */
+int vm_get_current_menu(vm_t *vm, int *menuid);
+int vm_get_current_title_part(vm_t *vm, int *title_result, int *part_result);
+int vm_get_audio_stream(vm_t *vm, int audioN);
+int vm_get_subp_stream(vm_t *vm, int subpN, int mode);
+int vm_get_audio_active_stream(vm_t *vm);
+int vm_get_subp_active_stream(vm_t *vm, int mode);
+void vm_get_angle_info(vm_t *vm, int *current, int *num_avail);
+#if 0
+/* currently unused */
+void vm_get_audio_info(vm_t *vm, int *current, int *num_avail);
+void vm_get_subp_info(vm_t *vm, int *current, int *num_avail);
+#endif
+void vm_get_video_res(vm_t *vm, int *width, int *height);
+int  vm_get_video_aspect(vm_t *vm);
+int  vm_get_video_scale_permission(vm_t *vm);
+video_attr_t vm_get_video_attr(vm_t *vm);
+audio_attr_t vm_get_audio_attr(vm_t *vm, int streamN);
+subp_attr_t  vm_get_subp_attr(vm_t *vm, int streamN);
+ifo_handle_t *vm_get_title_ifo(vm_t *vm, uint32_t title);
+void vm_ifo_close(ifo_handle_t *ifo);
+
+/* Uncomment for VM command tracing */
+/* #define TRACE */
+#ifdef TRACE
+/* Debug */
+void vm_position_print(vm_t *vm, vm_position_t *position);
+#endif
+
+int ifoOpenNewVTSI(vm_t *vm, dvd_reader_t *dvd, int vtsN);
+
+#endif /* LIBDVDNAV_VM_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/vmcmd.c Added

@@ -0,0 +1,549 @@
+/*
+ * Copyright (C) 2000, 2001 Martin Norbäck, Håkan Hjort
+ *               2002-2004 the dvdnav project
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+#include <inttypes.h>
+#include <limits.h>
+
+#include "dvdnav/dvdnav.h"
+#include <dvdread/nav_types.h>
+#include <dvdread/ifo_types.h>
+#include "decoder.h"
+#include "vm.h"
+#include "vmcmd.h"
+#include "../dvdnav_internal.h"
+
+/*  freebsd compatibility */
+#ifndef PRIu8
+#define PRIu8 "d"
+#endif
+
+/*  freebsd compatibility */
+#ifndef PRIu16
+#define PRIu16 "d"
+#endif
+
+static const char cmp_op_table4 = {
+  "", "&", "==", "!=", ">=", ">", "<=", "<"
+};
+static const char set_op_table4 = {
+  "", "=", "<->", "+=", "-=", "*=", "/=", "%=", "rnd", "&=", "|=", "^="
+};
+
+static const char link_table16 = {
+  "LinkNoLink",  "LinkTopC",    "LinkNextC",   "LinkPrevC",
+  "",            "LinkTopPG",   "LinkNextPG",  "LinkPrevPG",
+  "",            "LinkTopPGC",  "LinkNextPGC", "LinkPrevPGC",
+  "LinkGoUpPGC", "LinkTailPGC", "",            "",
+  "RSM"
+};
+
+static const char *const system_reg_table = {
+  "Menu Description Language Code",
+  "Audio Stream Number",
+  "Sub-picture Stream Number",
+  "Angle Number",
+  "Title Track Number",
+  "VTS Title Track Number",
+  "VTS PGC Number",
+  "PTT Number for One_Sequential_PGC_Title",
+  "Highlighted Button Number",
+  "Navigation Timer",
+  "Title PGC Number for Navigation Timer",
+  "Audio Mixing Mode for Karaoke",
+  "Country Code for Parental Management",
+  "Parental Level",
+  "Player Configurations for Video",
+  "Player Configurations for Audio",
+  "Initial Language Code for Audio",
+  "Initial Language Code Extension for Audio",
+  "Initial Language Code for Sub-picture",
+  "Initial Language Code Extension for Sub-picture",
+  "Player Regional Code",
+  "Reserved 21",
+  "Reserved 22",
+  "Reserved 23"
+};
+
+static const char system_reg_abbr_table8 = {
+  "",
+  "ASTN",
+  "SPSTN",
+  "AGLN",
+  "TTN",
+  "VTS_TTN",
+  "TT_PGCN",
+  "PTTN",
+  "HL_BTNN",
+  "NVTMR",
+  "NV_PGCN",
+  "",
+  "CC_PLT",
+  "PLT",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+  "",
+};
+
+// GPL is cancer
+#undef MSG_OUT
+#undef fprintf
+#define fprintf vm_debug_print
+#define MSG_OUT log
+
+static void print_system_reg(const trace_log_t* log, uint16_t reg) {
+  if(reg < sizeof(system_reg_abbr_table) / sizeof(system_reg_abbr_table0))
+    fprintf(MSG_OUT, "%s (SRPM:%d)", system_reg_tablereg, reg);
+  else
+    fprintf(MSG_OUT, " WARNING: Unknown system register ( reg=%d ) ", reg);
+}
+
+static void print_g_reg(const trace_log_t* log, uint8_t reg) {
+    if(reg < 16)
+      fprintf(MSG_OUT, "g%" PRIu8 "", reg);
+    else
+      fprintf(MSG_OUT, " WARNING: Unknown general register ");
+}
+
+static void print_reg(const trace_log_t* log, uint8_t reg) {
+  if(reg & 0x80)
+    print_system_reg(log, reg & 0x7f);
+  else
+    print_g_reg(log, reg & 0x7f);
+}
+
+static void print_cmp_op(const trace_log_t* log, uint8_t op) {
+  if(op < sizeof(cmp_op_table) / sizeof(cmp_op_table0))
+    fprintf(MSG_OUT, " %s ", cmp_op_tableop);
+  else
+    fprintf(MSG_OUT, " WARNING: Unknown compare op ");
+}
+
+static void print_set_op(const trace_log_t* log, uint8_t op) {
+  if(op < sizeof(set_op_table) / sizeof(cmp_op_table0))
+    fprintf(MSG_OUT, " %s ", set_op_tableop);
+  else
+    fprintf(MSG_OUT, " WARNING: Unknown set op ");
+}
+
+static void print_reg_or_data(const trace_log_t* log, command_t* command, int immediate, int start) {
+  if(immediate) {
+    uint32_t i = vm_getbits(command, start, 16);
+
+    fprintf(MSG_OUT, "0x%x", i);
+    if(isprint(i & 0xff) && isprint((i>>8) & 0xff))
+      fprintf(MSG_OUT, " (\"%c%c\")", (char)((i>>8) & 0xff), (char)(i & 0xff));
+  } else {
+    print_reg(log, vm_getbits(command, start - 8, 8));
+  }
+}
+
+static void print_reg_or_data_2(const trace_log_t* log, command_t* command, int immediate, int start) {
+  if(immediate)
+    fprintf(MSG_OUT, "0x%x", vm_getbits(command, start - 1, 7));
+  else
+    fprintf(MSG_OUT, "g%" PRIu8 "", vm_getbits(command, start - 4, 4));
+}
+
+static void print_reg_or_data_3(const trace_log_t* log, command_t* command, int immediate, int start) {
+  if(immediate) {
+    uint32_t i = vm_getbits(command, start, 16);
+
+    fprintf(MSG_OUT, "0x%x", i);
+    if(isprint(i & 0xff) && isprint((i>>8) & 0xff))
+      fprintf(MSG_OUT, " (\"%c%c\")", (char)((i>>8) & 0xff), (char)(i & 0xff));
+  } else {
+    print_reg(log, vm_getbits(command, start, 8));
+  }
+}
+
+
+static void print_if_version_1(const trace_log_t* log, command_t* command) {
+  uint8_t op = vm_getbits(command, 54, 3);
+
+  if(op) {
+    fprintf(MSG_OUT, "if (");
+    print_g_reg(log, vm_getbits(command,39,8));
+    print_cmp_op(log, op);
+    print_reg_or_data(log, command, vm_getbits(command, 55,1), 31);
+    fprintf(MSG_OUT, ") ");
+  }
+}
+
+static void print_if_version_2(const trace_log_t* log, command_t* command) {
+  uint8_t op = vm_getbits(command, 54, 3);
+
+  if(op) {
+    fprintf(MSG_OUT, "if (");
+    print_reg(log, vm_getbits(command, 15, 8));
+    print_cmp_op(log, op);
+    print_reg(log, vm_getbits(command, 7, 8));
+    fprintf(MSG_OUT, ") ");
+  }
+}
+
+static void print_if_version_3(const trace_log_t* log, command_t* command) {
+  uint8_t op = vm_getbits(command, 54, 3);
+
+  if(op) {
+    fprintf(MSG_OUT, "if (");
+    print_g_reg(log, vm_getbits(command, 43, 4));
+    print_cmp_op(log, op);
+    print_reg_or_data(log, command, vm_getbits(command, 55, 1), 15);
+    fprintf(MSG_OUT, ") ");
+  }
+}
+
+static void print_if_version_4(const trace_log_t* log, command_t* command) {
+  uint8_t op = vm_getbits(command, 54, 3);
+
+  if(op) {
+    fprintf(MSG_OUT, "if (");
+    print_g_reg(log, vm_getbits(command, 51, 4));
+    print_cmp_op(log, op);
+    print_reg_or_data(log, command, vm_getbits(command, 55, 1), 31);
+    fprintf(MSG_OUT, ") ");
+  }
+}
+
+static void print_if_version_5(const trace_log_t* log, command_t* command) {
+  uint8_t op = vm_getbits(command, 54, 3);
+  int set_immediate = vm_getbits(command, 60, 1);
+
+  if(op) {
+    if (set_immediate) {
+      fprintf(MSG_OUT, "if (");
+      print_g_reg(log, vm_getbits(command, 31, 8));
+      print_cmp_op(log, op);
+      print_reg(log, vm_getbits(command, 23, 8));
+      fprintf(MSG_OUT, ") ");
+    } else {
+      fprintf(MSG_OUT, "if (");
+      print_g_reg(log, vm_getbits(command, 39, 8));
+      print_cmp_op(log, op);
+      print_reg_or_data(log, command, vm_getbits(command, 55, 1), 31);
+      fprintf(MSG_OUT, ") ");
+    }
+  }
+}
+
+static void print_special_instruction(const trace_log_t* log, command_t* command) {
+  uint8_t op = vm_getbits(command, 51, 4);
+
+  switch(op) {
+    case 0: /*  NOP */
+      fprintf(MSG_OUT, "Nop");
+      break;
+    case 1: /*  Goto line */
+      fprintf(MSG_OUT, "Goto %" PRIu8, vm_getbits(command, 7, 8));
+      break;
+    case 2: /*  Break */
+      fprintf(MSG_OUT, "Break");
+      break;
+    case 3: /*  Parental level */
+      fprintf(MSG_OUT, "SetTmpPML %" PRIu8 ", Goto %" PRIu8,
+              vm_getbits(command, 11, 4), vm_getbits(command, 7, 8));
+      break;
+    default:
+      fprintf(MSG_OUT, "WARNING: Unknown special instruction (%i)",
+              vm_getbits(command, 51, 4));
+  }
+}
+
+static void print_linksub_instruction(const trace_log_t* log, command_t* command) {
+  uint32_t linkop = vm_getbits(command, 7, 8);
+  uint32_t button = vm_getbits(command, 15, 6);
+
+  if(linkop < sizeof(link_table)/sizeof(link_table0))
+    fprintf(MSG_OUT, "%s (button %" PRIu8 ")", link_tablelinkop, button);
+  else
+    fprintf(MSG_OUT, "WARNING: Unknown linksub instruction (%i)", linkop);
+}
+
+static void print_link_instruction(const trace_log_t* log, command_t* command, int optional) {
+  uint8_t op = vm_getbits(command, 51, 4);
+
+  if(optional && op)
+    fprintf(MSG_OUT, ", ");
+
+  switch(op) {
+    case 0:
+      if(!optional)
+      fprintf(MSG_OUT, "WARNING: NOP (link)!");
+      break;
+    case 1:
+      print_linksub_instruction(log, command);
+      break;
+    case 4:
+      fprintf(MSG_OUT, "LinkPGCN %" PRIu16, vm_getbits(command, 14, 15));
+      break;
+    case 5:
+      fprintf(MSG_OUT, "LinkPTT %" PRIu16 " (button %" PRIu8 ")",
+              vm_getbits(command, 9, 10), vm_getbits(command, 15, 6));
+      break;
+    case 6:
+      fprintf(MSG_OUT, "LinkPGN %" PRIu8 " (button %" PRIu8 ")",
+              vm_getbits(command, 6, 7), vm_getbits(command, 15, 6));
+      break;
+    case 7:
+      fprintf(MSG_OUT, "LinkCN %" PRIu8 " (button %" PRIu8 ")",
+              vm_getbits(command, 7, 8), vm_getbits(command, 15, 6));
+      break;
+    default:
+      fprintf(MSG_OUT, "WARNING: Unknown link instruction");
+  }
+}
+
+static void print_jump_instruction(const trace_log_t* log, command_t* command) {
+  switch(vm_getbits(command, 51, 4)) {
+    case 1:
+      fprintf(MSG_OUT, "Exit");
+      break;
+    case 2:
+      fprintf(MSG_OUT, "JumpTT %" PRIu8, vm_getbits(command, 22, 7));
+      break;
+    case 3:
+      fprintf(MSG_OUT, "JumpVTS_TT %" PRIu8, vm_getbits(command, 22, 7));
+      break;
+    case 5:
+      fprintf(MSG_OUT, "JumpVTS_PTT %" PRIu8 ":%" PRIu16,
+              vm_getbits(command, 22, 7), vm_getbits(command, 41, 10));
+      break;
+    case 6:
+      switch(vm_getbits(command, 23, 2)) {
+        case 0:
+          fprintf(MSG_OUT, "JumpSS FP");
+          break;
+        case 1:
+          fprintf(MSG_OUT, "JumpSS VMGM (menu %" PRIu8 ")", vm_getbits(command, 19, 4));
+          break;
+        case 2:
+          fprintf(MSG_OUT, "JumpSS VTSM (vts %" PRIu8 ", title %" PRIu8
+                  ", menu %" PRIu8 ")", vm_getbits(command, 30, 7), vm_getbits(command, 38, 7), vm_getbits(command, 19, 4));
+          break;
+        case 3:
+          fprintf(MSG_OUT, "JumpSS VMGM (pgc %" PRIu8 ")", vm_getbits(command, 46, 15));
+          break;
+        }
+      break;
+    case 8:
+      switch(vm_getbits(command, 23, 2)) {
+        case 0:
+          fprintf(MSG_OUT, "CallSS FP (rsm_cell %" PRIu8 ")",
+              vm_getbits(command, 31, 8));
+          break;
+        case 1:
+          fprintf(MSG_OUT, "CallSS VMGM (menu %" PRIu8
+                  ", rsm_cell %" PRIu8 ")", vm_getbits(command, 19, 4), vm_getbits(command, 31, 8));
+          break;
+        case 2:
+          fprintf(MSG_OUT, "CallSS VTSM (menu %" PRIu8
+                  ", rsm_cell %" PRIu8 ")", vm_getbits(command, 19, 4), vm_getbits(command, 31, 8));
+          break;
+        case 3:
+          fprintf(MSG_OUT, "CallSS VMGM (pgc %" PRIu8 ", rsm_cell %" PRIu8 ")",
+                  vm_getbits(command, 46, 15), vm_getbits(command, 31, 8));
+          break;
+      }
+      break;
+    default:
+      fprintf(MSG_OUT, "WARNING: Unknown Jump/Call instruction");
+  }
+}
+
+static void print_system_set(const trace_log_t* log, command_t* command) {
+  int i;
+/* FIXME: What about SPRM11 ? Karaoke */
+/*        Surely there must be some system set command for that ? */
+
+  switch(vm_getbits(command, 59, 4)) {
+    case 1: /*  Set system reg 1 &| 2 &| 3 (Audio, Subp. Angle) */
+      for(i = 1; i <= 3; i++) {
+        if(vm_getbits(command, 47 - (i*8), 1)) {
+          print_system_reg(log, i);
+          fprintf(MSG_OUT, " = ");
+          print_reg_or_data_2(log, command, vm_getbits(command, 60, 1), 47 - (i*8) );
+          fprintf(MSG_OUT, " ");
+        }
+      }
+      break;
+    case 2: /*  Set system reg 9 & 10 (Navigation timer, Title PGC number) */
+      print_system_reg(log, 9);
+      fprintf(MSG_OUT, " = ");
+      print_reg_or_data(log, command, vm_getbits(command, 60, 1), 47);
+      fprintf(MSG_OUT, " ");
+      print_system_reg(log, 10);
+      fprintf(MSG_OUT, " = %" PRIu16, vm_getbits(command, 30, 15)); /*  ?? */
+      break;
+    case 3: /*  Mode: Counter / Register + Set */
+      fprintf(MSG_OUT, "SetMode ");
+      if(vm_getbits(command, 23, 1))
+        fprintf(MSG_OUT, "Counter ");
+      else
+        fprintf(MSG_OUT, "Register ");
+      print_g_reg(log, vm_getbits(command, 19, 4));
+      print_set_op(log, 0x1); /*  '=' */
+      print_reg_or_data(log, command, vm_getbits(command, 60, 1), 47);
+      break;
+    case 6: /*  Set system reg 8 (Highlighted button) */
+      print_system_reg(log, 8);
+      if(vm_getbits(command, 60, 1)) /*  immediate */
+        fprintf(MSG_OUT, " = 0x%x (button no %d)", vm_getbits(command, 31, 16), vm_getbits(command, 31, 6));
+      else
+        fprintf(MSG_OUT, " = g%" PRIu8 "", vm_getbits(command, 19, 4));
+      break;
+    default:
+      fprintf(MSG_OUT, "WARNING: Unknown system set instruction (%i)",
+              vm_getbits(command, 59, 4));
+  }
+}
+
+static void print_set_version_1(const trace_log_t* log, command_t* command) {
+  uint8_t set_op = vm_getbits(command, 59, 4);
+
+  if(set_op) {
+    print_g_reg(log, vm_getbits(command, 35, 4));
+    print_set_op(log, set_op);
+    print_reg_or_data(log, command, vm_getbits(command, 60, 1), 31);
+  } else {
+    fprintf(MSG_OUT, "NOP");
+  }
+}
+
+static void print_set_version_2(const trace_log_t* log, command_t* command) {
+  uint8_t set_op = vm_getbits(command, 59, 4);
+
+  if(set_op) {
+    print_g_reg(log, vm_getbits(command, 51, 4));
+    print_set_op(log, set_op);
+    print_reg_or_data(log, command, vm_getbits(command, 60, 1), 47);
+  } else {
+    fprintf(MSG_OUT, "NOP");
+  }
+}
+
+static void print_set_version_3(const trace_log_t* log, command_t* command) {
+  uint8_t set_op = vm_getbits(command, 59, 4);
+
+  if(set_op) {
+    print_g_reg(log, vm_getbits(command, 51, 4));
+    print_set_op(log, set_op);
+    print_reg_or_data_3(log, command, vm_getbits(command, 60, 1), 47);
+  } else {
+    fprintf(MSG_OUT, "NOP");
+  }
+}
+
+
+void vm_print_mnemonic(const trace_log_t* log, vm_cmd_t *vm_command)  {
+  command_t command;
+  command.instruction =( (uint64_t) vm_command->bytes0 << 56 ) |
+        ( (uint64_t) vm_command->bytes1 << 48 ) |
+        ( (uint64_t) vm_command->bytes2 << 40 ) |
+        ( (uint64_t) vm_command->bytes3 << 32 ) |
+        ( (uint64_t) vm_command->bytes4 << 24 ) |
+        ( (uint64_t) vm_command->bytes5 << 16 ) |
+        ( (uint64_t) vm_command->bytes6 <<  8 ) |
+          (uint64_t) vm_command->bytes7 ;
+  command.examined = 0;
+
+  switch(vm_getbits(&command,63,3)) { /* three first bits */
+    case 0: /*  Special instructions */
+      print_if_version_1(log, &command);
+      print_special_instruction(log, &command);
+      break;
+    case 1: /*  Jump/Call or Link instructions */
+      if(vm_getbits(&command,60,1)) {
+        print_if_version_2(log, &command);
+        print_jump_instruction(log, &command);
+      } else {
+        print_if_version_1(log, &command);
+        print_link_instruction(log, &command, 0); /*  must be pressent */
+      }
+      break;
+    case 2: /*  Set System Parameters instructions */
+      print_if_version_2(log, &command);
+      print_system_set(log, &command);
+      print_link_instruction(log, &command, 1); /*  either 'if' or 'link' */
+      break;
+    case 3: /*  Set General Parameters instructions */
+      print_if_version_3(log, &command);
+      print_set_version_1(log, &command);
+      print_link_instruction(log, &command, 1); /*  either 'if' or 'link' */
+      break;
+    case 4: /*  Set, Compare -> LinkSub instructions */
+      print_set_version_2(log, &command);
+      fprintf(MSG_OUT, ", ");
+      print_if_version_4(log, &command);
+      print_linksub_instruction(log, &command);
+      break;
+    case 5: /*  Compare -> (Set and LinkSub) instructions */
+      print_if_version_5(log, &command);
+      fprintf(MSG_OUT, "{ ");
+      print_set_version_3(log, &command);
+      fprintf(MSG_OUT, ", ");
+      print_linksub_instruction(log, &command);
+      fprintf(MSG_OUT, " }");
+      break;
+    case 6: /*  Compare -> Set, always LinkSub instructions */
+      print_if_version_5(log, &command);
+      fprintf(MSG_OUT, "{ ");
+      print_set_version_3(log, &command);
+      fprintf(MSG_OUT, " } ");
+      print_linksub_instruction(log, &command);
+      break;
+    default:
+      fprintf(MSG_OUT, "WARNING: Unknown instruction type (%i)", vm_getbits(&command, 63, 3));
+  }
+  /*  Check if there still are bits set that were not examined */
+
+  if(command.instruction & ~ command.examined) {
+    fprintf(MSG_OUT, " libdvdnav: vmcmd.c: WARNING, unknown bits:");
+    fprintf(MSG_OUT, " %08"PRIx64, (command.instruction & ~ command.examined) );
+    fprintf(MSG_OUT, "");
+  }
+}
+
+void vm_print_cmd(const trace_log_t* log, int row, vm_cmd_t *vm_command) {
+  int i;
+
+  fprintf(MSG_OUT, "(%03d) ", row + 1);
+  for(i = 0; i < 8; i++)
+    fprintf(MSG_OUT, "%02x ", vm_command->bytesi);
+  fprintf(MSG_OUT, "| ");
+
+  vm_print_mnemonic(log, vm_command);
+  fprintf(MSG_OUT, "\n");
+}
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/vmcmd.h Added

@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2000, 2001 Martin Norbäck, Håkan Hjort
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDNAV_VMCMD_H
+#define LIBDVDNAV_VMCMD_H
+
+void vm_print_mnemonic(const trace_log_t* log,vm_cmd_t *command);
+void vm_print_cmd(const trace_log_t* log, int row, vm_cmd_t *command);
+
+#endif /* LIBDVDNAV_VMCMD_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnav/vm/vmget.c Added

@@ -0,0 +1,353 @@
+/*
+ * Copyright (C) 2000, 2001 Håkan Hjort
+ * Copyright (C) 2001 Rich Wareham <richwareham@users.sourceforge.net>
+ *               2002-2004 the dvdnav project
+ *
+ * This file is part of libdvdnav, a DVD navigation library. It is modified
+ * from a file originally part of the Ogle DVD player.
+ *
+ * libdvdnav 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.
+ *
+ * libdvdnav 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 libdvdnav; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <dvdread/nav_types.h>
+#include <dvdread/ifo_types.h>
+#include <dvdread/ifo_read.h>
+#include "dvdnav/dvdnav.h"
+
+#include "decoder.h"
+#include "vm.h"
+#include "getset.h"
+#include "../dvdnav_internal.h"
+#include "../logger.h"
+
+/* getting information */
+
+int vm_get_current_menu(vm_t *vm, int *menuid) {
+  pgcit_t* pgcit;
+  int pgcn;
+  pgcn = (vm->state).pgcN;
+  pgcit = get_PGCIT(vm);
+  if(pgcit==NULL) return 0;
+  *menuid = pgcit->pgci_srppgcn - 1.entry_id & 0xf ;
+  return 1;
+}
+
+int vm_get_current_title_part(vm_t *vm, int *title_result, int *part_result) {
+  vts_ptt_srpt_t *vts_ptt_srpt;
+  int title, part = 0, vts_ttn;
+  int found;
+  int16_t pgcN, pgN;
+
+  vts_ptt_srpt = vm->vtsi->vts_ptt_srpt;
+  pgcN = get_PGCN(vm);
+  pgN = vm->state.pgN;
+
+  found = 0;
+  for (vts_ttn = 0; (vts_ttn < vts_ptt_srpt->nr_of_srpts) && !found; vts_ttn++) {
+    for (part = 0; (part < vts_ptt_srpt->titlevts_ttn.nr_of_ptts) && !found; part++) {
+      if (vts_ptt_srpt->titlevts_ttn.pttpart.pgcn == pgcN) {
+        if (vts_ptt_srpt->titlevts_ttn.pttpart.pgn  == pgN) {
+          found = 1;
+          break;
+        }
+        if (part > 0 && vts_ptt_srpt->titlevts_ttn.pttpart.pgn > pgN &&
+            vts_ptt_srpt->titlevts_ttn.pttpart - 1.pgn < pgN) {
+          part--;
+          found = 1;
+          break;
+        }
+      }
+    }
+    if (found) break;
+  }
+  vts_ttn++;
+  part++;
+
+  if (!found) {
+    Log1(vm, "chapter NOT FOUND!");
+    return 0;
+  }
+
+  title = get_TT(vm, vm->state.vtsN, vts_ttn);
+
+#ifdef TRACE
+  if (title) {
+    Log3(vm, "************ this chapter FOUND!");
+    Log3(vm, "VTS_PTT_SRPT - Title %3i part %3i: PGC: %3i PG: %3i",
+             title, part,
+             vts_ptt_srpt->titlevts_ttn-1.pttpart-1.pgcn ,
+             vts_ptt_srpt->titlevts_ttn-1.pttpart-1.pgn );
+  }
+#endif
+  *title_result = title;
+  *part_result = part;
+  return 1;
+}
+
+/* Return the substream id for 'logical' audio stream audioN.
+ * 0 <= audioN < 8
+ */
+int vm_get_audio_stream(vm_t *vm, int audioN) {
+  int streamN = -1;
+
+  if((vm->state).domain != DVD_DOMAIN_VTSTitle)
+    audioN = 0;
+
+  if(audioN < 8) {
+    /* Is there any control info for this logical stream */
+    if((vm->state).pgc->audio_controlaudioN & (1<<15)) {
+      streamN = ((vm->state).pgc->audio_controlaudioN >> 8) & 0x07;
+    }
+  }
+
+  if((vm->state).domain != DVD_DOMAIN_VTSTitle && streamN == -1)
+    streamN = 0;
+
+  /* FIXME: Should also check in vtsi/vmgi status what kind of stream
+   * it is (ac3/lpcm/dts/sdds...) to find the right (sub)stream id */
+  return streamN;
+}
+
+/* Return the substream id for 'logical' subpicture stream subpN and given mode.
+ * 0 <= subpN < 32
+ * mode == 0 - widescreen
+ * mode == 1 - letterbox
+ * mode == 2 - pan&scan
+ */
+int vm_get_subp_stream(vm_t *vm, int subpN, int mode) {
+  int streamN = -1;
+  int source_aspect = vm_get_video_aspect(vm);
+
+  if((vm->state).domain != DVD_DOMAIN_VTSTitle)
+    subpN = 0;
+
+  if(subpN < 32) { /* a valid logical stream */
+    /* Is this logical stream present */
+    if((vm->state).pgc->subp_controlsubpN & (1<<31)) {
+      if(source_aspect == 0) /* 4:3 */
+        streamN = ((vm->state).pgc->subp_controlsubpN >> 24) & 0x1f;
+      if(source_aspect == 3) /* 16:9 */
+        switch (mode) {
+        case 0:
+          streamN = ((vm->state).pgc->subp_controlsubpN >> 16) & 0x1f;
+          break;
+        case 1:
+          streamN = ((vm->state).pgc->subp_controlsubpN >> 8) & 0x1f;
+          break;
+        case 2:
+          streamN = (vm->state).pgc->subp_controlsubpN & 0x1f;
+        }
+    }
+  }
+
+  if((vm->state).domain != DVD_DOMAIN_VTSTitle && streamN == -1)
+    streamN = 0;
+
+  /* FIXME: Should also check in vtsi/vmgi status what kind of stream it is. */
+  return streamN;
+}
+
+int vm_get_audio_active_stream(vm_t *vm) {
+  int audioN;
+  int streamN;
+  audioN = (vm->state).AST_REG ;
+  streamN = vm_get_audio_stream(vm, audioN);
+
+  /* If no such stream, then select the first one that exists. */
+  if(streamN == -1) {
+    for(audioN = 0; audioN < 8; audioN++) {
+      if((vm->state).pgc->audio_controlaudioN & (1<<15)) {
+        if ((streamN = vm_get_audio_stream(vm, audioN)) >= 0)
+          break;
+      }
+    }
+  }
+
+  return streamN;
+}
+
+int vm_get_subp_active_stream(vm_t *vm, int mode) {
+  int subpN;
+  int streamN;
+  subpN = (vm->state).SPST_REG & ~0x40;
+  streamN = vm_get_subp_stream(vm, subpN, mode);
+
+  /* If no such stream, then select the first one that exists. */
+  if(streamN == -1) {
+    for(subpN = 0; subpN < 32; subpN++) {
+      if((vm->state).pgc->subp_controlsubpN & (1<<31)) {
+        if ((streamN = vm_get_subp_stream(vm, subpN, mode)) >= 0)
+          break;
+      }
+    }
+  }
+
+  if((vm->state).domain == DVD_DOMAIN_VTSTitle && !((vm->state).SPST_REG & 0x40))
+    /* Bit 7 set means hide, and only let Forced display show */
+    return (streamN | 0x80);
+  else
+    return streamN;
+}
+
+void vm_get_angle_info(vm_t *vm, int *current, int *num_avail) {
+  *num_avail = 1;
+  *current = 1;
+
+  if((vm->state).domain == DVD_DOMAIN_VTSTitle) {
+    title_info_t *title;
+    /* TTN_REG does not allways point to the correct title.. */
+    if((vm->state).TTN_REG > vm->vmgi->tt_srpt->nr_of_srpts)
+      return;
+    title = &vm->vmgi->tt_srpt->title(vm->state).TTN_REG - 1;
+    if(title->title_set_nr != (vm->state).vtsN ||
+       title->vts_ttn != (vm->state).VTS_TTN_REG)
+      return;
+    *num_avail = title->nr_of_angles;
+    *current = (vm->state).AGL_REG;
+  }
+}
+
+#if 0
+/* currently unused */
+void vm_get_audio_info(vm_t *vm, int *current, int *num_avail) {
+  switch ((vm->state).domain) {
+  case DVD_DOMAIN_VTSTitle:
+    *num_avail = vm->vtsi->vtsi_mat->nr_of_vts_audio_streams;
+    *current = (vm->state).AST_REG;
+    break;
+  case DVD_DOMAIN_VTSMenu:
+    *num_avail = vm->vtsi->vtsi_mat->nr_of_vtsm_audio_streams; /*  1 */
+    *current = 1;
+    break;
+  case DVD_DOMAIN_VMGM:
+  case DVD_DOMAIN_FirstPlay:
+    *num_avail = vm->vmgi->vmgi_mat->nr_of_vmgm_audio_streams; /*  1 */
+    *current = 1;
+    break;
+  }
+}
+
+/* currently unused */
+void vm_get_subp_info(vm_t *vm, int *current, int *num_avail) {
+  switch ((vm->state).domain) {
+  case DVD_DOMAIN_VTSTitle:
+    *num_avail = vm->vtsi->vtsi_mat->nr_of_vts_subp_streams;
+    *current = (vm->state).SPST_REG;
+    break;
+  case DVD_DOMAIN_VTSMenu:
+    *num_avail = vm->vtsi->vtsi_mat->nr_of_vtsm_subp_streams; /*  1 */
+    *current = 0x41;
+    break;
+  case DVD_DOMAIN_VMGM:
+  case DVD_DOMAIN_FirstPlay:
+    *num_avail = vm->vmgi->vmgi_mat->nr_of_vmgm_subp_streams; /*  1 */
+    *current = 0x41;
+    break;
+  }
+}
+#endif
+
+void vm_get_video_res(vm_t *vm, int *width, int *height) {
+  video_attr_t attr = vm_get_video_attr(vm);
+
+  if(attr.video_format != 0)
+    *height = 576;
+  else
+    *height = 480;
+  switch(attr.picture_size) {
+  case 0:
+    *width = 720;
+    break;
+  case 1:
+    *width = 704;
+    break;
+  case 2:
+    *width = 352;
+    break;
+  case 3:
+    *width = 352;
+    *height /= 2;
+    break;
+  }
+}
+
+int vm_get_video_aspect(vm_t *vm) {
+  int aspect = vm_get_video_attr(vm).display_aspect_ratio;
+
+  if(aspect != 0 && aspect != 3) {
+    Log1(vm, "display aspect ratio is unexpected: %d!", aspect);
+    return -1;
+  }
+
+  (vm->state).registers.SPRM14 &= ~(0x3 << 10);
+  (vm->state).registers.SPRM14 |= aspect << 10;
+
+  return aspect;
+}
+
+int vm_get_video_scale_permission(vm_t *vm) {
+  return vm_get_video_attr(vm).permitted_df;
+}
+
+video_attr_t vm_get_video_attr(vm_t *vm) {
+  switch ((vm->state).domain) {
+  case DVD_DOMAIN_VTSTitle:
+    return vm->vtsi->vtsi_mat->vts_video_attr;
+  case DVD_DOMAIN_VTSMenu:
+    return vm->vtsi->vtsi_mat->vtsm_video_attr;
+  case DVD_DOMAIN_VMGM:
+  case DVD_DOMAIN_FirstPlay:
+    return vm->vmgi->vmgi_mat->vmgm_video_attr;
+  default:
+    vassert(0);
+  }
+}
+
+audio_attr_t vm_get_audio_attr(vm_t *vm, int streamN) {
+  switch ((vm->state).domain) {
+  case DVD_DOMAIN_VTSTitle:
+    return vm->vtsi->vtsi_mat->vts_audio_attrstreamN;
+  case DVD_DOMAIN_VTSMenu:
+    return vm->vtsi->vtsi_mat->vtsm_audio_attr;
+  case DVD_DOMAIN_VMGM:
+  case DVD_DOMAIN_FirstPlay:
+    return vm->vmgi->vmgi_mat->vmgm_audio_attr;
+  default:
+    vassert(0);
+  }
+}
+
+subp_attr_t vm_get_subp_attr(vm_t *vm, int streamN) {
+  switch ((vm->state).domain) {
+  case DVD_DOMAIN_VTSTitle:
+    return vm->vtsi->vtsi_mat->vts_subp_attrstreamN;
+  case DVD_DOMAIN_VTSMenu:
+    return vm->vtsi->vtsi_mat->vtsm_subp_attr;
+  case DVD_DOMAIN_VMGM:
+  case DVD_DOMAIN_FirstPlay:
+    return vm->vmgi->vmgi_mat->vmgm_subp_attr;
+  default:
+    vassert(0);
+  }
+}

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdnavsrv.cpp Added

@@ -0,0 +1,346 @@
+/*
+    GPL is cancer. A hacky and otherwise useless glue code to comply with GPL licensing.
+
+    Copyright (C) 2007-2022 GuinpinSoft inc <mmgpl@makemkv.com>
+
+    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.
+
+*/
+#include <dvdnav/mmdvdnav.h>
+#include <lgpl/aproxy.h>
+#include <lgpl/stl.h>
+#include <alloca.h>
+#include <strings.h>
+#include <dvdnav/dvdnav.h>
+#include <dvdnav/navbase.h>
+#include <lgpl/posixio.h>
+
+class CSrvTransport : public CPipeTransport , public IDvdNavBase
+{
+    uint64_t        m_PipeIn;
+    uint64_t        m_PipeOut;
+    stl::vector<dvdnav_t*>  m_nav;
+    int             m_log_fd;
+    uint8_t*        m_log_page;
+    unsigned int    m_log_size;
+    AP_SHMEM        m_mem;
+private:
+    static const unsigned int LogPageSize = (1 * 1024 * 1024) - 0x80;
+public:
+    CSrvTransport(uint64_t pipein, uint64_t pipeout, const char* logfile)
+        : m_PipeIn(pipein)
+        , m_PipeOut(pipeout)
+        , m_log_fd(0)
+        , m_log_page(NULL)
+        , m_log_size(0)
+    {
+        bzero(&m_mem, sizeof(m_mem));
+        if (NULL != logfile)
+        {
+            InitLog(logfile);
+        }
+    }
+    ~CSrvTransport();
+    bool RunServer();
+private:
+    bool SendEvent(dvdnav_event_type_t type, unsigned int arg_count, const uint32_t* args, const uint8_t* data, unsigned int data_size);
+    bool RecvCommand(dvdnav_cmd_type_t* p_cmd, unsigned int arg_count, uint32_t* args, unsigned int* p_data_size);
+    inline const uint8_t* RecvData() { return m_mem.strbuf; }
+    bool SendData(const void* Buffer, unsigned int Size) override;
+    bool RecvData(void* Buffer, unsigned int Size, unsigned int *p_Received) override;
+    void DvdNavLog(dvdnav_logger_level_t level, const char *str, va_list lst) override;
+    bool DvdNavReadVob(unsigned int id, uint32_t sector, uint8_t* data) override;
+    bool DoSendEvent(const dvdnav_event_t& evt);
+    bool DoClone(unsigned int ndx);
+    bool InitLog(const char* FileName);
+    bool FlushLog();
+    void AddLogData(const uint8_t* data, unsigned int size);
+public:
+    inline bool SendStatus(uint32_t value)
+    {
+        return SendEvent(dvdnav_evt_status, 1, &value, NULL, 0);
+    }
+    inline bool SendError(uint32_t value)
+    {
+        return SendEvent(dvdnav_evt_error, 1, &value, NULL, 0);
+    }
+};
+
+CSrvTransport::~CSrvTransport()
+{
+    if (0 != m_PipeIn) ApClosePipe(m_PipeIn);
+    if (0 != m_PipeOut) ApClosePipe(m_PipeOut);
+
+    {
+        unsigned int all_read, all_access;
+        DvdNavStat(&all_read, &all_access);
+
+        this->Log("\nblocks_read=%u (%umb), accessed=%u\n", all_read, all_read/512, all_access);
+    }
+
+    FlushLog();
+    if (0 != m_log_fd)
+    {
+        close(m_log_fd);
+    }
+    free(m_log_page);
+}
+
+bool CSrvTransport::SendData(const void* Buffer, unsigned int Size)
+{
+    return (Size == (unsigned int)ApWritePipe(m_PipeOut, Buffer, Size));
+}
+
+bool CSrvTransport::RecvData(void* Buffer, unsigned int Size, unsigned int *p_Received)
+{
+    int r = ApReadPipe(m_PipeIn, Buffer, Size, AP_SEM_TIMEOUT);
+    if (r <= 0) return false;
+    *p_Received = r;
+    return true;
+}
+
+bool CSrvTransport::SendEvent(dvdnav_event_type_t type, unsigned int arg_count, const uint32_t* args, const uint8_t* data, unsigned int data_size)
+{
+    m_mem.cmd = (( ((uint32_t)type) | 0x80) << 24) | (arg_count << 16) | data_size;
+    m_mem.flags = 0;
+    memcpy(m_mem.args, args, arg_count * sizeof(uint32_t));
+    memcpy(m_mem.strbuf, data, data_size);
+
+    return SendCmd(&m_mem);
+}
+
+bool CSrvTransport::RecvCommand(dvdnav_cmd_type_t* p_cmd, unsigned int arg_count, uint32_t* args, unsigned int* p_data_size)
+{
+    if (false == RecvCmd(&m_mem)) return false;
+    *p_cmd = (dvdnav_cmd_type_t)((m_mem.cmd >> 24) & 0x7f);
+    *p_data_size = m_mem.cmd & 0xffff;
+
+    memcpy(args,m_mem.args, arg_count * sizeof(uint32_t));
+
+    return true;
+}
+
+bool CSrvTransport::DoSendEvent(const dvdnav_event_t& evt)
+{
+    uint32_t args8;
+
+    args0 = evt.code;
+    args1 = evt.time;
+    args2 = (((uint32_t)evt.title_id) << 16) | evt.pgc_id;
+    args3 = (((uint32_t)evt.vtsn) << 24) |
+        (((uint32_t)evt.cell_id) << 16) |
+        (((uint32_t)evt.still_time) << 8) |
+        (((uint32_t)evt.highlight) << 0);
+    args4 = evt.vobu;
+    args5 = evt.sprm_flags;
+    args6 = 0;
+    args7 = 0;
+
+    return SendEvent(evt.type, 8, args, NULL, 0);
+}
+
+bool CSrvTransport::DoClone(unsigned int ndx)
+{
+    dvdnav_t *dvdnav;
+
+    dvdnav_status_t st = dvdnav_dup(&dvdnav, m_navndx);
+    if (DVDNAV_STATUS_OK != st)
+    {
+        return false;
+    }
+
+    if (m_nav.capacity() == m_nav.size())
+    {
+        m_nav.reserve(m_nav.capacity() + 512);
+    }
+    m_nav.push_back(dvdnav);
+
+    return SendStatus((uint32_t)(m_nav.size() - 1));
+}
+
+bool DvdNavRunServer(uint64_t pipein, uint64_t pipeout)
+{
+    const char* log_name = getenv("MMDVDNAVLOG");
+
+    CSrvTransport* trans = new CSrvTransport(pipein, pipeout, log_name);
+    bool r = trans->RunServer();
+    delete trans;
+    return r;
+}
+
+bool CSrvTransport::RunServer()
+{
+    uint32_t args4;
+    bool do_exit = false;
+
+    if (false==SendStatus(0xDA000000))
+    {
+        return false;
+    }
+
+    while (false==do_exit)
+    {
+        dvdnav_cmd_type_t cmd;
+        dvdnav_event_t evt;
+        unsigned int data_size;
+
+        if (false == RecvCommand(&cmd, 4, args, &data_size))
+        {
+            return false;
+        }
+
+        switch (cmd)
+        {
+        case dvdnav_cmd_add_ifo:
+            if (false == DvdNavAddIfo(args0,args1,args2,RecvData(),data_size)) return false;
+            if (false == SendStatus(0)) return false;
+            break;
+        case dvdnav_cmd_set_ifo:
+            if (false == DvdNavSetIfo(args0, args1, RecvData(), data_size)) return false;
+            if (false == SendStatus(0)) return false;
+            break;
+        case dvdnav_cmd_set_param:
+            if (args0 >= m_nav.size()) return false;
+            if (false == DvdNavSetParam(m_navargs0, args1, args2)) return false;
+            if (false == SendStatus(0)) return false;
+            break;
+        case dvdnav_cmd_run:
+            if (args0 >= m_nav.size()) return false;
+            if (false == DvdNavRun(m_navargs0, &evt)) return false;
+            if (false == DoSendEvent(evt)) return false;
+            break;
+        case dvdnav_cmd_clone:
+            if (true == m_nav.empty())
+            {
+                dvdnav_t* nav = DvdNavOpen(0 != m_log_fd);
+                if (NULL == nav) return false;
+
+                m_nav.reserve(512);
+                m_nav.push_back(nav);
+            }
+            if (args0 >= m_nav.size()) return false;
+            if (false == DoClone(args0)) return false;
+            break;
+        case dvdnav_cmd_die:
+            if (false == SendStatus(0)) return false;
+            do_exit = true;
+            break;
+        case dvdnav_cmd_log:
+            AddLogData(RecvData(), data_size);
+            if (false == SendStatus(0)) return false;
+            break;
+        default:
+            return false;
+            break;
+        }
+    }
+    return true;
+}
+
+bool CSrvTransport::DvdNavReadVob(unsigned int id, uint32_t sector, uint8_t* data)
+{
+    uint32_t args2;
+
+    args0 = id;
+    args1 = sector;
+    if (false == SendEvent(dvdnav_evt_read, 2, args, NULL, 0)) return false;
+
+    dvdnav_cmd_type_t cmd;
+    unsigned int data_size;
+
+    if (false == RecvCommand(&cmd, 0, NULL, &data_size)) return false;
+    if (dvdnav_cmd_add_vob != cmd) return false;
+    if (data_size != DVD_VIDEO_LB_LEN) return false;
+
+    memcpy(data, RecvData(), DVD_VIDEO_LB_LEN);
+
+    return true;
+}
+
+bool CSrvTransport::InitLog(const char* FileName)
+{
+    int fd;
+
+    fd = open(FileName, O_CREAT | O_WRONLY | O_TRUNC, S_IREAD| S_IWRITE);
+    if (fd <= 0) return false;
+
+    m_log_page = (uint8_t*)malloc(LogPageSize);
+    if (NULL == m_log_page)
+    {
+        close(fd);
+        return false;
+    }
+
+    m_log_fd = fd;
+    m_log_size = 0;
+
+    return true;
+}
+
+void CSrvTransport::DvdNavLog(dvdnav_logger_level_t level, const char *str, va_list lst)
+{
+    static const unsigned int MaxStrLen = 1024;
+
+    if ((NULL == m_log_page) || (0 == m_log_fd)) return;
+
+    if ((m_log_size + MaxStrLen + 2) >= LogPageSize)
+    {
+        FlushLog();
+    }
+
+    unsigned int rest = LogPageSize - m_log_size;
+
+    int r = vsnprintf((char*)(m_log_page + m_log_size), rest, str, lst);
+
+    if ((r < 0) || (((size_t)r) >= rest))
+    {
+        r = 0;
+    }
+
+    m_log_size += ((unsigned int)r);
+
+    m_log_pagem_log_size = '\n';
+    m_log_size += 1;
+}
+
+bool CSrvTransport::FlushLog()
+{
+    if ( (0 != m_log_size) && (0 != m_log_fd))
+    {
+        int len = m_log_size;
+        m_log_size = 0;
+
+        if (write(m_log_fd, m_log_page, len) != len)
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+void CSrvTransport::AddLogData(const uint8_t* data, unsigned int size)
+{
+    if ((NULL == m_log_page) || (0 == m_log_fd)) return;
+
+    if ((m_log_size + size) >= LogPageSize)
+    {
+        FlushLog();
+    }
+
+    memcpy(m_log_page + m_log_size, data, size);
+    m_log_size += size;
+}
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread Added

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread.cpp Added

@@ -0,0 +1,347 @@
+/*
+    GPL is cancer. A hacky and otherwise useless glue code to comply with GPL licensing.
+
+    Copyright (C) 2007-2022 GuinpinSoft inc <mmgpl@makemkv.com>
+
+    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.
+
+*/
+#include <dvdnav/mmdvdnav.h>
+#include <dvdread/dvd_reader.h>
+#include <lgpl/stl.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include <dvdread_internal.h>
+#include <dvdnav/navbase.h>
+
+static const unsigned int MaxVtsCount = 100;
+
+struct ifo_entry_t
+{
+    uint8_t*        data;
+    unsigned int    size;
+    uint32_t        tvob_offset;
+
+    ifo_entry_t() : data(NULL) , tvob_offset(0) {}
+};
+
+static stl::vector< ifo_entry_t>    g_ifo_entries;
+
+static uint8_t* data_malloc(unsigned int size);
+
+bool DvdNavAddIfo(unsigned int id, unsigned int size, uint32_t tvob_offset, const uint8_t* data, unsigned int data_size)
+{
+    if (id >= MaxVtsCount) return false;
+
+    if (g_ifo_entries.size() <= id)
+    {
+        g_ifo_entries.resize(id + 1);
+    }
+
+    if (NULL != g_ifo_entriesid.data) return false;
+
+    g_ifo_entriesid.data = data_malloc(size);
+    if (NULL == g_ifo_entriesid.data) return false;
+    g_ifo_entriesid.size = size;
+    g_ifo_entriesid.tvob_offset = tvob_offset;
+
+    memcpy(g_ifo_entriesid.data, data, data_size);
+
+    return true;
+}
+
+bool DvdNavSetIfo(unsigned int id, unsigned int offset, const uint8_t* data, unsigned int data_size)
+{
+    if (g_ifo_entries.size() <= id) return false;
+    if (NULL == g_ifo_entriesid.data) return false;
+    if (offset  > g_ifo_entriesid.size) return false;
+    if ((offset + data_size) > g_ifo_entriesid.size) return false;
+
+    memcpy(g_ifo_entriesid.data + offset, data, data_size);
+
+    return true;
+}
+
+typedef stl::map<uint32_t, uint8_t*> data_map_t;
+typedef stl::vector<data_map_t*> data_map_vector_t;
+
+data_map_vector_t g_data_vmg;
+data_map_vector_t g_data_vts;
+data_map_t        g_data_phys;
+
+static data_map_t* GetDataMap(uint32_t* p_key, unsigned int id, uint32_t sector)
+{
+    bool is_menu = (0 != (id&FLAG_MENU_VOB));
+    unsigned int n = id & VTS_ID_MASK;
+
+    if ((false == is_menu) &&
+        (n < g_ifo_entries.size()) &&
+        (0 != g_ifo_entriesn.tvob_offset))
+    {
+        *p_key = g_ifo_entriesn.tvob_offset + sector;
+        return &g_data_phys;
+    }
+
+    data_map_vector_t& map = is_menu ? g_data_vmg : g_data_vts;
+
+    if (map.size() <= n)
+    {
+        map.reserve(g_ifo_entries.size());
+        map.resize(n + 1);
+    }
+    if (NULL == mapn)
+    {
+        mapn = new data_map_t();
+    }
+
+    *p_key = sector;
+    return mapn;
+}
+
+
+bool DvdNavAddVob(unsigned int id, uint32_t sector, const uint8_t* data)
+{
+    uint32_t key;
+    data_map_t* p_map = GetDataMap(&key,id,sector);
+
+    uint8_t* p_data = data_malloc(DVD_VIDEO_LB_LEN);
+    if (NULL == p_data) return false;
+
+    memcpy(p_data, data, DVD_VIDEO_LB_LEN);
+
+    p_map->insert(data_map_t::value_type(key, p_data));
+
+    return true;
+}
+
+dvd_reader_t *DVDOpenStream2(void *ctx, const dvd_logger_cb *logcb, dvd_reader_stream_cb *strcb)
+{
+    dvd_reader_s* p = (dvd_reader_s*)malloc(sizeof(dvd_reader_s));
+    if (NULL == p) return NULL;
+
+    bzero(p, sizeof(*p));
+
+    if (NULL != logcb)
+    {
+        p->logcb.pf_log = logcb->pf_log;
+        p->priv = ctx;
+    }
+
+    IDvdNavBase* base = IDvdNavBase::GetBase(ctx, strcb);
+    p->rd = (dvd_reader_device_t*)base;
+
+    return p;
+}
+
+dvd_reader_t *DVDOpen2(void *ctx, const dvd_logger_cb *logcb, const char *name)
+{
+    return NULL;
+}
+
+void DVDClose(dvd_reader_t *dvd)
+{
+    free(dvd);
+}
+
+struct dvd_file_s
+{
+    dvd_reader_t*   dvd;
+    uint32_t        offset;
+    uint16_t        vts_id;
+};
+
+dvd_file_t *DVDOpenFile(dvd_reader_t *dvd, int titlenum, dvd_read_domain_t domain)
+{
+    dvd_file_s* p = (dvd_file_s*)malloc(sizeof(dvd_file_s));
+    if (NULL == p) return NULL;
+
+    p->dvd = dvd;
+    p->offset = 0;
+    p->vts_id = (uint16_t)titlenum;
+
+    if (DVD_READ_MENU_VOBS == domain)
+    {
+        p->vts_id |= FLAG_MENU_VOB;
+    }
+
+    return p;
+}
+
+void DVDCloseFile(dvd_file_t *dvd_file)
+{
+    free(dvd_file);
+}
+
+int32_t DVDFileSeek(dvd_file_t *dvd_file, int32_t seek_offset)
+{
+    dvd_file->offset = seek_offset;
+    return seek_offset;
+}
+
+int DVDFileSeekForce(dvd_file_t *dvd_file, int seek_offset, int force_size)
+{
+    dvd_file->offset = seek_offset;
+    return seek_offset;
+}
+
+ssize_t DVDReadBytes(dvd_file_t *dvd_file, void *data, size_t size)
+{
+    if (g_ifo_entries.size() <= dvd_file->vts_id) return -1;
+
+    ifo_entry_t* p_ifo = &g_ifo_entriesdvd_file->vts_id;
+
+    if (NULL == p_ifo->data) return -1;
+
+    if ((dvd_file->offset + size) > p_ifo->size) return -1;
+    memcpy(data, p_ifo->data + dvd_file->offset, size);
+    dvd_file->offset += size;
+    return size;
+}
+
+static unsigned int g_read_count = 0, g_access_count = 0;
+
+const unsigned char * DVDReadBlock(dvd_file_t *dvd_file, int offset, unsigned char *data)
+{
+    uint32_t key;
+    data_map_t* p_map = GetDataMap(&key,dvd_file->vts_id,offset);
+
+    data_map_t::iterator it = p_map->find(key);
+    if (p_map->end() != it)
+    {
+        g_access_count++;
+        return it->second;
+    }
+
+    IDvdNavBase* base = (IDvdNavBase*)dvd_file->dvd->rd;
+
+    if (false==base->DvdNavReadVob(dvd_file->vts_id, offset, data))
+    {
+        return NULL;
+    }
+
+    g_read_count++;
+
+    DvdNavAddVob(dvd_file->vts_id, offset, data);
+
+    return data;
+}
+
+void DvdNavStat(uint32_t* p_read, uint32_t* p_access)
+{
+    *p_read = g_read_count;
+    *p_access = g_access_count;
+}
+
+dvdnav_t* IDvdNavBase::DvdNavOpen(bool EnableLog)
+{
+    dvdnav_logger_cb logcb;
+    dvdnav_stream_cb strcb;
+    dvdnav_t* dvdnav;
+
+    bzero(&logcb, sizeof(logcb));
+    logcb.pf_log = IDvdNavBase::CbLog;
+
+    bzero(&strcb, sizeof(strcb));
+    strcb.pf_read = IDvdNavBase::CbRead;
+
+    if (DVDNAV_STATUS_OK != dvdnav_open_stream2(&dvdnav, this, EnableLog?&logcb:NULL, &strcb))
+    {
+        return NULL;
+    }
+    dvdnav_set_readahead_flag(dvdnav, 0);
+    dvdnav_set_nav_only_flag(dvdnav, 1);
+
+    return dvdnav;
+}
+
+/*static*/ void IDvdNavBase::CbLog(void *ctx, dvdnav_logger_level_t level, const char *str, va_list lst)
+{
+    IDvdNavBase* base = (IDvdNavBase*)ctx;
+
+    base->DvdNavLog(level, str, lst);
+}
+
+/*static*/ int IDvdNavBase::CbRead(void *p_stream, void* buffer, int i_read)
+{
+    if (i_read != 0x13) return false;
+    memcpy(buffer, &p_stream, sizeof(void*));
+    return 0x15;
+}
+
+/*static*/ IDvdNavBase* IDvdNavBase::GetBase(void* ctx, const dvdnav_stream_cb* strcb)
+{
+    void* buf8;
+
+    if (0x15 != (*strcb->pf_read)(ctx, buf, 0x13)) return NULL;
+
+    return (IDvdNavBase*)buf0;
+}
+
+void IDvdNavBase::Log(const char* fmt, ...)
+{
+    va_list lst;
+    va_start(lst, fmt);
+
+    this->DvdNavLog(DVDNAV_LOGGER_LEVEL_INFO, fmt, lst);
+
+    va_end(lst);
+}
+
+static const unsigned int BigPageSize = (16*1024*1024) - (DVD_VIDEO_LB_LEN/2);
+
+static uint8_t*     g_page_data = NULL;
+static unsigned int g_page_rest = 0;
+
+static uint8_t* data_malloc(unsigned int size)
+{
+    if (0 == g_page_rest)
+    {
+        g_page_data = (uint8_t*)malloc(BigPageSize);
+        if (NULL != g_page_data)
+        {
+            g_page_rest = BigPageSize;
+            uintptr_t off = ((uintptr_t)g_page_data) & (DVD_VIDEO_LB_LEN - 1);
+            if (0 != off)
+            {
+                off = DVD_VIDEO_LB_LEN - off;
+                g_page_data += off;
+                g_page_rest -= off;
+            }
+            g_page_rest -= (g_page_rest&(DVD_VIDEO_LB_LEN - 1));
+        }
+    }
+
+    if ((NULL == g_page_data) || (size > g_page_rest) || (0 != (size&(DVD_VIDEO_LB_LEN - 1))))
+    {
+        return (uint8_t*)malloc(size);
+    }
+
+    uint8_t* p = g_page_data;
+
+    g_page_data += size;
+    g_page_rest -= size;
+
+    return p;
+}
+
+extern "C" int dvdnav_critical_failure(void)
+{
+    fprintf(stderr, "\n\ndvdnav_critical_failure\n\n");
+    fflush(stderr);
+    exit(1);
+}
+

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/bitreader.c Added

@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2000, 2001, 2002, 2003 Håkan Hjort <d95hjort@dtek.chalmers.se>
+ *
+ * This file is part of libdvdread.
+ *
+ * libdvdread 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.
+ *
+ * libdvdread 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 libdvdread; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "dvdread/bitreader.h"
+
+int dvdread_getbits_init(getbits_state_t *state, uint8_t *start) {
+  if ((state == NULL) || (start == NULL)) return 0;
+  state->start = start;
+  state->bit_position = 0;
+  state->byte_position = 0;
+  state->byte = start0;
+  return 1;
+}
+
+/* Non-optimized getbits. */
+/* This can easily be optimized for particular platforms. */
+uint32_t dvdread_getbits(getbits_state_t *state, uint32_t number_of_bits) {
+  uint32_t result=0;
+  uint8_t byte=0;
+  if (number_of_bits > 32) {
+    fprintf(stderr,"Number of bits > 32 in getbits\n");
+    abort();
+  }
+
+  if ((state->bit_position) > 0) {  /* Last getbits left us in the middle of a byte. */
+    if (number_of_bits > (8-state->bit_position)) { /* this getbits will span 2 or more bytes. */
+      byte = state->byte;
+      byte = byte >> (state->bit_position);
+      result = byte;
+      number_of_bits -= (8-state->bit_position);
+      state->bit_position = 0;
+      state->byte_position++;
+      state->byte = state->startstate->byte_position;
+    } else {
+      byte=state->byte;
+      state->byte = state->byte << number_of_bits;
+      byte = byte >> (8 - number_of_bits);
+      result = byte;
+      state->bit_position += number_of_bits; /* Here it is impossible for bit_position > 8 */
+      if (state->bit_position == 8) {
+        state->bit_position = 0;
+        state->byte_position++;
+        state->byte = state->startstate->byte_position;
+      }
+      number_of_bits = 0;
+    }
+  }
+  if ((state->bit_position) == 0) {
+    while (number_of_bits > 7) {
+      result = (result << 8) + state->byte;
+      state->byte_position++;
+      state->byte = state->startstate->byte_position;
+      number_of_bits -= 8;
+    }
+    if (number_of_bits > 0) { /* number_of_bits < 8 */
+      byte = state->byte;
+      state->byte = state->byte << number_of_bits;
+      state->bit_position += number_of_bits; /* Here it is impossible for bit_position > 7 */
+      byte = byte >> (8 - number_of_bits);
+      result = (result << number_of_bits) + byte;
+      number_of_bits = 0;
+    }
+  }
+
+  return result;
+}
+
+#if 0  /* TODO: optimized versions not yet used */
+
+/* WARNING: This function can only be used on a byte boundary.
+            No checks are made that we are in fact on a byte boundary.
+ */
+uint16_t dvdread_get16bits(getbits_state_t *state) {
+  uint16_t result;
+  state->byte_position++;
+  result = (state->byte << 8) + state->startstate->byte_position++;
+  state->byte = state->startstate->byte_position;
+  return result;
+}
+
+/* WARNING: This function can only be used on a byte boundary.
+            No checks are made that we are in fact on a byte boundary.
+ */
+uint32_t dvdread_get32bits(getbits_state_t *state) {
+  uint32_t result;
+  state->byte_position++;
+  result = (state->byte << 8) + state->startstate->byte_position++;
+  result = (result << 8) + state->startstate->byte_position++;
+  result = (result << 8) + state->startstate->byte_position++;
+  state->byte = state->startstate->byte_position;
+  return result;
+}
+
+#endif

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/bitreader.h Added

@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2000, 2001, 2002 Håkan Hjort <d95hjort@dtek.chalmers.se>.
+ *
+ * This file is part of libdvdread.
+ *
+ * libdvdread 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.
+ *
+ * libdvdread 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 libdvdread; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDREAD_BITREADER_H
+#define LIBDVDREAD_BITREADER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+  uint8_t *start;
+  uint32_t byte_position;
+  uint32_t bit_position;
+  uint8_t byte;
+} getbits_state_t;
+
+int dvdread_getbits_init(getbits_state_t *state, uint8_t *start);
+uint32_t dvdread_getbits(getbits_state_t *state, uint32_t number_of_bits);
+
+#ifdef __cplusplus
+};
+#endif
+#endif /* LIBDVDREAD_BITREADER_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/bswap.h Added

@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2000, 2001 Billy Biggs <vektor@dumbterm.net>,
+ *                          Håkan Hjort <d95hjort@dtek.chalmers.se>
+ *
+ * This file is part of libdvdread.
+ *
+ * libdvdread 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.
+ *
+ * libdvdread 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 libdvdread; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDREAD_BSWAP_H
+#define LIBDVDREAD_BSWAP_H
+
+#include "config.h"
+
+#if defined(WORDS_BIGENDIAN)
+/* All bigendian systems are fine, just ignore the swaps. */
+#define B2N_16(x) (void)(x)
+#define B2N_32(x) (void)(x)
+#define B2N_64(x) (void)(x)
+
+#else
+
+/* For __FreeBSD_version */
+#if defined(HAVE_SYS_PARAM_H)
+#include <sys/param.h>
+#endif
+
+#if defined(__linux__) || defined(__GLIBC__)
+#include <byteswap.h>
+#define B2N_16(x) x = bswap_16(x)
+#define B2N_32(x) x = bswap_32(x)
+#define B2N_64(x) x = bswap_64(x)
+
+#elif defined(__APPLE__)
+#include <libkern/OSByteOrder.h>
+#define B2N_16(x) x = OSSwapBigToHostInt16(x)
+#define B2N_32(x) x = OSSwapBigToHostInt32(x)
+#define B2N_64(x) x = OSSwapBigToHostInt64(x)
+
+#elif defined(__NetBSD__)
+#include <sys/endian.h>
+#define B2N_16(x) BE16TOH(x)
+#define B2N_32(x) BE32TOH(x)
+#define B2N_64(x) BE64TOH(x)
+
+#elif defined(__OpenBSD__)
+#include <sys/endian.h>
+#define B2N_16(x) x = swap16(x)
+#define B2N_32(x) x = swap32(x)
+#define B2N_64(x) x = swap64(x)
+
+#elif defined(__FreeBSD__) && __FreeBSD_version >= 470000
+#include <sys/endian.h>
+#define B2N_16(x) x = be16toh(x)
+#define B2N_32(x) x = be32toh(x)
+#define B2N_64(x) x = be64toh(x)
+
+#elif defined(__QNXNTO__)
+#include <gulliver.h>
+#define B2N_16(x) x = ENDIAN_RET16(x)
+#define B2N_32(x) x = ENDIAN_RET32(x)
+#define B2N_64(x) x = ENDIAN_RET64(x)
+
+#elif defined(__DragonFly__)
+#include <sys/endian.h>
+#define B2N_16(x) x = bswap16(x)
+#define B2N_32(x) x = bswap32(x)
+#define B2N_64(x) x = bswap64(x)
+
+#elif defined(_MSC_VER)
+#include <stdlib.h>
+#pragma intrinsic(_byteswap_ulong, _byteswap_uint64, _byteswap_ushort)
+#define B2N_16(x) x = _byteswap_ushort(x)
+#define B2N_32(x) x = _byteswap_ulong(x)
+#define B2N_64(x) x = _byteswap_uint64(x)
+
+
+/* This is a slow but portable implementation, it has multiple evaluation
+ * problems so beware.
+ * Old FreeBSD's and Solaris don't have <byteswap.h> or any other such
+ * functionality!
+ */
+
+#elif defined(__FreeBSD__) || defined(__sun) || defined(__bsdi__) || defined(_WIN32) || defined(__CYGWIN__) || defined(__BEOS__) || defined(__OS2__)
+#define B2N_16(x)                             \
+ x = ((((x) & 0xff00) >> 8) |                 \
+      (((x) & 0x00ff) << 8))
+#define B2N_32(x)                             \
+ x = ((((x) & 0xff000000) >> 24) |            \
+      (((x) & 0x00ff0000) >>  8) |            \
+      (((x) & 0x0000ff00) <<  8) |            \
+      (((x) & 0x000000ff) << 24))
+#define B2N_64(x)                             \
+ x = ((((x) & 0xff00000000000000ULL) >> 56) | \
+      (((x) & 0x00ff000000000000ULL) >> 40) | \
+      (((x) & 0x0000ff0000000000ULL) >> 24) | \
+      (((x) & 0x000000ff00000000ULL) >>  8) | \
+      (((x) & 0x00000000ff000000ULL) <<  8) | \
+      (((x) & 0x0000000000ff0000ULL) << 24) | \
+      (((x) & 0x000000000000ff00ULL) << 40) | \
+      (((x) & 0x00000000000000ffULL) << 56))
+
+#else
+
+/* If there isn't a header provided with your system with this functionality
+ * add the relevant || define( ) to the portable implementation above.
+ */
+#error "You need to add endian swap macros for your system"
+
+#endif
+
+#endif /* WORDS_BIGENDIAN */
+
+#endif /* LIBDVDREAD_BSWAP_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/config.h Added

@@ -0,0 +1,27 @@
+/*
+    GPL is cancer. A hacky and otherwise useless glue code to comply with GPL licensing.
+
+    Copyright (C) 2007-2022 GuinpinSoft inc <mmgpl@makemkv.com>
+
+    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.
+
+*/
+#include <stdint.h>
+#include <unistd.h>
+#include <lgpl/byteorder.h>
+
+#if (_BYTE_ORDER == _BIG_ENDIAN)
+#define WORDS_BIGENDIAN 1
+#endif

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/dvd_reader.h Added

@@ -0,0 +1,362 @@
+/*
+ * Copyright (C) 2001, 2002 Billy Biggs <vektor@dumbterm.net>,
+ *                          Håkan Hjort <d95hjort@dtek.chalmers.se>,
+ *                          Björn Englund <d4bjorn@dtek.chalmers.se>
+ *
+ * This file is part of libdvdread.
+ *
+ * libdvdread 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.
+ *
+ * libdvdread 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 libdvdread; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDREAD_DVD_READER_H
+#define LIBDVDREAD_DVD_READER_H
+
+#include <sys/types.h>
+#include <inttypes.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <unistd.h>
+
+/**
+ * The DVD access interface.
+ *
+ * This file contains the functions that form the interface to to
+ * reading files located on a DVD.
+ */
+
+/**
+ * The current version.
+ */
+#include "version.h"
+
+/**
+ * The length of one Logical Block of a DVD.
+ */
+#define DVD_VIDEO_LB_LEN 2048
+
+/**
+ * Maximum length of filenames allowed in UDF.
+ */
+#define MAX_UDF_FILE_NAME_LEN 2048
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Opaque type that is used as a handle for one instance of an opened DVD.
+ */
+typedef struct dvd_reader_s dvd_reader_t;
+typedef struct dvd_reader_device_s dvd_reader_device_t;
+
+/**
+ * Opaque type for a file read handle, much like a normal fd or FILE *.
+ */
+typedef struct dvd_file_s dvd_file_t;
+
+struct dvd_reader_stream_cb
+{
+    int ( *pf_seek )  ( void *p_stream,  uint64_t i_pos);
+    int ( *pf_read )  ( void *p_stream, void* buffer, int i_read);
+    int ( *pf_readv ) ( void *p_stream, void *p_iovec, int i_blocks);
+};
+typedef struct dvd_reader_stream_cb dvd_reader_stream_cb;
+
+/**
+ * Custom logger callback for DVDOpenStream2
+ * @param private Handle as provided in Open functions
+ * @param level Log level
+ * @param fmt Format string
+ * @param args Arguments list
+ * pf_log(priv, level, fmt, args);
+ */
+typedef enum
+{
+    DVD_LOGGER_LEVEL_INFO,
+    DVD_LOGGER_LEVEL_ERROR,
+    DVD_LOGGER_LEVEL_WARN,
+    DVD_LOGGER_LEVEL_DEBUG,
+} dvd_logger_level_t;
+
+typedef struct
+{
+  void ( *pf_log )  ( void *, dvd_logger_level_t, const char *, va_list );
+} dvd_logger_cb;
+
+/**
+ * Public type that is used to provide statistics on a handle.
+ */
+typedef struct {
+  off_t size;          /**< Total size of file in bytes */
+  int nr_parts;        /**< Number of file parts */
+  off_t parts_size9; /**< Size of each part in bytes */
+} dvd_stat_t;
+
+/**
+ * Opens a block device of a DVD-ROM file, or an image file, or a directory
+ * name for a mounted DVD or HD copy of a DVD.
+ * The second form of Open function (DVDOpenStream) can be used to
+ * provide custom stream_cb functions to access the DVD (see libdvdcss).
+ *
+ * If the given file is a block device, or is the mountpoint for a block
+ * device, then that device is used for CSS authentication using libdvdcss.
+ * If no device is available, then no CSS authentication is performed,
+ * and we hope that the image is decrypted.
+ *
+ * If the path given is a directory, then the files in that directory may be
+ * in any one of these formats:
+ *
+ *   path/VIDEO_TS/VTS_01_1.VOB
+ *   path/video_ts/vts_01_1.vob
+ *   path/VTS_01_1.VOB
+ *   path/vts_01_1.vob
+ *
+ * @param path Specifies the the device, file or directory to be used.
+ * @param stream is a private handle used by stream_cb
+ * @param stream_cb is a struct containing seek and read functions
+ * @return If successful a a read handle is returned. Otherwise 0 is returned.
+ *
+ * dvd = DVDOpen(path);
+ * dvd = DVDOpenStream(stream, &stream_cb);
+ */
+dvd_reader_t *DVDOpen( const char * );
+dvd_reader_t *DVDOpenStream( void *, dvd_reader_stream_cb * );
+
+/**
+ * Same as DVDOpen, but with private handle to be passed back on callbacks
+ *
+ * @param path Specifies the the device, file or directory to be used.
+ * @param priv is a private handle
+ * @param logcb is a custom logger callback struct, or NULL if none needed
+ * @param stream_cb is a struct containing seek and read functions
+ * @return If successful a a read handle is returned. Otherwise 0 is returned.
+ *
+ * dvd = DVDOpen2(priv, logcb, path);
+ * dvd = DVDOpenStream2(priv, logcb, &stream_cb);
+ */
+dvd_reader_t *DVDOpen2( void *, const dvd_logger_cb *, const char * );
+dvd_reader_t *DVDOpenStream2( void *, const dvd_logger_cb *, dvd_reader_stream_cb * );
+
+/**
+ * Closes and cleans up the DVD reader object.
+ *
+ * You must close all open files before calling this function.
+ *
+ * @param dvd A read handle that should be closed.
+ *
+ * DVDClose(dvd);
+ */
+void DVDClose( dvd_reader_t * );
+
+/**
+ *
+ */
+typedef enum {
+  DVD_READ_INFO_FILE,        /**< VIDEO_TS.IFO  or VTS_XX_0.IFO (title) */
+  DVD_READ_INFO_BACKUP_FILE, /**< VIDEO_TS.BUP  or VTS_XX_0.BUP (title) */
+  DVD_READ_MENU_VOBS,        /**< VIDEO_TS.VOB  or VTS_XX_0.VOB (title) */
+  DVD_READ_TITLE_VOBS        /**< VTS_XX_1-9.VOB (title).  All files in
+                                  the title set are opened and read as a
+                                  single file. */
+} dvd_read_domain_t;
+
+/**
+ * Stats a file on the DVD given the title number and domain.
+ * The information about the file is stored in a dvd_stat_t
+ * which contains information about the size of the file and
+ * the number of parts in case of a multipart file and the respective
+ * sizes of the parts.
+ * A multipart file is for instance VTS_02_1.VOB, VTS_02_2.VOB, VTS_02_3.VOB
+ * The size of VTS_02_1.VOB will be stored in stat->parts_size0,
+ * VTS_02_2.VOB in stat->parts_size1, ...
+ * The total size (sum of all parts) is stored in stat->size and
+ * stat->nr_parts will hold the number of parts.
+ * Only DVD_READ_TITLE_VOBS (VTS_??_1-9.VOB) can be multipart files.
+ *
+ * This function is only of use if you want to get the size of each file
+ * in the filesystem. These sizes are not needed to use any other
+ * functions in libdvdread.
+ *
+ * @param dvd  A dvd read handle.
+ * @param titlenum Which Video Title Set should be used, VIDEO_TS is 0.
+ * @param domain Which domain.
+ * @param stat Pointer to where the result is stored.
+ * @return If successful 0, otherwise -1.
+ *
+ * int DVDFileStat(dvd, titlenum, domain, stat);
+ */
+int DVDFileStat(dvd_reader_t *, int, dvd_read_domain_t, dvd_stat_t *);
+
+/**
+ * Opens a file on the DVD given the title number and domain.
+ *
+ * If the title number is 0, the video manager information is opened
+ * (VIDEO_TS.IFO,BUP,VOB).  Returns a file structure which may be
+ * used for reads, or 0 if the file was not found.
+ *
+ * @param dvd  A dvd read handle.
+ * @param titlenum Which Video Title Set should be used, VIDEO_TS is 0.
+ * @param domain Which domain.
+ * @return If successful a a file read handle is returned, otherwise 0.
+ *
+ * dvd_file = DVDOpenFile(dvd, titlenum, domain); */
+dvd_file_t *DVDOpenFile( dvd_reader_t *, int, dvd_read_domain_t );
+
+/**
+ * Closes a file and frees the associated structure.
+ *
+ * @param dvd_file  The file read handle to be closed.
+ *
+ * DVDCloseFile(dvd_file);
+ */
+void DVDCloseFile( dvd_file_t * );
+
+/**
+ * Reads block_count number of blocks from the file at the given block offset.
+ * Returns number of blocks read on success, -1 on error.  This call is only
+ * for reading VOB data, and should not be used when reading the IFO files.
+ * When reading from an encrypted drive, blocks are decrypted using libdvdcss
+ * where required.
+ *
+ * @param dvd_file  A file read handle.
+ * @param offset Block offset from the start of the file to start reading at.
+ * @param block_count Number of block to read.
+ * @param data Pointer to a buffer to write the data into.
+ * @return Returns number of blocks read on success, -1 on error.
+ *
+ * blocks_read = DVDReadBlocks(dvd_file, offset, block_count, data);
+ */
+ssize_t DVDReadBlocks( dvd_file_t *, int, size_t, unsigned char * );
+
+const unsigned char * DVDReadBlock(dvd_file_t *, int, unsigned char *);
+
+/**
+ * Seek to the given position in the file.  Returns the resulting position in
+ * bytes from the beginning of the file.  The seek position is only used for
+ * byte reads from the file, the block read call always reads from the given
+ * offset.
+ *
+ * @param dvd_file  A file read handle.
+ * @param seek_offset Byte offset from the start of the file to seek to.
+ * @return The resulting position in bytes from the beginning of the file.
+ *
+ * offset_set = DVDFileSeek(dvd_file, seek_offset);
+ */
+int32_t DVDFileSeek( dvd_file_t *, int32_t );
+
+/**
+ * Reads the given number of bytes from the file.  This call can only be used
+ * on the information files, and may not be used for reading from a VOB.  This
+ * reads from and increments the currrent seek position for the file.
+ *
+ * @param dvd_file  A file read handle.
+ * @param data Pointer to a buffer to write the data into.
+ * @param bytes Number of bytes to read.
+ * @return Returns number of bytes read on success, -1 on error.
+ *
+ * bytes_read = DVDReadBytes(dvd_file, data, bytes);
+ */
+ssize_t DVDReadBytes( dvd_file_t *, void *, size_t );
+
+/**
+ * Returns the file size in blocks.
+ *
+ * @param dvd_file  A file read handle.
+ * @return The size of the file in blocks, -1 on error.
+ *
+ * blocks = DVDFileSize(dvd_file);
+ */
+ssize_t DVDFileSize( dvd_file_t * );
+
+/**
+ * Get a unique 128 bit disc ID.
+ * This is the MD5 sum of VIDEO_TS.IFO and the VTS_0?_0.IFO files
+ * in title order (those that exist).
+ * If you need a 'text' representation of the id, print it as a
+ * hexadecimal number, using lowercase letters, discid0 first.
+ * I.e. the same format as the command-line 'md5sum' program uses.
+ *
+ * @param dvd A read handle to get the disc ID from
+ * @param discid The buffer to put the disc ID into. The buffer must
+ *               have room for 128 bits (16 chars).
+ * @return 0 on success, -1 on error.
+ */
+int DVDDiscID( dvd_reader_t *, unsigned char * );
+
+/**
+ * Get the UDF VolumeIdentifier and VolumeSetIdentifier
+ * from the PrimaryVolumeDescriptor.
+ *
+ * @param dvd A read handle to get the disc ID from
+ * @param volid The buffer to put the VolumeIdentifier into.
+ *              The VolumeIdentifier is latin-1 encoded (8bit unicode)
+ *              null terminated and max 32 bytes (including '\0')
+ * @param volid_size No more than volid_size bytes will be copied to volid.
+ *                   If the VolumeIdentifier is truncated because of this
+ *                   it will still be null terminated.
+ * @param volsetid The buffer to put the VolumeSetIdentifier into.
+ *                 The VolumeIdentifier is 128 bytes as
+ *                 stored in the UDF PrimaryVolumeDescriptor.
+ *                 Note that this is not a null terminated string.
+ * @param volsetid_size At most volsetid_size bytes will be copied to volsetid.
+ * @return 0 on success, -1 on error.
+ */
+int DVDUDFVolumeInfo( dvd_reader_t *, char *, unsigned int,
+                      unsigned char *, unsigned int );
+
+int DVDFileSeekForce( dvd_file_t *, int offset, int force_size);
+
+/**
+ * Get the ISO9660 VolumeIdentifier and VolumeSetIdentifier
+ *
+ * * Only use this function as fallback if DVDUDFVolumeInfo returns 0   *
+ * * this will happen on a disc mastered only with a iso9660 filesystem *
+ * * All video DVD discs have UDF filesystem                            *
+ *
+ * @param dvd A read handle to get the disc ID from
+ * @param volid The buffer to put the VolumeIdentifier into.
+ *              The VolumeIdentifier is coded with '0-9','A-Z','_'
+ *              null terminated and max 33 bytes (including '\0')
+ * @param volid_size No more than volid_size bytes will be copied to volid.
+ *                   If the VolumeIdentifier is truncated because of this
+ *                   it will still be null terminated.
+ * @param volsetid The buffer to put the VolumeSetIdentifier into.
+ *                 The VolumeIdentifier is 128 bytes as
+ *                 stored in the ISO9660 PrimaryVolumeDescriptor.
+ *                 Note that this is not a null terminated string.
+ * @param volsetid_size At most volsetid_size bytes will be copied to volsetid.
+ * @return 0 on success, -1 on error.
+ */
+int DVDISOVolumeInfo( dvd_reader_t *, char *, unsigned int,
+                      unsigned char *, unsigned int );
+
+/**
+ * Sets the level of caching that is done when reading from a device
+ *
+ * @param dvd A read handle to get the disc ID from
+ * @param level The level of caching wanted.
+ *             -1 - returns the current setting.
+ *              0 - UDF Cache turned off.
+ *              1 - (default level) Pointers to IFO files and some data from
+ *                  PrimaryVolumeDescriptor are cached.
+ *
+ * @return The level of caching.
+ */
+int DVDUDFCacheLevel( dvd_reader_t *, int );
+
+#ifdef __cplusplus
+};
+#endif
+#endif /* LIBDVDREAD_DVD_READER_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/dvdread_internal.h Added

@@ -0,0 +1,81 @@
+/*
+ * This file is part of libdvdread.
+ *
+ * libdvdread 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.
+ *
+ * libdvdread 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 libdvdread; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDREAD_DVDREAD_INTERNAL_H
+#define LIBDVDREAD_DVDREAD_INTERNAL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+#include "dvdread/dvd_reader.h"
+#include "dvdread/ifo_types.h"
+
+#define container_of(ptr, type, member) \
+    ((type *)(((char *)(ptr)) - offsetof(type, member)))
+
+struct dvd_reader_s
+{
+    dvd_reader_device_t *rd;
+    void *priv; /* User provided context */
+    dvd_logger_cb logcb;
+    /* Set 100 flags for BUP fallback, most signifiant left
+       0 for upper remaining VTS, 1 for the first Main + 63 VTS */
+    uint64_t ifoBUPflags2;
+};
+
+struct ifo_handle_private_s
+{
+    ifo_handle_t handle;
+    dvd_reader_t *ctx;
+    dvd_file_t *file;
+};
+
+enum TagIdentifier {
+  /* ECMA 167 3/7.2.1 */
+  PrimaryVolumeDescriptor           = 1,
+  AnchorVolumeDescriptorPointer     = 2,
+  VolumeDescriptorPointer           = 3,
+  ImplementationUseVolumeDescriptor = 4,
+  PartitionDescriptor               = 5,
+  LogicalVolumeDescriptor           = 6,
+  UnallocatedSpaceDescriptor        = 7,
+  TerminatingDescriptor             = 8,
+  LogicalVolumeIntegrityDescriptor  = 9,
+  /* ECMA 167 4/7.2.1 */
+  FileSetDescriptor                 = 256,
+  FileIdentifierDescriptor          = 257,
+  AllocationExtentDescriptor        = 258,
+  IndirectEntry                     = 259,
+  TerminalEntry                     = 260,
+  FileEntry                         = 261,
+  ExtendedAttributeHeaderDescriptor = 262,
+  UnallocatedSpaceEntry             = 263,
+  SpaceBitmapDescriptor             = 264,
+  PartitionIntegrityEntry           = 265,
+  ExtendedFileEntry                 = 266,
+};
+
+int InternalUDFReadBlocksRaw(const dvd_reader_t *, uint32_t lb_number,
+                     size_t block_count, unsigned char *data, int encrypted);
+
+void *GetUDFCacheHandle(dvd_reader_t *);
+void SetUDFCacheHandle(dvd_reader_t *, void *cache);
+void FreeUDFCache(void *cache);
+
+#endif /* LIBDVDREAD_DVDREAD_INTERNAL_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/ifo_read.c Added

@@ -0,0 +1,2344 @@
+/*
+ * Copyright (C) 2000, 2001, 2002, 2003
+ *               Björn Englund <d4bjorn@dtek.chalmers.se>,
+ *               Håkan Hjort <d95hjort@dtek.chalmers.se>
+ *
+ * This file is part of libdvdread.
+ *
+ * libdvdread 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.
+ *
+ * libdvdread 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 libdvdread; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <inttypes.h>
+#include <string.h>
+
+#include "bswap.h"
+#include "dvdread/ifo_types.h"
+#include "dvdread/ifo_read.h"
+#include "dvdread/dvd_reader.h"
+#include "dvdread_internal.h"
+#include "logger.h"
+#include "dvdread/bitreader.h"
+
+#ifndef DVD_BLOCK_LEN
+#define DVD_BLOCK_LEN 2048
+#endif
+
+#define THISFILE__ "ifo_read.c"
+
+#define PRIV(a) container_of(a, struct ifo_handle_private_s, handle)
+
+#define CHECK_VALUE(arg)\
+  if(!(arg)) {\
+    Log1(ifop->ctx, "CHECK_VALUE failed in %s:%i for %s",\
+                THISFILE__, __LINE__, # arg );\
+  }
+
+#ifndef NDEBUG
+static inline char * makehexdump(const uint8_t *p_CZ, size_t i_CZ)
+{
+  char *alloc = malloc(i_CZ * 2 + 1);
+  if(alloc)
+  {
+    *alloc = 0;
+    for(size_t i = 0; i < i_CZ; i++)
+        sprintf(&alloci*2, "%02x", *((uint8_t*)&p_CZi));
+  }
+  return alloc;
+}
+#define CHECK_ZERO0(arg)                                                \
+  if(arg != 0) {                                                        \
+    Log1(ifop->ctx, "Zero check failed in %s:%i\n    for %s = 0x%x",    \
+            THISFILE__, __LINE__, # arg, arg);                            \
+  }
+#define CHECK_ZERO(arg)                                                 \
+  if(memcmp(my_friendly_zeros, &arg, sizeof(arg))) {                    \
+    char *dump = makehexdump((const uint8_t *)&arg, sizeof(arg));       \
+    Log0(ifop->ctx, "Zero check failed in %s:%i for %s : 0x%s",         \
+            THISFILE__, __LINE__, # arg, dump );                          \
+    free(dump);                                                         \
+  }
+static const uint8_t my_friendly_zeros2048;
+#else
+#define CHECK_ZERO0(arg) (void)(arg)
+#define CHECK_ZERO(arg) (void)(arg)
+#endif
+
+
+/* Prototypes for internal functions */
+static int ifoRead_VMG(ifo_handle_t *ifofile);
+static int ifoRead_VTS(ifo_handle_t *ifofile);
+static int ifoRead_PGC(ifo_handle_t *ifofile, pgc_t *pgc, unsigned int offset);
+static int ifoRead_PGC_COMMAND_TBL(ifo_handle_t *ifofile,
+                                   pgc_command_tbl_t *cmd_tbl,
+                                   unsigned int offset);
+static int ifoRead_PGC_PROGRAM_MAP(ifo_handle_t *ifofile,
+                                   pgc_program_map_t *program_map,
+                                   unsigned int nr, unsigned int offset);
+static int ifoRead_CELL_PLAYBACK_TBL(ifo_handle_t *ifofile,
+                                     cell_playback_t *cell_playback,
+                                     unsigned int nr, unsigned int offset);
+static int ifoRead_CELL_POSITION_TBL(ifo_handle_t *ifofile,
+                                     cell_position_t *cell_position,
+                                     unsigned int nr, unsigned int offset);
+static int ifoRead_VTS_ATTRIBUTES(ifo_handle_t *ifofile,
+                                  vts_attributes_t *vts_attributes,
+                                  unsigned int offset);
+static int ifoRead_C_ADT_internal(ifo_handle_t *ifofile, c_adt_t *c_adt,
+                                  unsigned int sector);
+static int ifoRead_VOBU_ADMAP_internal(ifo_handle_t *ifofile,
+                                       vobu_admap_t *vobu_admap,
+                                       unsigned int sector);
+static int ifoRead_PGCIT_internal(ifo_handle_t *ifofile, pgcit_t *pgcit,
+                                  unsigned int offset);
+
+static void ifoFree_PGC(pgc_t **pgc);
+static void ifoFree_PGC_COMMAND_TBL(pgc_command_tbl_t *cmd_tbl);
+static void ifoFree_PGCIT_internal(pgcit_t **pgcit);
+
+static inline int DVDFileSeekForce_( dvd_file_t *dvd_file, uint32_t offset, int force_size ) {
+  return (DVDFileSeekForce(dvd_file, (int)offset, force_size) == (int)offset);
+}
+
+static inline int DVDFileSeek_( dvd_file_t *dvd_file, uint32_t offset ) {
+  return (DVDFileSeek(dvd_file, (int)offset) == (int)offset);
+}
+
+static void read_video_attr(video_attr_t *va) {
+  getbits_state_t state;
+  uint8_t bufsizeof(video_attr_t);
+
+  memcpy(buf, va, sizeof(video_attr_t));
+  if (!dvdread_getbits_init(&state, buf)) abort();
+  va->mpeg_version = dvdread_getbits(&state, 2);
+  va->video_format = dvdread_getbits(&state, 2);
+  va->display_aspect_ratio = dvdread_getbits(&state, 2);
+  va->permitted_df = dvdread_getbits(&state, 2);
+  va->line21_cc_1 = dvdread_getbits(&state, 1);
+  va->line21_cc_2 = dvdread_getbits(&state, 1);
+  va->unknown1 = dvdread_getbits(&state, 1);
+  va->bit_rate = dvdread_getbits(&state, 1);
+  va->picture_size = dvdread_getbits(&state, 2);
+  va->letterboxed = dvdread_getbits(&state, 1);
+  va->film_mode = dvdread_getbits(&state, 1);
+}
+
+static void read_audio_attr(audio_attr_t *aa) {
+  getbits_state_t state;
+  uint8_t bufsizeof(audio_attr_t);
+
+  memcpy(buf, aa, sizeof(audio_attr_t));
+  if (!dvdread_getbits_init(&state, buf)) abort();
+  aa->audio_format = dvdread_getbits(&state, 3);
+  aa->multichannel_extension = dvdread_getbits(&state, 1);
+  aa->lang_type = dvdread_getbits(&state, 2);
+  aa->application_mode = dvdread_getbits(&state, 2);
+  aa->quantization = dvdread_getbits(&state, 2);
+  aa->sample_frequency = dvdread_getbits(&state, 2);
+  aa->unknown1 = dvdread_getbits(&state, 1);
+  aa->channels = dvdread_getbits(&state, 3);
+  aa->lang_code = dvdread_getbits(&state, 16);
+  aa->lang_extension = dvdread_getbits(&state, 8);
+  aa->code_extension = dvdread_getbits(&state, 8);
+  aa->unknown3 = dvdread_getbits(&state, 8);
+  aa->app_info.karaoke.unknown4 = dvdread_getbits(&state, 1);
+  aa->app_info.karaoke.channel_assignment = dvdread_getbits(&state, 3);
+  aa->app_info.karaoke.version = dvdread_getbits(&state, 2);
+  aa->app_info.karaoke.mc_intro = dvdread_getbits(&state, 1);
+  aa->app_info.karaoke.mode = dvdread_getbits(&state, 1);
+}
+
+static void read_multichannel_ext(multichannel_ext_t *me) {
+  getbits_state_t state;
+  uint8_t bufsizeof(multichannel_ext_t);
+
+  memcpy(buf, me, sizeof(multichannel_ext_t));
+  if (!dvdread_getbits_init(&state, buf)) abort();
+  me->zero1 = dvdread_getbits(&state, 7);
+  me->ach0_gme = dvdread_getbits(&state, 1);
+  me->zero2 = dvdread_getbits(&state, 7);
+  me->ach1_gme = dvdread_getbits(&state, 1);
+  me->zero3 = dvdread_getbits(&state, 4);
+  me->ach2_gv1e = dvdread_getbits(&state, 1);
+  me->ach2_gv2e = dvdread_getbits(&state, 1);
+  me->ach2_gm1e = dvdread_getbits(&state, 1);
+  me->ach2_gm2e = dvdread_getbits(&state, 1);
+  me->zero4 = dvdread_getbits(&state, 4);
+  me->ach3_gv1e = dvdread_getbits(&state, 1);
+  me->ach3_gv2e = dvdread_getbits(&state, 1);
+  me->ach3_gmAe = dvdread_getbits(&state, 1);
+  me->ach3_se2e = dvdread_getbits(&state, 1);
+  me->zero5 = dvdread_getbits(&state, 4);
+  me->ach4_gv1e = dvdread_getbits(&state, 1);
+  me->ach4_gv2e = dvdread_getbits(&state, 1);
+  me->ach4_gmBe = dvdread_getbits(&state, 1);
+  me->ach4_seBe = dvdread_getbits(&state, 1);
+}
+
+static void read_subp_attr(subp_attr_t *sa) {
+  getbits_state_t state;
+  uint8_t bufsizeof(subp_attr_t);
+
+  memcpy(buf, sa, sizeof(subp_attr_t));
+  if (!dvdread_getbits_init(&state, buf)) abort();
+  sa->code_mode = dvdread_getbits(&state, 3);
+  sa->zero1 = dvdread_getbits(&state, 3);
+  sa->type = dvdread_getbits(&state, 2);
+  sa->zero2 = dvdread_getbits(&state, 8);
+  sa->lang_code = dvdread_getbits(&state, 16);
+  sa->lang_extension = dvdread_getbits(&state, 8);
+  sa->code_extension = dvdread_getbits(&state, 8);
+}
+
+static void read_user_ops(user_ops_t *uo) {
+  getbits_state_t state;
+  uint8_t bufsizeof(user_ops_t);
+
+  memcpy(buf, uo, sizeof(user_ops_t));
+  if (!dvdread_getbits_init(&state, buf)) abort();
+  uo->zero                           = dvdread_getbits(&state, 7);
+  uo->video_pres_mode_change         = dvdread_getbits(&state, 1);
+  uo->karaoke_audio_pres_mode_change = dvdread_getbits(&state, 1);
+  uo->angle_change                   = dvdread_getbits(&state, 1);
+  uo->subpic_stream_change           = dvdread_getbits(&state, 1);
+  uo->audio_stream_change            = dvdread_getbits(&state, 1);
+  uo->pause_on                       = dvdread_getbits(&state, 1);
+  uo->still_off                      = dvdread_getbits(&state, 1);
+  uo->button_select_or_activate      = dvdread_getbits(&state, 1);
+  uo->resume                         = dvdread_getbits(&state, 1);
+  uo->chapter_menu_call              = dvdread_getbits(&state, 1);
+  uo->angle_menu_call                = dvdread_getbits(&state, 1);
+  uo->audio_menu_call                = dvdread_getbits(&state, 1);
+  uo->subpic_menu_call               = dvdread_getbits(&state, 1);
+  uo->root_menu_call                 = dvdread_getbits(&state, 1);
+  uo->title_menu_call                = dvdread_getbits(&state, 1);
+  uo->backward_scan                  = dvdread_getbits(&state, 1);
+  uo->forward_scan                   = dvdread_getbits(&state, 1);
+  uo->next_pg_search                 = dvdread_getbits(&state, 1);
+  uo->prev_or_top_pg_search          = dvdread_getbits(&state, 1);
+  uo->time_or_chapter_search         = dvdread_getbits(&state, 1);
+  uo->go_up                          = dvdread_getbits(&state, 1);
+  uo->stop                           = dvdread_getbits(&state, 1);
+  uo->title_play                     = dvdread_getbits(&state, 1);
+  uo->chapter_search_or_play         = dvdread_getbits(&state, 1);
+  uo->title_or_time_play             = dvdread_getbits(&state, 1);
+}
+
+static void read_pgci_srp(pgci_srp_t *ps) {
+  getbits_state_t state;
+  uint8_t bufsizeof(pgci_srp_t);
+
+  memcpy(buf, ps, sizeof(pgci_srp_t));
+  if (!dvdread_getbits_init(&state, buf)) abort();
+  ps->entry_id                       = dvdread_getbits(&state, 8);
+  ps->block_mode                     = dvdread_getbits(&state, 2);
+  ps->block_type                     = dvdread_getbits(&state, 2);
+  ps->zero_1                         = dvdread_getbits(&state, 4);
+  ps->ptl_id_mask                    = dvdread_getbits(&state, 16);
+  ps->pgc_start_byte                 = dvdread_getbits(&state, 32);
+}
+
+static void read_cell_playback(cell_playback_t *cp) {
+  getbits_state_t state;
+  uint8_t bufsizeof(cell_playback_t);
+
+  memcpy(buf, cp, sizeof(cell_playback_t));
+  if (!dvdread_getbits_init(&state, buf)) abort();
+  cp->block_mode                      = dvdread_getbits(&state, 2);
+  cp->block_type                      = dvdread_getbits(&state, 2);
+  cp->seamless_play                   = dvdread_getbits(&state, 1);
+  cp->interleaved                     = dvdread_getbits(&state, 1);
+  cp->stc_discontinuity               = dvdread_getbits(&state, 1);
+  cp->seamless_angle                  = dvdread_getbits(&state, 1);
+  cp->zero_1                          = dvdread_getbits(&state, 1);
+  cp->playback_mode                   = dvdread_getbits(&state, 1);
+  cp->restricted                      = dvdread_getbits(&state, 1);
+  cp->cell_type                       = dvdread_getbits(&state, 5);
+  cp->still_time                      = dvdread_getbits(&state, 8);
+  cp->cell_cmd_nr                     = dvdread_getbits(&state, 8);
+
+  cp->playback_time.hour              = dvdread_getbits(&state, 8);
+  cp->playback_time.minute            = dvdread_getbits(&state, 8);
+  cp->playback_time.second            = dvdread_getbits(&state, 8);
+  cp->playback_time.frame_u           = dvdread_getbits(&state, 8);
+
+  cp->first_sector                    = dvdread_getbits(&state, 32);
+  cp->first_ilvu_end_sector           = dvdread_getbits(&state, 32);
+  cp->last_vobu_start_sector          = dvdread_getbits(&state, 32);
+  cp->last_sector                     = dvdread_getbits(&state, 32);
+}
+
+static void read_playback_type(playback_type_t *pt) {
+  getbits_state_t state;
+  uint8_t bufsizeof(playback_type_t);
+
+  memcpy(buf, pt, sizeof(playback_type_t));
+  if (!dvdread_getbits_init(&state, buf)) abort();
+  pt->zero_1                          = dvdread_getbits(&state, 1);
+  pt->multi_or_random_pgc_title       = dvdread_getbits(&state, 1);
+  pt->jlc_exists_in_cell_cmd          = dvdread_getbits(&state, 1);
+  pt->jlc_exists_in_prepost_cmd       = dvdread_getbits(&state, 1);
+  pt->jlc_exists_in_button_cmd        = dvdread_getbits(&state, 1);
+  pt->jlc_exists_in_tt_dom            = dvdread_getbits(&state, 1);
+  pt->chapter_search_or_play          = dvdread_getbits(&state, 1);
+  pt->title_or_time_play              = dvdread_getbits(&state, 1);
+}
+
+static void free_ptl_mait(ptl_mait_t* ptl_mait, int num_entries) {
+  int i;
+  for (i = 0; i < num_entries; i++)
+    free(ptl_mait->countriesi.pf_ptl_mai);
+
+  free(ptl_mait->countries);
+  free(ptl_mait);
+}
+
+static ifo_handle_t *ifoOpenFileOrBackup(dvd_reader_t *ctx, int title,
+                                         int backup) {
+  struct ifo_handle_private_s *ifop;
+  dvd_read_domain_t domain = backup ? DVD_READ_INFO_BACKUP_FILE
+                                    : DVD_READ_INFO_FILE;
+  char ifo_filename13;
+
+  ifop = calloc(1, sizeof(*ifop));
+  if(!ifop)
+    return NULL;
+
+  ifop->ctx = ctx;
+  ifop->file = DVDOpenFile(ctx, title, domain);
+  if(!ifop->file)
+  {
+      free(ifop);
+      return NULL;
+  }
+
+  if (title)
+    snprintf(ifo_filename, 13, "VTS_%02d_0.%s", title, backup ? "BUP" : "IFO");
+  else
+    snprintf(ifo_filename, 13, "VIDEO_TS.%s", backup ? "BUP" : "IFO");
+
+  if(!ifop->file) {
+    Log1(ctx, "Can't open file %s.", ifo_filename);
+    free(ifop);
+    return NULL;
+  }
+
+  ifo_handle_t *ifofile = &ifop->handle;
+  /* First check if this is a VMGI file. */
+  if(ifoRead_VMG(ifofile)) {
+
+    /* These are both mandatory. */
+    if(!ifoRead_FP_PGC(ifofile) || !ifoRead_TT_SRPT(ifofile))
+      goto ifoOpen_fail;
+
+    ifoRead_PGCI_UT(ifofile);
+    ifoRead_PTL_MAIT(ifofile);
+
+    /* This is also mandatory. */
+    if(!ifoRead_VTS_ATRT(ifofile))
+      goto ifoOpen_fail;
+
+    ifoRead_TXTDT_MGI(ifofile);
+    ifoRead_C_ADT(ifofile);
+    ifoRead_VOBU_ADMAP(ifofile);
+
+    return ifofile;
+  }
+
+  if(ifoRead_VTS(ifofile)) {
+
+    if(!ifoRead_VTS_PTT_SRPT(ifofile) || !ifoRead_PGCIT(ifofile))
+      goto ifoOpen_fail;
+
+    ifoRead_PGCI_UT(ifofile);
+    ifoRead_VTS_TMAPT(ifofile);
+    ifoRead_C_ADT(ifofile);
+    ifoRead_VOBU_ADMAP(ifofile);
+
+    if(!ifoRead_TITLE_C_ADT(ifofile) || !ifoRead_TITLE_VOBU_ADMAP(ifofile))
+      goto ifoOpen_fail;
+
+    return ifofile;
+  }
+
+ifoOpen_fail:
+  Log1(ctx, "Invalid IFO for title %d (%s).", title, ifo_filename);
+  ifoClose(ifofile);
+  return NULL;
+}
+
+static void ifoSetBupFlag(dvd_reader_t *ctx, int title)
+{
+    if(title > 63)
+        ctx->ifoBUPflags0 |= 1ull << (title - 64);
+    else
+        ctx->ifoBUPflags1 |= 1ull << title;
+}
+
+static int ifoGetBupFlag(const dvd_reader_t *ctx, int title)
+{
+    int bupflag;
+    if(title > 63)
+        bupflag = !! (ctx->ifoBUPflags0 & (1ull << (title - 64)));
+    else
+        bupflag = !! (ctx->ifoBUPflags1 & (1ull << title));
+    return bupflag;
+}
+
+ifo_handle_t *ifoOpen(dvd_reader_t *ctx, int title) {
+  ifo_handle_t *ifofile;
+  int bupflag = ifoGetBupFlag(ctx, title);
+
+  ifofile = ifoOpenFileOrBackup(ctx, title, bupflag);
+  if(!ifofile) /* Try backup */
+  {
+      ifofile = ifoOpenFileOrBackup(ctx, title, 1);
+      if(ifofile && !bupflag)
+          ifoSetBupFlag(ctx, title);
+  }
+  return ifofile;
+}
+
+ifo_handle_t *ifoOpenVMGI(dvd_reader_t *ctx) {
+  struct ifo_handle_private_s *ifop;
+
+  for(int backup = ifoGetBupFlag(ctx, 0); backup <= 1; backup++)
+  {
+    ifop = calloc(1, sizeof(*ifop));
+    if(!ifop)
+      return NULL;
+
+    const dvd_read_domain_t domain = backup ? DVD_READ_INFO_BACKUP_FILE
+                                            : DVD_READ_INFO_FILE;
+    const char *ext = backup ? "BUP" : "IFO";
+
+    ifop->ctx = ctx;
+    ifop->file = DVDOpenFile(ctx, 0, domain);
+    if(!ifop->file) { /* Should really catch any error */
+      Log1(ctx, "Can't open file VIDEO_TS.%s.", ext);
+      free(ifop);
+      return NULL;
+    }
+
+    if(ifoRead_VMG(&ifop->handle))
+      return &ifop->handle;
+
+    Log1(ctx, "ifoOpenVMGI(): Invalid main menu IFO (VIDEO_TS.%s).", ext);
+    ifoClose(&ifop->handle);
+  }
+  return NULL;
+}
+
+
+ifo_handle_t *ifoOpenVTSI(dvd_reader_t *ctx, int title) {
+  struct ifo_handle_private_s *ifop;
+
+  if(title <= 0 || title > 99) {
+    Log1(ctx, "ifoOpenVTSI invalid title (%d).", title);
+    return NULL;
+  }
+
+  for(int backup = ifoGetBupFlag(ctx, title); backup <= 1; backup++)
+  {
+    ifop = calloc(1, sizeof(*ifop));
+    if(!ifop)
+      return NULL;
+
+    const dvd_read_domain_t domain = backup ? DVD_READ_INFO_BACKUP_FILE
+                                            : DVD_READ_INFO_FILE;
+    const char *ext = backup ? "BUP" : "IFO";
+    ifop->ctx = ctx;
+    ifop->file = DVDOpenFile(ctx, title, domain);
+    /* Should really catch any error */
+    if(!ifop->file) {
+      Log1(ctx, "Can't open file VTS_%02d_0.%s.", title, ext);
+      free(ifop);
+      continue;
+    }
+
+    if(ifoRead_VTS(&ifop->handle) && ifop->handle.vtsi_mat)
+      return &ifop->handle;
+
+    Log1(ctx, "Invalid IFO for title %d (VTS_%02d_0.%s).",
+            title, title, ext);
+    ifoClose(&ifop->handle);
+  }
+
+  return NULL;
+}
+
+void ifoAddRef(ifo_handle_t *ifofile) {
+    ifofile->refcount++;
+}
+
+void ifoClose(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  if (0!=ifofile->refcount) {
+      ifofile->refcount--;
+      return;
+  }
+
+  ifoFree_VOBU_ADMAP(ifofile);
+  ifoFree_TITLE_VOBU_ADMAP(ifofile);
+  ifoFree_C_ADT(ifofile);
+  ifoFree_TITLE_C_ADT(ifofile);
+  ifoFree_TXTDT_MGI(ifofile);
+  ifoFree_VTS_ATRT(ifofile);
+  ifoFree_PTL_MAIT(ifofile);
+  ifoFree_PGCI_UT(ifofile);
+  ifoFree_TT_SRPT(ifofile);
+  ifoFree_FP_PGC(ifofile);
+  ifoFree_PGCIT(ifofile);
+  ifoFree_VTS_PTT_SRPT(ifofile);
+  ifoFree_VTS_TMAPT(ifofile);
+
+  if(ifofile->vmgi_mat)
+    free(ifofile->vmgi_mat);
+
+  if(ifofile->vtsi_mat)
+    free(ifofile->vtsi_mat);
+
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  DVDCloseFile(ifop->file);
+  free(ifop);
+}
+
+
+static int ifoRead_VMG(ifo_handle_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  vmgi_mat_t *vmgi_mat;
+
+  vmgi_mat = calloc(1, sizeof(vmgi_mat_t));
+  if(!vmgi_mat)
+    return 0;
+
+  ifofile->vmgi_mat = vmgi_mat;
+
+  if(!DVDFileSeek_(ifop->file, 0)) {
+    free(ifofile->vmgi_mat);
+    ifofile->vmgi_mat = NULL;
+    return 0;
+  }
+
+  if(!DVDReadBytes(ifop->file, vmgi_mat, sizeof(vmgi_mat_t))) {
+    free(ifofile->vmgi_mat);
+    ifofile->vmgi_mat = NULL;
+    return 0;
+  }
+
+  if(strncmp("DVDVIDEO-VMG", vmgi_mat->vmg_identifier, 12) != 0) {
+    free(ifofile->vmgi_mat);
+    ifofile->vmgi_mat = NULL;
+    return 0;
+  }
+
+  B2N_32(vmgi_mat->vmg_last_sector);
+  B2N_32(vmgi_mat->vmgi_last_sector);
+  B2N_32(vmgi_mat->vmg_category);
+  B2N_16(vmgi_mat->vmg_nr_of_volumes);
+  B2N_16(vmgi_mat->vmg_this_volume_nr);
+  B2N_16(vmgi_mat->vmg_nr_of_title_sets);
+  B2N_64(vmgi_mat->vmg_pos_code);
+  B2N_32(vmgi_mat->vmgi_last_byte);
+  B2N_32(vmgi_mat->first_play_pgc);
+  B2N_32(vmgi_mat->vmgm_vobs);
+  B2N_32(vmgi_mat->tt_srpt);
+  B2N_32(vmgi_mat->vmgm_pgci_ut);
+  B2N_32(vmgi_mat->ptl_mait);
+  B2N_32(vmgi_mat->vts_atrt);
+  B2N_32(vmgi_mat->txtdt_mgi);
+  B2N_32(vmgi_mat->vmgm_c_adt);
+  B2N_32(vmgi_mat->vmgm_vobu_admap);
+  read_video_attr(&vmgi_mat->vmgm_video_attr);
+  read_audio_attr(&vmgi_mat->vmgm_audio_attr);
+  read_subp_attr(&vmgi_mat->vmgm_subp_attr);
+
+
+  CHECK_ZERO(vmgi_mat->zero_1);
+  CHECK_ZERO(vmgi_mat->zero_2);
+  /* DVDs created by VDR-to-DVD device LG RC590M violate the following check with
+   * vmgi_mat->zero_3 = 0x00000000010000000000000000000000000000. */
+  CHECK_ZERO(vmgi_mat->zero_3);
+  CHECK_ZERO(vmgi_mat->zero_4);
+  CHECK_ZERO(vmgi_mat->zero_5);
+  CHECK_ZERO(vmgi_mat->zero_6);
+  CHECK_ZERO(vmgi_mat->zero_7);
+  CHECK_ZERO(vmgi_mat->zero_8);
+  CHECK_ZERO(vmgi_mat->zero_9);
+  CHECK_ZERO(vmgi_mat->zero_10);
+  CHECK_VALUE(vmgi_mat->vmg_last_sector != 0);
+  CHECK_VALUE(vmgi_mat->vmgi_last_sector != 0);
+  CHECK_VALUE(vmgi_mat->vmgi_last_sector * 2 <= vmgi_mat->vmg_last_sector);
+  CHECK_VALUE(vmgi_mat->vmgi_last_sector * 2 <= vmgi_mat->vmg_last_sector);
+  CHECK_VALUE(vmgi_mat->vmg_nr_of_volumes != 0);
+  CHECK_VALUE(vmgi_mat->vmg_this_volume_nr != 0);
+  CHECK_VALUE(vmgi_mat->vmg_this_volume_nr <= vmgi_mat->vmg_nr_of_volumes);
+  CHECK_VALUE(vmgi_mat->disc_side == 1 || vmgi_mat->disc_side == 2);
+  CHECK_VALUE(vmgi_mat->vmg_nr_of_title_sets != 0);
+  CHECK_VALUE(vmgi_mat->vmgi_last_byte >= 341);
+  CHECK_VALUE(vmgi_mat->vmgi_last_byte / DVD_BLOCK_LEN <=
+              vmgi_mat->vmgi_last_sector);
+  /* It seems that first_play_pgc is optional. */
+  CHECK_VALUE(vmgi_mat->first_play_pgc < vmgi_mat->vmgi_last_byte);
+  CHECK_VALUE(vmgi_mat->vmgm_vobs == 0 ||
+              (vmgi_mat->vmgm_vobs > vmgi_mat->vmgi_last_sector &&
+               vmgi_mat->vmgm_vobs < vmgi_mat->vmg_last_sector));
+  CHECK_VALUE(vmgi_mat->tt_srpt <= vmgi_mat->vmgi_last_sector);
+  CHECK_VALUE(vmgi_mat->vmgm_pgci_ut <= vmgi_mat->vmgi_last_sector);
+  CHECK_VALUE(vmgi_mat->ptl_mait <= vmgi_mat->vmgi_last_sector);
+  CHECK_VALUE(vmgi_mat->vts_atrt <= vmgi_mat->vmgi_last_sector);
+  CHECK_VALUE(vmgi_mat->txtdt_mgi <= vmgi_mat->vmgi_last_sector);
+  CHECK_VALUE(vmgi_mat->vmgm_c_adt <= vmgi_mat->vmgi_last_sector);
+  CHECK_VALUE(vmgi_mat->vmgm_vobu_admap <= vmgi_mat->vmgi_last_sector);
+
+  CHECK_VALUE(vmgi_mat->nr_of_vmgm_audio_streams <= 1);
+  CHECK_VALUE(vmgi_mat->nr_of_vmgm_subp_streams <= 1);
+
+  return 1;
+}
+
+
+static int ifoRead_VTS(ifo_handle_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  vtsi_mat_t *vtsi_mat;
+  int i;
+
+  vtsi_mat = calloc(1, sizeof(vtsi_mat_t));
+  if(!vtsi_mat)
+    return 0;
+
+  ifofile->vtsi_mat = vtsi_mat;
+
+  if(!DVDFileSeek_(ifop->file, 0)) {
+    free(ifofile->vtsi_mat);
+    ifofile->vtsi_mat = NULL;
+    return 0;
+  }
+
+  if(!(DVDReadBytes(ifop->file, vtsi_mat, sizeof(vtsi_mat_t)))) {
+    free(ifofile->vtsi_mat);
+    ifofile->vtsi_mat = NULL;
+    return 0;
+  }
+
+  if(strncmp("DVDVIDEO-VTS", vtsi_mat->vts_identifier, 12) != 0) {
+    free(ifofile->vtsi_mat);
+    ifofile->vtsi_mat = NULL;
+    return 0;
+  }
+
+  read_video_attr(&vtsi_mat->vtsm_video_attr);
+  read_video_attr(&vtsi_mat->vts_video_attr);
+  read_audio_attr(&vtsi_mat->vtsm_audio_attr);
+  for(i=0; i<8; i++)
+    read_audio_attr(&vtsi_mat->vts_audio_attri);
+  read_subp_attr(&vtsi_mat->vtsm_subp_attr);
+  for(i=0; i<32; i++)
+    read_subp_attr(&vtsi_mat->vts_subp_attri);
+  B2N_32(vtsi_mat->vts_last_sector);
+  B2N_32(vtsi_mat->vtsi_last_sector);
+  B2N_32(vtsi_mat->vts_category);
+  B2N_32(vtsi_mat->vtsi_last_byte);
+  B2N_32(vtsi_mat->vtsm_vobs);
+  B2N_32(vtsi_mat->vtstt_vobs);
+  B2N_32(vtsi_mat->vts_ptt_srpt);
+  B2N_32(vtsi_mat->vts_pgcit);
+  B2N_32(vtsi_mat->vtsm_pgci_ut);
+  B2N_32(vtsi_mat->vts_tmapt);
+  B2N_32(vtsi_mat->vtsm_c_adt);
+  B2N_32(vtsi_mat->vtsm_vobu_admap);
+  B2N_32(vtsi_mat->vts_c_adt);
+  B2N_32(vtsi_mat->vts_vobu_admap);
+
+
+  CHECK_ZERO(vtsi_mat->zero_1);
+  CHECK_ZERO(vtsi_mat->zero_2);
+  CHECK_ZERO(vtsi_mat->zero_3);
+  CHECK_ZERO(vtsi_mat->zero_4);
+  CHECK_ZERO(vtsi_mat->zero_5);
+  CHECK_ZERO(vtsi_mat->zero_6);
+  CHECK_ZERO(vtsi_mat->zero_7);
+  CHECK_ZERO(vtsi_mat->zero_8);
+  CHECK_ZERO(vtsi_mat->zero_9);
+  CHECK_ZERO(vtsi_mat->zero_10);
+  CHECK_ZERO(vtsi_mat->zero_11);
+  CHECK_ZERO(vtsi_mat->zero_12);
+  CHECK_ZERO(vtsi_mat->zero_13);
+  CHECK_ZERO(vtsi_mat->zero_14);
+  CHECK_ZERO(vtsi_mat->zero_15);
+  CHECK_ZERO(vtsi_mat->zero_16);
+  CHECK_ZERO(vtsi_mat->zero_17);
+  CHECK_ZERO(vtsi_mat->zero_18);
+  CHECK_ZERO(vtsi_mat->zero_19);
+  CHECK_ZERO(vtsi_mat->zero_20);
+  CHECK_ZERO(vtsi_mat->zero_21);
+  CHECK_VALUE(vtsi_mat->vtsi_last_sector*2 <= vtsi_mat->vts_last_sector);
+  CHECK_VALUE(vtsi_mat->vtsi_last_byte/DVD_BLOCK_LEN <= vtsi_mat->vtsi_last_sector);
+  CHECK_VALUE(vtsi_mat->vtsm_vobs == 0 ||
+              (vtsi_mat->vtsm_vobs > vtsi_mat->vtsi_last_sector &&
+               vtsi_mat->vtsm_vobs < vtsi_mat->vts_last_sector));
+  CHECK_VALUE(vtsi_mat->vtstt_vobs == 0 ||
+              (vtsi_mat->vtstt_vobs > vtsi_mat->vtsi_last_sector &&
+               vtsi_mat->vtstt_vobs < vtsi_mat->vts_last_sector));
+  CHECK_VALUE(vtsi_mat->vts_ptt_srpt <= vtsi_mat->vtsi_last_sector);
+  CHECK_VALUE(vtsi_mat->vts_pgcit <= vtsi_mat->vtsi_last_sector);
+  CHECK_VALUE(vtsi_mat->vtsm_pgci_ut <= vtsi_mat->vtsi_last_sector);
+  CHECK_VALUE(vtsi_mat->vts_tmapt <= vtsi_mat->vtsi_last_sector);
+  CHECK_VALUE(vtsi_mat->vtsm_c_adt <= vtsi_mat->vtsi_last_sector);
+  CHECK_VALUE(vtsi_mat->vtsm_vobu_admap <= vtsi_mat->vtsi_last_sector);
+  CHECK_VALUE(vtsi_mat->vts_c_adt <= vtsi_mat->vtsi_last_sector);
+  CHECK_VALUE(vtsi_mat->vts_vobu_admap <= vtsi_mat->vtsi_last_sector);
+
+  CHECK_VALUE(vtsi_mat->nr_of_vtsm_audio_streams <= 1);
+  CHECK_VALUE(vtsi_mat->nr_of_vtsm_subp_streams <= 1);
+
+  CHECK_VALUE(vtsi_mat->nr_of_vts_audio_streams <= 8);
+  for(i = vtsi_mat->nr_of_vts_audio_streams; i < 8; i++)
+    CHECK_ZERO(vtsi_mat->vts_audio_attri);
+
+  CHECK_VALUE(vtsi_mat->nr_of_vts_subp_streams <= 32);
+  for(i = vtsi_mat->nr_of_vts_subp_streams; i < 32; i++)
+    CHECK_ZERO(vtsi_mat->vts_subp_attri);
+
+  for(i = 0; i < 8; i++) {
+    read_multichannel_ext(&vtsi_mat->vts_mu_audio_attri);
+    CHECK_ZERO0(vtsi_mat->vts_mu_audio_attri.zero1);
+    CHECK_ZERO0(vtsi_mat->vts_mu_audio_attri.zero2);
+    CHECK_ZERO0(vtsi_mat->vts_mu_audio_attri.zero3);
+    CHECK_ZERO0(vtsi_mat->vts_mu_audio_attri.zero4);
+    CHECK_ZERO0(vtsi_mat->vts_mu_audio_attri.zero5);
+    CHECK_ZERO(vtsi_mat->vts_mu_audio_attri.zero6);
+  }
+
+  return 1;
+}
+
+
+static int ifoRead_PGC_COMMAND_TBL(ifo_handle_t *ifofile,
+                                   pgc_command_tbl_t *cmd_tbl,
+                                   unsigned int offset) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  if(!DVDFileSeek_(ifop->file, offset))
+    return 0;
+
+  if(!(DVDReadBytes(ifop->file, cmd_tbl, PGC_COMMAND_TBL_SIZE)))
+    return 0;
+
+  B2N_16(cmd_tbl->nr_of_pre);
+  B2N_16(cmd_tbl->nr_of_post);
+  B2N_16(cmd_tbl->nr_of_cell);
+
+  CHECK_VALUE(cmd_tbl->nr_of_pre + cmd_tbl->nr_of_post + cmd_tbl->nr_of_cell<= 255);
+
+  if(cmd_tbl->nr_of_pre != 0) {
+    unsigned int pre_cmds_size  = cmd_tbl->nr_of_pre * COMMAND_DATA_SIZE;
+    cmd_tbl->pre_cmds = malloc(pre_cmds_size);
+    if(!cmd_tbl->pre_cmds)
+      return 0;
+
+    if(!(DVDReadBytes(ifop->file, cmd_tbl->pre_cmds, pre_cmds_size))) {
+      free(cmd_tbl->pre_cmds);
+      return 0;
+    }
+  }
+
+  if(cmd_tbl->nr_of_post != 0) {
+    unsigned int post_cmds_size = cmd_tbl->nr_of_post * COMMAND_DATA_SIZE;
+    cmd_tbl->post_cmds = malloc(post_cmds_size);
+    if(!cmd_tbl->post_cmds) {
+      if(cmd_tbl->pre_cmds)
+        free(cmd_tbl->pre_cmds);
+      return 0;
+    }
+    if(!(DVDReadBytes(ifop->file, cmd_tbl->post_cmds, post_cmds_size))) {
+      if(cmd_tbl->pre_cmds)
+        free(cmd_tbl->pre_cmds);
+      free(cmd_tbl->post_cmds);
+      return 0;
+    }
+  }
+
+  if(cmd_tbl->nr_of_cell != 0) {
+    unsigned int cell_cmds_size = cmd_tbl->nr_of_cell * COMMAND_DATA_SIZE;
+    cmd_tbl->cell_cmds = malloc(cell_cmds_size);
+    if(!cmd_tbl->cell_cmds) {
+      if(cmd_tbl->pre_cmds)
+        free(cmd_tbl->pre_cmds);
+      if(cmd_tbl->post_cmds)
+        free(cmd_tbl->post_cmds);
+      return 0;
+    }
+    if(!(DVDReadBytes(ifop->file, cmd_tbl->cell_cmds, cell_cmds_size))) {
+      if(cmd_tbl->pre_cmds)
+        free(cmd_tbl->pre_cmds);
+      if(cmd_tbl->post_cmds)
+        free(cmd_tbl->post_cmds);
+      free(cmd_tbl->cell_cmds);
+      return 0;
+    }
+  }
+
+  /*
+   * Make a run over all the commands and see that we can interpret them all?
+   */
+  return 1;
+}
+
+
+static void ifoFree_PGC_COMMAND_TBL(pgc_command_tbl_t *cmd_tbl) {
+  if(cmd_tbl) {
+    if(cmd_tbl->nr_of_pre && cmd_tbl->pre_cmds)
+      free(cmd_tbl->pre_cmds);
+    if(cmd_tbl->nr_of_post && cmd_tbl->post_cmds)
+      free(cmd_tbl->post_cmds);
+    if(cmd_tbl->nr_of_cell && cmd_tbl->cell_cmds)
+      free(cmd_tbl->cell_cmds);
+    free(cmd_tbl);
+  }
+}
+
+static int ifoRead_PGC_PROGRAM_MAP(ifo_handle_t *ifofile,
+                                   pgc_program_map_t *program_map,
+                                   unsigned int nr, unsigned int offset) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  unsigned int size = nr * sizeof(pgc_program_map_t);
+
+  if(!DVDFileSeek_(ifop->file, offset))
+    return 0;
+
+  if(!(DVDReadBytes(ifop->file, program_map, size)))
+    return 0;
+
+  return 1;
+}
+
+static int ifoRead_CELL_PLAYBACK_TBL(ifo_handle_t *ifofile,
+                                     cell_playback_t *cell_playback,
+                                     unsigned int nr, unsigned int offset) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  unsigned int i;
+  unsigned int size = nr * sizeof(cell_playback_t);
+
+  if(!DVDFileSeek_(ifop->file, offset))
+    return 0;
+
+  if(!(DVDReadBytes(ifop->file, cell_playback, size)))
+    return 0;
+
+  for(i = 0; i < nr; i++) {
+    read_cell_playback(&cell_playbacki);
+    /* Changed < to <= because this was false in the movie 'Pi'. */
+    CHECK_VALUE(cell_playbacki.last_vobu_start_sector <=
+                cell_playbacki.last_sector);
+    CHECK_VALUE(cell_playbacki.first_sector <=
+                cell_playbacki.last_vobu_start_sector);
+  }
+
+  return 1;
+}
+
+
+static int ifoRead_CELL_POSITION_TBL(ifo_handle_t *ifofile,
+                                     cell_position_t *cell_position,
+                                     unsigned int nr, unsigned int offset) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  unsigned int i;
+  unsigned int size = nr * sizeof(cell_position_t);
+
+  if(!DVDFileSeek_(ifop->file, offset))
+    return 0;
+
+  if(!(DVDReadBytes(ifop->file, cell_position, size)))
+    return 0;
+
+  for(i = 0; i < nr; i++) {
+    B2N_16(cell_positioni.vob_id_nr);
+    CHECK_ZERO(cell_positioni.zero_1);
+  }
+
+  return 1;
+}
+
+static int ifoRead_PGC(ifo_handle_t *ifofile, pgc_t *pgc, unsigned int offset) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  unsigned int i;
+
+  if(!DVDFileSeek_(ifop->file, offset))
+    return 0;
+
+  if(!(DVDReadBytes(ifop->file, pgc, PGC_SIZE)))
+    return 0;
+
+  read_user_ops(&pgc->prohibited_ops);
+  B2N_16(pgc->next_pgc_nr);
+  B2N_16(pgc->prev_pgc_nr);
+  B2N_16(pgc->goup_pgc_nr);
+  B2N_16(pgc->command_tbl_offset);
+  B2N_16(pgc->program_map_offset);
+  B2N_16(pgc->cell_playback_offset);
+  B2N_16(pgc->cell_position_offset);
+
+  for(i = 0; i < 8; i++)
+    B2N_16(pgc->audio_controli);
+  for(i = 0; i < 32; i++)
+    B2N_32(pgc->subp_controli);
+  for(i = 0; i < 16; i++)
+    B2N_32(pgc->palettei);
+
+  CHECK_ZERO(pgc->zero_1);
+  CHECK_VALUE(pgc->nr_of_programs <= pgc->nr_of_cells);
+
+  /* verify time (look at print_time) */
+  for(i = 0; i < 8; i++)
+    if(!(pgc->audio_controli & 0x8000)) /* The 'is present' bit */
+      CHECK_ZERO(pgc->audio_controli);
+  for(i = 0; i < 32; i++)
+    if(!(pgc->subp_controli & 0x80000000)) /* The 'is present' bit */
+      CHECK_ZERO(pgc->subp_controli);
+
+  /* Check that time is 0:0:0:0 also if nr_of_programs == 0 */
+  if(pgc->nr_of_programs == 0) {
+    CHECK_ZERO(pgc->still_time);
+    CHECK_ZERO(pgc->pg_playback_mode); /* ?? */
+    CHECK_VALUE(pgc->program_map_offset == 0);
+    CHECK_VALUE(pgc->cell_playback_offset == 0);
+    CHECK_VALUE(pgc->cell_position_offset == 0);
+  } else {
+    CHECK_VALUE(pgc->program_map_offset != 0);
+    CHECK_VALUE(pgc->cell_playback_offset != 0);
+    CHECK_VALUE(pgc->cell_position_offset != 0);
+  }
+
+  if(pgc->command_tbl_offset != 0) {
+    pgc->command_tbl = calloc(1, sizeof(pgc_command_tbl_t));
+    if(!pgc->command_tbl)
+      return 0;
+
+    if(!ifoRead_PGC_COMMAND_TBL(ifofile, pgc->command_tbl,
+                                offset + pgc->command_tbl_offset)) {
+      return 0;
+    }
+  } else {
+    pgc->command_tbl = NULL;
+  }
+
+  if(pgc->program_map_offset != 0 && pgc->nr_of_programs>0) {
+    pgc->program_map = calloc(pgc->nr_of_programs, sizeof(pgc_program_map_t));
+    if(!pgc->program_map) {
+      return 0;
+    }
+    if(!ifoRead_PGC_PROGRAM_MAP(ifofile, pgc->program_map,pgc->nr_of_programs,
+                                offset + pgc->program_map_offset)) {
+      return 0;
+    }
+  } else {
+    pgc->program_map = NULL;
+  }
+
+  if(pgc->cell_playback_offset != 0 && pgc->nr_of_cells>0) {
+    pgc->cell_playback = calloc(pgc->nr_of_cells, sizeof(cell_playback_t));
+    if(!pgc->cell_playback) {
+      return 0;
+    }
+    if(!ifoRead_CELL_PLAYBACK_TBL(ifofile, pgc->cell_playback,
+                                  pgc->nr_of_cells,
+                                  offset + pgc->cell_playback_offset)) {
+      return 0;
+    }
+  } else {
+    pgc->cell_playback = NULL;
+  }
+
+  if(pgc->cell_position_offset != 0 && pgc->nr_of_cells>0) {
+    pgc->cell_position = calloc(pgc->nr_of_cells, sizeof(cell_position_t));
+    if(!pgc->cell_position) {
+      return 0;
+    }
+    if(!ifoRead_CELL_POSITION_TBL(ifofile, pgc->cell_position,
+                                  pgc->nr_of_cells,
+                                  offset + pgc->cell_position_offset)) {
+      return 0;
+    }
+  } else {
+    pgc->cell_position = NULL;
+  }
+
+  return 1;
+}
+
+int ifoRead_FP_PGC(ifo_handle_t *ifofile) {
+
+  if(!ifofile)
+    return 0;
+
+  if(!ifofile->vmgi_mat)
+    return 0;
+
+  /* It seems that first_play_pgc is optional after all. */
+  ifofile->first_play_pgc = NULL;
+  if(!ifofile->vmgi_mat->first_play_pgc)
+    return 1;
+
+  ifofile->first_play_pgc = calloc(1, sizeof(pgc_t));
+  if(!ifofile->first_play_pgc)
+    return 0;
+
+  ifofile->first_play_pgc->ref_count = 1;
+  if(!ifoRead_PGC(ifofile, ifofile->first_play_pgc,
+                  ifofile->vmgi_mat->first_play_pgc)) {
+    ifoFree_PGC(&ifofile->first_play_pgc);
+    return 0;
+  }
+
+  return 1;
+}
+
+static void ifoFree_PGC(pgc_t **pgc) {
+  if(pgc && *pgc && (--(*pgc)->ref_count) <= 0) {
+    ifoFree_PGC_COMMAND_TBL((*pgc)->command_tbl);
+    if((*pgc)->program_map)
+      free((*pgc)->program_map);
+    if((*pgc)->cell_playback)
+      free((*pgc)->cell_playback);
+    if((*pgc)->cell_position)
+      free((*pgc)->cell_position);
+    free(*pgc);
+  }
+  if (pgc) {
+    *pgc = NULL;
+  }
+}
+
+void ifoFree_FP_PGC(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  if(ifofile->first_play_pgc) {
+    ifoFree_PGC(&ifofile->first_play_pgc);
+  }
+}
+
+
+int ifoRead_TT_SRPT(ifo_handle_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  tt_srpt_t *tt_srpt;
+  unsigned int i;
+  size_t info_length;
+
+  if(!ifofile)
+    return 0;
+
+  if(!ifofile->vmgi_mat)
+    return 0;
+
+  if(ifofile->vmgi_mat->tt_srpt == 0) /* mandatory */
+    return 0;
+
+  if(!DVDFileSeek_(ifop->file, ifofile->vmgi_mat->tt_srpt * DVD_BLOCK_LEN))
+    return 0;
+
+  tt_srpt = calloc(1, sizeof(tt_srpt_t));
+  if(!tt_srpt)
+    return 0;
+
+  ifofile->tt_srpt = tt_srpt;
+
+  if(!(DVDReadBytes(ifop->file, tt_srpt, TT_SRPT_SIZE))) {
+    Log0(ifop->ctx, "Unable to read read TT_SRPT.");
+    free(tt_srpt);
+    return 0;
+  }
+
+  B2N_16(tt_srpt->nr_of_srpts);
+  B2N_32(tt_srpt->last_byte);
+
+  /* E-One releases don't fill this field */
+  if(tt_srpt->last_byte == 0) {
+    tt_srpt->last_byte = tt_srpt->nr_of_srpts * sizeof(title_info_t) - 1 + TT_SRPT_SIZE;
+  }
+  info_length = tt_srpt->last_byte + 1 - TT_SRPT_SIZE;
+
+  tt_srpt->title = calloc(1, info_length);
+  if(!tt_srpt->title) {
+    free(tt_srpt);
+    ifofile->tt_srpt = NULL;
+    return 0;
+  }
+  if(!(DVDReadBytes(ifop->file, tt_srpt->title, info_length))) {
+    Log0(ifop->ctx, "libdvdread: Unable to read read TT_SRPT.");
+    ifoFree_TT_SRPT(ifofile);
+    return 0;
+  }
+
+  if(tt_srpt->nr_of_srpts>info_length/sizeof(title_info_t)){
+    Log1(ifop->ctx, "data mismatch: info_length (%zd)!= nr_of_srpts (%d). Truncating.",
+            info_length/sizeof(title_info_t),tt_srpt->nr_of_srpts);
+    tt_srpt->nr_of_srpts=info_length/sizeof(title_info_t);
+  }
+
+  for(i =  0; i < tt_srpt->nr_of_srpts; i++) {
+    B2N_16(tt_srpt->titlei.nr_of_ptts);
+    B2N_16(tt_srpt->titlei.parental_id);
+    B2N_32(tt_srpt->titlei.title_set_sector);
+  }
+
+
+  CHECK_ZERO(tt_srpt->zero_1);
+  CHECK_VALUE(tt_srpt->nr_of_srpts != 0);
+  CHECK_VALUE(tt_srpt->nr_of_srpts < 100); /* ?? */
+  CHECK_VALUE(tt_srpt->nr_of_srpts * sizeof(title_info_t) <= info_length);
+
+  for(i = 0; i < tt_srpt->nr_of_srpts; i++) {
+    read_playback_type(&tt_srpt->titlei.pb_ty);
+    CHECK_VALUE(tt_srpt->titlei.pb_ty.zero_1 == 0);
+    CHECK_VALUE(tt_srpt->titlei.nr_of_angles != 0);
+    CHECK_VALUE(tt_srpt->titlei.nr_of_angles < 10);
+    /* CHECK_VALUE(tt_srpt->titlei.nr_of_ptts != 0); */
+    /* XXX: this assertion breaks Ghostbusters: */
+    CHECK_VALUE(tt_srpt->titlei.nr_of_ptts < 1000); /* ?? */
+    CHECK_VALUE(tt_srpt->titlei.title_set_nr != 0);
+    CHECK_VALUE(tt_srpt->titlei.title_set_nr < 100); /* ?? */
+    CHECK_VALUE(tt_srpt->titlei.vts_ttn != 0);
+    CHECK_VALUE(tt_srpt->titlei.vts_ttn < 100); /* ?? */
+    /* CHECK_VALUE(tt_srpt->titlei.title_set_sector != 0); */
+  }
+
+  /* Make this a function */
+#if 0
+  if(memcmp((uint8_t *)tt_srpt->title +
+            tt_srpt->nr_of_srpts * sizeof(title_info_t),
+            my_friendly_zeros,
+            info_length - tt_srpt->nr_of_srpts * sizeof(title_info_t))) {
+    Log1(ifop->ctx, "VMG_PTT_SRPT slack is != 0, ");
+    hexdump((uint8_t *)tt_srpt->title +
+            tt_srpt->nr_of_srpts * sizeof(title_info_t),
+            info_length - tt_srpt->nr_of_srpts * sizeof(title_info_t));
+  }
+#endif
+
+  return 1;
+}
+
+
+void ifoFree_TT_SRPT(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  if(ifofile->tt_srpt) {
+    free(ifofile->tt_srpt->title);
+    ifofile->tt_srpt->title = NULL;
+    free(ifofile->tt_srpt);
+    ifofile->tt_srpt = NULL;
+  }
+}
+
+
+int ifoRead_VTS_PTT_SRPT(ifo_handle_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  vts_ptt_srpt_t *vts_ptt_srpt = NULL;
+  int info_length, i, j;
+  uint32_t *data = NULL;
+
+  if(!ifofile)
+    return 0;
+
+  if(!ifofile->vtsi_mat)
+    return 0;
+
+  if(ifofile->vtsi_mat->vts_ptt_srpt == 0) /* mandatory */
+    return 0;
+
+  if(!DVDFileSeek_(ifop->file,
+                   ifofile->vtsi_mat->vts_ptt_srpt * DVD_BLOCK_LEN))
+    return 0;
+
+  vts_ptt_srpt = calloc(1, sizeof(vts_ptt_srpt_t));
+  if(!vts_ptt_srpt)
+    return 0;
+
+  vts_ptt_srpt->title = NULL;
+  ifofile->vts_ptt_srpt = vts_ptt_srpt;
+
+  if(!(DVDReadBytes(ifop->file, vts_ptt_srpt, VTS_PTT_SRPT_SIZE))) {
+    Log0(ifop->ctx, "Unable to read PTT search table.");
+    goto fail;
+  }
+
+  B2N_16(vts_ptt_srpt->nr_of_srpts);
+  B2N_32(vts_ptt_srpt->last_byte);
+
+  CHECK_ZERO(vts_ptt_srpt->zero_1);
+  CHECK_VALUE(vts_ptt_srpt->nr_of_srpts != 0);
+  CHECK_VALUE(vts_ptt_srpt->nr_of_srpts < 100); /* ?? */
+
+  /* E-One releases don't fill this field */
+  if(vts_ptt_srpt->last_byte == 0) {
+    vts_ptt_srpt->last_byte  = vts_ptt_srpt->nr_of_srpts * sizeof(*data) - 1 + VTS_PTT_SRPT_SIZE;
+  }
+  info_length = vts_ptt_srpt->last_byte + 1 - VTS_PTT_SRPT_SIZE;
+  data = calloc(1, info_length);
+  if(!data)
+    goto fail;
+
+  if(!(DVDReadBytes(ifop->file, data, info_length))) {
+    Log0(ifop->ctx, "Unable to read PTT search table.");
+    goto fail;
+  }
+
+  if(vts_ptt_srpt->nr_of_srpts > info_length / sizeof(*data)) {
+    Log0(ifop->ctx, "PTT search table too small.");
+    goto fail;
+  }
+
+  if(vts_ptt_srpt->nr_of_srpts == 0) {
+    Log0(ifop->ctx, "Zero entries in PTT search table.");
+    goto fail;
+  }
+
+  for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) {
+    /* Transformers 3 has PTT start bytes that point outside the SRPT PTT */
+    uint32_t start = datai;
+    B2N_32(start);
+    if(start + sizeof(ptt_info_t) > vts_ptt_srpt->last_byte + 1) {
+      /* don't mess with any bytes beyond the end of the allocation */
+      vts_ptt_srpt->nr_of_srpts = i;
+      break;
+    }
+    datai = start;
+    /* assert(datai + sizeof(ptt_info_t) <= vts_ptt_srpt->last_byte + 1);
+       Magic Knight Rayearth Daybreak is mastered very strange and has
+       Titles with 0 PTTs. They all have a datai offsets beyond the end of
+       of the vts_ptt_srpt structure. */
+    CHECK_VALUE(datai + sizeof(ptt_info_t) <= vts_ptt_srpt->last_byte + 1 + 4);
+  }
+
+  vts_ptt_srpt->ttu_offset = data;
+
+  vts_ptt_srpt->title = calloc(vts_ptt_srpt->nr_of_srpts, sizeof(ttu_t));
+  if(!vts_ptt_srpt->title)
+    goto fail;
+
+  for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) {
+    int n;
+    if(i < vts_ptt_srpt->nr_of_srpts - 1)
+      n = (datai+1 - datai);
+    else
+      n = (vts_ptt_srpt->last_byte + 1 - datai);
+
+    /* assert(n > 0 && (n % 4) == 0);
+       Magic Knight Rayearth Daybreak is mastered very strange and has
+       Titles with 0 PTTs. */
+    if(n < 0) n = 0;
+
+    /* DVDs created by the VDR-to-DVD device LG RC590M violate the following requirement */
+    CHECK_VALUE(n % 4 == 0);
+
+    vts_ptt_srpt->titlei.nr_of_ptts = n / 4;
+    vts_ptt_srpt->titlei.ptt = calloc(n, sizeof(ptt_info_t));
+    if(!vts_ptt_srpt->titlei.ptt) {
+      for(n = 0; n < i; n++)
+        free(vts_ptt_srpt->titlen.ptt);
+
+      goto fail;
+    }
+    for(j = 0; j < vts_ptt_srpt->titlei.nr_of_ptts; j++) {
+      /* The assert placed here because of Magic Knight Rayearth Daybreak */
+      CHECK_VALUE(datai + sizeof(ptt_info_t) <= vts_ptt_srpt->last_byte + 1);
+      vts_ptt_srpt->titlei.pttj.pgcn
+        = *(uint16_t*)(((char *)data) + datai + 4*j - VTS_PTT_SRPT_SIZE);
+      vts_ptt_srpt->titlei.pttj.pgn
+        = *(uint16_t*)(((char *)data) + datai + 4*j + 2 - VTS_PTT_SRPT_SIZE);
+    }
+  }
+
+  for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) {
+    for(j = 0; j < vts_ptt_srpt->titlei.nr_of_ptts; j++) {
+      B2N_16(vts_ptt_srpt->titlei.pttj.pgcn);
+      B2N_16(vts_ptt_srpt->titlei.pttj.pgn);
+    }
+  }
+
+  for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) {
+    CHECK_VALUE(vts_ptt_srpt->titlei.nr_of_ptts < 1000); /* ?? */
+    for(j = 0; j < vts_ptt_srpt->titlei.nr_of_ptts; j++) {
+      CHECK_VALUE(vts_ptt_srpt->titlei.pttj.pgcn != 0 );
+      CHECK_VALUE(vts_ptt_srpt->titlei.pttj.pgcn < 1000); /* ?? */
+      CHECK_VALUE(vts_ptt_srpt->titlei.pttj.pgn != 0);
+      CHECK_VALUE(vts_ptt_srpt->titlei.pttj.pgn < 100); /* ?? */
+      //don't abort here. E-One DVDs contain PTT with pgcn or pgn == 0
+    }
+  }
+
+  return 1;
+
+fail:
+  free(data);
+  ifofile->vts_ptt_srpt = NULL;
+  free(vts_ptt_srpt->title);
+  free(vts_ptt_srpt);
+  return 0;
+}
+
+
+void ifoFree_VTS_PTT_SRPT(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  if(ifofile->vts_ptt_srpt) {
+    int i;
+    for(i = 0; i < ifofile->vts_ptt_srpt->nr_of_srpts; i++)
+      free(ifofile->vts_ptt_srpt->titlei.ptt);
+    free(ifofile->vts_ptt_srpt->ttu_offset);
+    free(ifofile->vts_ptt_srpt->title);
+    free(ifofile->vts_ptt_srpt);
+    ifofile->vts_ptt_srpt = 0;
+  }
+}
+
+
+int ifoRead_PTL_MAIT(ifo_handle_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  ptl_mait_t *ptl_mait;
+  int info_length;
+  unsigned int i, j;
+
+  if(!ifofile)
+    return 0;
+
+  if(!ifofile->vmgi_mat)
+    return 0;
+
+  if(!ifofile->vmgi_mat->ptl_mait)
+    return 1;
+
+  if(!DVDFileSeek_(ifop->file, ifofile->vmgi_mat->ptl_mait * DVD_BLOCK_LEN))
+    return 0;
+
+  ptl_mait = calloc(1, sizeof(ptl_mait_t));
+  if(!ptl_mait)
+    return 0;
+
+  ifofile->ptl_mait = ptl_mait;
+
+  if(!(DVDReadBytes(ifop->file, ptl_mait, PTL_MAIT_SIZE))) {
+    free(ptl_mait);
+    ifofile->ptl_mait = NULL;
+    return 0;
+  }
+
+  B2N_16(ptl_mait->nr_of_countries);
+  B2N_16(ptl_mait->nr_of_vtss);
+  B2N_32(ptl_mait->last_byte);
+
+  CHECK_VALUE(ptl_mait->nr_of_countries != 0);
+  CHECK_VALUE(ptl_mait->nr_of_countries < 100); /* ?? */
+  CHECK_VALUE(ptl_mait->nr_of_vtss != 0);
+  CHECK_VALUE(ptl_mait->nr_of_vtss < 100); /* ?? */
+  CHECK_VALUE(ptl_mait->nr_of_countries * PTL_MAIT_COUNTRY_SIZE
+              <= ptl_mait->last_byte + 1 - PTL_MAIT_SIZE);
+
+  info_length = ptl_mait->nr_of_countries * sizeof(ptl_mait_country_t);
+  ptl_mait->countries = calloc(1, info_length);
+  if(!ptl_mait->countries) {
+    free(ptl_mait);
+    ifofile->ptl_mait = NULL;
+    return 0;
+  }
+  for(i = 0; i < ptl_mait->nr_of_countries; i++) {
+    ptl_mait->countriesi.pf_ptl_mai = NULL;
+  }
+
+  for(i = 0; i < ptl_mait->nr_of_countries; i++) {
+    if(!(DVDReadBytes(ifop->file, &ptl_mait->countriesi, PTL_MAIT_COUNTRY_SIZE))) {
+      Log0(ifop->ctx, "Unable to read PTL_MAIT.");
+      free(ptl_mait->countries);
+      free(ptl_mait);
+      ifofile->ptl_mait = NULL;
+      return 0;
+    }
+  }
+
+  for(i = 0; i < ptl_mait->nr_of_countries; i++) {
+    B2N_16(ptl_mait->countriesi.country_code);
+    B2N_16(ptl_mait->countriesi.pf_ptl_mai_start_byte);
+  }
+
+  for(i = 0; i < ptl_mait->nr_of_countries; i++) {
+    CHECK_ZERO(ptl_mait->countriesi.zero_1);
+    CHECK_ZERO(ptl_mait->countriesi.zero_2);
+    CHECK_VALUE(ptl_mait->countriesi.pf_ptl_mai_start_byte
+                + sizeof(pf_level_t) * (ptl_mait->nr_of_vtss + 1) <= ptl_mait->last_byte + 1);
+  }
+
+  for(i = 0; i < ptl_mait->nr_of_countries; i++) {
+    uint16_t *pf_temp;
+
+    if(!DVDFileSeek_(ifop->file,
+                     ifofile->vmgi_mat->ptl_mait * DVD_BLOCK_LEN
+                     + ptl_mait->countriesi.pf_ptl_mai_start_byte)) {
+      Log0(ifop->ctx, "Unable to seek PTL_MAIT table at index %d.",i);
+      free(ptl_mait->countries);
+      free(ptl_mait);
+      ifofile->ptl_mait = NULL;
+      return 0;
+    }
+    info_length = (ptl_mait->nr_of_vtss + 1) * sizeof(pf_level_t);
+    pf_temp = calloc(1, info_length);
+    if(!pf_temp) {
+      free_ptl_mait(ptl_mait, i);
+      ifofile->ptl_mait = NULL;
+      return 0;
+    }
+    if(!(DVDReadBytes(ifop->file, pf_temp, info_length))) {
+      Log0(ifop->ctx, "Unable to read PTL_MAIT table at index %d.",i);
+      free(pf_temp);
+      free_ptl_mait(ptl_mait, i);
+      ifofile->ptl_mait = NULL;
+      return 0;
+    }
+    for (j = 0; j < ((ptl_mait->nr_of_vtss + 1U) * 8U); j++) {
+      B2N_16(pf_tempj);
+    }
+    ptl_mait->countriesi.pf_ptl_mai = calloc(1, info_length);
+    if(!ptl_mait->countriesi.pf_ptl_mai) {
+      free(pf_temp);
+      free_ptl_mait(ptl_mait, i);
+      ifofile->ptl_mait = NULL;
+      return 0;
+    }
+    { /* Transpose the array so we can use C indexing. */
+      int level, vts;
+      for(level = 0; level < PTL_MAIT_NUM_LEVEL; level++) {
+        for(vts = 0; vts <= ptl_mait->nr_of_vtss; vts++) {
+          ptl_mait->countriesi.pf_ptl_maivtslevel =
+            pf_temp(7-level)*(ptl_mait->nr_of_vtss+1) + vts;
+        }
+      }
+      free(pf_temp);
+    }
+  }
+  return 1;
+}
+
+void ifoFree_PTL_MAIT(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  if(ifofile->ptl_mait) {
+    unsigned int i;
+
+    for(i = 0; i < ifofile->ptl_mait->nr_of_countries; i++) {
+      free(ifofile->ptl_mait->countriesi.pf_ptl_mai);
+    }
+    free(ifofile->ptl_mait->countries);
+    free(ifofile->ptl_mait);
+    ifofile->ptl_mait = NULL;
+  }
+}
+
+int ifoRead_VTS_TMAPT(ifo_handle_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  vts_tmapt_t *vts_tmapt;
+  uint32_t *vts_tmap_srp;
+  unsigned int offset;
+  int info_length;
+  unsigned int i, j;
+
+  if(!ifofile)
+    return 0;
+
+  if(!ifofile->vtsi_mat)
+    return 0;
+
+  if(ifofile->vtsi_mat->vts_tmapt == 0) {
+    ifofile->vts_tmapt = NULL;
+    return 1;
+  }
+
+  offset = ifofile->vtsi_mat->vts_tmapt * DVD_BLOCK_LEN;
+
+  if(!DVDFileSeek_(ifop->file, offset))
+    return 0;
+
+  vts_tmapt = calloc(1, sizeof(vts_tmapt_t));
+  if(!vts_tmapt)
+    return 0;
+
+  ifofile->vts_tmapt = vts_tmapt;
+
+  if(!(DVDReadBytes(ifop->file, vts_tmapt, VTS_TMAPT_SIZE))) {
+    Log0(ifop->ctx, "Unable to read VTS_TMAPT.");
+    free(vts_tmapt);
+    ifofile->vts_tmapt = NULL;
+    return 0;
+  }
+
+  B2N_16(vts_tmapt->nr_of_tmaps);
+  B2N_32(vts_tmapt->last_byte);
+
+  CHECK_ZERO(vts_tmapt->zero_1);
+
+  info_length = vts_tmapt->nr_of_tmaps * 4;
+
+  vts_tmap_srp = calloc(1, info_length);
+  if(!vts_tmap_srp) {
+    free(vts_tmapt);
+    ifofile->vts_tmapt = NULL;
+    return 0;
+  }
+
+  vts_tmapt->tmap_offset = vts_tmap_srp;
+
+  if(!(DVDReadBytes(ifop->file, vts_tmap_srp, info_length))) {
+    Log0(ifop->ctx, "Unable to read VTS_TMAPT.");
+    free(vts_tmap_srp);
+    free(vts_tmapt);
+    ifofile->vts_tmapt = NULL;
+    return 0;
+  }
+
+  for (i = 0; i < vts_tmapt->nr_of_tmaps; i++) {
+    B2N_32(vts_tmap_srpi);
+  }
+
+
+  info_length = vts_tmapt->nr_of_tmaps * sizeof(vts_tmap_t);
+
+  vts_tmapt->tmap = calloc(1, info_length);
+  if(!vts_tmapt->tmap) {
+    free(vts_tmap_srp);
+    free(vts_tmapt);
+    ifofile->vts_tmapt = NULL;
+    return 0;
+  }
+
+  for(i = 0; i < vts_tmapt->nr_of_tmaps; i++) {
+    if(!DVDFileSeek_(ifop->file, offset + vts_tmap_srpi)) {
+      ifoFree_VTS_TMAPT(ifofile);
+      return 0;
+    }
+
+    if(!(DVDReadBytes(ifop->file, &vts_tmapt->tmapi, VTS_TMAP_SIZE))) {
+      Log0(ifop->ctx, "Unable to read VTS_TMAP.");
+      ifoFree_VTS_TMAPT(ifofile);
+      return 0;
+    }
+
+    B2N_16(vts_tmapt->tmapi.nr_of_entries);
+    CHECK_ZERO(vts_tmapt->tmapi.zero_1);
+
+    if(vts_tmapt->tmapi.nr_of_entries == 0) { /* Early out if zero entries */
+      vts_tmapt->tmapi.map_ent = NULL;
+      continue;
+    }
+
+    info_length = vts_tmapt->tmapi.nr_of_entries * sizeof(map_ent_t);
+
+    vts_tmapt->tmapi.map_ent = calloc(1, info_length);
+    if(!vts_tmapt->tmapi.map_ent) {
+      ifoFree_VTS_TMAPT(ifofile);
+      return 0;
+    }
+
+    if(!(DVDReadBytes(ifop->file, vts_tmapt->tmapi.map_ent, info_length))) {
+      Log0(ifop->ctx, "Unable to read VTS_TMAP_ENT.");
+      ifoFree_VTS_TMAPT(ifofile);
+      return 0;
+    }
+
+    for(j = 0; j < vts_tmapt->tmapi.nr_of_entries; j++)
+      B2N_32(vts_tmapt->tmapi.map_entj);
+  }
+
+  return 1;
+}
+
+void ifoFree_VTS_TMAPT(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  if(ifofile->vts_tmapt) {
+    unsigned int i;
+
+    for(i = 0; i < ifofile->vts_tmapt->nr_of_tmaps; i++)
+      if(ifofile->vts_tmapt->tmapi.map_ent)
+        free(ifofile->vts_tmapt->tmapi.map_ent);
+    free(ifofile->vts_tmapt->tmap);
+    free(ifofile->vts_tmapt->tmap_offset);
+    free(ifofile->vts_tmapt);
+    ifofile->vts_tmapt = NULL;
+  }
+}
+
+
+int ifoRead_TITLE_C_ADT(ifo_handle_t *ifofile) {
+
+  if(!ifofile)
+    return 0;
+
+  if(!ifofile->vtsi_mat)
+    return 0;
+
+  if(ifofile->vtsi_mat->vts_c_adt == 0) /* mandatory */
+    return 0;
+
+  ifofile->vts_c_adt = calloc(1, sizeof(c_adt_t));
+  if(!ifofile->vts_c_adt)
+    return 0;
+
+  if(!ifoRead_C_ADT_internal(ifofile, ifofile->vts_c_adt,
+                             ifofile->vtsi_mat->vts_c_adt)) {
+    free(ifofile->vts_c_adt);
+    ifofile->vts_c_adt = NULL;
+    return 0;
+  }
+
+  return 1;
+}
+
+int ifoRead_C_ADT(ifo_handle_t *ifofile) {
+  unsigned int sector;
+
+  if(!ifofile)
+    return 0;
+
+  if(ifofile->vmgi_mat) {
+    if(ifofile->vmgi_mat->vmgm_c_adt == 0)
+      return 1;
+    sector = ifofile->vmgi_mat->vmgm_c_adt;
+  } else if(ifofile->vtsi_mat) {
+    if(ifofile->vtsi_mat->vtsm_c_adt == 0)
+      return 1;
+    sector = ifofile->vtsi_mat->vtsm_c_adt;
+  } else {
+    return 0;
+  }
+
+  ifofile->menu_c_adt = calloc(1, sizeof(c_adt_t));
+  if(!ifofile->menu_c_adt)
+    return 0;
+
+  if(!ifoRead_C_ADT_internal(ifofile, ifofile->menu_c_adt, sector)) {
+    free(ifofile->menu_c_adt);
+    ifofile->menu_c_adt = NULL;
+    return 0;
+  }
+
+  return 1;
+}
+
+static int ifoRead_C_ADT_internal(ifo_handle_t *ifofile,
+                                  c_adt_t *c_adt, unsigned int sector) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  size_t i, info_length;
+
+  if(!DVDFileSeek_(ifop->file, sector * DVD_BLOCK_LEN))
+    return 0;
+
+  if(!(DVDReadBytes(ifop->file, c_adt, C_ADT_SIZE)))
+    return 0;
+
+  B2N_16(c_adt->nr_of_vobs);
+  B2N_32(c_adt->last_byte);
+
+  if(c_adt->last_byte + 1 < C_ADT_SIZE)
+    return 0;
+
+  info_length = c_adt->last_byte + 1 - C_ADT_SIZE;
+
+  CHECK_ZERO(c_adt->zero_1);
+  /* assert(c_adt->nr_of_vobs > 0);
+     Magic Knight Rayearth Daybreak is mastered very strange and has
+     Titles with a VOBS that has no cells. */
+  CHECK_VALUE(info_length % sizeof(cell_adr_t) == 0);
+
+  /* assert(info_length / sizeof(cell_adr_t) >= c_adt->nr_of_vobs);
+     Enemy of the State region 2 (de) has Titles where nr_of_vobs field
+     is to high, they high ones are never referenced though. */
+  if(info_length / sizeof(cell_adr_t) < c_adt->nr_of_vobs) {
+    Log1(ifop->ctx, "C_ADT nr_of_vobs > available info entries");
+    c_adt->nr_of_vobs = info_length / sizeof(cell_adr_t);
+  }
+
+  c_adt->cell_adr_table = calloc(1, info_length);
+  if(!c_adt->cell_adr_table)
+    return 0;
+
+  if(info_length &&
+     !(DVDReadBytes(ifop->file, c_adt->cell_adr_table, info_length))) {
+    free(c_adt->cell_adr_table);
+    return 0;
+  }
+
+  for(i = 0; i < info_length/sizeof(cell_adr_t); i++) {
+    B2N_16(c_adt->cell_adr_tablei.vob_id);
+    B2N_32(c_adt->cell_adr_tablei.start_sector);
+    B2N_32(c_adt->cell_adr_tablei.last_sector);
+
+    CHECK_ZERO(c_adt->cell_adr_tablei.zero_1);
+    CHECK_VALUE(c_adt->cell_adr_tablei.vob_id > 0);
+    CHECK_VALUE(c_adt->cell_adr_tablei.vob_id <= c_adt->nr_of_vobs);
+    CHECK_VALUE(c_adt->cell_adr_tablei.cell_id > 0);
+    CHECK_VALUE(c_adt->cell_adr_tablei.start_sector <
+                c_adt->cell_adr_tablei.last_sector);
+  }
+
+  return 1;
+}
+
+
+static void ifoFree_C_ADT_internal(c_adt_t *c_adt) {
+  if(c_adt) {
+    free(c_adt->cell_adr_table);
+    free(c_adt);
+  }
+}
+
+void ifoFree_C_ADT(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  ifoFree_C_ADT_internal(ifofile->menu_c_adt);
+  ifofile->menu_c_adt = NULL;
+}
+
+void ifoFree_TITLE_C_ADT(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  ifoFree_C_ADT_internal(ifofile->vts_c_adt);
+  ifofile->vts_c_adt = NULL;
+}
+
+int ifoRead_TITLE_VOBU_ADMAP(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return 0;
+
+  if(!ifofile->vtsi_mat)
+    return 0;
+
+  if(ifofile->vtsi_mat->vts_vobu_admap == 0) /* mandatory */
+    return 0;
+
+  ifofile->vts_vobu_admap = calloc(1, sizeof(vobu_admap_t));
+  if(!ifofile->vts_vobu_admap)
+    return 0;
+
+  if(!ifoRead_VOBU_ADMAP_internal(ifofile, ifofile->vts_vobu_admap,
+                                  ifofile->vtsi_mat->vts_vobu_admap)) {
+    free(ifofile->vts_vobu_admap);
+    ifofile->vts_vobu_admap = NULL;
+    return 0;
+  }
+
+  return 1;
+}
+
+int ifoRead_VOBU_ADMAP(ifo_handle_t *ifofile) {
+  unsigned int sector;
+
+  if(!ifofile)
+    return 0;
+
+  if(ifofile->vmgi_mat) {
+    if(ifofile->vmgi_mat->vmgm_vobu_admap == 0)
+      return 1;
+    sector = ifofile->vmgi_mat->vmgm_vobu_admap;
+  } else if(ifofile->vtsi_mat) {
+    if(ifofile->vtsi_mat->vtsm_vobu_admap == 0)
+      return 1;
+    sector = ifofile->vtsi_mat->vtsm_vobu_admap;
+  } else {
+    return 0;
+  }
+
+  ifofile->menu_vobu_admap = calloc(1, sizeof(vobu_admap_t));
+  if(!ifofile->menu_vobu_admap)
+    return 0;
+
+  if(!ifoRead_VOBU_ADMAP_internal(ifofile, ifofile->menu_vobu_admap, sector)) {
+    free(ifofile->menu_vobu_admap);
+    ifofile->menu_vobu_admap = NULL;
+    return 0;
+  }
+
+  return 1;
+}
+
+static int ifoRead_VOBU_ADMAP_internal(ifo_handle_t *ifofile,
+                                       vobu_admap_t *vobu_admap,
+                                       unsigned int sector) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  unsigned int i;
+  int info_length;
+
+  if(!DVDFileSeekForce_(ifop->file, sector * DVD_BLOCK_LEN, sector))
+    return 0;
+
+  if(!(DVDReadBytes(ifop->file, vobu_admap, VOBU_ADMAP_SIZE)))
+    return 0;
+
+  B2N_32(vobu_admap->last_byte);
+
+  info_length = vobu_admap->last_byte + 1 - VOBU_ADMAP_SIZE;
+  /* assert(info_length > 0);
+     Magic Knight Rayearth Daybreak is mastered very strange and has
+     Titles with a VOBS that has no VOBUs. */
+  CHECK_VALUE(info_length % sizeof(uint32_t) == 0);
+
+  vobu_admap->vobu_start_sectors = calloc(1, info_length);
+  if(!vobu_admap->vobu_start_sectors) {
+    return 0;
+  }
+  if(info_length &&
+     !(DVDReadBytes(ifop->file,
+                    vobu_admap->vobu_start_sectors, info_length))) {
+    free(vobu_admap->vobu_start_sectors);
+    return 0;
+  }
+
+  for(i = 0; i < info_length/sizeof(uint32_t); i++)
+    B2N_32(vobu_admap->vobu_start_sectorsi);
+
+  return 1;
+}
+
+
+static void ifoFree_VOBU_ADMAP_internal(vobu_admap_t *vobu_admap) {
+  if(vobu_admap) {
+    free(vobu_admap->vobu_start_sectors);
+    free(vobu_admap);
+  }
+}
+
+void ifoFree_VOBU_ADMAP(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  ifoFree_VOBU_ADMAP_internal(ifofile->menu_vobu_admap);
+  ifofile->menu_vobu_admap = NULL;
+}
+
+void ifoFree_TITLE_VOBU_ADMAP(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  ifoFree_VOBU_ADMAP_internal(ifofile->vts_vobu_admap);
+  ifofile->vts_vobu_admap = NULL;
+}
+
+int ifoRead_PGCIT(ifo_handle_t *ifofile) {
+
+  if(!ifofile)
+    return 0;
+
+  if(!ifofile->vtsi_mat)
+    return 0;
+
+  if(ifofile->vtsi_mat->vts_pgcit == 0) /* mandatory */
+    return 0;
+
+  ifofile->vts_pgcit = calloc(1, sizeof(pgcit_t));
+  if(!ifofile->vts_pgcit)
+    return 0;
+
+  ifofile->vts_pgcit->ref_count = 1;
+  if(!ifoRead_PGCIT_internal(ifofile, ifofile->vts_pgcit,
+                             ifofile->vtsi_mat->vts_pgcit * DVD_BLOCK_LEN)) {
+    free(ifofile->vts_pgcit);
+    ifofile->vts_pgcit = NULL;
+    return 0;
+  }
+
+  return 1;
+}
+
+static int find_dup_pgc(pgci_srp_t *pgci_srp, uint32_t start_byte, int count) {
+  int i;
+
+  for(i = 0; i < count; i++) {
+    if(pgci_srpi.pgc_start_byte == start_byte) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+static int ifoRead_PGCIT_internal(ifo_handle_t *ifofile, pgcit_t *pgcit,
+                                  unsigned int offset) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  int i, info_length;
+  uint8_t *data, *ptr;
+
+  if(!DVDFileSeek_(ifop->file, offset))
+    return 0;
+
+  if(!(DVDReadBytes(ifop->file, pgcit, PGCIT_SIZE)))
+    return 0;
+
+  B2N_16(pgcit->nr_of_pgci_srp);
+  B2N_32(pgcit->last_byte);
+
+  CHECK_ZERO(pgcit->zero_1);
+  /* assert(pgcit->nr_of_pgci_srp != 0);
+     Magic Knight Rayearth Daybreak is mastered very strange and has
+     Titles with 0 PTTs. */
+  CHECK_VALUE(pgcit->nr_of_pgci_srp < 10000); /* ?? seen max of 1338 */
+
+  info_length = pgcit->nr_of_pgci_srp * PGCI_SRP_SIZE;
+  data = calloc(1, info_length);
+  if(!data)
+    return 0;
+
+  if(info_length && !(DVDReadBytes(ifop->file, data, info_length))) {
+    free(data);
+    return 0;
+  }
+
+  pgcit->pgci_srp = calloc(pgcit->nr_of_pgci_srp, sizeof(pgci_srp_t));
+  if(!pgcit->pgci_srp) {
+    free(data);
+    return 0;
+  }
+  ptr = data;
+  for(i = 0; i < pgcit->nr_of_pgci_srp; i++) {
+    memcpy(&pgcit->pgci_srpi, ptr, PGCI_SRP_SIZE);
+    ptr += PGCI_SRP_SIZE;
+    read_pgci_srp(&pgcit->pgci_srpi);
+    CHECK_VALUE(pgcit->pgci_srpi.zero_1 == 0);
+  }
+  free(data);
+
+  for(i = 0; i < pgcit->nr_of_pgci_srp; i++)
+    CHECK_VALUE(pgcit->pgci_srpi.pgc_start_byte + PGC_SIZE <= pgcit->last_byte+1);
+
+  for(i = 0; i < pgcit->nr_of_pgci_srp; i++) {
+    int dup;
+    if((dup = find_dup_pgc(pgcit->pgci_srp, pgcit->pgci_srpi.pgc_start_byte, i)) >= 0) {
+      pgcit->pgci_srpi.pgc = pgcit->pgci_srpdup.pgc;
+      pgcit->pgci_srpi.pgc->ref_count++;
+      continue;
+    }
+    pgcit->pgci_srpi.pgc = calloc(1, sizeof(pgc_t));
+    if(!pgcit->pgci_srpi.pgc) {
+      int j;
+      for(j = 0; j < i; j++) {
+        ifoFree_PGC(&pgcit->pgci_srpj.pgc);
+      }
+      goto fail;
+    }
+    pgcit->pgci_srpi.pgc->ref_count = 1;
+    if(!ifoRead_PGC(ifofile, pgcit->pgci_srpi.pgc,
+                    offset + pgcit->pgci_srpi.pgc_start_byte)) {
+      Log0(ifop->ctx, "Unable to read invalid PCG");
+      //E-One releases provide boggus PGC, ie: out of bound start_byte
+      free(pgcit->pgci_srpi.pgc);
+      pgcit->pgci_srpi.pgc = NULL;
+    }
+  }
+
+  return 1;
+fail:
+  free(pgcit->pgci_srp);
+  pgcit->pgci_srp = NULL;
+  return 0;
+}
+
+static void ifoFree_PGCIT_internal(pgcit_t **pgcit) {
+  if(pgcit && *pgcit && (--(*pgcit)->ref_count <= 0)) {
+    int i;
+    for(i = 0; i < (*pgcit)->nr_of_pgci_srp; i++)
+    {
+      ifoFree_PGC(&(*pgcit)->pgci_srpi.pgc);
+    }
+    free((*pgcit)->pgci_srp);
+    free(*pgcit);
+  }
+  if (pgcit)
+    *pgcit = NULL;
+}
+
+void ifoFree_PGCIT(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  if(ifofile->vts_pgcit) {
+    ifoFree_PGCIT_internal(&ifofile->vts_pgcit);
+  }
+}
+
+static int find_dup_lut(pgci_lu_t *lu, uint32_t start_byte, int count) {
+  int i;
+
+  for(i = 0; i < count; i++) {
+    if(lui.lang_start_byte == start_byte) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+int ifoRead_PGCI_UT(ifo_handle_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  pgci_ut_t *pgci_ut;
+  unsigned int sector;
+  unsigned int i;
+  int info_length;
+  uint8_t *data, *ptr;
+
+  if(!ifofile)
+    return 0;
+
+  if(ifofile->vmgi_mat) {
+    if(ifofile->vmgi_mat->vmgm_pgci_ut == 0)
+      return 1;
+    sector = ifofile->vmgi_mat->vmgm_pgci_ut;
+  } else if(ifofile->vtsi_mat) {
+    if(ifofile->vtsi_mat->vtsm_pgci_ut == 0)
+      return 1;
+    sector = ifofile->vtsi_mat->vtsm_pgci_ut;
+  } else {
+    return 0;
+  }
+
+  ifofile->pgci_ut = calloc(1, sizeof(pgci_ut_t));
+  if(!ifofile->pgci_ut)
+    return 0;
+
+  if(!DVDFileSeek_(ifop->file, sector * DVD_BLOCK_LEN)) {
+    free(ifofile->pgci_ut);
+    ifofile->pgci_ut = NULL;
+    return 0;
+  }
+
+  if(!(DVDReadBytes(ifop->file, ifofile->pgci_ut, PGCI_UT_SIZE))) {
+    free(ifofile->pgci_ut);
+    ifofile->pgci_ut = NULL;
+    return 0;
+  }
+
+  pgci_ut = ifofile->pgci_ut;
+
+  B2N_16(pgci_ut->nr_of_lus);
+  B2N_32(pgci_ut->last_byte);
+
+  CHECK_ZERO(pgci_ut->zero_1);
+  CHECK_VALUE(pgci_ut->nr_of_lus != 0);
+  CHECK_VALUE(pgci_ut->nr_of_lus < 100); /* ?? 3-4 ? */
+  CHECK_VALUE((uint32_t)pgci_ut->nr_of_lus * PGCI_LU_SIZE < pgci_ut->last_byte);
+
+  info_length = pgci_ut->nr_of_lus * PGCI_LU_SIZE;
+  data = calloc(1, info_length);
+  if(!data) {
+    free(pgci_ut);
+    ifofile->pgci_ut = NULL;
+    return 0;
+  }
+  if(!(DVDReadBytes(ifop->file, data, info_length))) {
+    free(data);
+    free(pgci_ut);
+    ifofile->pgci_ut = NULL;
+    return 0;
+  }
+
+  pgci_ut->lu = calloc(pgci_ut->nr_of_lus, sizeof(pgci_lu_t));
+  if(!pgci_ut->lu) {
+    free(data);
+    free(pgci_ut);
+    ifofile->pgci_ut = NULL;
+    return 0;
+  }
+  ptr = data;
+  for(i = 0; i < pgci_ut->nr_of_lus; i++) {
+    memcpy(&pgci_ut->lui, ptr, PGCI_LU_SIZE);
+    ptr += PGCI_LU_SIZE;
+    B2N_16(pgci_ut->lui.lang_code);
+    B2N_32(pgci_ut->lui.lang_start_byte);
+  }
+  free(data);
+
+  for(i = 0; i < pgci_ut->nr_of_lus; i++) {
+    /* Maybe this is only defined for v1.1 and later titles? */
+    /* If the bits in 'lui.exists' are enumerated abcd efgh then:
+       VTS_x_yy.IFO        VIDEO_TS.IFO
+       a == 0x83 "Root"         0x82 "Title"
+       b == 0x84 "Subpicture"
+       c == 0x85 "Audio"
+       d == 0x86 "Angle"
+       e == 0x87 "PTT"
+    */
+    CHECK_VALUE((pgci_ut->lui.exists & 0x07) == 0);
+  }
+
+  for(i = 0; i < pgci_ut->nr_of_lus; i++) {
+    int dup;
+    if((dup = find_dup_lut(pgci_ut->lu, pgci_ut->lui.lang_start_byte, i)) >= 0) {
+      pgci_ut->lui.pgcit = pgci_ut->ludup.pgcit;
+      pgci_ut->lui.pgcit->ref_count++;
+      continue;
+    }
+    pgci_ut->lui.pgcit = calloc(1, sizeof(pgcit_t));
+    if(!pgci_ut->lui.pgcit) {
+      unsigned int j;
+      for(j = 0; j < i; j++) {
+        ifoFree_PGCIT_internal(&pgci_ut->luj.pgcit);
+      }
+      free(pgci_ut->lu);
+      free(pgci_ut);
+      ifofile->pgci_ut = NULL;
+      return 0;
+    }
+    pgci_ut->lui.pgcit->ref_count = 1;
+    if(!ifoRead_PGCIT_internal(ifofile, pgci_ut->lui.pgcit,
+                               sector * DVD_BLOCK_LEN
+                               + pgci_ut->lui.lang_start_byte)) {
+      unsigned int j;
+      for(j = 0; j <= i; j++) {
+        ifoFree_PGCIT_internal(&pgci_ut->luj.pgcit);
+      }
+      free(pgci_ut->lu);
+      free(pgci_ut);
+      ifofile->pgci_ut = NULL;
+      return 0;
+    }
+    /* FIXME: Iterate and verify that all menus that should exists accordingly
+     * to pgci_ut->lui.exists really do? */
+  }
+
+  return 1;
+}
+
+
+void ifoFree_PGCI_UT(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  if(ifofile->pgci_ut) {
+    unsigned int i;
+
+    for(i = 0; i < ifofile->pgci_ut->nr_of_lus; i++) {
+      ifoFree_PGCIT_internal(&ifofile->pgci_ut->lui.pgcit);
+    }
+    free(ifofile->pgci_ut->lu);
+    free(ifofile->pgci_ut);
+    ifofile->pgci_ut = NULL;
+  }
+}
+
+static int ifoRead_VTS_ATTRIBUTES(ifo_handle_t *ifofile,
+                                  vts_attributes_t *vts_attributes,
+                                  unsigned int offset) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  unsigned int i;
+
+  if(!DVDFileSeek_(ifop->file, offset))
+    return 0;
+
+  if(!(DVDReadBytes(ifop->file, vts_attributes, sizeof(vts_attributes_t))))
+    return 0;
+
+  read_video_attr(&vts_attributes->vtsm_vobs_attr);
+  read_video_attr(&vts_attributes->vtstt_vobs_video_attr);
+  read_audio_attr(&vts_attributes->vtsm_audio_attr);
+  for(i=0; i<8; i++)
+    read_audio_attr(&vts_attributes->vtstt_audio_attri);
+  read_subp_attr(&vts_attributes->vtsm_subp_attr);
+  for(i=0; i<32; i++)
+    read_subp_attr(&vts_attributes->vtstt_subp_attri);
+  B2N_32(vts_attributes->last_byte);
+  B2N_32(vts_attributes->vts_cat);
+
+  CHECK_ZERO(vts_attributes->zero_1);
+  CHECK_ZERO(vts_attributes->zero_2);
+  CHECK_ZERO(vts_attributes->zero_3);
+  CHECK_ZERO(vts_attributes->zero_4);
+  CHECK_ZERO(vts_attributes->zero_5);
+  CHECK_ZERO(vts_attributes->zero_6);
+  CHECK_ZERO(vts_attributes->zero_7);
+  CHECK_VALUE(vts_attributes->nr_of_vtsm_audio_streams <= 1);
+  CHECK_VALUE(vts_attributes->nr_of_vtsm_subp_streams <= 1);
+  CHECK_VALUE(vts_attributes->nr_of_vtstt_audio_streams <= 8);
+  for(i = vts_attributes->nr_of_vtstt_audio_streams; i < 8; i++)
+    CHECK_ZERO(vts_attributes->vtstt_audio_attri);
+  CHECK_VALUE(vts_attributes->nr_of_vtstt_subp_streams <= 32);
+  {
+    unsigned int nr_coded;
+    CHECK_VALUE(vts_attributes->last_byte + 1 >= VTS_ATTRIBUTES_MIN_SIZE);
+    nr_coded = (vts_attributes->last_byte + 1 - VTS_ATTRIBUTES_MIN_SIZE)/6;
+    /* This is often nr_coded = 70, how do you know how many there really are? */
+    if(nr_coded > 32) { /* We haven't read more from disk/file anyway */
+      nr_coded = 32;
+    }
+    CHECK_VALUE(vts_attributes->nr_of_vtstt_subp_streams <= nr_coded);
+    for(i = vts_attributes->nr_of_vtstt_subp_streams; i < nr_coded; i++)
+      CHECK_ZERO(vts_attributes->vtstt_subp_attri);
+  }
+
+  return 1;
+}
+
+
+
+int ifoRead_VTS_ATRT(ifo_handle_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  vts_atrt_t *vts_atrt;
+  unsigned int i, info_length, sector;
+  uint32_t *data;
+
+  if(!ifofile)
+    return 0;
+
+  if(!ifofile->vmgi_mat)
+    return 0;
+
+  if(ifofile->vmgi_mat->vts_atrt == 0) /* mandatory */
+    return 0;
+
+  sector = ifofile->vmgi_mat->vts_atrt;
+  if(!DVDFileSeek_(ifop->file, sector * DVD_BLOCK_LEN))
+    return 0;
+
+  vts_atrt = calloc(1, sizeof(vts_atrt_t));
+  if(!vts_atrt)
+    return 0;
+
+  ifofile->vts_atrt = vts_atrt;
+
+  if(!(DVDReadBytes(ifop->file, vts_atrt, VTS_ATRT_SIZE))) {
+    free(vts_atrt);
+    ifofile->vts_atrt = NULL;
+    return 0;
+  }
+
+  B2N_16(vts_atrt->nr_of_vtss);
+  B2N_32(vts_atrt->last_byte);
+
+  CHECK_ZERO(vts_atrt->zero_1);
+  CHECK_VALUE(vts_atrt->nr_of_vtss != 0);
+  CHECK_VALUE(vts_atrt->nr_of_vtss < 100); /* ?? */
+  CHECK_VALUE((uint32_t)vts_atrt->nr_of_vtss * (4 + VTS_ATTRIBUTES_MIN_SIZE) +
+              VTS_ATRT_SIZE < vts_atrt->last_byte + 1);
+
+  info_length = vts_atrt->nr_of_vtss * sizeof(uint32_t);
+  data = calloc(1, info_length);
+  if(!data) {
+    free(vts_atrt);
+    ifofile->vts_atrt = NULL;
+    return 0;
+  }
+
+  vts_atrt->vts_atrt_offsets = data;
+
+  if(!(DVDReadBytes(ifop->file, data, info_length))) {
+    free(data);
+    free(vts_atrt);
+    ifofile->vts_atrt = NULL;
+    return 0;
+  }
+
+  for(i = 0; i < vts_atrt->nr_of_vtss; i++) {
+    B2N_32(datai);
+    CHECK_VALUE(datai + VTS_ATTRIBUTES_MIN_SIZE < vts_atrt->last_byte + 1);
+  }
+
+  info_length = vts_atrt->nr_of_vtss * sizeof(vts_attributes_t);
+  vts_atrt->vts = calloc(1, info_length);
+  if(!vts_atrt->vts) {
+    free(data);
+    free(vts_atrt);
+    ifofile->vts_atrt = NULL;
+    return 0;
+  }
+  for(i = 0; i < vts_atrt->nr_of_vtss; i++) {
+    unsigned int offset = datai;
+    if(!ifoRead_VTS_ATTRIBUTES(ifofile, &(vts_atrt->vtsi),
+                               (sector * DVD_BLOCK_LEN) + offset)) {
+      free(data);
+      free(vts_atrt);
+      ifofile->vts_atrt = NULL;
+      return 0;
+    }
+
+    /* This assert cant be in ifoRead_VTS_ATTRIBUTES */
+    CHECK_VALUE(offset + vts_atrt->vtsi.last_byte <= vts_atrt->last_byte + 1);
+    /* Is this check correct? */
+  }
+
+  return 1;
+}
+
+
+void ifoFree_VTS_ATRT(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  if(ifofile->vts_atrt) {
+    free(ifofile->vts_atrt->vts);
+    free(ifofile->vts_atrt->vts_atrt_offsets);
+    free(ifofile->vts_atrt);
+    ifofile->vts_atrt = NULL;
+  }
+}
+
+
+int ifoRead_TXTDT_MGI(ifo_handle_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  txtdt_mgi_t *txtdt_mgi;
+
+  if(!ifofile)
+    return 0;
+
+  if(!ifofile->vmgi_mat)
+    return 0;
+
+  /* Return successfully if there is nothing to read. */
+  if(ifofile->vmgi_mat->txtdt_mgi == 0)
+    return 1;
+
+  if(!DVDFileSeek_(ifop->file,
+                   ifofile->vmgi_mat->txtdt_mgi * DVD_BLOCK_LEN))
+    return 0;
+
+  txtdt_mgi = calloc(1, sizeof(txtdt_mgi_t));
+  if(!txtdt_mgi) {
+    return 0;
+  }
+  ifofile->txtdt_mgi = txtdt_mgi;
+
+  if(!(DVDReadBytes(ifop->file, txtdt_mgi, TXTDT_MGI_SIZE))) {
+    Log0(ifop->ctx, "Unable to read TXTDT_MGI.");
+    free(txtdt_mgi);
+    ifofile->txtdt_mgi = NULL;
+    return 0;
+  }
+
+  /* Log1(ifop->ctx, "-- Not done yet --\n"); */
+  return 1;
+}
+
+void ifoFree_TXTDT_MGI(ifo_handle_t *ifofile) {
+  if(!ifofile)
+    return;
+
+  if(ifofile->txtdt_mgi) {
+    free(ifofile->txtdt_mgi);
+    ifofile->txtdt_mgi = NULL;
+  }
+}

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/ifo_read.h Added

@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2000, 2001, 2002 Björn Englund <d4bjorn@dtek.chalmers.se>,
+ *                                Håkan Hjort <d95hjort@dtek.chalmers.se>
+ *
+ * This file is part of libdvdread.
+ *
+ * libdvdread 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.
+ *
+ * libdvdread 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 libdvdread; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDREAD_IFO_READ_H
+#define LIBDVDREAD_IFO_READ_H
+
+#include "ifo_types.h"
+#include "dvdread/dvd_reader.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * handle = ifoOpen(dvd, title);
+ *
+ * Opens an IFO and reads in all the data for the IFO file corresponding to the
+ * given title.  If title 0 is given, the video manager IFO file is read.
+ * Returns a handle to a completely parsed structure.
+ */
+ifo_handle_t *ifoOpen(dvd_reader_t *, int );
+
+/**
+ * handle = ifoOpenVMGI(dvd);
+ *
+ * Opens an IFO and reads in _only_ the vmgi_mat data.  This call can be used
+ * together with the calls below to read in each segment of the IFO file on
+ * demand.
+ */
+ifo_handle_t *ifoOpenVMGI(dvd_reader_t *);
+
+/**
+ * handle = ifoOpenVTSI(dvd, title);
+ *
+ * Opens an IFO and reads in _only_ the vtsi_mat data.  This call can be used
+ * together with the calls below to read in each segment of the IFO file on
+ * demand.
+ */
+ifo_handle_t *ifoOpenVTSI(dvd_reader_t *, int);
+
+/**
+ * ifoClose(ifofile);
+ * Cleans up the IFO information.  This will free all data allocated for the
+ * substructures.
+ */
+void ifoClose(ifo_handle_t *);
+
+void ifoAddRef(ifo_handle_t *);
+
+/**
+ * The following functions are for reading only part of the VMGI/VTSI files.
+ * Returns 1 if the data was successfully read and 0 on error.
+ */
+
+/**
+ * okay = ifoRead_PLT_MAIT(ifofile);
+ *
+ * Read in the Parental Management Information table, filling the
+ * ifofile->ptl_mait structure and its substructures.  This data is only
+ * located in the video manager information file.  This fills the
+ * ifofile->ptl_mait structure and all its substructures.
+ */
+int ifoRead_PTL_MAIT(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_VTS_ATRT(ifofile);
+ *
+ * Read in the attribute table for the main menu vob, filling the
+ * ifofile->vts_atrt structure and its substructures.  Only located in the
+ * video manager information file.  This fills in the ifofile->vts_atrt
+ * structure and all its substructures.
+ */
+int ifoRead_VTS_ATRT(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_TT_SRPT(ifofile);
+ *
+ * Reads the title info for the main menu, filling the ifofile->tt_srpt
+ * structure and its substructures.  This data is only located in the video
+ * manager information file.  This structure is mandatory in the IFO file.
+ */
+int ifoRead_TT_SRPT(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_VTS_PTT_SRPT(ifofile);
+ *
+ * Reads in the part of title search pointer table, filling the
+ * ifofile->vts_ptt_srpt structure and its substructures.  This data is only
+ * located in the video title set information file.  This structure is
+ * mandatory, and must be included in the VTSI file.
+ */
+int ifoRead_VTS_PTT_SRPT(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_FP_PGC(ifofile);
+ *
+ * Reads in the first play program chain data, filling the
+ * ifofile->first_play_pgc structure.  This data is only located in the video
+ * manager information file (VMGI).  This structure is optional.
+ */
+int ifoRead_FP_PGC(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_PGCIT(ifofile);
+ *
+ * Reads in the program chain information table for the video title set.  Fills
+ * in the ifofile->vts_pgcit structure and its substructures, which includes
+ * the data for each program chain in the set.  This data is only located in
+ * the video title set information file.  This structure is mandatory, and must
+ * be included in the VTSI file.
+ */
+int ifoRead_PGCIT(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_PGCI_UT(ifofile);
+ *
+ * Reads in the menu PGCI unit table for the menu VOB.  For the video manager,
+ * this corresponds to the VIDEO_TS.VOB file, and for each title set, this
+ * corresponds to the VTS_XX_0.VOB file.  This data is located in both the
+ * video manager and video title set information files.  For VMGI files, this
+ * fills the ifofile->vmgi_pgci_ut structure and all its substructures.  For
+ * VTSI files, this fills the ifofile->vtsm_pgci_ut structure.
+ */
+int ifoRead_PGCI_UT(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_VTS_TMAPT(ifofile);
+ *
+ * Reads in the VTS Time Map Table, this data is only located in the video
+ * title set information file.  This fills the ifofile->vts_tmapt structure
+ * and all its substructures.  When pressent enables VOBU level time-based
+ * seeking for One_Sequential_PGC_Titles.
+ */
+int ifoRead_VTS_TMAPT(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_C_ADT(ifofile);
+ *
+ * Reads in the cell address table for the menu VOB.  For the video manager,
+ * this corresponds to the VIDEO_TS.VOB file, and for each title set, this
+ * corresponds to the VTS_XX_0.VOB file.  This data is located in both the
+ * video manager and video title set information files.  For VMGI files, this
+ * fills the ifofile->vmgm_c_adt structure and all its substructures.  For VTSI
+ * files, this fills the ifofile->vtsm_c_adt structure.
+ */
+int ifoRead_C_ADT(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_TITLE_C_ADT(ifofile);
+ *
+ * Reads in the cell address table for the video title set corresponding to
+ * this IFO file.  This data is only located in the video title set information
+ * file.  This structure is mandatory, and must be included in the VTSI file.
+ * This call fills the ifofile->vts_c_adt structure and its substructures.
+ */
+int ifoRead_TITLE_C_ADT(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_VOBU_ADMAP(ifofile);
+ *
+ * Reads in the VOBU address map for the menu VOB.  For the video manager, this
+ * corresponds to the VIDEO_TS.VOB file, and for each title set, this
+ * corresponds to the VTS_XX_0.VOB file.  This data is located in both the
+ * video manager and video title set information files.  For VMGI files, this
+ * fills the ifofile->vmgm_vobu_admap structure and all its substructures.  For
+ * VTSI files, this fills the ifofile->vtsm_vobu_admap structure.
+ */
+int ifoRead_VOBU_ADMAP(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_TITLE_VOBU_ADMAP(ifofile);
+ *
+ * Reads in the VOBU address map for the associated video title set.  This data
+ * is only located in the video title set information file.  This structure is
+ * mandatory, and must be included in the VTSI file.  Fills the
+ * ifofile->vts_vobu_admap structure and its substructures.
+ */
+int ifoRead_TITLE_VOBU_ADMAP(ifo_handle_t *);
+
+/**
+ * okay = ifoRead_TXTDT_MGI(ifofile);
+ *
+ * Reads in the text data strings for the DVD.  Fills the ifofile->txtdt_mgi
+ * structure and all its substructures.  This data is only located in the video
+ * manager information file.  This structure is mandatory, and must be included
+ * in the VMGI file.
+ */
+int ifoRead_TXTDT_MGI(ifo_handle_t *);
+
+/**
+ * The following functions are used for freeing parsed sections of the
+ * ifo_handle_t structure and the allocated substructures.  The free calls
+ * below are safe:  they will not mind if you attempt to free part of an IFO
+ * file which was not read in or which does not exist.
+ */
+void ifoFree_PTL_MAIT(ifo_handle_t *);
+void ifoFree_VTS_ATRT(ifo_handle_t *);
+void ifoFree_TT_SRPT(ifo_handle_t *);
+void ifoFree_VTS_PTT_SRPT(ifo_handle_t *);
+void ifoFree_FP_PGC(ifo_handle_t *);
+void ifoFree_PGCIT(ifo_handle_t *);
+void ifoFree_PGCI_UT(ifo_handle_t *);
+void ifoFree_VTS_TMAPT(ifo_handle_t *);
+void ifoFree_C_ADT(ifo_handle_t *);
+void ifoFree_TITLE_C_ADT(ifo_handle_t *);
+void ifoFree_VOBU_ADMAP(ifo_handle_t *);
+void ifoFree_TITLE_VOBU_ADMAP(ifo_handle_t *);
+void ifoFree_TXTDT_MGI(ifo_handle_t *);
+
+#ifdef __cplusplus
+};
+#endif
+#endif /* LIBDVDREAD_IFO_READ_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/ifo_types.h Added

@@ -0,0 +1,756 @@
+/*
+ * Copyright (C) 2000, 2001 Björn Englund <d4bjorn@dtek.chalmers.se>,
+ *                          Håkan Hjort <d95hjort@dtek.chalmers.se>
+ *
+ * This file is part of libdvdread.
+ *
+ * libdvdread 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.
+ *
+ * libdvdread 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 libdvdread; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDREAD_IFO_TYPES_H
+#define LIBDVDREAD_IFO_TYPES_H
+
+#include <inttypes.h>
+#include "dvdread/dvd_reader.h"
+
+
+#undef ATTRIBUTE_PACKED
+#undef PRAGMA_PACK_BEGIN
+#undef PRAGMA_PACK_END
+
+#if defined(__GNUC__)
+#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95)
+#define ATTRIBUTE_PACKED __attribute__ ((packed))
+#define PRAGMA_PACK 0
+#endif
+#endif
+
+#if !defined(ATTRIBUTE_PACKED)
+#define ATTRIBUTE_PACKED
+#define PRAGMA_PACK 1
+#endif
+
+#if PRAGMA_PACK
+#pragma pack(push)
+#pragma pack(1)
+#endif
+
+
+/**
+ * Common
+ *
+ * The following structures are used in both the VMGI and VTSI.
+ */
+
+
+/**
+ * DVD Time Information.
+ */
+typedef struct {
+  uint8_t hour;
+  uint8_t minute;
+  uint8_t second;
+  uint8_t frame_u; /* The two high bits are the frame rate. */
+} ATTRIBUTE_PACKED dvd_time_t;
+
+/**
+ * Type to store per-command data.
+ */
+typedef struct {
+  uint8_t bytes8;
+} ATTRIBUTE_PACKED vm_cmd_t;
+#define COMMAND_DATA_SIZE 8U
+
+
+/**
+ * Video Attributes.
+ */
+typedef struct {
+  unsigned char mpeg_version         : 2;
+  unsigned char video_format         : 2;
+  unsigned char display_aspect_ratio : 2;
+  unsigned char permitted_df         : 2;
+
+  unsigned char line21_cc_1          : 1;
+  unsigned char line21_cc_2          : 1;
+  unsigned char unknown1             : 1;
+  unsigned char bit_rate             : 1;
+
+  unsigned char picture_size         : 2;
+  unsigned char letterboxed          : 1;
+  unsigned char film_mode            : 1;
+} ATTRIBUTE_PACKED video_attr_t;
+
+/**
+ * Audio Attributes.
+ */
+typedef struct {
+  unsigned char audio_format           : 3;
+  unsigned char multichannel_extension : 1;
+  unsigned char lang_type              : 2;
+  unsigned char application_mode       : 2;
+
+  unsigned char quantization           : 2;
+  unsigned char sample_frequency       : 2;
+  unsigned char unknown1               : 1;
+  unsigned char channels               : 3;
+  uint16_t lang_code;
+  uint8_t  lang_extension;
+  uint8_t  code_extension;
+  uint8_t unknown3;
+  union {
+    struct ATTRIBUTE_PACKED {
+      unsigned char unknown4           : 1;
+      unsigned char channel_assignment : 3;
+      unsigned char version            : 2;
+      unsigned char mc_intro           : 1; /* probably 0: true, 1:false */
+      unsigned char mode               : 1; /* Karaoke mode 0: solo 1: duet */
+    } karaoke;
+    struct ATTRIBUTE_PACKED {
+      unsigned char unknown5           : 4;
+      unsigned char dolby_encoded      : 1; /* suitable for surround decoding */
+      unsigned char unknown6           : 3;
+    } surround;
+  } ATTRIBUTE_PACKED app_info;
+} ATTRIBUTE_PACKED audio_attr_t;
+
+
+/**
+ * MultiChannel Extension
+ */
+typedef struct {
+  unsigned int zero1      : 7;
+  unsigned int ach0_gme   : 1;
+
+  unsigned int zero2      : 7;
+  unsigned int ach1_gme   : 1;
+
+  unsigned int zero3      : 4;
+  unsigned int ach2_gv1e  : 1;
+  unsigned int ach2_gv2e  : 1;
+  unsigned int ach2_gm1e  : 1;
+  unsigned int ach2_gm2e  : 1;
+
+  unsigned int zero4      : 4;
+  unsigned int ach3_gv1e  : 1;
+  unsigned int ach3_gv2e  : 1;
+  unsigned int ach3_gmAe  : 1;
+  unsigned int ach3_se2e  : 1;
+
+  unsigned int zero5      : 4;
+  unsigned int ach4_gv1e  : 1;
+  unsigned int ach4_gv2e  : 1;
+  unsigned int ach4_gmBe  : 1;
+  unsigned int ach4_seBe  : 1;
+  uint8_t zero619;
+} ATTRIBUTE_PACKED multichannel_ext_t;
+
+
+/**
+ * Subpicture Attributes.
+ */
+typedef struct {
+  /*
+   * type: 0 not specified
+   *       1 language
+   *       2 other
+   * coding mode: 0 run length
+   *              1 extended
+   *              2 other
+   * language: indicates language if type == 1
+   * lang extension: if type == 1 contains the lang extension
+   */
+  unsigned char code_mode : 3;
+  unsigned char zero1     : 3;
+  unsigned char type      : 2;
+  uint8_t  zero2;
+  uint16_t lang_code;
+  uint8_t  lang_extension;
+  uint8_t  code_extension;
+} ATTRIBUTE_PACKED subp_attr_t;
+
+
+
+/**
+ * PGC Command Table.
+ */
+typedef struct {
+  uint16_t nr_of_pre;
+  uint16_t nr_of_post;
+  uint16_t nr_of_cell;
+  uint16_t zero_1;
+  vm_cmd_t *pre_cmds;
+  vm_cmd_t *post_cmds;
+  vm_cmd_t *cell_cmds;
+} ATTRIBUTE_PACKED pgc_command_tbl_t;
+#define PGC_COMMAND_TBL_SIZE 8U
+
+/**
+ * PGC Program Map
+ */
+typedef uint8_t pgc_program_map_t;
+
+/**
+ * Cell Playback Information.
+ */
+typedef struct {
+  uint16_t block_mode       : 2;
+  uint16_t block_type       : 2;
+  uint16_t seamless_play    : 1;
+  uint16_t interleaved      : 1;
+  uint16_t stc_discontinuity: 1;
+  uint16_t seamless_angle   : 1;
+  uint16_t zero_1           : 1;
+  uint16_t playback_mode    : 1;  /**< When set, enter StillMode after each VOBU */
+  uint16_t restricted       : 1;  /**< ?? drop out of fastforward? */
+  uint16_t cell_type        : 5;  /** for karaoke, reserved otherwise */
+  uint8_t still_time;
+  uint8_t cell_cmd_nr;
+  dvd_time_t playback_time;
+  uint32_t first_sector;
+  uint32_t first_ilvu_end_sector;
+  uint32_t last_vobu_start_sector;
+  uint32_t last_sector;
+} ATTRIBUTE_PACKED cell_playback_t;
+
+#define BLOCK_TYPE_NONE         0x0
+#define BLOCK_TYPE_ANGLE_BLOCK  0x1
+
+#define BLOCK_MODE_NOT_IN_BLOCK 0x0
+#define BLOCK_MODE_FIRST_CELL   0x1
+#define BLOCK_MODE_IN_BLOCK     0x2
+#define BLOCK_MODE_LAST_CELL    0x3
+
+/**
+ * Cell Position Information.
+ */
+typedef struct {
+  uint16_t vob_id_nr;
+  uint8_t  zero_1;
+  uint8_t  cell_nr;
+} ATTRIBUTE_PACKED cell_position_t;
+
+/**
+ * User Operations.
+ */
+typedef struct {
+  uint32_t zero                           : 7; /* 25-31 */
+  uint32_t video_pres_mode_change         : 1; /* 24 */
+
+  uint32_t karaoke_audio_pres_mode_change : 1; /* 23 */
+  uint32_t angle_change                   : 1;
+  uint32_t subpic_stream_change           : 1;
+  uint32_t audio_stream_change            : 1;
+  uint32_t pause_on                       : 1;
+  uint32_t still_off                      : 1;
+  uint32_t button_select_or_activate      : 1;
+  uint32_t resume                         : 1; /* 16 */
+
+  uint32_t chapter_menu_call              : 1; /* 15 */
+  uint32_t angle_menu_call                : 1;
+  uint32_t audio_menu_call                : 1;
+  uint32_t subpic_menu_call               : 1;
+  uint32_t root_menu_call                 : 1;
+  uint32_t title_menu_call                : 1;
+  uint32_t backward_scan                  : 1;
+  uint32_t forward_scan                   : 1; /* 8 */
+
+  uint32_t next_pg_search                 : 1; /* 7 */
+  uint32_t prev_or_top_pg_search          : 1;
+  uint32_t time_or_chapter_search         : 1;
+  uint32_t go_up                          : 1;
+  uint32_t stop                           : 1;
+  uint32_t title_play                     : 1;
+  uint32_t chapter_search_or_play         : 1;
+  uint32_t title_or_time_play             : 1; /* 0 */
+} ATTRIBUTE_PACKED user_ops_t;
+
+/**
+ * Program Chain Information.
+ */
+typedef struct {
+  uint16_t zero_1;
+  uint8_t  nr_of_programs;
+  uint8_t  nr_of_cells;
+  dvd_time_t playback_time;
+  user_ops_t prohibited_ops;
+  uint16_t audio_control8; /* New type? */
+  uint32_t subp_control32; /* New type? */
+  uint16_t next_pgc_nr;
+  uint16_t prev_pgc_nr;
+  uint16_t goup_pgc_nr;
+  uint8_t  pg_playback_mode;
+  uint8_t  still_time;
+  uint32_t palette16; /* New type struct {zero_1, Y, Cr, Cb} ? */
+  uint16_t command_tbl_offset;
+  uint16_t program_map_offset;
+  uint16_t cell_playback_offset;
+  uint16_t cell_position_offset;
+  pgc_command_tbl_t *command_tbl;
+  pgc_program_map_t  *program_map;
+  cell_playback_t *cell_playback;
+  cell_position_t *cell_position;
+  int      ref_count;
+} ATTRIBUTE_PACKED pgc_t;
+#define PGC_SIZE 236U
+
+/**
+ * Program Chain Information Search Pointer.
+ */
+typedef struct {
+  uint8_t  entry_id;
+  uint8_t  block_mode : 2;
+  uint8_t  block_type : 2;
+  uint8_t  zero_1   : 4;
+  uint16_t ptl_id_mask;
+  uint32_t pgc_start_byte;
+  pgc_t *pgc;
+} ATTRIBUTE_PACKED pgci_srp_t;
+#define PGCI_SRP_SIZE 8U
+
+/**
+ * Program Chain Information Table.
+ */
+typedef struct {
+  uint16_t nr_of_pgci_srp;
+  uint16_t zero_1;
+  uint32_t last_byte;
+  pgci_srp_t *pgci_srp;
+  int      ref_count;
+} ATTRIBUTE_PACKED pgcit_t;
+#define PGCIT_SIZE 8U
+
+/**
+ * Menu PGCI Language Unit.
+ */
+typedef struct {
+  uint16_t lang_code;
+  uint8_t  lang_extension;
+  uint8_t  exists;
+  uint32_t lang_start_byte;
+  pgcit_t *pgcit;
+} ATTRIBUTE_PACKED pgci_lu_t;
+#define PGCI_LU_SIZE 8U
+
+/**
+ * Menu PGCI Unit Table.
+ */
+typedef struct {
+  uint16_t nr_of_lus;
+  uint16_t zero_1;
+  uint32_t last_byte;
+  pgci_lu_t *lu;
+} ATTRIBUTE_PACKED pgci_ut_t;
+#define PGCI_UT_SIZE 8U
+
+/**
+ * Cell Address Information.
+ */
+typedef struct {
+  uint16_t vob_id;
+  uint8_t  cell_id;
+  uint8_t  zero_1;
+  uint32_t start_sector;
+  uint32_t last_sector;
+} ATTRIBUTE_PACKED cell_adr_t;
+
+/**
+ * Cell Address Table.
+ */
+typedef struct {
+  uint16_t nr_of_vobs; /* VOBs */
+  uint16_t zero_1;
+  uint32_t last_byte;
+  cell_adr_t *cell_adr_table;  /* No explicit size given. */
+} ATTRIBUTE_PACKED c_adt_t;
+#define C_ADT_SIZE 8U
+
+/**
+ * VOBU Address Map.
+ */
+typedef struct {
+  uint32_t last_byte;
+  uint32_t *vobu_start_sectors;
+} ATTRIBUTE_PACKED vobu_admap_t;
+#define VOBU_ADMAP_SIZE 4U
+
+
+
+
+/**
+ * VMGI
+ *
+ * The following structures relate to the Video Manager.
+ */
+
+/**
+ * Video Manager Information Management Table.
+ */
+typedef struct {
+  char     vmg_identifier12;
+  uint32_t vmg_last_sector;
+  uint8_t  zero_112;
+  uint32_t vmgi_last_sector;
+  uint8_t  zero_2;
+  uint8_t  specification_version;
+  uint32_t vmg_category;
+  uint16_t vmg_nr_of_volumes;
+  uint16_t vmg_this_volume_nr;
+  uint8_t  disc_side;
+  uint8_t  zero_319;
+  uint16_t vmg_nr_of_title_sets;  /* Number of VTSs. */
+  char     provider_identifier32;
+  uint64_t vmg_pos_code;
+  uint8_t  zero_424;
+  uint32_t vmgi_last_byte;
+  uint32_t first_play_pgc;
+  uint8_t  zero_556;
+  uint32_t vmgm_vobs;             /* sector */
+  uint32_t tt_srpt;               /* sector */
+  uint32_t vmgm_pgci_ut;          /* sector */
+  uint32_t ptl_mait;              /* sector */
+  uint32_t vts_atrt;              /* sector */
+  uint32_t txtdt_mgi;             /* sector */
+  uint32_t vmgm_c_adt;            /* sector */
+  uint32_t vmgm_vobu_admap;       /* sector */
+  uint8_t  zero_632;
+
+  video_attr_t vmgm_video_attr;
+  uint8_t  zero_7;
+  uint8_t  nr_of_vmgm_audio_streams; /* should be 0 or 1 */
+  audio_attr_t vmgm_audio_attr;
+  audio_attr_t zero_87;
+  uint8_t  zero_917;
+  uint8_t  nr_of_vmgm_subp_streams; /* should be 0 or 1 */
+  subp_attr_t  vmgm_subp_attr;
+  subp_attr_t  zero_1027;  /* XXX: how much 'padding' here? */
+} ATTRIBUTE_PACKED vmgi_mat_t;
+
+typedef struct {
+  uint8_t zero_1                    : 1;
+  uint8_t multi_or_random_pgc_title : 1; /* 0: one sequential pgc title */
+  uint8_t jlc_exists_in_cell_cmd    : 1;
+  uint8_t jlc_exists_in_prepost_cmd : 1;
+  uint8_t jlc_exists_in_button_cmd  : 1;
+  uint8_t jlc_exists_in_tt_dom      : 1;
+  uint8_t chapter_search_or_play    : 1; /* UOP 1 */
+  uint8_t title_or_time_play        : 1; /* UOP 0 */
+} ATTRIBUTE_PACKED playback_type_t;
+
+/**
+ * Title Information.
+ */
+typedef struct {
+  playback_type_t pb_ty;
+  uint8_t  nr_of_angles;
+  uint16_t nr_of_ptts;
+  uint16_t parental_id;
+  uint8_t  title_set_nr;
+  uint8_t  vts_ttn;
+  uint32_t title_set_sector;
+} ATTRIBUTE_PACKED title_info_t;
+
+/**
+ * PartOfTitle Search Pointer Table.
+ */
+typedef struct {
+  uint16_t nr_of_srpts;
+  uint16_t zero_1;
+  uint32_t last_byte;
+  title_info_t *title;
+} ATTRIBUTE_PACKED tt_srpt_t;
+#define TT_SRPT_SIZE 8U
+
+
+/**
+ * Parental Management Information Unit Table.
+ * Level 1 (US: G), ..., 7 (US: NC-17), 8
+ */
+#define PTL_MAIT_NUM_LEVEL 8
+typedef uint16_t pf_level_tPTL_MAIT_NUM_LEVEL;
+
+/**
+ * Parental Management Information Unit Table.
+ */
+typedef struct {
+  uint16_t country_code;
+  uint16_t zero_1;
+  uint16_t pf_ptl_mai_start_byte;
+  uint16_t zero_2;
+  pf_level_t *pf_ptl_mai; /* table of (nr_of_vtss + 1), video_ts is first */
+} ATTRIBUTE_PACKED ptl_mait_country_t;
+#define PTL_MAIT_COUNTRY_SIZE 8U
+
+/**
+ * Parental Management Information Table.
+ */
+typedef struct {
+  uint16_t nr_of_countries;
+  uint16_t nr_of_vtss;
+  uint32_t last_byte;
+  ptl_mait_country_t *countries;
+} ATTRIBUTE_PACKED ptl_mait_t;
+#define PTL_MAIT_SIZE 8U
+
+/**
+ * Video Title Set Attributes.
+ */
+typedef struct {
+  uint32_t last_byte;
+  uint32_t vts_cat;
+
+  video_attr_t vtsm_vobs_attr;
+  uint8_t  zero_1;
+  uint8_t  nr_of_vtsm_audio_streams; /* should be 0 or 1 */
+  audio_attr_t vtsm_audio_attr;
+  audio_attr_t zero_27;
+  uint8_t  zero_316;
+  uint8_t  zero_4;
+  uint8_t  nr_of_vtsm_subp_streams; /* should be 0 or 1 */
+  subp_attr_t vtsm_subp_attr;
+  subp_attr_t zero_527;
+
+  uint8_t  zero_62;
+
+  video_attr_t vtstt_vobs_video_attr;
+  uint8_t  zero_7;
+  uint8_t  nr_of_vtstt_audio_streams;
+  audio_attr_t vtstt_audio_attr8;
+  uint8_t  zero_816;
+  uint8_t  zero_9;
+  uint8_t  nr_of_vtstt_subp_streams;
+  subp_attr_t vtstt_subp_attr32;
+} ATTRIBUTE_PACKED vts_attributes_t;
+#define VTS_ATTRIBUTES_SIZE 542U
+#define VTS_ATTRIBUTES_MIN_SIZE 356U
+
+/**
+ * Video Title Set Attribute Table.
+ */
+typedef struct {
+  uint16_t nr_of_vtss;
+  uint16_t zero_1;
+  uint32_t last_byte;
+  vts_attributes_t *vts;
+  uint32_t *vts_atrt_offsets; /* offsets table for each vts_attributes */
+} ATTRIBUTE_PACKED vts_atrt_t;
+#define VTS_ATRT_SIZE 8U
+
+/**
+ * Text Data. (Incomplete)
+ */
+typedef struct {
+  uint32_t last_byte;    /* offsets are relative here */
+  uint16_t offsets100; /* == nr_of_srpts + 1 (first is disc title) */
+#if 0
+  uint16_t unknown; /* 0x48 ?? 0x48 words (16bit) info following */
+  uint16_t zero_1;
+
+  uint8_t type_of_info; /* ?? 01 == disc, 02 == Title, 04 == Title part */
+  uint8_t unknown1;
+  uint8_t unknown2;
+  uint8_t unknown3;
+  uint8_t unknown4; /* ?? allways 0x30 language?, text format? */
+  uint8_t unknown5;
+  uint16_t offset; /* from first */
+
+  char text12; /* ended by 0x09 */
+#endif
+} ATTRIBUTE_PACKED txtdt_t;
+
+/**
+ * Text Data Language Unit. (Incomplete)
+ */
+typedef struct {
+  uint16_t lang_code;
+  uint8_t  zero_1;
+  uint8_t char_set;      /* 0x00 reserved Unicode, 0x01 ISO 646, 0x10 JIS Roman & JIS Kanji, 0x11 ISO 8859-1, 0x12 Shift JIS Kanji */
+  uint32_t txtdt_start_byte;  /* prt, rel start of vmg_txtdt_mgi  */
+  txtdt_t  *txtdt;
+} ATTRIBUTE_PACKED txtdt_lu_t;
+#define TXTDT_LU_SIZE 8U
+
+/**
+ * Text Data Manager Information. (Incomplete)
+ */
+typedef struct {
+  char disc_name12;
+  uint16_t zero_1;
+  uint16_t nr_of_language_units;
+  uint32_t last_byte;
+  txtdt_lu_t *lu;
+} ATTRIBUTE_PACKED txtdt_mgi_t;
+#define TXTDT_MGI_SIZE 20U
+
+
+/**
+ * VTS
+ *
+ * Structures relating to the Video Title Set (VTS).
+ */
+
+/**
+ * Video Title Set Information Management Table.
+ */
+typedef struct {
+  char vts_identifier12;
+  uint32_t vts_last_sector;
+  uint8_t  zero_112;
+  uint32_t vtsi_last_sector;
+  uint8_t  zero_2;
+  uint8_t  specification_version;
+  uint32_t vts_category;
+  uint16_t zero_3;
+  uint16_t zero_4;
+  uint8_t  zero_5;
+  uint8_t  zero_619;
+  uint16_t zero_7;
+  uint8_t  zero_832;
+  uint64_t zero_9;
+  uint8_t  zero_1024;
+  uint32_t vtsi_last_byte;
+  uint32_t zero_11;
+  uint8_t  zero_1256;
+  uint32_t vtsm_vobs;       /* sector */
+  uint32_t vtstt_vobs;      /* sector */
+  uint32_t vts_ptt_srpt;    /* sector */
+  uint32_t vts_pgcit;       /* sector */
+  uint32_t vtsm_pgci_ut;    /* sector */
+  uint32_t vts_tmapt;       /* sector */
+  uint32_t vtsm_c_adt;      /* sector */
+  uint32_t vtsm_vobu_admap; /* sector */
+  uint32_t vts_c_adt;       /* sector */
+  uint32_t vts_vobu_admap;  /* sector */
+  uint8_t  zero_1324;
+
+  video_attr_t vtsm_video_attr;
+  uint8_t  zero_14;
+  uint8_t  nr_of_vtsm_audio_streams; /* should be 0 or 1 */
+  audio_attr_t vtsm_audio_attr;
+  audio_attr_t zero_157;
+  uint8_t  zero_1617;
+  uint8_t  nr_of_vtsm_subp_streams; /* should be 0 or 1 */
+  subp_attr_t vtsm_subp_attr;
+  subp_attr_t zero_1727;
+  uint8_t  zero_182;
+
+  video_attr_t vts_video_attr;
+  uint8_t  zero_19;
+  uint8_t  nr_of_vts_audio_streams;
+  audio_attr_t vts_audio_attr8;
+  uint8_t  zero_2017;
+  uint8_t  nr_of_vts_subp_streams;
+  subp_attr_t vts_subp_attr32;
+  uint16_t zero_21;
+  multichannel_ext_t vts_mu_audio_attr8;
+  /* XXX: how much 'padding' here, if any? */
+} ATTRIBUTE_PACKED vtsi_mat_t;
+
+/**
+ * PartOfTitle Unit Information.
+ */
+typedef struct {
+  uint16_t pgcn;
+  uint16_t pgn;
+} ATTRIBUTE_PACKED ptt_info_t;
+
+/**
+ * PartOfTitle Information.
+ */
+typedef struct {
+  uint16_t nr_of_ptts;
+  ptt_info_t *ptt;
+} ATTRIBUTE_PACKED ttu_t;
+
+/**
+ * PartOfTitle Search Pointer Table.
+ */
+typedef struct {
+  uint16_t nr_of_srpts;
+  uint16_t zero_1;
+  uint32_t last_byte;
+  ttu_t  *title;
+  uint32_t *ttu_offset; /* offset table for each ttu */
+} ATTRIBUTE_PACKED vts_ptt_srpt_t;
+#define VTS_PTT_SRPT_SIZE 8U
+
+
+/**
+ * Time Map Entry.
+ */
+/* Should this be bit field at all or just the uint32_t? */
+typedef uint32_t map_ent_t;
+
+/**
+ * Time Map.
+ */
+typedef struct {
+  uint8_t  tmu;   /* Time unit, in seconds */
+  uint8_t  zero_1;
+  uint16_t nr_of_entries;
+  map_ent_t *map_ent;
+} ATTRIBUTE_PACKED vts_tmap_t;
+#define VTS_TMAP_SIZE 4U
+
+/**
+ * Time Map Table.
+ */
+typedef struct {
+  uint16_t nr_of_tmaps;
+  uint16_t zero_1;
+  uint32_t last_byte;
+  vts_tmap_t *tmap;
+  uint32_t *tmap_offset; /* offset table for each tmap */
+} ATTRIBUTE_PACKED vts_tmapt_t;
+#define VTS_TMAPT_SIZE 8U
+
+
+#if PRAGMA_PACK
+#pragma pack(pop)
+#endif
+
+
+/**
+ * The following structure defines an IFO file.  The structure is divided into
+ * two parts, the VMGI, or Video Manager Information, which is read from the
+ * VIDEO_TS.IFO,BUP file, and the VTSI, or Video Title Set Information, which
+ * is read in from the VTS_XX_0.IFO,BUP files.
+ */
+typedef struct {
+  /* VMGI */
+  vmgi_mat_t     *vmgi_mat;
+  tt_srpt_t      *tt_srpt;
+  pgc_t          *first_play_pgc;
+  ptl_mait_t     *ptl_mait;
+  vts_atrt_t     *vts_atrt;
+  txtdt_mgi_t    *txtdt_mgi;
+
+  /* Common */
+  pgci_ut_t      *pgci_ut;
+  c_adt_t        *menu_c_adt;
+  vobu_admap_t   *menu_vobu_admap;
+
+  /* VTSI */
+  vtsi_mat_t     *vtsi_mat;
+  vts_ptt_srpt_t *vts_ptt_srpt;
+  pgcit_t        *vts_pgcit;
+  vts_tmapt_t    *vts_tmapt;
+  c_adt_t        *vts_c_adt;
+  vobu_admap_t   *vts_vobu_admap;
+
+  int            refcount;
+} ifo_handle_t;
+
+#endif /* LIBDVDREAD_IFO_TYPES_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/logger.c Added

@@ -0,0 +1,43 @@
+/*
+ * This file is part of libdvdread.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+ */
+
+#include "config.h"
+#include <stdio.h>
+#include <stdarg.h>
+
+#include "dvdread/dvd_reader.h"
+#include "logger.h"
+
+void DVDReadLog( void *priv, const dvd_logger_cb *logcb,
+                 dvd_logger_level_t level, const char *fmt, ... )
+{
+    va_list list;
+    va_start(list, fmt);
+    if(logcb && logcb->pf_log)
+        logcb->pf_log(priv, level, fmt, list);
+#if 0
+    else
+    {
+        FILE *stream = (level == DVD_LOGGER_LEVEL_ERROR) ? stderr : stdout;
+        fprintf(stream, "libdvdread: ");
+        vfprintf(stream, fmt, list);
+        fprintf(stream, "\n");
+    }
+#endif
+    va_end(list);
+}

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/logger.h Added

@@ -0,0 +1,32 @@
+/*
+ * This file is part of libdvdread.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser 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.
+ */
+
+#ifndef LIBDVDREAD_LOGGER_H
+#define LIBDVDREAD_LOGGER_H
+
+void DVDReadLog( void *priv, const dvd_logger_cb *logcb,
+                 dvd_logger_level_t level, const char *fmt, ... );
+
+#define LOG(ctx, level, ...) \
+  DVDReadLog(ctx->priv, &ctx->logcb, level, __VA_ARGS__)
+#define Log0(ctx, ...) LOG(ctx, DVD_LOGGER_LEVEL_ERROR, __VA_ARGS__)
+#define Log1(ctx, ...) LOG(ctx, DVD_LOGGER_LEVEL_WARN,  __VA_ARGS__)
+#define Log2(ctx, ...) LOG(ctx, DVD_LOGGER_LEVEL_INFO,  __VA_ARGS__)
+#define Log3(ctx, ...) LOG(ctx, DVD_LOGGER_LEVEL_DEBUG, __VA_ARGS__)
+
+#endif

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/nav_read.c Added

@@ -0,0 +1,275 @@
+/*
+ * Copyright (C) 2000, 2001, 2002, 2003 Håkan Hjort <d95hjort@dtek.chalmers.se>
+ *
+ * This file is part of libdvdread.
+ *
+ * libdvdread 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.
+ *
+ * libdvdread 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 libdvdread; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+
+#include "bswap.h"
+#include "dvdread/nav_types.h"
+#include "dvdread/nav_read.h"
+#include "dvdread_internal.h"
+#include "logger.h"
+#include "dvdread/bitreader.h"
+
+#define getbits_init dvdread_getbits_init
+#define getbits dvdread_getbits
+
+#define THISFILE__ "nav_read.c"
+
+#define CHECK_VALUE(arg)\
+  if(!(arg)) {\
+    DVDReadLog(NULL, NULL, DVD_LOGGER_LEVEL_WARN,\
+                "CHECK_VALUE failed in %s:%i for %s",\
+                THISFILE__, __LINE__, # arg );\
+  }
+
+void navRead_PCI(pci_t *pci, unsigned char *buffer) {
+  int32_t i, j;
+  getbits_state_t state;
+  if (!getbits_init(&state, buffer)) abort(); /* Passed NULL pointers */
+
+  /* pci pci_gi */
+  pci->pci_gi.nv_pck_lbn = getbits(&state, 32 );
+  pci->pci_gi.vobu_cat = getbits(&state, 16 );
+  pci->pci_gi.zero1 = getbits(&state, 16 );
+  pci->pci_gi.vobu_uop_ctl.zero = getbits(&state, 7 );
+  pci->pci_gi.vobu_uop_ctl.video_pres_mode_change         = getbits(&state, 1 );
+
+  pci->pci_gi.vobu_uop_ctl.karaoke_audio_pres_mode_change = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.angle_change                   = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.subpic_stream_change           = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.audio_stream_change            = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.pause_on                       = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.still_off                      = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.button_select_or_activate      = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.resume                         = getbits(&state, 1 );
+
+  pci->pci_gi.vobu_uop_ctl.chapter_menu_call              = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.angle_menu_call                = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.audio_menu_call                = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.subpic_menu_call               = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.root_menu_call                 = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.title_menu_call                = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.backward_scan                  = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.forward_scan                   = getbits(&state, 1 );
+
+  pci->pci_gi.vobu_uop_ctl.next_pg_search                 = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.prev_or_top_pg_search          = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.time_or_chapter_search         = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.go_up                          = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.stop                           = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.title_play                     = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.chapter_search_or_play         = getbits(&state, 1 );
+  pci->pci_gi.vobu_uop_ctl.title_or_time_play             = getbits(&state, 1 );
+  pci->pci_gi.vobu_s_ptm = getbits(&state, 32 );
+  pci->pci_gi.vobu_e_ptm = getbits(&state, 32 );
+  pci->pci_gi.vobu_se_e_ptm = getbits(&state, 32 );
+  pci->pci_gi.e_eltm.hour   = getbits(&state, 8 );
+  pci->pci_gi.e_eltm.minute = getbits(&state, 8 );
+  pci->pci_gi.e_eltm.second = getbits(&state, 8 );
+  pci->pci_gi.e_eltm.frame_u = getbits(&state, 8 );
+  for(i = 0; i < 32; i++)
+    pci->pci_gi.vobu_isrci = getbits(&state, 8 );
+
+  /* pci nsml_agli */
+  for(i = 0; i < 9; i++)
+    pci->nsml_agli.nsml_agl_dstai = getbits(&state, 32 );
+
+  /* pci hli hli_gi */
+  pci->hli.hl_gi.hli_ss = getbits(&state, 16 );
+  pci->hli.hl_gi.hli_s_ptm = getbits(&state, 32 );
+  pci->hli.hl_gi.hli_e_ptm = getbits(&state, 32 );
+  pci->hli.hl_gi.btn_se_e_ptm = getbits(&state, 32 );
+  pci->hli.hl_gi.zero1 = getbits(&state, 2 );
+  pci->hli.hl_gi.btngr_ns = getbits(&state, 2 );
+  pci->hli.hl_gi.zero2 = getbits(&state, 1 );
+  pci->hli.hl_gi.btngr1_dsp_ty = getbits(&state, 3 );
+  pci->hli.hl_gi.zero3 = getbits(&state, 1 );
+  pci->hli.hl_gi.btngr2_dsp_ty = getbits(&state, 3 );
+  pci->hli.hl_gi.zero4 = getbits(&state, 1 );
+  pci->hli.hl_gi.btngr3_dsp_ty = getbits(&state, 3 );
+  pci->hli.hl_gi.btn_ofn = getbits(&state, 8 );
+  pci->hli.hl_gi.btn_ns = getbits(&state, 8 );
+  pci->hli.hl_gi.nsl_btn_ns = getbits(&state, 8 );
+  pci->hli.hl_gi.zero5 = getbits(&state, 8 );
+  pci->hli.hl_gi.fosl_btnn = getbits(&state, 8 );
+  pci->hli.hl_gi.foac_btnn = getbits(&state, 8 );
+
+  /* pci hli btn_colit */
+  for(i = 0; i < 3; i++)
+    for(j = 0; j < 2; j++)
+      pci->hli.btn_colit.btn_coliij = getbits(&state, 32 );
+
+  /* NOTE: I've had to change the structure from the disk layout to get
+   * the packing to work with Sun's Forte C compiler. */
+
+  /* pci hli btni */
+  for(i = 0; i < 36; i++) {
+    pci->hli.btniti.btn_coln = getbits(&state, 2 );
+    pci->hli.btniti.x_start = getbits(&state, 10 );
+    pci->hli.btniti.zero1 = getbits(&state, 2 );
+    pci->hli.btniti.x_end = getbits(&state, 10 );
+
+    pci->hli.btniti.auto_action_mode = getbits(&state, 2 );
+    pci->hli.btniti.y_start = getbits(&state, 10 );
+    pci->hli.btniti.zero2 = getbits(&state, 2 );
+    pci->hli.btniti.y_end = getbits(&state, 10 );
+
+    pci->hli.btniti.zero3 = getbits(&state, 2 );
+    pci->hli.btniti.up = getbits(&state, 6 );
+    pci->hli.btniti.zero4 = getbits(&state, 2 );
+    pci->hli.btniti.down = getbits(&state, 6 );
+    pci->hli.btniti.zero5 = getbits(&state, 2 );
+    pci->hli.btniti.left = getbits(&state, 6 );
+    pci->hli.btniti.zero6 = getbits(&state, 2 );
+    pci->hli.btniti.right = getbits(&state, 6 );
+    /* pci vm_cmd */
+    for(j = 0; j < 8; j++)
+      pci->hli.btniti.cmd.bytesj = getbits(&state, 8 );
+  }
+
+
+#ifndef NDEBUG
+  /* Asserts */
+
+  /* pci pci gi */
+  CHECK_VALUE(pci->pci_gi.zero1 == 0);
+
+  /* pci hli hli_gi */
+  CHECK_VALUE(pci->hli.hl_gi.zero1 == 0);
+  CHECK_VALUE(pci->hli.hl_gi.zero2 == 0);
+  CHECK_VALUE(pci->hli.hl_gi.zero3 == 0);
+  CHECK_VALUE(pci->hli.hl_gi.zero4 == 0);
+  CHECK_VALUE(pci->hli.hl_gi.zero5 == 0);
+
+  /* Are there buttons defined here? */
+  if((pci->hli.hl_gi.hli_ss & 0x03) != 0) {
+    CHECK_VALUE(pci->hli.hl_gi.btn_ns != 0);
+    CHECK_VALUE(pci->hli.hl_gi.btngr_ns != 0);
+  } else {
+    CHECK_VALUE((pci->hli.hl_gi.btn_ns != 0 && pci->hli.hl_gi.btngr_ns != 0)
+                || (pci->hli.hl_gi.btn_ns == 0 && pci->hli.hl_gi.btngr_ns == 0));
+  }
+
+  /* pci hli btnit */
+  for(i = 0; i < pci->hli.hl_gi.btngr_ns; i++) {
+    for(j = 0; j < (36 / pci->hli.hl_gi.btngr_ns); j++) {
+      int n = (36 / pci->hli.hl_gi.btngr_ns) * i + j;
+      CHECK_VALUE(pci->hli.btnitn.zero1 == 0);
+      CHECK_VALUE(pci->hli.btnitn.zero2 == 0);
+      CHECK_VALUE(pci->hli.btnitn.zero3 == 0);
+      CHECK_VALUE(pci->hli.btnitn.zero4 == 0);
+      CHECK_VALUE(pci->hli.btnitn.zero5 == 0);
+      CHECK_VALUE(pci->hli.btnitn.zero6 == 0);
+
+      if (j < pci->hli.hl_gi.btn_ns) {
+        CHECK_VALUE(pci->hli.btnitn.x_start <= pci->hli.btnitn.x_end);
+        CHECK_VALUE(pci->hli.btnitn.y_start <= pci->hli.btnitn.y_end);
+        CHECK_VALUE(pci->hli.btnitn.up <= pci->hli.hl_gi.btn_ns);
+        CHECK_VALUE(pci->hli.btnitn.down <= pci->hli.hl_gi.btn_ns);
+        CHECK_VALUE(pci->hli.btnitn.left <= pci->hli.hl_gi.btn_ns);
+        CHECK_VALUE(pci->hli.btnitn.right <= pci->hli.hl_gi.btn_ns);
+        /* vmcmd_verify(pci->hli.btnitn.cmd); */
+      } else {
+        int k;
+        CHECK_VALUE(pci->hli.btnitn.btn_coln == 0);
+        CHECK_VALUE(pci->hli.btnitn.auto_action_mode == 0);
+        CHECK_VALUE(pci->hli.btnitn.x_start == 0);
+        CHECK_VALUE(pci->hli.btnitn.y_start == 0);
+        CHECK_VALUE(pci->hli.btnitn.x_end == 0);
+        CHECK_VALUE(pci->hli.btnitn.y_end == 0);
+        CHECK_VALUE(pci->hli.btnitn.up == 0);
+        CHECK_VALUE(pci->hli.btnitn.down == 0);
+        CHECK_VALUE(pci->hli.btnitn.left == 0);
+        CHECK_VALUE(pci->hli.btnitn.right == 0);
+        for (k = 0; k < 8; k++)
+          CHECK_VALUE(pci->hli.btnitn.cmd.bytesk == 0); /* CHECK_ZERO? */
+      }
+    }
+  }
+#endif /* !NDEBUG */
+}
+
+void navRead_DSI(dsi_t *dsi, unsigned char *buffer) {
+  int i;
+  getbits_state_t state;
+  if (!getbits_init(&state, buffer)) abort(); /* Passed NULL pointers */
+
+  /* dsi dsi gi */
+  dsi->dsi_gi.nv_pck_scr = getbits(&state, 32 );
+  dsi->dsi_gi.nv_pck_lbn = getbits(&state, 32 );
+  dsi->dsi_gi.vobu_ea = getbits(&state, 32 );
+  dsi->dsi_gi.vobu_1stref_ea = getbits(&state, 32 );
+  dsi->dsi_gi.vobu_2ndref_ea = getbits(&state, 32 );
+  dsi->dsi_gi.vobu_3rdref_ea = getbits(&state, 32 );
+  dsi->dsi_gi.vobu_vob_idn = getbits(&state, 16 );
+  dsi->dsi_gi.zero1 = getbits(&state, 8 );
+  dsi->dsi_gi.vobu_c_idn = getbits(&state, 8 );
+  dsi->dsi_gi.c_eltm.hour   = getbits(&state, 8 );
+  dsi->dsi_gi.c_eltm.minute = getbits(&state, 8 );
+  dsi->dsi_gi.c_eltm.second = getbits(&state, 8 );
+  dsi->dsi_gi.c_eltm.frame_u = getbits(&state, 8 );
+
+  /* dsi sml pbi */
+  dsi->sml_pbi.category = getbits(&state, 16 );
+  dsi->sml_pbi.ilvu_ea = getbits(&state, 32 );
+  dsi->sml_pbi.ilvu_sa = getbits(&state, 32 );
+  dsi->sml_pbi.size = getbits(&state, 16 );
+  dsi->sml_pbi.vob_v_s_s_ptm = getbits(&state, 32 );
+  dsi->sml_pbi.vob_v_e_e_ptm = getbits(&state, 32 );
+  for(i = 0; i < 8; i++) {
+    dsi->sml_pbi.vob_ai.stp_ptm1 = getbits(&state, 32 );
+    dsi->sml_pbi.vob_ai.stp_ptm2 = getbits(&state, 32 );
+    dsi->sml_pbi.vob_ai.gap_len1 = getbits(&state, 32 );
+    dsi->sml_pbi.vob_ai.gap_len2 = getbits(&state, 32 );
+  }
+
+  /* dsi sml agli */
+  for(i = 0; i < 9; i++) {
+    dsi->sml_agli.data i .address = getbits(&state, 32 );
+    dsi->sml_agli.data i .size = getbits(&state, 16 );
+  }
+
+  /* dsi vobu sri */
+  dsi->vobu_sri.next_video = getbits(&state, 32 );
+  for(i = 0; i < 19; i++)
+    dsi->vobu_sri.fwdai = getbits(&state, 32 );
+  dsi->vobu_sri.next_vobu = getbits(&state, 32 );
+  dsi->vobu_sri.prev_vobu = getbits(&state, 32 );
+  for(i = 0; i < 19; i++)
+    dsi->vobu_sri.bwdai = getbits(&state, 32 );
+  dsi->vobu_sri.prev_video = getbits(&state, 32 );
+
+  /* dsi synci */
+  for(i = 0; i < 8; i++)
+    dsi->synci.a_syncai = getbits(&state, 16 );
+  for(i = 0; i < 32; i++)
+    dsi->synci.sp_syncai = getbits(&state, 32 );
+
+
+  /* Asserts */
+
+  /* dsi dsi gi */
+  CHECK_VALUE(dsi->dsi_gi.zero1 == 0);
+}

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/nav_read.h Added

@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2000, 2001, 2002 Håkan Hjort <d95hjort@dtek.chalmers.se>.
+ *
+ * This file is part of libdvdread.
+ *
+ * libdvdread 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.
+ *
+ * libdvdread 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 libdvdread; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#ifndef LIBDVDREAD_NAV_READ_H
+#define LIBDVDREAD_NAV_READ_H
+
+#include "nav_types.h"
+
+/**
+ * Parsing of NAV data, PCI and DSI parts.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Reads the PCI packet data pointed to into th pci struct.
+ *
+ * @param pci Pointer to the PCI data structure to be filled in.
+ * @param bufffer Pointer to the buffer of the on disc PCI data.
+ */
+void navRead_PCI(pci_t *, unsigned char *);
+
+/**
+ * Reads the DSI packet data pointed to into dsi struct.
+ *
+ * @param dsi Pointer to the DSI data structure to be filled in.
+ * @param bufffer Pointer to the buffer of the on disc DSI data.
+ */
+void navRead_DSI(dsi_t *, unsigned char *);
+
+#ifdef __cplusplus
+};
+#endif
+#endif /* LIBDVDREAD_NAV_READ_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/nav_types.h Added

@@ -0,0 +1,253 @@
+/*
+ * Copyright (C) 2000, 2001, 2002 Håkan Hjort <d95hjort@dtek.chalmers.se>
+ *
+ * The data structures in this file should represent the layout of the
+ * pci and dsi packets as they are stored in the stream.  Information
+ * found by reading the source to VOBDUMP is the base for the structure
+ * and names of these data types.
+ *
+ * VOBDUMP: a program for examining DVD .VOB files.
+ * Copyright 1998, 1999 Eric Smith <eric@brouhaha.com>
+ *
+ * VOBDUMP is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.  Note that I am not
+ * granting permission to redistribute or modify VOBDUMP under the terms
+ * of any later version of the General Public License.
+ *
+ * This program is distributed in the hope that it will be useful (or at
+ * least amusing), 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.
+ */
+
+#ifndef LIBDVDREAD_NAV_TYPES_H
+#define LIBDVDREAD_NAV_TYPES_H
+
+#include <inttypes.h>
+#include "ifo_types.h" /* only dvd_time_t, vm_cmd_t and user_ops_t */
+
+/* The length including the substream id byte. */
+#define PCI_BYTES 0x3d4
+#define DSI_BYTES 0x3fa
+
+#define PS2_PCI_SUBSTREAM_ID 0x00
+#define PS2_DSI_SUBSTREAM_ID 0x01
+
+/* Remove this */
+#define DSI_START_BYTE 1031
+
+#if PRAGMA_PACK
+#pragma pack(push)
+#pragma pack(1)
+#endif
+
+/**
+ * PCI General Information
+ */
+typedef struct {
+  uint32_t nv_pck_lbn;      /**< sector address of this nav pack */
+  uint16_t vobu_cat;        /**< 'category' of vobu */
+  uint16_t zero1;           /**< reserved */
+  user_ops_t vobu_uop_ctl;  /**< UOP of vobu */
+  uint32_t vobu_s_ptm;      /**< start presentation time of vobu */
+  uint32_t vobu_e_ptm;      /**< end presentation time of vobu */
+  uint32_t vobu_se_e_ptm;   /**< end ptm of sequence end in vobu */
+  dvd_time_t e_eltm;        /**< Cell elapsed time */
+  char vobu_isrc32;
+} ATTRIBUTE_PACKED pci_gi_t;
+
+/**
+ * Non Seamless Angle Information
+ */
+typedef struct {
+  uint32_t nsml_agl_dsta9;  /**< address of destination vobu in AGL_C#n */
+} ATTRIBUTE_PACKED nsml_agli_t;
+
+/**
+ * Highlight General Information
+ *
+ * For btngrX_dsp_ty the bits have the following meaning:
+ * 000b: normal 4/3 only buttons
+ * XX1b: wide (16/9) buttons
+ * X1Xb: letterbox buttons
+ * 1XXb: pan&scan buttons
+ */
+typedef struct {
+  uint16_t hli_ss; /**< status, only low 2 bits 0: no buttons, 1: different 2: equal 3: eual except for button cmds */
+  uint32_t hli_s_ptm;              /**< start ptm of hli */
+  uint32_t hli_e_ptm;              /**< end ptm of hli */
+  uint32_t btn_se_e_ptm;           /**< end ptm of button select */
+  unsigned int zero1 : 2;          /**< reserved */
+  unsigned int btngr_ns : 2;       /**< number of button groups 1, 2 or 3 with 36/18/12 buttons */
+  unsigned int zero2 : 1;          /**< reserved */
+  unsigned int btngr1_dsp_ty : 3;  /**< display type of subpic stream for button group 1 */
+  unsigned int zero3 : 1;          /**< reserved */
+  unsigned int btngr2_dsp_ty : 3;  /**< display type of subpic stream for button group 2 */
+  unsigned int zero4 : 1;          /**< reserved */
+  unsigned int btngr3_dsp_ty : 3;  /**< display type of subpic stream for button group 3 */
+  uint8_t btn_ofn;     /**< button offset number range 0-255 */
+  uint8_t btn_ns;      /**< number of valid buttons  <= 36/18/12 (low 6 bits) */
+  uint8_t nsl_btn_ns;  /**< number of buttons selectable by U_BTNNi (low 6 bits)   nsl_btn_ns <= btn_ns */
+  uint8_t zero5;       /**< reserved */
+  uint8_t fosl_btnn;   /**< forcedly selected button  (low 6 bits) */
+  uint8_t foac_btnn;   /**< forcedly activated button (low 6 bits) */
+} ATTRIBUTE_PACKED hl_gi_t;
+
+
+/**
+ * Button Color Information Table
+ * Each entry beeing a 32bit word that contains the color indexs and alpha
+ * values to use.  They are all represented by 4 bit number and stored
+ * like this Ci3, Ci2, Ci1, Ci0, A3, A2, A1, A0.   The actual palette
+ * that the indexes reference is in the PGC.
+ * @TODO split the uint32_t into a struct
+ */
+typedef struct {
+  uint32_t btn_coli32;  /**< button color number-1select:0/action:1 */
+} ATTRIBUTE_PACKED btn_colit_t;
+
+/**
+ * Button Information
+ *
+ * NOTE: I've had to change the structure from the disk layout to get
+ * the packing to work with Sun's Forte C compiler.
+ * The 4 and 7 bytes are 'rotated' was: ABC DEF GHIJ  is: ABCG DEFH IJ
+ */
+typedef struct {
+  unsigned int btn_coln         : 2;  /**< button color number */
+  unsigned int x_start          : 10; /**< x start offset within the overlay */
+  unsigned int zero1            : 2;  /**< reserved */
+  unsigned int x_end            : 10; /**< x end offset within the overlay */
+
+  unsigned int auto_action_mode : 2;  /**< 0: no, 1: activated if selected */
+  unsigned int y_start          : 10; /**< y start offset within the overlay */
+  unsigned int zero2            : 2;  /**< reserved */
+  unsigned int y_end            : 10; /**< y end offset within the overlay */
+
+  unsigned int zero3            : 2;  /**< reserved */
+  unsigned int up               : 6;  /**< button index when pressing up */
+  unsigned int zero4            : 2;  /**< reserved */
+  unsigned int down             : 6;  /**< button index when pressing down */
+  unsigned int zero5            : 2;  /**< reserved */
+  unsigned int left             : 6;  /**< button index when pressing left */
+  unsigned int zero6            : 2;  /**< reserved */
+  unsigned int right            : 6;  /**< button index when pressing right */
+  vm_cmd_t cmd;
+} ATTRIBUTE_PACKED btni_t;
+
+/**
+ * Highlight Information
+ */
+typedef struct {
+  hl_gi_t     hl_gi;
+  btn_colit_t btn_colit;
+  btni_t      btnit36;
+} ATTRIBUTE_PACKED hli_t;
+
+/**
+ * PCI packet
+ */
+typedef struct {
+  pci_gi_t    pci_gi;
+  nsml_agli_t nsml_agli;
+  hli_t       hli;
+  uint8_t     zero1189;
+} ATTRIBUTE_PACKED pci_t;
+
+
+
+
+/**
+ * DSI General Information
+ */
+typedef struct {
+  uint32_t nv_pck_scr;
+  uint32_t nv_pck_lbn;      /**< sector address of this nav pack */
+  uint32_t vobu_ea;         /**< end address of this VOBU */
+  uint32_t vobu_1stref_ea;  /**< end address of the 1st reference image */
+  uint32_t vobu_2ndref_ea;  /**< end address of the 2nd reference image */
+  uint32_t vobu_3rdref_ea;  /**< end address of the 3rd reference image */
+  uint16_t vobu_vob_idn;    /**< VOB Id number that this VOBU is part of */
+  uint8_t  zero1;           /**< reserved */
+  uint8_t  vobu_c_idn;      /**< Cell Id number that this VOBU is part of */
+  dvd_time_t c_eltm;        /**< Cell elapsed time */
+} ATTRIBUTE_PACKED dsi_gi_t;
+
+/**
+ * Seamless Playback Information
+ */
+typedef struct {
+  uint16_t category;       /**< 'category' of seamless VOBU */
+  uint32_t ilvu_ea;        /**< end address of interleaved Unit */
+  uint32_t ilvu_sa;        /**< start address of next interleaved unit */
+  uint16_t size;           /**< size of next interleaved unit */
+  uint32_t vob_v_s_s_ptm;  /**< video start ptm in vob */
+  uint32_t vob_v_e_e_ptm;  /**< video end ptm in vob */
+  struct {
+    uint32_t stp_ptm1;
+    uint32_t stp_ptm2;
+    uint32_t gap_len1;
+    uint32_t gap_len2;
+  } vob_a8;
+} ATTRIBUTE_PACKED sml_pbi_t;
+
+/**
+ * Seamless Angle Information for one angle
+ */
+typedef struct {
+  uint32_t address; /**< offset to next ILVU, high bit is before/after */
+  uint16_t size;    /**< byte size of the ILVU pointed to by address */
+} ATTRIBUTE_PACKED sml_agl_data_t;
+
+/**
+ * Seamless Angle Information
+ */
+typedef struct {
+  sml_agl_data_t data9;
+} ATTRIBUTE_PACKED sml_agli_t;
+
+/**
+ * VOBU Search Information
+ */
+typedef struct {
+  uint32_t next_video; /**< Next vobu that contains video */
+  uint32_t fwda19;   /**< Forwards, time */
+  uint32_t next_vobu;
+  uint32_t prev_vobu;
+  uint32_t bwda19;   /**< Backwards, time */
+  uint32_t prev_video;
+} ATTRIBUTE_PACKED vobu_sri_t;
+
+#define SRI_END_OF_CELL 0x3fffffff
+
+/**
+ * Synchronous Information
+ */
+typedef struct {
+  uint16_t a_synca8;   /**< offset to first audio packet for this VOBU */
+  uint32_t sp_synca32; /**< offset to first subpicture packet */
+} ATTRIBUTE_PACKED synci_t;
+
+/**
+ * DSI packet
+ */
+typedef struct {
+  dsi_gi_t   dsi_gi;
+  sml_pbi_t  sml_pbi;
+  sml_agli_t sml_agli;
+  vobu_sri_t vobu_sri;
+  synci_t    synci;
+  uint8_t    zero1471;
+} ATTRIBUTE_PACKED dsi_t;
+
+
+#if PRAGMA_PACK
+#pragma pack(pop)
+#endif
+
+#endif /* LIBDVDREAD_NAV_TYPES_H */

makemkv-oss-1.17.0.tar.gz/mmgpl/dvdread/version.h Added

@@ -0,0 +1,37 @@
+/*
+ * This file is part of libdvdread
+ * Copyright (C) 2015 VideoLAN
+ *
+ * This file is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This file 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef DVDREAD_VERSION_H_
+#define DVDREAD_VERSION_H_
+
+#define DVDREAD_VERSION_CODE(major, minor, micro) \
+    (((major) * 10000) +                         \
+     ((minor) *   100) +                         \
+     ((micro) *     1))
+
+#define DVDREAD_VERSION_MAJOR 6
+#define DVDREAD_VERSION_MINOR 1
+#define DVDREAD_VERSION_MICRO 2
+
+#define DVDREAD_VERSION_STRING "6.1.2"
+
+#define DVDREAD_VERSION \
+    DVDREAD_VERSION_CODE(DVDREAD_VERSION_MAJOR, DVDREAD_VERSION_MINOR, DVDREAD_VERSION_MICRO)
+
+#endif /* DVDREAD_VERSION_H_ */

makemkv-oss-1.17.0.tar.gz/mmgpl/mmgpl.cpp Added

@@ -0,0 +1,59 @@
+/*
+    GPL is cancer. A hacky and otherwise useless glue code to comply with GPL licensing.
+
+    Copyright (C) 2007-2022 GuinpinSoft inc <mmgpl@makemkv.com>
+
+    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.
+
+*/
+#include <stdio.h>
+#include <string.h>
+#include <dvdnav/mmdvdnav.h>
+
+#ifdef _WIN32
+
+#include <Windows.h>
+#include <winnt.h>
+
+#endif
+
+
+extern "C"
+int main(int argc,char **argv)
+{
+    if (argc <= 1)
+    {
+        return 0;
+    }
+
+    if ((argc >= 2) && (0 == strcmp(argv1, "libdvdnav-server")))
+    {
+        uint64_t pipe_in, pipe_out;
+
+#ifdef _WIN32
+        pipe_in = (uintptr_t)(void*)GetStdHandle(STD_INPUT_HANDLE);
+        pipe_out = (uintptr_t)(void*)GetStdHandle(STD_OUTPUT_HANDLE);
+#else
+        pipe_in = 0;
+        pipe_out = 1;
+#endif
+
+        DvdNavRunServer(pipe_in, pipe_out);
+        return 0;
+    }
+
+    return -1;
+}
+

makemkv-oss-1.17.0.tar.gz/mmgpl/navapi.cpp Added

@@ -0,0 +1,126 @@
+/*
+    GPL is cancer. A hacky and otherwise useless glue code to comply with GPL licensing.
+
+    Copyright (C) 2007-2022 GuinpinSoft inc <mmgpl@makemkv.com>
+
+    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.
+
+*/
+#include <dvdnav/mmdvdnav.h>
+#include <dvdnav/dvdnav.h>
+#include <strings.h>
+#include <stdio.h>
+
+bool DvdNavSetParam(dvdnav_t* ctx, int id, uint32_t value)
+{
+    dvdnav_status_t st;
+    uint8_t sbuf5;
+
+    sbuf0 = (uint8_t)(value >> (0 * 8));
+    sbuf1 = (uint8_t)(value >> (1 * 8));
+    sbuf2 = (uint8_t)(value >> (2 * 8));
+    sbuf3 = (uint8_t)(value >> (3 * 8));
+    sbuf4 = 0;
+
+    switch (id)
+    {
+    case dvdnav_region_mask: st = dvdnav_set_region_mask(ctx, value); break;
+    case dvdnav_menu_language: st = dvdnav_menu_language_select(ctx, (char*)sbuf); break;
+    case dvdnav_audio_language: st = dvdnav_audio_language_select(ctx, (char*)sbuf); break;
+    case dvdnav_spu_language: st = dvdnav_spu_language_select(ctx, (char*)sbuf); break;
+    case dvdnav_angle: st = dvdnav_angle_change(ctx, value); break;
+    case dvdnav_button: st = dvdnav_button_select_and_activate(ctx, dvdnav_get_current_nav_pci(ctx), value); break;
+    case dvdnav_title: st = dvdnav_title_play(ctx, value); break;
+    case dvdnav_program: st = dvdnav_program_play(ctx, (value>>16),(value>>8)&0xff,(value&0xff)); break;
+    case dvdnav_highlight: st = dvdnav_button_select(ctx, dvdnav_get_current_nav_pci(ctx), value); break;
+    default: st = DVDNAV_STATUS_ERR; break;
+    }
+    return (DVDNAV_STATUS_OK == st);
+}
+
+static void fill_position_info(dvdnav_t* ctx, dvdnav_event_t* p_event)
+{
+    int32_t title, vtsn, pgcn, pgn, celln;
+    if (DVDNAV_STATUS_OK != dvdnav_current_title_program2(ctx, &title, &vtsn, &pgcn, &pgn, &celln))
+    {
+        p_event->title_id = 0xffff;
+    } else {
+        p_event->vtsn = (uint8_t)vtsn;
+        p_event->pgc_id = (uint16_t)pgcn;
+        p_event->cell_id = (uint8_t)celln;
+        if (title >= 0)
+        {
+            p_event->title_id = (uint16_t)title;
+        } else {
+            p_event->title_id = 0xffff;
+        }
+    }
+
+    pci_t* pci = dvdnav_get_current_nav_pci(ctx);
+    if (NULL != pci)
+    {
+        p_event->vobu = pci->pci_gi.nv_pck_lbn;
+    }
+}
+
+bool DvdNavRun(dvdnav_t* ctx, dvdnav_event_t* p_event)
+{
+    uint8_t dataDVD_VIDEO_LB_LEN;
+    int len = DVD_VIDEO_LB_LEN;
+    dvdnav_status_t st;
+
+    int32_t code;
+
+    bzero(p_event, sizeof(*p_event));
+
+    st = dvdnav_get_next_block(ctx, data, &code, &len);
+    p_event->time = (uint32_t)(dvdnav_get_absolute_time(ctx)/90);
+    p_event->sprm_flags = dvdnav_get_prm(ctx,3,0);
+    p_event->highlight = (uint8_t)(dvdnav_get_prm(ctx, 1, 8) >> 10);
+    if (DVDNAV_STATUS_OK != st)
+    {
+        p_event->type = dvdnav_evt_error;
+        p_event->code = st;
+        return true;
+    }
+
+    p_event->type = dvdnav_evt_libdvdnav;
+    p_event->code = code;
+
+    switch (code)
+    {
+    case DVDNAV_STILL_FRAME:
+        p_event->still_time = (uint8_t) ((dvdnav_still_event_t *)data)->length;
+        fill_position_info(ctx, p_event);
+        if (0xff != p_event->still_time)
+        {
+            dvdnav_still_skip(ctx);
+        }
+        break;
+    case DVDNAV_WAIT:
+        dvdnav_wait_skip(ctx);
+        break;
+    case DVDNAV_NAV_PACKET:
+        fill_position_info(ctx, p_event);
+        break;
+    case DVDNAV_CELL_CHANGE:
+        fill_position_info(ctx, p_event);
+        break;
+    default:
+        break;
+    }
+
+    return true;
+}

Build Results
RPM Lint

Refresh

Comments for request 5586 0

Request History

manfred.h created request over 2 years ago

microchip8 accepted request over 2 years ago