Request 6326 (accepted)

Overview

Request 6326 (accepted)

- Update to version 1.18.2
* Improved handling for discs with mastering errors
* Small improvements and bugfixes
- Remove now obsolete silence-return-type.patch

Created by manfred-h 2 months 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 Deleted

@@ -1,44 +0,0 @@
-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.18.1.tar.gz/bin/amd64/makemkvcon -> makemkv-bin-1.18.2.tar.gz/bin/amd64/makemkvcon Changed

makemkv-bin-1.18.1.tar.gz/bin/arm64/makemkvcon -> makemkv-bin-1.18.2.tar.gz/bin/arm64/makemkvcon Changed

makemkv-bin-1.18.1.tar.gz/bin/armhf/makemkvcon -> makemkv-bin-1.18.2.tar.gz/bin/armhf/makemkvcon Changed

makemkv-bin-1.18.1.tar.gz/bin/i386/makemkvcon -> makemkv-bin-1.18.2.tar.gz/bin/i386/makemkvcon Changed

makemkv-bin-1.18.1.tar.gz/src/share/blues.jar -> makemkv-bin-1.18.2.tar.gz/src/share/blues.jar Changed

makemkv-oss-1.18.1.tar.gz/Makefile.in -> makemkv-oss-1.18.2.tar.gz/Makefile.in Changed

makemkv-oss-1.18.1.tar.gz/libffabi/src/ffabi.c -> makemkv-oss-1.18.2.tar.gz/libffabi/src/ffabi.c Changed

@@ -211,8 +211,7 @@
     av_packet_free(&ctx->pck);
 
     if (ctx->avctx) {
-        avcodec_close(ctx->avctx);
-        av_free(ctx->avctx);
+        avcodec_free_context(&ctx->avctx);
     }
 
     av_free(ctx);
@@ -374,7 +373,7 @@
 #endif
 
     ctx->avctx->profile = (info->profile != FFM_PROFILE_UNKNOWN) ?
-        info->profile : FF_PROFILE_UNKNOWN;
+        info->profile : AV_PROFILE_UNKNOWN;
 
     if ((CodecFlags&FFM_CODEC_FLAG_GLOBAL_HEADER)!=0)
         ctx->avctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
@@ -420,8 +419,7 @@
     av_freep(&ctx->frame_extended_data);
 
     if (ctx->avctx) {
-        avcodec_close(ctx->avctx);
-        av_free(ctx->avctx);
+        avcodec_free_context(&ctx->avctx);
     }
 
     av_free(ctx);
@@ -604,7 +602,7 @@
     info->capabilities = codec->capabilities;
     if (codec->profiles) {
         for (i=0;i<32;i++) {
-            if (codec->profilesi.profile==FF_PROFILE_UNKNOWN)
+            if (codec->profilesi.profile==AV_PROFILE_UNKNOWN)
                 break;
             info->profiles_namesi=codec->profilesi.name;
             info->profiles_valuesi=codec->profilesi.profile;
@@ -655,6 +653,7 @@
     }
 
     rest = size;
+    outbuf_size = 0;
     while(rest) {
         err = av_parser_parse2(pctx,avctx,&outbuf,&outbuf_size,
             data,rest,0,0,0);
@@ -695,59 +694,11 @@
     }
 
     if (avctx) {
-        avcodec_close(avctx);
-        av_free(avctx);
+        avcodec_free_context(&avctx);
     }
     return err;
 }
 
-int __cdecl ffm_mpa_decode_header(uint32_t hdr,FFM_AudioInfo* info,uint32_t* layer,uint32_t* frame_size,uint32_t* bitrate)
-{
-    MPADecodeHeader s;
-    int err;
-
-    if (ff_mpa_check_header(hdr)) {
-        return ffmerr(0,0);
-    }
-
-    err = avpriv_mpegaudio_decode_header(&s, hdr);
-    if ((err < 0) || (err > 1)) {
-        return ffmerr(1,err);
-    }
-    if (err==0) {
-        *bitrate = s.bit_rate;
-        *frame_size = s.frame_size;
-    } else {
-        *bitrate = 0;
-        *frame_size = 0;
-    }
-
-    info->bits_per_sample = 0;
-    info->channel_layout = 0;
-
-    info->sample_rate = s.sample_rate;
-    info->channels = s.nb_channels;
-    *layer = s.layer;
-
-    switch(s.layer) {
-    case 1:
-        info->frame_size = 384;
-        break;
-    case 2:
-        info->frame_size = 1152;
-        break;
-    default:
-    case 3:
-        if (s.lsf)
-            info->frame_size = 576;
-        else
-            info->frame_size = 1152;
-        break;
-    }
-
-    return 0;
-}
-
 int __cdecl ffm_get_channel_layout_string(char *buf,int buf_size,uint64_t channel_layout)
 {
 #ifdef FFABI_HAVE_OLD_CHANNEL_LAYOUT

makemkv-oss-1.18.1.tar.gz/libffabi/src/internal.h -> makemkv-oss-1.18.2.tar.gz/libffabi/src/internal.h Changed

makemkv-oss-1.18.2.tar.gz/libffabi/src/mpegaudio.h Added

@@ -0,0 +1,57 @@
+/*
+ * copyright (c) 2001 Fabrice Bellard
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * mpeg audio declarations for both encoder and decoder.
+ */
+
+#ifndef FFABI_AVCODEC_MPEGAUDIO_H
+#define FFABI_AVCODEC_MPEGAUDIO_H
+
+#include <stdint.h>
+
+/* max frame size, in samples */
+#define MPA_FRAME_SIZE 1152
+
+/* max compressed frame size */
+#define MPA_MAX_CODED_FRAME_SIZE 1792
+
+#define MPA_MAX_CHANNELS 2
+
+#define SBLIMIT 32 /* number of subbands */
+
+#define MPA_STEREO  0
+#define MPA_JSTEREO 1
+#define MPA_DUAL    2
+#define MPA_MONO    3
+
+#ifndef FRAC_BITS
+#define FRAC_BITS   23   /* fractional bits for sb_samples and dct */
+#define WFRAC_BITS  16   /* fractional bits for window */
+#endif
+
+#define IMDCT_SCALAR 1.759
+
+#define FRAC_ONE    (1 << FRAC_BITS)
+
+#define FIX(a)   ((int)((a) * FRAC_ONE))
+
+#endif /* AVCODEC_MPEGAUDIO_H */

makemkv-oss-1.18.2.tar.gz/libffabi/src/mpegaudiodecheader.c Added

@@ -0,0 +1,164 @@
+/*
+ * MPEG Audio header decoder
+ * Copyright (c) 2001, 2002 Fabrice Bellard
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * MPEG Audio header decoder.
+ */
+
+#include <lgpl/ffabi.h>
+
+#include "mpegaudio.h"
+#include "mpegaudiotabs.h"
+#include "mpegaudiodecheader.h"
+
+#define FF_ARRAY_ELEMS(a) (sizeof(a) / sizeof((a)0))
+
+static int ffm_avpriv_mpegaudio_decode_header(MPADecodeHeader *s, uint32_t header)
+{
+    int sample_rate, frame_size, mpeg25, padding;
+    int sample_rate_index, bitrate_index;
+    int ret;
+
+    ret = ff_mpa_check_header(header);
+    if (ret < 0)
+        return ret;
+
+    if (header & (1<<20)) {
+        s->lsf = (header & (1<<19)) ? 0 : 1;
+        mpeg25 = 0;
+    } else {
+        s->lsf = 1;
+        mpeg25 = 1;
+    }
+
+    s->layer = 4 - ((header >> 17) & 3);
+    /* extract frequency */
+    sample_rate_index = (header >> 10) & 3;
+    if (sample_rate_index >= FF_ARRAY_ELEMS(ff_mpa_freq_tab))
+        sample_rate_index = 0;
+    sample_rate = ff_mpa_freq_tabsample_rate_index >> (s->lsf + mpeg25);
+    sample_rate_index += 3 * (s->lsf + mpeg25);
+    s->sample_rate_index = sample_rate_index;
+    s->error_protection = ((header >> 16) & 1) ^ 1;
+    s->sample_rate = sample_rate;
+
+    bitrate_index = (header >> 12) & 0xf;
+    padding = (header >> 9) & 1;
+    //extension = (header >> 8) & 1;
+    s->mode = (header >> 6) & 3;
+    s->mode_ext = (header >> 4) & 3;
+    //copyright = (header >> 3) & 1;
+    //original = (header >> 2) & 1;
+    //emphasis = header & 3;
+
+    if (s->mode == MPA_MONO)
+        s->nb_channels = 1;
+    else
+        s->nb_channels = 2;
+
+    if (bitrate_index != 0) {
+        frame_size = ff_mpa_bitrate_tabs->lsfs->layer - 1bitrate_index;
+        s->bit_rate = frame_size * 1000;
+        switch(s->layer) {
+        case 1:
+            frame_size = (frame_size * 12000) / sample_rate;
+            frame_size = (frame_size + padding) * 4;
+            break;
+        case 2:
+            frame_size = (frame_size * 144000) / sample_rate;
+            frame_size += padding;
+            break;
+        default:
+        case 3:
+            frame_size = (frame_size * 144000) / (sample_rate << s->lsf);
+            frame_size += padding;
+            break;
+        }
+        s->frame_size = frame_size;
+    } else {
+        /* if no frame size computed, signal it */
+        return 1;
+    }
+
+#if 0 // defined(DEBUG)
+    ff_dlog(NULL, "layer%d, %d Hz, %d kbits/s, ",
+           s->layer, s->sample_rate, s->bit_rate);
+    if (s->nb_channels == 2) {
+        if (s->layer == 3) {
+            if (s->mode_ext & MODE_EXT_MS_STEREO)
+                ff_dlog(NULL, "ms-");
+            if (s->mode_ext & MODE_EXT_I_STEREO)
+                ff_dlog(NULL, "i-");
+        }
+        ff_dlog(NULL, "stereo");
+    } else {
+        ff_dlog(NULL, "mono");
+    }
+    ff_dlog(NULL, "\n");
+#endif
+    return 0;
+}
+
+int __cdecl ffm_mpa_decode_header(uint32_t head, FFM_AudioInfo* info, uint32_t* layer, uint32_t* frame_size, uint32_t* bit_rate)
+{
+    MPADecodeHeader s;
+    int err;
+
+    err = ffm_avpriv_mpegaudio_decode_header(&s, head);
+    if ((err < 0) || (err > 1)) {
+        return -1;
+    }
+
+    if (err == 0) {
+        *bit_rate = s.bit_rate;
+        *frame_size = s.frame_size;
+    } else {
+        *bit_rate = 0;
+        *frame_size = 0;
+    }
+
+    info->bits_per_sample = 0;
+    info->channel_layout = 0;
+
+    *layer = s.layer;
+
+    switch(s.layer) {
+    case 1:
+        info->frame_size = 384;
+        break;
+    case 2:
+        info->frame_size = 1152;
+        break;
+    default:
+    case 3:
+        if (s.lsf)
+            info->frame_size = 576;
+        else
+            info->frame_size = 1152;
+        break;
+    }
+
+    info->sample_rate = s.sample_rate;
+    info->channels = s.nb_channels;
+
+    return 0;
+}

makemkv-oss-1.18.1.tar.gz/libffabi/src/mpegaudiodecheader.h -> makemkv-oss-1.18.2.tar.gz/libffabi/src/mpegaudiodecheader.h Changed

makemkv-oss-1.18.2.tar.gz/libffabi/src/mpegaudiotabs.h Added

@@ -0,0 +1,39 @@
+/*
+ * MPEG Audio common tables
+ * copyright (c) 2002 Fabrice Bellard
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef FFABI_AVCODEC_MPEGAUDIOTABS_H
+#define FFABI_AVCODEC_MPEGAUDIOTABS_H
+
+#include <stdint.h>
+
+const uint16_t ff_mpa_bitrate_tab2315 = {
+    { { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448 },
+      { 0, 32, 48, 56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320, 384 },
+      { 0, 32, 40, 48,  56,  64,  80,  96, 112, 128, 160, 192, 224, 256, 320 } },
+    { { 0, 32, 48, 56,  64,  80,  96, 112, 128, 144, 160, 176, 192, 224, 256 },
+      { 0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160 },
+      { 0,  8, 16, 24,  32,  40,  48,  56,  64,  80,  96, 112, 128, 144, 160 }
+    }
+};
+
+const uint16_t ff_mpa_freq_tab3 = { 44100, 48000, 32000 };
+
+#endif

makemkv-oss-1.18.1.tar.gz/makefile.common -> makemkv-oss-1.18.2.tar.gz/makefile.common Changed

@@ -37,7 +37,7 @@
 LIBFFABI_INC=libffabi/inc
 
 LIBFFABI_SRC=libffabi/src/ffabi.c libffabi/src/mlp.c libffabi/src/log.c libffabi/src/audio_convert.c \
-    libffabi/src/audio_mix.c libffabi/src/audio_mix_matrix.c
+    libffabi/src/audio_mix.c libffabi/src/audio_mix_matrix.c libffabi/src/mpegaudiodecheader.c
 
 LIBMAKEMKV_INC=libmakemkv/inc
 
@@ -76,7 +76,7 @@
   makemkvgui/src/spawn_posix.cpp
 
 
-MMGPL_DEF=-DLOG_DEBUG=1 -DTRACE=1 -DDVDNAV_NO_CACHE=1 -DDVDNAV_NO_LOCKING=1 -DDVDNAV_NO_TXTDT=1 -DDVDNAV_NO_ERRSTR=1
+MMGPL_DEF=
 
 MMGPL_INC=mmgpl
 DVDNAV_INC=mmgpl/dvdnav
@@ -85,8 +85,5 @@
 MMGPL_SRC_LINUX=makemkvgui/src/api_posix.cpp makemkvgui/src/api_linux.cpp
 
 MMGPL_SRC=mmgpl/mmgpl.cpp mmgpl/dvdnavsrv.cpp mmgpl/dvdread.cpp mmgpl/navapi.cpp makemkvgui/src/clt_pipe.cpp \
-  mmgpl/dvdread/bitreader.c mmgpl/dvdread/ifo_read.c mmgpl/dvdread/logger.c mmgpl/dvdread/nav_read.c \
-  mmgpl/dvdnav/dvdnav.c mmgpl/dvdnav/highlight.c mmgpl/dvdnav/logger.c mmgpl/dvdnav/navigation.c \
-  mmgpl/dvdnav/settings.c mmgpl/dvdnav/vm/decoder.c mmgpl/dvdnav/vm/getset.c mmgpl/dvdnav/vm/play.c \
-  mmgpl/dvdnav/vm/rand.cpp mmgpl/dvdnav/vm/vm.c mmgpl/dvdnav/vm/vmcmd.c mmgpl/dvdnav/vm/vmget.c \
+  mmgpl/dvdread/dvdreadsrc.cpp  mmgpl/dvdnav/dvdnavsrc.cpp mmgpl/dvdnav/vm/rand.cpp

makemkv-oss-1.18.1.tar.gz/makemkvgui/inc/ver_num.h -> makemkv-oss-1.18.2.tar.gz/makemkvgui/inc/ver_num.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/dvd_types.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/dvd_types.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/dvdnav.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/dvdnav.c Changed

@@ -37,7 +37,6 @@
 #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"
@@ -293,7 +292,7 @@
   pthread_mutex_lock(&this->vm_lock);
 
 #ifdef LOG_DEBUG
-  Log3(this, "reseting vm");
+  Log3(this, "resetting vm");
 #endif
   if(!vm_reset(this->vm, NULL, NULL, NULL)) {
     printerr("Error restarting the VM.");
@@ -329,7 +328,7 @@
 }
 
 /* converts a dvd_time_t to PTS ticks */
-int64_t dvdnav_convert_time(dvd_time_t *time) {
+int64_t dvdnav_convert_time(const dvd_time_t *time) {
   int64_t result;
   int64_t frames;
 
@@ -495,7 +494,7 @@
  * 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.
+ * hands out pointers targeting 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.
@@ -659,7 +658,7 @@
       /* we seeked -> check for multiple angles */
       vm_get_angle_info(this->vm, &current, &num_angles);
       if (num_angles > 1) {
-        int32_t result, block;
+        int32_t 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;
@@ -805,7 +804,7 @@
       (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;
+    state = &this->vm->state;
 
     this->cur_cell_time = 0;
     (*event) = DVDNAV_CELL_CHANGE;
@@ -896,7 +895,7 @@
     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
+    /* This is not really 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
      */
@@ -1053,7 +1052,7 @@
   }
 
   if (this->nav_only) {
-      pgc_t* pgc = this->vm->state.pgc;
+      const pgc_t* pgc = this->vm->state.pgc;
 
       if ((NULL != pgc) && (0==pgc->pg_playback_mode) && (this->vm->state.domain == DVD_DOMAIN_VTSTitle)) {
 
@@ -1137,6 +1136,28 @@
   (*serial_str) = this->vm->dvd_serial;
   return DVDNAV_STATUS_OK;
 }
+
+char * dvdnav_get_volid_string(dvdnav_t *this) {
+  if (!this || !this->vm || !this->vm->dvd) {
+    printerr("Invalid state, vm or reader not available.");
+    return NULL;
+  }
+
+  char *volid_str = malloc(33);
+  if (volid_str == NULL) {
+    printerr("Insufficient memory available.");
+    return NULL;
+  }
+
+  if (DVDUDFVolumeInfo(this->vm->dvd, volid_str, 32, NULL, 0) == -1) {
+    if (DVDISOVolumeInfo(this->vm->dvd, volid_str, 33, NULL, 0) == -1) {
+      printerr("Failed to obtain volume id.");
+      free(volid_str);
+      return NULL;
+    }
+  }
+  return volid_str;
+}
 #endif
 
 uint8_t dvdnav_get_video_aspect(dvdnav_t *this) {
@@ -1294,6 +1315,54 @@
   return retval;
 }
 
+int8_t dvdnav_get_number_of_streams(dvdnav_t *this, dvdnav_stream_type_t stream_type) {
+
+  if (stream_type != DVD_SUBTITLE_STREAM && stream_type != DVD_AUDIO_STREAM) {
+    printerr("Invalid provided stream type");
+    return -1;
+  }
+
+  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;
+  }
+
+  if (this->vm->state.domain != DVD_DOMAIN_VTSTitle &&
+      this->vm->state.domain != DVD_DOMAIN_VTSMenu)
+  {
+    printerr("Invalid domain provided");
+    pthread_mutex_unlock(&this->vm_lock);
+    return -1;
+  }
+
+  int8_t count = 0;
+  switch (stream_type) {
+  case DVD_SUBTITLE_STREAM:
+    for (int i = 0; i < 32; i++)
+    {
+      if (this->vm->state.pgc->subp_controli & (1<<31))
+        count++;
+    }
+    break;
+  case DVD_AUDIO_STREAM:
+    for (int i = 0; i < 8; i++)
+    {
+      if (this->vm->state.pgc->audio_controli & (1<<15))
+        count++;
+    }
+    break;
+  }
+  pthread_mutex_unlock(&this->vm_lock);
+  return count;
+}
+
 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.");
@@ -1387,6 +1456,80 @@
   return retval;
 }
 
+dvdnav_status_t dvdnav_set_active_stream(dvdnav_t *this, uint8_t stream_num, dvdnav_stream_type_t stream_type) {
+   if (stream_type != DVD_SUBTITLE_STREAM && stream_type != DVD_AUDIO_STREAM) {
+    printerr("Invalid provided stream type");
+    return DVDNAV_STATUS_ERR;
+  }
+
+  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;
+  }
+
+  if (this->vm->state.domain != DVD_DOMAIN_VTSTitle &&
+      this->vm->state.domain != DVD_DOMAIN_VTSMenu)
+  {
+    printerr("Invalid active domain");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+
+  switch (stream_type) {
+  case DVD_SUBTITLE_STREAM:
+    if (stream_num >= 32 ||
+        !(this->vm->state.pgc->subp_controlstream_num & (1 << 31))) {
+      printerr("Invalid stream index not allowed");
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_ERR;
+    }
+    // set state without changing the current visibility
+    this->vm->state.SPST_REG = stream_num | (this->vm->state.SPST_REG & 0x40);
+    break;
+  case DVD_AUDIO_STREAM:
+    if (stream_num >= 8 ||
+        !(this->vm->state.pgc->audio_controlstream_num & (1 << 15))) {
+      printerr("Invalid stream index not allowed");
+      pthread_mutex_unlock(&this->vm_lock);
+      return DVDNAV_STATUS_ERR;
+    }
+    this->vm->state.AST_REG = stream_num;
+    break;
+  }
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_OK;
+}
+
+dvdnav_status_t dvdnav_toggle_spu_stream(dvdnav_t *this, uint8_t visibility) {
+  if(!this->started) {
+    printerr("Virtual DVD machine not started.");
+    return DVDNAV_STATUS_ERR;
+  }
+
+  pthread_mutex_lock(&this->vm_lock);
+  switch(visibility) {
+  case 0: /* disable */
+    this->vm->state.SPST_REG &= ~0x40;
+    break;
+  case 1:  /* enable */
+    this->vm->state.SPST_REG |= 0x40;
+    break;
+  default:
+    printerr("Invalid provided enabled_flag value");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+  pthread_mutex_unlock(&this->vm_lock);
+  return DVDNAV_STATUS_OK;
+}
+
 static int8_t dvdnav_is_domain(dvdnav_t *this, DVDDomain_t domain) {
   int8_t        retval;
 
@@ -1447,6 +1590,19 @@
   return DVDNAV_STATUS_OK;
 }
 
+dvdnav_status_t dvdnav_get_disk_region_mask(dvdnav_t *this, int32_t *region_mask) {
+  pthread_mutex_lock(&this->vm_lock);
+  if (!this->vm || !this->vm->vmgi || !this->vm->vmgi->vmgi_mat) {
+    printerr("Bad VM state.");
+    pthread_mutex_unlock(&this->vm_lock);
+    return DVDNAV_STATUS_ERR;
+  }
+
+  (*region_mask) = ((this->vm->vmgi->vmgi_mat->vmg_category >> 16) & 0xff) ^ 0xff;
+  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;
@@ -1475,7 +1631,7 @@
 
   ops.ops_int = 0;
 
-  if(!this->started) {
+  if(!this || !this->started) {
     printerr("Virtual DVD machine not started.");
     return ops.ops_struct;
   }

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/dvdnav.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/dvdnav.h Changed

@@ -30,11 +30,20 @@
 extern "C" {
 #endif
 
-#include "version.h"
+#ifdef DVDNAV_API_EXPORT
+#  if defined(_WIN32)
+#    define DVDNAV_API  __declspec(dllexport)
+#  elif defined(__GNUC__) && __GNUC__ >= 4
+#    define DVDNAV_API  __attribute__((visibility("default")))
+#  endif
+#else
+#  define DVDNAV_API
+#endif
+
+#include <dvdnav/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>
@@ -100,44 +109,44 @@
  *
  * 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_API dvdnav_status_t dvdnav_open(dvdnav_t **dest, const char *path);
+DVDNAV_API dvdnav_status_t
 dvdnav_open_stream(dvdnav_t **dest, void *priv, dvdnav_stream_cb *stream_cb);
 
-dvdnav_status_t dvdnav_open2(dvdnav_t **dest,
+DVDNAV_API 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,
+DVDNAV_API 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);
+DVDNAV_API dvdnav_status_t dvdnav_dup(dvdnav_t **dest, dvdnav_t *src);
+DVDNAV_API 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);
+DVDNAV_API dvdnav_status_t dvdnav_close(dvdnav_t *self);
 
 /*
  * Resets the DVD virtual machine and cache buffers.
  */
-dvdnav_status_t dvdnav_reset(dvdnav_t *self);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API const char* dvdnav_err_to_string(dvdnav_t *self);
 
-const char* dvdnav_version(void);
+DVDNAV_API const char* dvdnav_version(void);
 
 /*********************************************************************
  * changing and reading DVD player characteristics                   *
@@ -156,7 +165,7 @@
  *
  * 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);
+DVDNAV_API 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
@@ -164,7 +173,7 @@
  *
  * 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);
+DVDNAV_API 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
@@ -179,12 +188,12 @@
  * 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);
+DVDNAV_API 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);
+DVDNAV_API dvdnav_status_t dvdnav_get_readahead_flag(dvdnav_t *self, int32_t *read_ahead_flag);
 
 /*
  * Specify whether the positioning works PGC or PG based.
@@ -193,12 +202,12 @@
  * 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);
+DVDNAV_API 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_API 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);
@@ -226,7 +235,7 @@
  *
  * 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,
+DVDNAV_API dvdnav_status_t dvdnav_get_next_block(dvdnav_t *self, uint8_t *buf,
                                       int32_t *event, int32_t *len);
 
 /*
@@ -237,7 +246,7 @@
  * 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,
+DVDNAV_API dvdnav_status_t dvdnav_get_next_cache_block(dvdnav_t *self, uint8_t **buf,
                                             int32_t *event, int32_t *len);
 
 /*
@@ -245,14 +254,14 @@
  * 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);
+DVDNAV_API 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);
+DVDNAV_API dvdnav_status_t dvdnav_still_skip(dvdnav_t *self);
 
 /*
  * If we are currently in WAIT state, that is: the application is required to
@@ -261,7 +270,7 @@
  *
  * See also the DVDNAV_WAIT event.
  */
-dvdnav_status_t dvdnav_wait_skip(dvdnav_t *self);
+DVDNAV_API dvdnav_status_t dvdnav_wait_skip(dvdnav_t *self);
 
 /*
  * Returns the still time from the currently playing cell.
@@ -271,7 +280,7 @@
  * 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);
+DVDNAV_API uint32_t dvdnav_get_next_still_flag(dvdnav_t *self);
 
 /*
  * Stops playback. The next event obtained with one of the get_next_block
@@ -279,8 +288,21 @@
  *
  * It is not required to call this before dvdnav_close().
  */
-dvdnav_status_t dvdnav_stop(dvdnav_t *self);
+DVDNAV_API dvdnav_status_t dvdnav_stop(dvdnav_t *self);
 
+/*
+ * Returns the region mask (bit 0 set implies region 1, bit 1 set implies
+ * region 2, etc) reported by the dvd disc being played.
+ *
+ * Note this has no relation with the region setting of the DVD drive.
+ * Old DVD drives (RPC-I) used to delegate most of the RCE handling to the CPU and
+ * will actually call the virtual machine (VM) for its region setting. In those cases,
+ * changing the VM region mask via dvdnav_set_region_mask() will circunvent
+ * the region protection scheme. This is no longer the case with more recent (RPC-II) drives
+ * as RCE is handled internally by the drive firmware.
+ *
+ */
+DVDNAV_API dvdnav_status_t dvdnav_get_disk_region_mask(dvdnav_t *self, int32_t *region_mask);
 
 /*********************************************************************
  * title/part navigation                                             *
@@ -289,32 +311,32 @@
 /*
  * Returns the number of titles on the disk.
  */
-dvdnav_status_t dvdnav_get_number_of_titles(dvdnav_t *self, int32_t *titles);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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
@@ -323,7 +345,7 @@
  * 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);
+DVDNAV_API 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
@@ -331,7 +353,7 @@
  *
  * Currently unimplemented!
  */
-dvdnav_status_t dvdnav_part_play_auto_stop(dvdnav_t *self, int32_t title,
+DVDNAV_API dvdnav_status_t dvdnav_part_play_auto_stop(dvdnav_t *self, int32_t title,
                                            int32_t part, int32_t parts_to_play);
 
 /*
@@ -339,7 +361,7 @@
  *
  * Currently unimplemented!
  */
-dvdnav_status_t dvdnav_time_play(dvdnav_t *self, int32_t title,
+DVDNAV_API dvdnav_status_t dvdnav_time_play(dvdnav_t *self, int32_t title,
                                  uint64_t time);
 
 /*
@@ -347,21 +369,21 @@
  *
  * See also DVDMenuID_t from libdvdread
  */
-dvdnav_status_t dvdnav_menu_call(dvdnav_t *self, DVDMenuID_t menu);
+DVDNAV_API 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,
+DVDNAV_API 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,
+DVDNAV_API 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);
 
 /*
@@ -371,7 +393,7 @@
  * Current implementation is wrong and likely to behave unpredictably!
  * Use is discouraged!
  */
-dvdnav_status_t dvdnav_get_position_in_title(dvdnav_t *self,
+DVDNAV_API dvdnav_status_t dvdnav_get_position_in_title(dvdnav_t *self,
                                              uint32_t *pos,
                                              uint32_t *len);
 
@@ -381,7 +403,7 @@
  * 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);
+DVDNAV_API dvdnav_status_t dvdnav_part_search(dvdnav_t *self, int32_t part);
 
 
 /*********************************************************************
@@ -402,14 +424,14 @@
  * '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,
+DVDNAV_API 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);
+DVDNAV_API int64_t dvdnav_get_current_time(dvdnav_t *self);
 
 uint64_t dvdnav_get_absolute_time(dvdnav_t *self);
 
@@ -422,32 +444,45 @@
  * Currently implemented using interpolation. That interpolation is slightly
  * inaccurate.
  */
-dvdnav_status_t dvdnav_time_search(dvdnav_t *self,
+DVDNAV_API dvdnav_status_t dvdnav_time_search(dvdnav_t *self,
                                    uint64_t time);
 
 /*
+ * Find the nearest vobu and jump to it
+ *
+ * Alternative to dvdnav_time_search (see full documentation on searching.jump_to_time.readme)
+ * Jumps to the provided PTS (which is defined as time_in_ms * 90). mode means the navigation mode,
+ * currently only the Default (0) is implemented:
+ *  0: Default. Jump to a time which may be either <> time_in_pts_ticks
+ *  1: After. Always jump to a time that is > time_in_pts_ticks
+ * -1: Before. Always jump to a time that is < time_in_pts_ticks
+ */
+DVDNAV_API dvdnav_status_t dvdnav_jump_to_sector_by_time(dvdnav_t *self,
+                                              uint64_t time_in_pts_ticks, int32_t mode);
+
+/*
  * 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API dvdnav_status_t dvdnav_next_pg_search(dvdnav_t *self);
 
 /*
  * Return the current position (in blocks) within the current
@@ -457,7 +492,7 @@
  * (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,
+DVDNAV_API dvdnav_status_t dvdnav_get_position(dvdnav_t *self, uint32_t *pos,
                                     uint32_t *len);
 
 
@@ -479,7 +514,7 @@
  * 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);
+DVDNAV_API dvdnav_status_t dvdnav_get_current_highlight(dvdnav_t *self, int32_t *button);
 
 /*
  * Returns the Presentation Control Information (PCI) structure associated
@@ -488,7 +523,7 @@
  * 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);
+DVDNAV_API pci_t* dvdnav_get_current_nav_pci(dvdnav_t *self);
 
 /*
  * Returns the DSI (data search information) structure associated
@@ -497,51 +532,51 @@
  * 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);
+DVDNAV_API 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_API 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);
+DVDNAV_API dvdnav_status_t dvdnav_upper_button_select(dvdnav_t *self, pci_t *pci);
+DVDNAV_API dvdnav_status_t dvdnav_lower_button_select(dvdnav_t *self, pci_t *pci);
+DVDNAV_API dvdnav_status_t dvdnav_right_button_select(dvdnav_t *self, pci_t *pci);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API dvdnav_status_t dvdnav_mouse_activate(dvdnav_t *self, pci_t *pci, int32_t x, int32_t y);
 
 
 /*********************************************************************
@@ -556,19 +591,19 @@
 /*
  * Set which menu language we should use per default.
  */
-dvdnav_status_t dvdnav_menu_language_select(dvdnav_t *self,
+DVDNAV_API 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,
+DVDNAV_API 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,
+DVDNAV_API dvdnav_status_t dvdnav_spu_language_select(dvdnav_t *self,
                                           char *code);
 
 
@@ -582,16 +617,29 @@
  * 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'.
+ * `DVDVolume' (see also dvdnav_get_volid_string).
  */
-dvdnav_status_t dvdnav_get_title_string(dvdnav_t *self, const char **title_str);
+DVDNAV_API 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);
+DVDNAV_API dvdnav_status_t dvdnav_get_serial_string(dvdnav_t *self, const char **serial_str);
+
+/*
+ * Returns the VolumeIdentifier of the disc or NULL if it could
+ * not be obtained. The VolumeIdentifier might be latin-1 encoded
+ * (8bit unicode) null terminated and max 32 bytes (including '\0');
+ * or coded with '0-9','A-Z','_' null terminated and max 33 bytes
+ * (including '\0').
+ * See also dvdnav_get_title_string
+ *
+ * Note: The string is malloc'd so caller has to free() the returned
+ * string when done with it.
+ */
+DVDNAV_API char * dvdnav_get_volid_string(dvdnav_t *self);
 
 /*
  * Get video aspect code.
@@ -600,12 +648,12 @@
  *
  * 0 -- 4:3, 2 -- 16:9
  */
-uint8_t dvdnav_get_video_aspect(dvdnav_t *self);
+DVDNAV_API 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);
+DVDNAV_API dvdnav_status_t dvdnav_get_video_resolution(dvdnav_t *self, uint32_t *width, uint32_t *height);
 
 /*
  * Get video scaling permissions.
@@ -614,73 +662,97 @@
  *
  * bit0 set = deny letterboxing, bit1 set = deny pan&scan
  */
-uint8_t dvdnav_get_video_scale_permission(dvdnav_t *self);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API int8_t dvdnav_get_active_audio_stream(dvdnav_t *self);
 
 /*
  * Get active spu stream.
  */
-int8_t dvdnav_get_active_spu_stream(dvdnav_t *self);
+DVDNAV_API 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);
+DVDNAV_API user_ops_t dvdnav_get_restrictions(dvdnav_t *self);
+
+/*
+ * Returns the number of streams provided its type (e.g. subtitles, audio, etc)
+ */
+DVDNAV_API int8_t dvdnav_get_number_of_streams(dvdnav_t *self, dvdnav_stream_type_t stream_type);
 
 
 /*********************************************************************
+ * setting stream attributes                                         *
+ *********************************************************************/
+
+/*
+ * Set the visible (enable) status of the current spu stream
+ * (to enable/disable subtitles)
+ * visibility defines if the spu stream should be enabled/visible (1) or disabled (0)
+ */
+DVDNAV_API dvdnav_status_t dvdnav_toggle_spu_stream(dvdnav_t *self, uint8_t visibility);
+
+/*
+ * Set the given stream id and stream type as active
+ * stream_num - the physical index of the stream
+ * stream_type - the stream type (audio or subtitles)
+ */
+DVDNAV_API dvdnav_status_t dvdnav_set_active_stream(dvdnav_t *self, uint8_t stream_num,
+                                        dvdnav_stream_type_t stream_type);
+
+/*********************************************************************
  * multiple angles                                                   *
  *********************************************************************/
 
@@ -701,12 +773,12 @@
  * 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);
+DVDNAV_API 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,
+DVDNAV_API dvdnav_status_t dvdnav_get_angle_info(dvdnav_t *self, int32_t *current_angle,
                                       int32_t *number_of_angles);
 
 /*********************************************************************
@@ -716,22 +788,22 @@
 /*
  * Are we in the First Play domain?
  */
-int8_t dvdnav_is_domain_fp(dvdnav_t *self);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API 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);
+DVDNAV_API int8_t dvdnav_is_domain_vts(dvdnav_t *self);
 
 
 #ifdef __cplusplus

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/dvdnav_events.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/dvdnav_events.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/dvdnav_internal.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/dvdnav_internal.h Changed

@@ -74,7 +74,7 @@
 #endif
 
 typedef enum {
-  DSI_ILVU_PRE   = 1 << 15, /* set during the last 3 VOBU preceeding an interleaved block. */
+  DSI_ILVU_PRE   = 1 << 15, /* set during the last 3 VOBU preceding 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 */
@@ -95,15 +95,15 @@
 #ifndef audio_status_t
 typedef struct {
 #ifdef WORDS_BIGENDIAN
-  unsigned int available     : 1;
-  unsigned int zero1         : 4;
-  unsigned int stream_number : 3;
+  unsigned char available     : 1;
+  unsigned char zero1         : 4;
+  unsigned char stream_number : 3;
   uint8_t zero2;
 #else
   uint8_t zero2;
-  unsigned int stream_number : 3;
-  unsigned int zero1         : 4;
-  unsigned int available     : 1;
+  unsigned char stream_number : 3;
+  unsigned char zero1         : 4;
+  unsigned char available     : 1;
 #endif
 } ATTRIBUTE_PACKED audio_status_t;
 #endif
@@ -111,25 +111,25 @@
 #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;
+  unsigned char available               : 1;
+  unsigned char zero1                   : 2;
+  unsigned char stream_number_4_3       : 5;
+  unsigned char zero2                   : 3;
+  unsigned char stream_number_wide      : 5;
+  unsigned char zero3                   : 3;
+  unsigned char stream_number_letterbox : 5;
+  unsigned char zero4                   : 3;
+  unsigned char 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;
+  unsigned char stream_number_pan_scan  : 5;
+  unsigned char zero4                   : 3;
+  unsigned char stream_number_letterbox : 5;
+  unsigned char zero3                   : 3;
+  unsigned char stream_number_wide      : 5;
+  unsigned char zero2                   : 3;
+  unsigned char stream_number_4_3       : 5;
+  unsigned char zero1                   : 2;
+  unsigned char available               : 1;
 #endif
 } ATTRIBUTE_PACKED spu_status_t;
 #endif
@@ -163,7 +163,7 @@
 typedef struct {
   vobu_admap_t        *admap;
   int32_t             admap_len;
-  vts_tmap_t          *tmap;
+  const vts_tmap_t    *tmap;
   int32_t             tmap_len;
   int32_t             tmap_interval;
 } dvdnav_jump_args_t;
@@ -237,7 +237,7 @@
 /** HELPER FUNCTIONS **/
 
 /* converts a dvd_time_t to PTS ticks */
-int64_t dvdnav_convert_time(dvd_time_t *time);
+DVDNAV_API int64_t dvdnav_convert_time(const dvd_time_t *time);
 
 /** USEFUL MACROS **/

makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/dvdnavsrc.cpp Added

@@ -0,0 +1,42 @@
+/*
+    Copyright (C) 2007-2025 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 <inttypes.h>
+
+#define LOG_DEBUG 1
+#define TRACE 1
+#define DVDNAV_NO_CACHE 1
+#define DVDNAV_NO_LOCKING 1
+#define DVDNAV_NO_TXTDT 1
+#define DVDNAV_NO_ERRSTR 1
+
+#define this c_this
+
+#include "dvdnav.c"
+#include "highlight.c"
+#include "logger.c"
+#include "navigation.c"
+#include "settings.c"
+#include "vm/decoder.c"
+#include "vm/getset.c"
+#include "vm/play.c"
+#include "vm/vm.c"
+#include "vm/vmcmd.c"
+#include "vm/vmget.c"
+

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/highlight.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/highlight.c Changed

@@ -220,7 +220,7 @@
   return DVDNAV_STATUS_OK;
 }
 
-static btni_t *get_current_button(dvdnav_t *this, pci_t *pci) {
+static const btni_t *get_current_button(dvdnav_t *this, pci_t *pci) {
   int32_t button = 0;
 
   if(!pci->hli.hl_gi.hli_ss) {
@@ -241,7 +241,7 @@
 }
 
 static dvdnav_status_t button_auto_action(dvdnav_t *this, pci_t *pci) {
-  btni_t *button_ptr;
+  const btni_t *button_ptr;
   if ((button_ptr = get_current_button(this, pci)) == NULL)
       return DVDNAV_STATUS_ERR;
 
@@ -252,7 +252,7 @@
 }
 
 dvdnav_status_t dvdnav_upper_button_select(dvdnav_t *this, pci_t *pci) {
-  btni_t *button_ptr;
+  const btni_t *button_ptr;
 
   if(!(button_ptr = get_current_button(this, pci)))
     return DVDNAV_STATUS_ERR;
@@ -262,7 +262,7 @@
 }
 
 dvdnav_status_t dvdnav_lower_button_select(dvdnav_t *this, pci_t *pci) {
-  btni_t *button_ptr;
+  const btni_t *button_ptr;
 
   if(!(button_ptr = get_current_button(this, pci)))
     return DVDNAV_STATUS_ERR;
@@ -272,7 +272,7 @@
 }
 
 dvdnav_status_t dvdnav_right_button_select(dvdnav_t *this, pci_t *pci) {
-  btni_t *button_ptr;
+  const btni_t *button_ptr;
 
   if(!(button_ptr = get_current_button(this, pci)))
     return DVDNAV_STATUS_ERR;
@@ -282,7 +282,7 @@
 }
 
 dvdnav_status_t dvdnav_left_button_select(dvdnav_t *this, pci_t *pci) {
-  btni_t *button_ptr;
+  const btni_t *button_ptr;
 
   if(!(button_ptr = get_current_button(this, pci)))
     return DVDNAV_STATUS_ERR;
@@ -293,7 +293,7 @@
 
 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;
+  const btni_t *button_ptr;
 
 #ifdef BUTTON_TESTING
   fprintf(MSG_OUT, "libdvdnav: Button get_highlight_area %i\n", button);
@@ -331,7 +331,7 @@
 
 dvdnav_status_t dvdnav_button_activate(dvdnav_t *this, pci_t *pci) {
   int32_t button;
-  btni_t *button_ptr = NULL;
+  const btni_t *button_ptr = NULL;
 
   if(!pci->hli.hl_gi.hli_ss) {
     printerr("Not in a menu.");
@@ -480,7 +480,7 @@
 
   /* Loop through all buttons */
   for(button = 1; button <= pci->hli.hl_gi.btn_ns; button++) {
-    btni_t *button_ptr = &(pci->hli.btnitbutton-1);
+    const 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)) {

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/logger.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/logger.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/navigation.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/navigation.c Changed

@@ -27,7 +27,6 @@
 #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"
@@ -66,7 +65,7 @@
 }
 
 static dvdnav_status_t get_title_by_number(dvdnav_t *this, int32_t title,
-                                           title_info_t **pp_title)
+                                           const title_info_t **pp_title)
 {
     int32_t titlescount;
     dvdnav_status_t status = dvdnav_get_number_of_titles(this, &titlescount);
@@ -84,7 +83,7 @@
 }
 
 dvdnav_status_t dvdnav_get_number_of_parts(dvdnav_t *this, int32_t title, int32_t *parts) {
-  title_info_t *info;
+  const 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;
@@ -92,7 +91,7 @@
 }
 
 dvdnav_status_t dvdnav_get_number_of_angles(dvdnav_t *this, int32_t title, int32_t *angles) {
-    title_info_t *info;
+    const 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;

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/settings.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/settings.c Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/decoder.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/decoder.c Changed

@@ -32,7 +32,6 @@
 #include <stdarg.h>
 
 #include <dvdread/nav_types.h>
-#include <dvdread/ifo_types.h> /* vm_cmd_t */
 
 #include "dvdnav/dvdnav.h"
 #include "decoder.h"
@@ -116,7 +115,7 @@
 
 #ifdef TRACE
 
-static char *linkcmd2str(link_cmd_t cmd) {
+static const char *linkcmd2str(link_cmd_t cmd) {
   switch(cmd) {
   case LinkNoLink:
     return "LinkNoLink";
@@ -183,7 +182,7 @@
 }
 
 void vm_print_link(const trace_log_t* log, const link_t* value) {
-  char *cmd = linkcmd2str(value->command);
+  const char *cmd = linkcmd2str(value->command);
 
   switch(value->command) {
   case LinkNoLink:
@@ -393,7 +392,7 @@
     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->command = (link_cmd_t)linkop;
   return_values->data1 = button;
   return cond;
 }
@@ -502,7 +501,7 @@
   return 0;
 }
 
-/* Evaluate a set sytem register instruction
+/* Evaluate a set system 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;
@@ -641,7 +640,7 @@
 /* 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) {
+static int32_t eval_command(const uint8_t *bytes, registers_t* registers, link_t *return_values) {
   int32_t cond, res = 0;
   command_t command;
   command.instruction =( (uint64_t) bytes0 << 56 ) |
@@ -706,7 +705,7 @@
       if(res)
         res = -1;
       break;
-    case 6: /*  Compare -> Set, allways Link Sub-Instruction */
+    case 6: /*  Compare -> Set, always 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);
@@ -721,7 +720,7 @@
 
   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, " %08" PRIx64, (command.instruction & ~ command.examined) );
     fprintf(MSG_OUT, "\n");
   }
 
@@ -729,7 +728,7 @@
 }
 
 /* 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,
+int32_t vmEval_CMD(const trace_log_t* log, const vm_cmd_t commands, int32_t num_commands,
                registers_t *registers, link_t *return_values) {
   int32_t i = 0;
   int32_t total = 0;

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/decoder.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/decoder.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/getset.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/getset.c Changed

@@ -30,7 +30,6 @@
 #include <inttypes.h>
 
 #include <dvdread/nav_types.h>
-#include <dvdread/ifo_types.h>
 #include <dvdread/ifo_read.h>
 #include "dvdnav/dvdnav.h"
 
@@ -144,7 +143,7 @@
 }
 
 int set_PGCN(vm_t *vm, int pgcN) {
-  pgcit_t *pgcit;
+  const pgcit_t *pgcit;
 
   pgcit = get_PGCIT(vm);
   if (pgcit == NULL)
@@ -252,7 +251,7 @@
  */
 int get_ID(vm_t *vm, int id) {
   int pgcN, i;
-  pgcit_t *pgcit;
+  const pgcit_t *pgcit;
 
   /* Relies on state to get the correct pgcit. */
   pgcit = get_PGCIT(vm);
@@ -291,7 +290,7 @@
 
 /* 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;
+  const pgcit_t *pgcit;
   int pgcN = 1;
 
   if ((vm->state).pgc == NULL) {
@@ -314,7 +313,7 @@
   return 0; /*  error */
 }
 
-pgcit_t* get_MENU_PGCIT(vm_t *vm, ifo_handle_t *h, uint16_t lang) {
+const pgcit_t* get_MENU_PGCIT(vm_t *vm, ifo_handle_v_t *h, uint16_t lang) {
   int i;
 
   if(h == NULL || h->pgci_ut == NULL) {
@@ -331,7 +330,7 @@
             (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);
+    char *buffer = (char*)malloc(3 * h->pgci_ut->nr_of_lus + 1);
     if(buffer)
     {
         buffer3 * h->pgci_ut->nr_of_lus = 0;
@@ -350,8 +349,8 @@
 }
 
 /* Uses state to decide what to return */
-pgcit_t* get_PGCIT(vm_t *vm) {
-  pgcit_t *pgcit = NULL;
+const pgcit_t* get_PGCIT(vm_t *vm) {
+  const pgcit_t *pgcit = NULL;
 
   switch ((vm->state).domain) {
   case DVD_DOMAIN_VTSTitle:

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/getset.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/getset.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/play.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/play.c Changed

@@ -29,7 +29,6 @@
 #include <stdio.h>
 
 #include <dvdread/nav_types.h>
-#include <dvdread/ifo_types.h>
 #include <dvdread/ifo_read.h>
 #include "dvdnav/dvdnav.h"
 
@@ -180,7 +179,11 @@
     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);
+    if((vm->state).pgN > (vm->state).pgc->nr_of_programs + 1) {
+      /* bogus link, ignore it */
+      link_t link_values = { LinkNoLink, 0, 0, 0 };
+      return link_values;
+    }
     return play_PGC_post(vm);
   }
 
@@ -202,7 +205,11 @@
     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);
+    if((vm->state).cellN > (vm->state).pgc->nr_of_cells + 1) {
+      /* bogus link, ignore it */
+      link_t link_values = { LinkNoLink, 0, 0, 0 };
+      return link_values;
+    }
     return play_PGC_post(vm);
   }
 
@@ -263,7 +270,7 @@
 }
 
 link_t play_Cell_post(vm_t *vm) {
-  cell_playback_t *cell;
+  const cell_playback_t *cell;
 
 #ifdef TRACE
   Log3(vm, "play_Cell_post: (vm->state).cellN (%i)", (vm->state).cellN);

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/rand.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/rand.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/vm.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/vm.c Changed

@@ -37,7 +37,6 @@
 #include <ctype.h>
 
 #include <dvdread/nav_types.h>
-#include <dvdread/ifo_types.h>
 #include <dvdread/ifo_read.h>
 #include "dvdnav/dvdnav.h"
 
@@ -65,7 +64,7 @@
 static void dvd_reader_logger_handler( void *priv, dvd_logger_level_t level,
                                        const char *fmt, va_list list )
 {
-    vm_t *vm = priv;
+    vm_t *vm = (vm_t*)priv;
     if(vm->logcb.pf_log)
         vm->logcb.pf_log(vm->priv, (dvdnav_logger_level_t) level, fmt, list );
 }
@@ -73,7 +72,7 @@
 
 static int dvd_reader_seek_handler(void *priv, uint64_t pos)
 {
-    vm_t *vm = priv;
+    vm_t *vm = (vm_t*)priv;
     if(vm->streamcb.pf_seek)
         return vm->streamcb.pf_seek(vm->priv, pos);
     return 1;
@@ -81,7 +80,7 @@
 
 static int dvd_reader_read_handler(void *priv, void *buffer, int count)
 {
-    vm_t *vm = priv;
+    vm_t *vm = (vm_t*)priv;
     if(vm->streamcb.pf_read)
         return vm->streamcb.pf_read(vm->priv, buffer, count);
     return 1;
@@ -89,7 +88,7 @@
 
 static int dvd_reader_readv_handler(void *priv, void *iovec, int count)
 {
-    vm_t *vm = priv;
+    vm_t *vm = (vm_t*)priv;
     if(vm->streamcb.pf_readv)
         return vm->streamcb.pf_readv(vm->priv, iovec, count);
     return 1;
@@ -258,11 +257,11 @@
 
 int ifoOpenNewVTSI(vm_t *vm, dvd_reader_t *dvd, int vtsN) {
   if(vm->state.vtsN == vtsN) {
-    return 1; /*  We alread have it */
+    return 1; /*  We already have it */
   }
 
   if (vm->vtsi != NULL)
-      ifoClose(vm->vtsi);
+      ifoCloseV(vm->vtsi);
 
   vm->vtsi = ifoOpenVTSI(dvd, vtsN);
   if(vm->vtsi == NULL) {
@@ -298,7 +297,7 @@
 /* Initialisation & Destruction */
 
 vm_t* vm_new_vm(void *priv, const dvdnav_logger_cb *logcb) {
-  vm_t *vm = calloc(1, sizeof(vm_t));
+  vm_t *vm = (vm_t*)calloc(1, sizeof(vm_t));
   if(vm)
   {
     vm->priv = priv;
@@ -316,11 +315,11 @@
 
 /* IFO Access */
 
-ifo_handle_t *vm_get_vmgi(vm_t *vm) {
+ifo_handle_v_t *vm_get_vmgi(vm_t *vm) {
   return vm->vmgi;
 }
 
-ifo_handle_t *vm_get_vtsi(vm_t *vm) {
+ifo_handle_v_t *vm_get_vtsi(vm_t *vm) {
   return vm->vtsi;
 }
 
@@ -355,11 +354,11 @@
   if(!vm)
     return;
   if(vm->vmgi) {
-    ifoClose(vm->vmgi);
+    ifoCloseV(vm->vmgi);
     vm->vmgi=NULL;
   }
   if(vm->vtsi) {
-    ifoClose(vm->vtsi);
+    ifoCloseV(vm->vtsi);
     vm->vtsi=NULL;
   }
   if(vm->dvd) {
@@ -378,7 +377,7 @@
   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.registers.SPRM0  = ('e'<<8)|'n'; /* Player Menu Language code */
   vm->state.AST_REG            = 15;           /* 15 why? */
   vm->state.SPST_REG           = 62;           /* 62 why? */
   vm->state.AGL_REG            = 1;
@@ -411,8 +410,10 @@
   /* save target callbacks */
   if(stream_cb)
       vm->streamcb = *stream_cb;
-  else
-      vm->streamcb = (dvdnav_stream_cb) { NULL, NULL, NULL };
+  else {
+      dvdnav_stream_cb t = { NULL, NULL, NULL };
+      vm->streamcb = t;
+  }
 
   /* bind local callbacks */
   vm->dvdstreamcb.pf_seek = vm->streamcb.pf_seek ? dvd_reader_seek_handler : NULL;
@@ -426,7 +427,7 @@
   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 };
+    dvd_logger_cb dvdread_logcb; 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)
@@ -519,10 +520,10 @@
 
   /* GPL is cancer */
   if (NULL != target->vmgi) {
-      ifoAddRef(target->vmgi);
+      ifoAddRefV(target->vmgi);
   }
   if (NULL != target->vtsi) {
-      ifoAddRef(target->vtsi);
+      ifoAddRefV(target->vtsi);
   }
 
   return target;
@@ -536,14 +537,14 @@
 
 void vm_merge(vm_t *target, vm_t *source) {
   if(target->vtsi)
-    ifoClose(target->vtsi);
+    ifoCloseV(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);
+    ifoCloseV(vm->vtsi);
   free(vm);
 }
 
@@ -635,7 +636,7 @@
   /* 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 */
+    /* jump occurred -> ignore it and play the PG anyway */
     process_command(vm, play_PG(vm));
   else
     process_command(vm, link);
@@ -655,7 +656,7 @@
    * 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 */
+    /* jump occurred -> ignore it and play the PG anyway */
     process_command(vm, play_PG(vm));
   else
     process_command(vm, link);
@@ -749,13 +750,13 @@
   return !!process_command(vm, link_values);
 }
 
-int vm_exec_cmd(vm_t *vm, vm_cmd_t *cmd) {
+int vm_exec_cmd(vm_t *vm, const 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... */
+    return 0; /*  It updated some state that's all... */
 }
 
 /* link processing */

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/vm.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/vm.h Changed

@@ -31,9 +31,9 @@
 
   DVDDomain_t  domain;
   int       vtsN;         /* 0 is vmgm? */
-  pgc_t    *pgc;          /* either this or 'int pgcN' is enough? */
+  const 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;          /* is this needed? can always fid pgN from cellN? */
   int       pgN_step;
   int       cellN;
   int32_t   cell_restart; /* get cell to restart */
@@ -74,8 +74,8 @@
   dvdnav_stream_cb streamcb;
   dvd_reader_t *dvd;
   dvd_reader_stream_cb dvdstreamcb;
-  ifo_handle_t *vmgi;
-  ifo_handle_t *vtsi;
+  ifo_handle_v_t *vmgi;
+  ifo_handle_v_t *vtsi;
   dvd_state_t   state;
   int32_t       hop_channel;
 #ifndef DVDNAV_NO_TXTDT
@@ -113,8 +113,8 @@
 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);
+ifo_handle_v_t *vm_get_vmgi(vm_t *vm);
+ifo_handle_v_t *vm_get_vtsi(vm_t *vm);
 
 /* Reader Access */
 dvd_reader_t *vm_get_dvd_reader(vm_t *vm);
@@ -145,7 +145,7 @@
 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);
+int vm_exec_cmd(vm_t *vm, const vm_cmd_t *cmd);
 
 /* getting information */
 int vm_get_current_menu(vm_t *vm, int *menuid);

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/vmcmd.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/vmcmd.c Changed

@@ -31,7 +31,6 @@
 
 #include "dvdnav/dvdnav.h"
 #include <dvdread/nav_types.h>
-#include <dvdread/ifo_types.h>
 #include "decoder.h"
 #include "vm.h"
 #include "vmcmd.h"
@@ -466,7 +465,7 @@
 }
 
 
-void vm_print_mnemonic(const trace_log_t* log, vm_cmd_t *vm_command)  {
+void vm_print_mnemonic(const trace_log_t* log, const vm_cmd_t *vm_command)  {
   command_t command;
   command.instruction =( (uint64_t) vm_command->bytes0 << 56 ) |
         ( (uint64_t) vm_command->bytes1 << 48 ) |
@@ -489,7 +488,7 @@
         print_jump_instruction(log, &command);
       } else {
         print_if_version_1(log, &command);
-        print_link_instruction(log, &command, 0); /*  must be pressent */
+        print_link_instruction(log, &command, 0); /*  must be present */
       }
       break;
     case 2: /*  Set System Parameters instructions */
@@ -530,12 +529,12 @@
 
   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, " %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) {
+void vm_print_cmd(const trace_log_t* log, int row, const vm_cmd_t *vm_command) {
   int i;
 
   fprintf(MSG_OUT, "(%03d) ", row + 1);

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/vmcmd.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/vmcmd.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdnav/vm/vmget.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdnav/vm/vmget.c Changed

@@ -31,7 +31,6 @@
 #include <stdlib.h>
 
 #include <dvdread/nav_types.h>
-#include <dvdread/ifo_types.h>
 #include <dvdread/ifo_read.h>
 #include "dvdnav/dvdnav.h"
 
@@ -44,7 +43,7 @@
 /* getting information */
 
 int vm_get_current_menu(vm_t *vm, int *menuid) {
-  pgcit_t* pgcit;
+  const pgcit_t* pgcit;
   int pgcn;
   pgcn = (vm->state).pgcN;
   pgcit = get_PGCIT(vm);
@@ -144,7 +143,7 @@
 
   if(subpN < 32) { /* a valid logical stream */
     /* Is this logical stream present */
-    if((vm->state).pgc->subp_controlsubpN & (1<<31)) {
+    if((vm->state).pgc->subp_controlsubpN & (1u<<31)) {
       if(source_aspect == 0) /* 4:3 */
         streamN = ((vm->state).pgc->subp_controlsubpN >> 24) & 0x1f;
       if(source_aspect == 3) /* 16:9 */
@@ -215,8 +214,8 @@
   *current = 1;
 
   if((vm->state).domain == DVD_DOMAIN_VTSTitle) {
-    title_info_t *title;
-    /* TTN_REG does not allways point to the correct title.. */
+    const title_info_t *title;
+    /* TTN_REG does not always 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;
@@ -321,6 +320,7 @@
     return vm->vmgi->vmgi_mat->vmgm_video_attr;
   default:
     vassert(0);
+    return vm->vmgi->vmgi_mat->vmgm_video_attr;
   }
 }
 
@@ -335,6 +335,7 @@
     return vm->vmgi->vmgi_mat->vmgm_audio_attr;
   default:
     vassert(0);
+    return vm->vmgi->vmgi_mat->vmgm_audio_attr;
   }
 }
 
@@ -349,5 +350,6 @@
     return vm->vmgi->vmgi_mat->vmgm_subp_attr;
   default:
     vassert(0);
+    return vm->vmgi->vmgi_mat->vmgm_subp_attr;
   }
 }

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread.cpp -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread.cpp Changed

makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/attributes.h Added

@@ -0,0 +1,33 @@
+/*
+ * This file is part of libdvdread
+ * Copyright (C) 2010-2025 hpi1 and VideoLAN
+ *
+ * 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, see
+ * <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef LIBDVDREAD_ATTRIBUTES_H
+#define LIBDVDREAD_ATTRIBUTES_H
+
+#ifdef DVDREAD_API_EXPORT
+#  if defined(_WIN32)
+#    define DVDREAD_API  __declspec(dllexport)
+#  elif defined(__GNUC__) && __GNUC__ >= 4
+#    define DVDREAD_API  __attribute__((visibility("default")))
+#  endif
+#else
+#  define DVDREAD_API
+#endif
+
+#endif /* LIBDVDREAD_ATTRIBUTES_H */

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/bitreader.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/bitreader.c Changed

@@ -23,15 +23,15 @@
 #include <stdlib.h>
 #include <string.h>
 #include <inttypes.h>
+#include <assert.h>
 
 #include "dvdread/bitreader.h"
 
-int dvdread_getbits_init(getbits_state_t *state, uint8_t *start) {
+int dvdread_getbits_init(getbits_state_t *state, const 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;
 }
 
@@ -47,37 +47,32 @@
 
   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 = state->startstate->byte_position << state->bit_position;
       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 = state->startstate->byte_position << state->bit_position;
       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;
+      result = (result << 8) + state->startstate->byte_position;
       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;
+      byte = state->startstate->byte_position << state->bit_position;
       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;
@@ -115,3 +110,54 @@
 }
 
 #endif
+
+#ifdef BITREADER_TESTS
+
+int main()
+{
+    uint8_t buff2 = {
+        0x6E, 0xC2
+        // 0b 01101110 11000010
+    };
+    getbits_state_t state;
+    dvdread_getbits_init(&state, buff);
+
+    uint32_t bits = dvdread_getbits(&state, 3);
+    assert(bits == 3);
+
+    bits = dvdread_getbits(&state, 3);
+    assert(bits == 3);
+
+    bits = dvdread_getbits(&state, 4);
+    assert(bits == 11);
+
+    bits = dvdread_getbits(&state, 6);
+    assert(bits == 2);
+
+    dvdread_getbits_init(&state, buff);
+    bits = dvdread_getbits(&state, 10);
+    assert(bits == 443);
+
+    bits = dvdread_getbits(&state, 6);
+    assert(bits == 2);
+
+    dvdread_getbits_init(&state, buff);
+    bits = dvdread_getbits(&state, 16);
+    assert(bits == 28354);
+
+    buff0 = buff1 = 0xFF;
+    dvdread_getbits_init(&state, buff);
+    bits = dvdread_getbits(&state, 16);
+    assert(bits == 0xFFFF);
+
+    uint8_t large5 = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
+    dvdread_getbits_init(&state, large);
+    bits = dvdread_getbits(&state, 8);
+    assert(bits == 0xFF);
+    bits = dvdread_getbits(&state, 32);
+    assert(bits == 0xFFFFFFFF);
+
+    return 0;
+}
+
+#endif

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/bitreader.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/bitreader.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/bswap.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/bswap.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/dvd_reader.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/dvd_reader.h Changed

@@ -29,17 +29,23 @@
 #include <stdint.h>
 #include <unistd.h>
 
+#ifdef _MSC_VER
+typedef ptrdiff_t ssize_t;
+#endif
+
+#include <dvdread/attributes.h>
+
 /**
  * The DVD access interface.
  *
- * This file contains the functions that form the interface to to
+ * This file contains the functions that form the interface for
  * reading files located on a DVD.
  */
 
 /**
  * The current version.
  */
-#include "version.h"
+#include <dvdread/version.h>
 
 /**
  * The length of one Logical Block of a DVD.
@@ -123,31 +129,36 @@
  *   path/VTS_01_1.VOB
  *   path/vts_01_1.vob
  *
- * @param path Specifies the the device, file or directory to be used.
+ * @param path Specifies 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.
+ * @return If successful 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 * );
+DVDREAD_API dvd_reader_t *DVDOpen( const char * );
+DVDREAD_API 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 path Specifies 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.
+ * @return If successful 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 * );
+DVDREAD_API dvd_reader_t *DVDOpen2( void *, const dvd_logger_cb *, const char *);
+DVDREAD_API dvd_reader_t *DVDOpenStream2( void *, const dvd_logger_cb *, dvd_reader_stream_cb *);
+
+/* same as the functions above, but with the dvd_a flag passed to dvdopencommon*/
+DVDREAD_API dvd_reader_t *DVDOpenAudio( void *, const dvd_logger_cb *, const char *);
+DVDREAD_API dvd_reader_t *DVDOpenStreamAudio( void *, const dvd_logger_cb *, dvd_reader_stream_cb *);
+
 
 /**
  * Closes and cleans up the DVD reader object.
@@ -158,7 +169,7 @@
  *
  * DVDClose(dvd);
  */
-void DVDClose( dvd_reader_t * );
+DVDREAD_API void DVDClose( dvd_reader_t * );
 
 /**
  *
@@ -167,9 +178,10 @@
   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
+  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_SAMG_INFO,        /* for the AUDIO_PP.IFO */
 } dvd_read_domain_t;
 
 /**
@@ -197,7 +209,7 @@
  *
  * int DVDFileStat(dvd, titlenum, domain, stat);
  */
-int DVDFileStat(dvd_reader_t *, int, dvd_read_domain_t, dvd_stat_t *);
+DVDREAD_API 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.
@@ -212,7 +224,7 @@
  * @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 );
+DVDREAD_API dvd_file_t *DVDOpenFile( dvd_reader_t *, int, dvd_read_domain_t );
 
 /**
  * Closes a file and frees the associated structure.
@@ -221,7 +233,7 @@
  *
  * DVDCloseFile(dvd_file);
  */
-void DVDCloseFile( dvd_file_t * );
+DVDREAD_API void DVDCloseFile( dvd_file_t * );
 
 /**
  * Reads block_count number of blocks from the file at the given block offset.
@@ -238,7 +250,7 @@
  *
  * blocks_read = DVDReadBlocks(dvd_file, offset, block_count, data);
  */
-ssize_t DVDReadBlocks( dvd_file_t *, int, size_t, unsigned char * );
+DVDREAD_API ssize_t DVDReadBlocks( dvd_file_t *, int, size_t, unsigned char * );
 
 const unsigned char * DVDReadBlock(dvd_file_t *, int, unsigned char *);
 
@@ -254,12 +266,12 @@
  *
  * offset_set = DVDFileSeek(dvd_file, seek_offset);
  */
-int32_t DVDFileSeek( dvd_file_t *, int32_t );
+DVDREAD_API 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.
+ * reads from and increments the current seek position for the file.
  *
  * @param dvd_file  A file read handle.
  * @param data Pointer to a buffer to write the data into.
@@ -268,7 +280,7 @@
  *
  * bytes_read = DVDReadBytes(dvd_file, data, bytes);
  */
-ssize_t DVDReadBytes( dvd_file_t *, void *, size_t );
+DVDREAD_API ssize_t DVDReadBytes( dvd_file_t *, void *, size_t );
 
 /**
  * Returns the file size in blocks.
@@ -278,7 +290,7 @@
  *
  * blocks = DVDFileSize(dvd_file);
  */
-ssize_t DVDFileSize( dvd_file_t * );
+DVDREAD_API ssize_t DVDFileSize( dvd_file_t * );
 
 /**
  * Get a unique 128 bit disc ID.
@@ -293,7 +305,7 @@
  *               have room for 128 bits (16 chars).
  * @return 0 on success, -1 on error.
  */
-int DVDDiscID( dvd_reader_t *, unsigned char * );
+DVDREAD_API int DVDDiscID( dvd_reader_t *, unsigned char * );
 
 /**
  * Get the UDF VolumeIdentifier and VolumeSetIdentifier
@@ -313,15 +325,15 @@
  * @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,
+DVDREAD_API int DVDUDFVolumeInfo( dvd_reader_t *, char *, unsigned int,
                       unsigned char *, unsigned int );
 
-int DVDFileSeekForce( dvd_file_t *, int offset, int force_size);
+DVDREAD_API 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   *
+ * * Only use this function as fallback if DVDUDFVolumeInfo returns -1  *
  * * this will happen on a disc mastered only with a iso9660 filesystem *
  * * All video DVD discs have UDF filesystem                            *
  *
@@ -339,7 +351,7 @@
  * @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,
+DVDREAD_API int DVDISOVolumeInfo( dvd_reader_t *, char *, unsigned int,
                       unsigned char *, unsigned int );
 
 /**
@@ -354,7 +366,7 @@
  *
  * @return The level of caching.
  */
-int DVDUDFCacheLevel( dvd_reader_t *, int );
+DVDREAD_API int DVDUDFCacheLevel( dvd_reader_t *, int );
 
 #ifdef __cplusplus
 };

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/dvdread_internal.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/dvdread_internal.h Changed

makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/dvdreadsrc.cpp Added

@@ -0,0 +1,33 @@
+/*
+    Copyright (C) 2007-2025 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 <inttypes.h>
+
+#define DVDREAD_NO_DVDA 1
+#define DVDREAD_NO_TXTDT 1
+
+#include "bitreader.c"
+#include "logger.c"
+
+#include "ifo_read.c"
+
+#undef THISFILE__
+#undef CHECK_VALUE
+#include "nav_read.c"
+

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/ifo_read.c -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/ifo_read.c Changed

@@ -35,13 +35,45 @@
 #include "logger.h"
 #include "dvdread/bitreader.h"
 
+#ifdef __cplusplus
+#define _Static_assert(x, y)  static_assert((x),y)
+#else
+#ifndef HAVE_STATIC_ASSERT
+#if defined(_MSC_VER)
+#include <crtdbg.h>
+#define _Static_assert(x, y)  _STATIC_ASSERT(x)
+#else
+#define _Static_assert(x, y) // packed size checks not supported by this compiler
+#endif
+#endif
+#endif
+
+#define POINTER_SIZE  sizeof(void*)
+
+
 #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)
+static inline ifo_handle_private_s* PRIV(ifo_handle_t *ifofile)
+{
+    return static_cast<ifo_handle_private_s*>(ifofile);
+}
+
+static inline ifo_handle_private_s* PRIV(ifo_handle_v_t *ifofile)
+{
+    static_assert(offsetof(ifo_handle_t, u.v) == 0, "");
+    return PRIV((ifo_handle_t*)ifofile);
+}
+
+static inline ifo_handle_private_s* PRIV(ifo_handle_a_t *ifofile)
+{
+    static_assert(offsetof(ifo_handle_t, u.a) == 0, "");
+    return PRIV((ifo_handle_t*)ifofile);
+}
+
 
 #define CHECK_VALUE(arg)\
   if(!(arg)) {\
@@ -50,9 +82,10 @@
   }
 
 #ifndef NDEBUG
+
 static inline char * makehexdump(const uint8_t *p_CZ, size_t i_CZ)
 {
-  char *alloc = malloc(i_CZ * 2 + 1);
+  char *alloc = (char*)malloc(i_CZ * 2 + 1);
   if(alloc)
   {
     *alloc = 0;
@@ -61,19 +94,28 @@
   }
   return alloc;
 }
+
+static bool memcmp_my_friendly_zeros(const void* ptr, size_t size)
+{
+    for (size_t i = 0; i < size; i++)
+    {
+        if (((const uint8_t*)ptr)i != 0) return true;
+    }
+    return false;
+}
+
 #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))) {                    \
+  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)
@@ -81,30 +123,38 @@
 
 
 /* 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,
+static int ifoRead_VMG(ifo_handle_v_t *ifofile);
+
+#ifndef DVDREAD_NO_DVDA
+static int ifoRead_AMG(ifo_handle_a_t *ifofile);
+/* Can be used to make simple dvd-a playback, no menus*/
+static int ifoRead_SAMG(ifo_handle_a_t *ifofile);
+#endif // DVDREAD_NO_DVDA
+
+static int ifoRead_VTS(ifo_handle_v_t *ifofile);
+static int ifoRead_ATS(ifo_handle_a_t *ifofile);
+static int ifoRead_PGC(ifo_handle_v_t *ifofile, pgc_t *pgc, unsigned int offset);
+static int ifoRead_PGC_COMMAND_TBL(ifo_handle_v_t *ifofile,
                                    pgc_command_tbl_t *cmd_tbl,
                                    unsigned int offset);
-static int ifoRead_PGC_PROGRAM_MAP(ifo_handle_t *ifofile,
+static int ifoRead_PGC_PROGRAM_MAP(ifo_handle_v_t *ifofile,
                                    pgc_program_map_t *program_map,
                                    unsigned int nr, unsigned int offset);
-static int ifoRead_CELL_PLAYBACK_TBL(ifo_handle_t *ifofile,
+static int ifoRead_CELL_PLAYBACK_TBL(ifo_handle_v_t *ifofile,
                                      cell_playback_t *cell_playback,
                                      unsigned int nr, unsigned int offset);
-static int ifoRead_CELL_POSITION_TBL(ifo_handle_t *ifofile,
+static int ifoRead_CELL_POSITION_TBL(ifo_handle_v_t *ifofile,
                                      cell_position_t *cell_position,
                                      unsigned int nr, unsigned int offset);
-static int ifoRead_VTS_ATTRIBUTES(ifo_handle_t *ifofile,
+static int ifoRead_VTS_ATTRIBUTES(ifo_handle_v_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,
+static int ifoRead_C_ADT_internal(ifo_handle_v_t *ifofile, c_adt_t *c_adt,
                                   unsigned int sector);
-static int ifoRead_VOBU_ADMAP_internal(ifo_handle_t *ifofile,
+static int ifoRead_VOBU_ADMAP_internal(ifo_handle_v_t *ifofile,
                                        vobu_admap_t *vobu_admap,
                                        unsigned int sector);
-static int ifoRead_PGCIT_internal(ifo_handle_t *ifofile, pgcit_t *pgcit,
+static int ifoRead_PGCIT_internal(ifo_handle_v_t *ifofile, pgcit_t *pgcit,
                                   unsigned int offset);
 
 static void ifoFree_PGC(pgc_t **pgc);
@@ -119,6 +169,65 @@
   return (DVDFileSeek(dvd_file, (int)offset) == (int)offset);
 }
 
+#define STRINGIFY_NAME( z )   STRINGIFY_NAME_( z )
+#define STRINGIFY_NAME_( z ) #z
+
+#define CHECK_STRUCT_SIZE(strt, size) \
+  _Static_assert(sizeof(strt)  <= size , STRINGIFY_NAME(strt) " bigger than " STRINGIFY_NAME(size)); \
+  _Static_assert(sizeof(strt)  >= size , STRINGIFY_NAME(strt) " smaller than " STRINGIFY_NAME(size))
+
+/* size checks on packed structures */
+CHECK_STRUCT_SIZE(dvd_time_t,                DVD_TIME_SIZE);
+CHECK_STRUCT_SIZE(vm_cmd_t,                  COMMAND_DATA_SIZE);
+CHECK_STRUCT_SIZE(video_attr_t,              VIDEO_ATTR_SIZE);
+CHECK_STRUCT_SIZE(audio_attr_t,              AUDIO_ATTR_SIZE);
+CHECK_STRUCT_SIZE(multichannel_ext_t,        MULTICHANNEL_EXT_SIZE);
+CHECK_STRUCT_SIZE(subp_attr_t,               SUBP_ATTR_SIZE);
+CHECK_STRUCT_SIZE(pgc_command_tbl_data_t,    PGC_COMMAND_TBL_SIZE);
+CHECK_STRUCT_SIZE(cell_playback_t,           CELL_PLAYBACK_SIZE);
+CHECK_STRUCT_SIZE(cell_position_t,           CELL_POSITION_SIZE);
+CHECK_STRUCT_SIZE(user_ops_t,                USER_OPS_SIZE);
+CHECK_STRUCT_SIZE(pgc_data_t,                PGC_SIZE);
+CHECK_STRUCT_SIZE(pgci_srp_data_t,           PGCI_SRP_SIZE);
+CHECK_STRUCT_SIZE(pgcit_data_t,              PGCIT_SIZE);
+CHECK_STRUCT_SIZE(pgci_lu_data_t,            PGCI_LU_SIZE);
+CHECK_STRUCT_SIZE(pgci_ut_data_t,            PGCI_UT_SIZE);
+CHECK_STRUCT_SIZE(cell_adr_t,                CELL_ADDR_SIZE);
+CHECK_STRUCT_SIZE(c_adt_data_t,              C_ADT_SIZE);
+CHECK_STRUCT_SIZE(vobu_admap_data_t,         VOBU_ADMAP_SIZE);
+CHECK_STRUCT_SIZE(vmgi_mat_t,                VMGI_MAT_SIZE);
+
+CHECK_STRUCT_SIZE(playback_type_t,           PLAYBACK_TYPE_SIZE);
+CHECK_STRUCT_SIZE(title_info_t,              TITLE_INFO_SIZE);
+CHECK_STRUCT_SIZE(tt_srpt_data_t,            TT_SRPT_SIZE);
+CHECK_STRUCT_SIZE(ptl_mait_country_data_t,   PTL_MAIT_COUNTRY_SIZE);
+CHECK_STRUCT_SIZE(ptl_mait_data_t,           PTL_MAIT_SIZE);
+CHECK_STRUCT_SIZE(vts_attributes_t,          VTS_ATTRIBUTES_SIZE);
+
+CHECK_STRUCT_SIZE(vts_atrt_data_t,           VTS_ATRT_SIZE);
+CHECK_STRUCT_SIZE(txtdt_t,                   TXTDT_SIZE);
+CHECK_STRUCT_SIZE(txtdt_lu_data_t,           TXTDT_LU_SIZE);
+CHECK_STRUCT_SIZE(txtdt_mgi_data_t,          TXTDT_MGI_SIZE);
+CHECK_STRUCT_SIZE(vtsi_mat_t,                VTSI_MAT_SIZE);
+CHECK_STRUCT_SIZE(ptt_info_t,                PTT_INFO_SIZE);
+CHECK_STRUCT_SIZE(ttu_data_t,                TTU_SIZE);
+CHECK_STRUCT_SIZE(vts_ptt_srpt_data_t,       VTS_PTT_SRPT_SIZE);
+CHECK_STRUCT_SIZE(vts_tmap_data_t,           VTS_TMAP_SIZE);
+CHECK_STRUCT_SIZE(vts_tmapt_data_t,          VTS_TMAPT_SIZE);
+CHECK_STRUCT_SIZE(samg_chapter_t,            SAMG_CHAPTER_SIZE);
+CHECK_STRUCT_SIZE(samg_mat_data_t,           SAMG_MAT_SIZE);
+CHECK_STRUCT_SIZE(amgi_mat_t,                AMGI_MAT_SIZE);
+CHECK_STRUCT_SIZE(track_info_t,              TRACK_INFO_SIZE);
+CHECK_STRUCT_SIZE(tracks_info_table_data_t,  TRACKS_INFO_TABLE_SIZE);
+CHECK_STRUCT_SIZE(atsi_record_t,             ATSI_RECORD_SIZE);
+CHECK_STRUCT_SIZE(atsi_mat_t,                ATSI_MAT_SIZE);
+CHECK_STRUCT_SIZE(atsi_title_index_t,        ATSI_TITLE_INDEX_SIZE);
+CHECK_STRUCT_SIZE(atsi_track_timestamp_t,    ATSI_TRACK_TIMESTAMP_SIZE);
+CHECK_STRUCT_SIZE(atsi_track_pointer_t,      ATSI_TRACK_POINTER_SIZE);
+CHECK_STRUCT_SIZE(atsi_title_record_data_t,  ATSI_TITLE_ROW_TABLE_SIZE);
+CHECK_STRUCT_SIZE(atsi_title_table_data_t,   ATSI_TITLE_TABLE_SIZE);
+CHECK_STRUCT_SIZE(downmix_coeff_t,           DOWNMIX_COEFF_SIZE);
+
 static void read_video_attr(video_attr_t *va) {
   getbits_state_t state;
   uint8_t bufsizeof(video_attr_t);
@@ -313,9 +422,9 @@
   struct ifo_handle_private_s *ifop;
   dvd_read_domain_t domain = backup ? DVD_READ_INFO_BACKUP_FILE
                                     : DVD_READ_INFO_FILE;
-  char ifo_filename13;
+  char ifo_filenameMAX_UDF_FILE_NAME_LEN;
 
-  ifop = calloc(1, sizeof(*ifop));
+  ifop = (struct ifo_handle_private_s*)calloc(1, sizeof(*ifop));
   if(!ifop)
     return NULL;
 
@@ -328,9 +437,10 @@
   }
 
   if (title)
-    snprintf(ifo_filename, 13, "VTS_%02d_0.%s", title, backup ? "BUP" : "IFO");
+    snprintf(ifo_filename, 13, "%cTS_%02d_0.%s", STREAM_TYPE_STRING( ctx->dvd_type )
+             ,title, backup ? "BUP" : "IFO");
   else
-    snprintf(ifo_filename, 13, "VIDEO_TS.%s", backup ? "BUP" : "IFO");
+    snprintf(ifo_filename, 13, "%s_TS.%s", DVD_TYPE_STRING( ctx->dvd_type ), backup ? "BUP" : "IFO" );
 
   if(!ifop->file) {
     Log1(ctx, "Can't open file %s.", ifo_filename);
@@ -338,44 +448,82 @@
     return NULL;
   }
 
-  ifo_handle_t *ifofile = &ifop->handle;
+  ifo_handle_t* ifofile = ifop;
+  ifo_handle_v_t *ifofile_v = &ifop->u.v;
   /* First check if this is a VMGI file. */
-  if(ifoRead_VMG(ifofile)) {
+  if(ifoRead_VMG(ifofile_v)) {
 
+    ifofile->ifo_format=IFO_VIDEO;
     /* These are both mandatory. */
-    if(!ifoRead_FP_PGC(ifofile) || !ifoRead_TT_SRPT(ifofile))
+    if(!ifoRead_FP_PGC(ifofile_v) || !ifoRead_TT_SRPT(ifofile_v))
       goto ifoOpen_fail;
 
-    ifoRead_PGCI_UT(ifofile);
-    ifoRead_PTL_MAIT(ifofile);
+    ifoRead_PGCI_UT(ifofile_v);
+    ifoRead_PTL_MAIT(ifofile_v);
 
     /* This is also mandatory. */
-    if(!ifoRead_VTS_ATRT(ifofile))
+    if(!ifoRead_VTS_ATRT(ifofile_v))
       goto ifoOpen_fail;
 
-    ifoRead_TXTDT_MGI(ifofile);
-    ifoRead_C_ADT(ifofile);
-    ifoRead_VOBU_ADMAP(ifofile);
+#ifndef DVDREAD_NO_TXTDT
+    ifoRead_TXTDT_MGI(ifofile_v);
+#endif
+
+    ifoRead_C_ADT(ifofile_v);
+    ifoRead_VOBU_ADMAP(ifofile_v);
 
     return ifofile;
   }
 
-  if(ifoRead_VTS(ifofile)) {
+  if(ifoRead_VTS(ifofile_v)) {
 
-    if(!ifoRead_VTS_PTT_SRPT(ifofile) || !ifoRead_PGCIT(ifofile))
+    ifofile->ifo_format=IFO_VIDEO;
+    if(!ifoRead_VTS_PTT_SRPT(ifofile_v) || !ifoRead_PGCIT(ifofile_v))
       goto ifoOpen_fail;
 
-    ifoRead_PGCI_UT(ifofile);
-    ifoRead_VTS_TMAPT(ifofile);
-    ifoRead_C_ADT(ifofile);
-    ifoRead_VOBU_ADMAP(ifofile);
+    ifoRead_PGCI_UT(ifofile_v);
+    ifoRead_VTS_TMAPT(ifofile_v);
+    ifoRead_C_ADT(ifofile_v);
+    ifoRead_VOBU_ADMAP(ifofile_v);
 
-    if(!ifoRead_TITLE_C_ADT(ifofile) || !ifoRead_TITLE_VOBU_ADMAP(ifofile))
+    if(!ifoRead_TITLE_C_ADT(ifofile_v) || !ifoRead_TITLE_VOBU_ADMAP(ifofile_v))
       goto ifoOpen_fail;
 
     return ifofile;
   }
 
+#ifndef DVDREAD_NO_DVDA
+  ifo_handle_a_t* ifofile_a = &ifop->u.a;
+
+  if(ifoRead_AMG(ifofile_a)){
+    ifofile->ifo_format=IFO_AUDIO;
+    /* same function for both tables, will not be the same table in the case of non hybrid discs */
+    if(!ifoRead_TIF(ifofile_a,1))
+      goto ifoOpen_fail;
+    if(!ifoRead_TIF(ifofile_a,2))
+      goto ifoOpen_fail;
+
+    /* Should read SAMG as it contains location to AOB pointers */
+    ifop->file = DVDOpenFile(ctx, 2, DVD_READ_SAMG_INFO);
+    if(!ifop->file)
+      goto ifoOpen_fail;
+    if(!ifoRead_SAMG(ifofile_a))
+      goto ifoOpen_fail;
+
+    return ifofile;
+  }
+
+
+  if(ifoRead_ATS(ifofile_a)){
+    ifofile->ifo_format=IFO_AUDIO;
+
+    if(!ifoRead_TT(ifofile_a))
+      goto ifoOpen_fail;
+
+    return ifofile;
+  }
+#endif // DVDREAD_NO_DVDA
+
 ifoOpen_fail:
   Log1(ctx, "Invalid IFO for title %d (%s).", title, ifo_filename);
   ifoClose(ifofile);
@@ -385,18 +533,18 @@
 static void ifoSetBupFlag(dvd_reader_t *ctx, int title)
 {
     if(title > 63)
-        ctx->ifoBUPflags0 |= 1ull << (title - 64);
+        ctx->ifoBUPflags0 |= UINT64_C(1) << (title - 64);
     else
-        ctx->ifoBUPflags1 |= 1ull << title;
+        ctx->ifoBUPflags1 |= UINT64_C(1) << title;
 }
 
 static int ifoGetBupFlag(const dvd_reader_t *ctx, int title)
 {
     int bupflag;
     if(title > 63)
-        bupflag = !! (ctx->ifoBUPflags0 & (1ull << (title - 64)));
+        bupflag = !! (ctx->ifoBUPflags0 & (UINT64_C(1) << (title - 64)));
     else
-        bupflag = !! (ctx->ifoBUPflags1 & (1ull << title));
+        bupflag = !! (ctx->ifoBUPflags1 & (UINT64_C(1) << title));
     return bupflag;
 }
 
@@ -414,12 +562,12 @@
   return ifofile;
 }
 
-ifo_handle_t *ifoOpenVMGI(dvd_reader_t *ctx) {
+ifo_handle_t *ifoOpenXMGI(dvd_reader_t *ctx) {
   struct ifo_handle_private_s *ifop;
 
   for(int backup = ifoGetBupFlag(ctx, 0); backup <= 1; backup++)
   {
-    ifop = calloc(1, sizeof(*ifop));
+    ifop = (struct ifo_handle_private_s*)calloc(1, sizeof(*ifop));
     if(!ifop)
       return NULL;
 
@@ -430,22 +578,35 @@
     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);
+      Log1(ctx, "Can't open file %s_TS.%s.",
+           DVD_TYPE_STRING( ctx->dvd_type ), ext);
       free(ifop);
       return NULL;
     }
 
-    if(ifoRead_VMG(&ifop->handle))
-      return &ifop->handle;
+    int r = 0;
+    if (ctx->dvd_type == DVD_V) {
+        r = ifoRead_VMG(&ifop->u.v);
+    } else {
+#ifndef DVDREAD_NO_DVDA
+        r = ifoRead_AMG(&ifop->u.a);
+#endif // DVDREAD_NO_DVDA
+    }
+
+    if(r){
+      ifop->ifo_format = ctx->dvd_type == DVD_V ? IFO_VIDEO : IFO_AUDIO;
+      return ifop;
+     }
 
-    Log1(ctx, "ifoOpenVMGI(): Invalid main menu IFO (VIDEO_TS.%s).", ext);
-    ifoClose(&ifop->handle);
+    Log1(ctx, "ifoOpenXMGI(): Invalid main menu IFO (%s_TS.%s).",
+         DVD_TYPE_STRING( ctx->dvd_type ), ext);
+    ifoClose(ifop);
   }
   return NULL;
 }
 
 
-ifo_handle_t *ifoOpenVTSI(dvd_reader_t *ctx, int title) {
+ifo_handle_t *ifoOpenXTSI(dvd_reader_t *ctx, int title) {
   struct ifo_handle_private_s *ifop;
 
   if(title <= 0 || title > 99) {
@@ -455,7 +616,7 @@
 
   for(int backup = ifoGetBupFlag(ctx, title); backup <= 1; backup++)
   {
-    ifop = calloc(1, sizeof(*ifop));
+    ifop = (struct ifo_handle_private_s*)calloc(1, sizeof(*ifop));
     if(!ifop)
       return NULL;
 
@@ -466,22 +627,95 @@
     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);
+      Log1(ctx, "Can't open file %cTS_%02d_0.%s.",
+           STREAM_TYPE_STRING( ctx->dvd_type ), title, ext);
       free(ifop);
       continue;
     }
 
-    if(ifoRead_VTS(&ifop->handle) && ifop->handle.vtsi_mat)
-      return &ifop->handle;
+    int r = 0;
+    if (ctx->dvd_type == DVD_V) {
+        r = ifoRead_VTS(&ifop->u.v) && (NULL != ifop->u.v.vtsi_mat);
+    } else {
+#ifndef DVDREAD_NO_DVDA
+        r = ifoRead_ATS(&ifop->u.a) && (NULL != ifop->u.a.atsi_mat);
+#endif // DVDREAD_NO_DVDA
+    }
+
+      if (r) {
+        ifop->ifo_format = ctx->dvd_type == DVD_V ? IFO_VIDEO : IFO_AUDIO;
+        return ifop;
+      }
 
-    Log1(ctx, "Invalid IFO for title %d (VTS_%02d_0.%s).",
-            title, title, ext);
-    ifoClose(&ifop->handle);
+    Log1(ctx, "Invalid IFO for title %d (%cTS_%02d_0.%s).",
+            title, STREAM_TYPE_STRING( ctx->dvd_type ), title, ext);
+    ifoClose(ifop);
   }
 
   return NULL;
 }
 
+ifo_handle_v_t* ifoOpenVMGI(dvd_reader_t* ctx)
+{
+    ifo_handle_t* ifop = ifoOpenXMGI(ctx);
+    if ((NULL != ifop) && (IFO_VIDEO != ifop->ifo_format))
+    {
+        Log1(ctx, "ifoOpenVMGI(): Non-video main menu IFO (%s_TS.%s).");
+        ifoClose(ifop);
+        ifop = NULL;
+    }
+    return (NULL != ifop) ? &ifop->u.v : NULL;
+}
+
+ifo_handle_v_t* ifoOpenVTSI(dvd_reader_t *ctx, int title)
+{
+    ifo_handle_t* ifop = ifoOpenXTSI(ctx, title);
+    if ((NULL != ifop) && (IFO_VIDEO != ifop->ifo_format))
+    {
+        Log1(ctx, "ifoOpenVTSI(): Non-video IFO for title %d.", title);
+        ifoClose(ifop);
+        ifop = NULL;
+    }
+    return (NULL != ifop) ? &ifop->u.v : NULL;
+}
+
+
+
+#ifndef DVDREAD_NO_DVDA
+
+void ifoFree_TT(ifo_handle_a_t *ifofile){
+  if(!ifofile)
+    return;
+
+  if (ifofile->atsi_title_table) {
+    for (int j=0;j<ifofile->atsi_title_table->nr_titles;j++){
+      free((ifofile->atsi_title_table->atsi_title_row_tables+j)->atsi_track_pointer_rows);
+      free((ifofile->atsi_title_table->atsi_title_row_tables+j)->atsi_track_timestamp_rows);
+    }
+    free(ifofile->atsi_title_table->atsi_title_row_tables);
+    free(ifofile->atsi_title_table->atsi_index_rows);
+    free(ifofile->atsi_title_table);
+    ifofile->atsi_title_table= NULL;
+  }
+}
+
+#endif // DVDREAD_NO_DVDA
+
+
+void ifoAddRefV(ifo_handle_v_t *ifofile)
+{
+    static_assert(offsetof(ifo_handle_t, u.v) == 0, "");
+    ifoAddRef((ifo_handle_t*)ifofile);
+}
+
+
+void ifoCloseV(ifo_handle_v_t *ifofile)
+{
+    static_assert(offsetof(ifo_handle_t, u.v) == 0, "");
+    ifoClose((ifo_handle_t*)ifofile);
+}
+
+
 void ifoAddRef(ifo_handle_t *ifofile) {
     ifofile->refcount++;
 }
@@ -495,37 +729,71 @@
       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);
+  ifo_handle_v_t* ifofile_v = &ifofile->u.v;
+  ifo_handle_a_t* ifofile_a = &ifofile->u.a;
+
+  switch(ifofile->ifo_format) {
+    case IFO_VIDEO:
+      ifoFree_VOBU_ADMAP(ifofile_v);
+      ifoFree_TITLE_VOBU_ADMAP(ifofile_v);
+      ifoFree_C_ADT(ifofile_v);
+      ifoFree_TITLE_C_ADT(ifofile_v);
+#ifndef DVDREAD_NO_TXTDT
+      ifoFree_TXTDT_MGI(ifofile_v);
+#endif // DVDREAD_NO_TXTDT
+      ifoFree_VTS_ATRT(ifofile_v);
+      ifoFree_PTL_MAIT(ifofile_v);
+      ifoFree_PGCI_UT(ifofile_v);
+      ifoFree_TT_SRPT(ifofile_v);
+      ifoFree_FP_PGC(ifofile_v);
+      ifoFree_PGCIT(ifofile_v);
+      ifoFree_VTS_PTT_SRPT(ifofile_v);
+      ifoFree_VTS_TMAPT(ifofile_v);
+
+      if(ifofile_v->vmgi_mat)
+        free(ifofile_v->vmgi_mat);
+
+      if(ifofile_v->vtsi_mat)
+        free(ifofile_v->vtsi_mat);
+    break;
+
+#ifndef DVDREAD_NO_DVDA
+    case IFO_AUDIO:
+      if(ifofile_a->amgi_mat)
+        free(ifofile_a->amgi_mat);
+
+      if(ifofile_a->atsi_mat)
+        free(ifofile_a->atsi_mat);
+
+      if(ifofile_a->samg_mat){
+        free(ifofile_a->samg_mat->samg_chapters);
+        free(ifofile_a->samg_mat);
+      }
 
-  if(ifofile->vtsi_mat)
-    free(ifofile->vtsi_mat);
+      if(ifofile_a->info_table_first_sector){
+        free(ifofile_a->info_table_first_sector->tracks_info);
+        free(ifofile_a->info_table_first_sector);
+      }
+      if(ifofile_a->atsi_title_table)
+        ifoFree_TT(ifofile_a);
+      break;
+#endif // DVDREAD_NO_DVDA
 
+    default:
+    case IFO_UNKNOWN:
+      break;
+  }
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   DVDCloseFile(ifop->file);
   free(ifop);
 }
 
 
-static int ifoRead_VMG(ifo_handle_t *ifofile) {
+static int ifoRead_VMG(ifo_handle_v_t *ifofile) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   vmgi_mat_t *vmgi_mat;
 
-  vmgi_mat = calloc(1, sizeof(vmgi_mat_t));
+  vmgi_mat = (vmgi_mat_t*)calloc(1, sizeof(vmgi_mat_t));
   if(!vmgi_mat)
     return 0;
 
@@ -614,13 +882,333 @@
   return 1;
 }
 
+#ifndef DVDREAD_NO_DVDA
+
+static int ifoRead_SAMG(ifo_handle_a_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  samg_mat_t *samg_mat;
+
+  samg_mat = (samg_mat_t*)calloc(1, sizeof(samg_mat_t));
+  if(!samg_mat)
+    return 0;
+
+
+  ifofile->samg_mat = samg_mat;
+
+  if(!DVDFileSeek_(ifop->file, 0)) {
+    free(ifofile->samg_mat);
+    ifofile->samg_mat = NULL;
+    return 0;
+  }
+
+  if(!DVDReadBytes(ifop->file, samg_mat, SAMG_MAT_SIZE)) {
+    free(ifofile->samg_mat);
+    ifofile->samg_mat = NULL;
+    return 0;
+  }
+
+  if(strncmp("DVDAUDIOSAPP", samg_mat->samg_identifier, 12) != 0) {
+    free(ifofile->samg_mat);
+    ifofile->samg_mat = NULL;
+    return 0;
+  }
+
+  B2N_16(samg_mat->nr_chapters);
+  B2N_16(samg_mat->specification_version);
+
+  samg_mat->samg_chapters = (samg_chapter_t*)calloc(samg_mat->nr_chapters, sizeof(samg_chapter_t));
+  if(!samg_mat->samg_chapters) {
+    free(ifofile->samg_mat);
+    ifofile->samg_mat = NULL;
+    return 0;
+  }
+
+  if(!DVDReadBytes(ifop->file, samg_mat->samg_chapters,
+                   samg_mat->nr_chapters * sizeof(samg_chapter_t))) {
+    free(ifofile->samg_mat->samg_chapters);
+    free(ifofile->samg_mat);
+    ifofile->samg_mat = NULL;
+    return 0;
+  }
+
+  for (int i = 0; i < samg_mat->nr_chapters; i++) {
+    samg_chapter_t *index = &samg_mat->samg_chaptersi;
+    CHECK_ZERO(index->zero_1);
+    B2N_32(index->timestamp_pts);
+    B2N_32(index->chapter_len);
+    CHECK_ZERO(index->zero_2);
+    B2N_32(index->start_sector_1);
+    B2N_32(index->start_sector_2);
+    B2N_32(index->end_sector);
+    CHECK_ZERO(index->zero_3);
+  }
+
+  return 1;
+}
+
+int ifoRead_TT(ifo_handle_a_t *ifofile) {
+
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  atsi_title_table_t *atsi_title_table;
+
+  atsi_title_table= (atsi_title_table_t*)calloc(1, sizeof(atsi_title_table_t));
+
+  if(!atsi_title_table)
+    return 0;
+
+  ifofile->atsi_title_table = atsi_title_table;
+
+  if(!DVDFileSeek_(ifop->file, DVD_BLOCK_LEN)) {
+    free(ifofile->atsi_title_table);
+    ifofile->atsi_title_table = NULL;
+    return 0;
+  }
+
+  if(!DVDReadBytes(ifop->file, atsi_title_table, ATSI_TITLE_TABLE_SIZE)) {
+    free(ifofile->atsi_title_table);
+    ifofile->atsi_title_table = NULL;
+    return 0;
+  }
+
+  B2N_16(atsi_title_table->nr_titles);
+  B2N_32(atsi_title_table->last_byte_address);
+
+  atsi_title_table->atsi_index_rows = (atsi_title_index_t*)calloc(atsi_title_table->nr_titles,sizeof(atsi_title_index_t));
+  if(!atsi_title_table->atsi_index_rows) {
+    free(ifofile->atsi_title_table);
+    ifofile->atsi_title_table = NULL;
+    return 0;
+  }
+
+
+  if(!DVDReadBytes(ifop->file, atsi_title_table->atsi_index_rows,
+                   atsi_title_table->nr_titles * sizeof(atsi_title_index_t))) {
+    free(ifofile->atsi_title_table->atsi_index_rows);
+    free(ifofile->atsi_title_table);
+    ifofile->atsi_title_table = NULL;
+    return 0;
+  }
+
+  for(int i=0; i<atsi_title_table->nr_titles; i++)
+    B2N_32(atsi_title_table->atsi_index_rowsi.offset_record_table);
+
+
+  atsi_title_table->atsi_title_row_tables = (atsi_title_record_t*)calloc(atsi_title_table->nr_titles, sizeof(atsi_title_record_t));
+
+  if(!atsi_title_table->atsi_title_row_tables) {
+    free(ifofile->atsi_title_table->atsi_index_rows);
+    free(ifofile->atsi_title_table);
+    ifofile->atsi_title_table = NULL;
+    return 0;
+  }
+
+  int i;
+  for (i=0; i < atsi_title_table->nr_titles; i++){
+    atsi_title_record_t *index = (atsi_title_table->atsi_title_row_tables + i);
+
+    uint32_t record_offset = (atsi_title_table->atsi_index_rows+i)->offset_record_table;
+    if(!DVDFileSeek_(ifop->file, record_offset + DVD_BLOCK_LEN))
+      goto fail_audio;
+
+    if(!DVDReadBytes(ifop->file, index, ATSI_TITLE_ROW_TABLE_SIZE))
+      goto fail_audio;
+
+    B2N_16(index->start_sector_pointers_table);
+    B2N_32(index->length_pts);
+    int nr_tracks=index->nr_tracks;
+    int nr_pointer_records = index->nr_pointer_records;
+
+    index->atsi_track_timestamp_rows = (atsi_track_timestamp_t*)calloc(nr_tracks, sizeof(atsi_track_timestamp_t));
+    if(!index->atsi_track_timestamp_rows)
+      goto fail_audio;
+
+    index->atsi_track_pointer_rows = (atsi_track_pointer_t*)calloc(nr_pointer_records, sizeof(atsi_track_pointer_t));
+    if(!index->atsi_track_pointer_rows)
+      goto fail_audio;
+
+    if(!DVDReadBytes(ifop->file, index->atsi_track_timestamp_rows,
+                     nr_tracks * sizeof(atsi_track_timestamp_t))) {
+      free(index->atsi_track_timestamp_rows);
+      goto fail_audio;
+    }
+
+    if(!DVDFileSeek_(ifop->file, (atsi_title_table->atsi_index_rows + i)->offset_record_table
+                     + index->start_sector_pointers_table + DVD_BLOCK_LEN)) {
+      free(index->atsi_track_timestamp_rows);
+      free(index->atsi_track_pointer_rows);
+      goto fail_audio;
+    }
+
+    if(!DVDReadBytes(ifop->file, index->atsi_track_pointer_rows,
+                     nr_pointer_records * sizeof(atsi_track_pointer_t))) {
+      free(index->atsi_track_timestamp_rows);
+      free(index->atsi_track_pointer_rows);
+      goto fail_audio;
+    }
+
+    for (int j = 0; j<nr_tracks; j++) {
+      CHECK_ZERO(index->atsi_track_timestamp_rowsj.zero);
+      B2N_32(index->atsi_track_timestamp_rowsj.first_pts_of_track);
+      B2N_32(index->atsi_track_timestamp_rowsj.length_pts_of_track);
+    }
+
+    for (int j = 0; j<nr_pointer_records; j++) {
+      B2N_32(index->atsi_track_pointer_rowsj.start_sector);
+      B2N_32(index->atsi_track_pointer_rowsj.end_sector);
+    }
+
+    /* Sanity Check */
+    CHECK_VALUE( index->start_sector_pointers_table
+                 == ( ATSI_TITLE_ROW_TABLE_SIZE
+                 + index->nr_tracks * ATSI_TRACK_TIMESTAMP_SIZE ) );
+
+  }
+  return 1;
+
+  fail_audio:
+      for (int j = 0; j < i; j++){
+        free((atsi_title_table->atsi_title_row_tables + j)->atsi_track_pointer_rows);
+        free((atsi_title_table->atsi_title_row_tables + j)->atsi_track_timestamp_rows);
+      }
+      free(atsi_title_table->atsi_title_row_tables);
+      free(ifofile->atsi_title_table->atsi_index_rows);
+      free(ifofile->atsi_title_table);
+      ifofile->atsi_title_table = NULL;
+      return 0;
+}
+
+int ifoRead_TIF(ifo_handle_a_t *ifofile, int sector_offset) {
+  /* check early if sector_offset corresponds to one of the tables */
+  if (sector_offset != 2 && sector_offset != 1)
+    return 0;
+
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  tracks_info_table_t *tracks_info_table;
+
+  tracks_info_table= (tracks_info_table_t*)calloc(1, sizeof(tracks_info_table_t));
+  if(!tracks_info_table)
+    return 0;
+
+  if(!DVDFileSeek_(ifop->file,DVD_BLOCK_LEN * sector_offset)) {
+    free(tracks_info_table);
+    return 0;
+  }
+
+  if(!DVDReadBytes(ifop->file, tracks_info_table,TRACKS_INFO_TABLE_SIZE)) {
+    free(tracks_info_table);
+    return 0;
+  }
+
+  B2N_16(tracks_info_table->nr_of_titles);
+  B2N_16(tracks_info_table->last_byte_in_table);
+
+  tracks_info_table->tracks_info = (track_info_t*)calloc(tracks_info_table->nr_of_titles,sizeof(track_info_t));
+  if(!tracks_info_table->tracks_info) {
+    free(tracks_info_table);
+    return 0;
+  }
+
+  if(!DVDReadBytes(ifop->file, tracks_info_table->tracks_info,
+                   tracks_info_table->nr_of_titles * sizeof(track_info_t))) {
+    free(tracks_info_table->tracks_info);
+    free(tracks_info_table);
+    return 0;
+  }
+
+  /* the second table is an audio_ts only table, the first is audio_ts, video_ts, strangly the nr_titles in second table doesnt match up with the true nr_titles for this table. Need to subtract video titles*/
+  for(int i=0; i<tracks_info_table->nr_of_titles; i++) {
+    if(tracks_info_table->tracks_infoi.type_and_rank==0 && sector_offset == 2) {
+      tracks_info_table->tracks_info = (track_info_t*)realloc(tracks_info_table->tracks_info, i * sizeof(track_info_t));
+      tracks_info_table->nr_of_titles = i;
+      break;
+    }
+    B2N_32(tracks_info_table->tracks_infoi.len_audio_zone_pts);
+    CHECK_ZERO(tracks_info_table->tracks_infoi.zero_1);
+    B2N_32(tracks_info_table->tracks_infoi.ts_pointer_relative_sector);
+  }
+
+  /* sanity check */
+  /* sector table two's size and end byte are always the same as sector one's table
+   * even though it will be equal to or smaller, since it only lists audio titles
+   * sector two's table has been resized in the ifo to match it's true size */
+  if(sector_offset == 1)
+    CHECK_VALUE( (TRACKS_INFO_TABLE_SIZE +
+                  tracks_info_table->nr_of_titles * TRACK_INFO_SIZE -
+                  1) == tracks_info_table->last_byte_in_table );
+
+  switch(sector_offset) {
+    case 1:
+      ifofile->info_table_first_sector = tracks_info_table;
+      break;
+    case 2:
+      ifofile->info_table_second_sector = tracks_info_table;
+      break;
+  }
+
+  return 1;
+}
+
 
-static int ifoRead_VTS(ifo_handle_t *ifofile) {
+static int ifoRead_AMG(ifo_handle_a_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  amgi_mat_t *amgi_mat;
+
+  amgi_mat = (amgi_mat_t*)calloc(1, sizeof(amgi_mat_t));
+  if(!amgi_mat)
+    return 0;
+
+  ifofile->amgi_mat = amgi_mat;
+
+  if(!DVDFileSeek_(ifop->file, 0)) {
+    free(ifofile->amgi_mat);
+    ifofile->amgi_mat = NULL;
+    return 0;
+  }
+
+  if(!DVDReadBytes(ifop->file, amgi_mat, sizeof(amgi_mat_t))) {
+    free(ifofile->amgi_mat);
+    ifofile->amgi_mat = NULL;
+    return 0;
+  }
+
+  if(strncmp("DVDAUDIO-AMG", amgi_mat->amg_identifier, 12) != 0) {
+    free(ifofile->amgi_mat);
+    ifofile->amgi_mat = NULL;
+    return 0;
+  }
+
+  /* Should be some checks and conversions here, will see about this later*/
+  B2N_32(amgi_mat->audio_sv_ifo_relative_p);
+  B2N_32(amgi_mat->amg_end_byte_address);
+  B2N_32(amgi_mat->amg_start_sector);
+  B2N_32(amgi_mat->amgi_last_sector);
+  B2N_16(amgi_mat->amg_nr_of_volumes);
+  B2N_16(amgi_mat->specification_version);
+  B2N_16(amgi_mat->amg_this_volume_nr);
+  B2N_16(amgi_mat->amg_nr_of_zones);
+  CHECK_ZERO(amgi_mat->zero_1);
+  CHECK_ZERO(amgi_mat->zero_2);
+  CHECK_ZERO(amgi_mat->zero_3);
+  CHECK_ZERO(amgi_mat->zero_4);
+  CHECK_ZERO(amgi_mat->zero_5);
+  CHECK_ZERO(amgi_mat->zero_6);
+  CHECK_ZERO(amgi_mat->zero_7);
+  CHECK_ZERO(amgi_mat->zero_8);
+  CHECK_ZERO(amgi_mat->zero_9);
+  CHECK_ZERO(amgi_mat->zero_10);
+  CHECK_VALUE(amgi_mat->specification_version == 0x0012);
+
+  return 1;
+}
+
+#endif // DVDREAD_NO_DVDA
+
+static int ifoRead_VTS(ifo_handle_v_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));
+  vtsi_mat = (vtsi_mat_t*)calloc(1, sizeof(vtsi_mat_t));
   if(!vtsi_mat)
     return 0;
 
@@ -730,8 +1318,65 @@
   return 1;
 }
 
+#ifndef DVDREAD_NO_DVDA
+
+static int ifoRead_ATS(ifo_handle_a_t *ifofile) {
+  struct ifo_handle_private_s *ifop = PRIV(ifofile);
+  atsi_mat_t *atsi_mat;
+
+  atsi_mat = (atsi_mat_t*)calloc(1, sizeof(atsi_mat_t));
+  if(!atsi_mat)
+    return 0;
+
+  ifofile->atsi_mat = atsi_mat;
+
+  if(!DVDFileSeek_(ifop->file, 0)) {
+    free(ifofile->atsi_mat);
+    ifofile->atsi_mat = NULL;
+    return 0;
+  }
+
+  if(!(DVDReadBytes(ifop->file, atsi_mat, sizeof(atsi_mat_t)))) {
+    free(ifofile->atsi_mat);
+    ifofile->atsi_mat = NULL;
+    return 0;
+  }
+
+  if(strncmp("DVDAUDIO-ATS", atsi_mat->ats_identifier, 12) != 0) {
+    free(ifofile->atsi_mat);
+    ifofile->atsi_mat = NULL;
+    return 0;
+  }
+
+  for (int i=0; i < DOWNMIX_COEFF_MAX_SIZE; i++) {
+    CHECK_ZERO(atsi_mat->downmix_coefficientsi.zero_1);
+    CHECK_ZERO(atsi_mat->downmix_coefficientsi.zero_2);
+  }
+
+
+  B2N_32(atsi_mat->ats_last_sector);
+  B2N_32(atsi_mat->atsi_last_sector);
+  B2N_32(atsi_mat->atst_aobs);
+  B2N_32(atsi_mat->atsi_last_byte);
+  B2N_32(atsi_mat->ats_pgci_ut);
+  B2N_32(atsi_mat->vts_tmapt);
+  B2N_32(atsi_mat->vtsm_c_adt);
+  B2N_32(atsi_mat->vtsm_vobu_admap);
+  B2N_32(atsi_mat->vts_c_adt);
+  B2N_32(atsi_mat->vts_vobu_admap);
+
+
+  CHECK_ZERO(atsi_mat->zero_1);
+  CHECK_ZERO(atsi_mat->zero_2);
+  CHECK_ZERO(atsi_mat->zero_3);
+  CHECK_ZERO(atsi_mat->zero_4);
+
+  return 1;
+}
+
+#endif // DVDREAD_NO_DVDA
 
-static int ifoRead_PGC_COMMAND_TBL(ifo_handle_t *ifofile,
+static int ifoRead_PGC_COMMAND_TBL(ifo_handle_v_t *ifofile,
                                    pgc_command_tbl_t *cmd_tbl,
                                    unsigned int offset) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
@@ -744,12 +1389,15 @@
   B2N_16(cmd_tbl->nr_of_pre);
   B2N_16(cmd_tbl->nr_of_post);
   B2N_16(cmd_tbl->nr_of_cell);
+  B2N_16(cmd_tbl->last_byte);
 
   CHECK_VALUE(cmd_tbl->nr_of_pre + cmd_tbl->nr_of_post + cmd_tbl->nr_of_cell<= 255);
+  CHECK_VALUE((cmd_tbl->nr_of_pre + cmd_tbl->nr_of_post + cmd_tbl->nr_of_cell) * COMMAND_DATA_SIZE
+              + PGC_COMMAND_TBL_SIZE <= cmd_tbl->last_byte + 1);
 
   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);
+    cmd_tbl->pre_cmds = (vm_cmd_t*)malloc(pre_cmds_size);
     if(!cmd_tbl->pre_cmds)
       return 0;
 
@@ -761,7 +1409,7 @@
 
   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);
+    cmd_tbl->post_cmds = (vm_cmd_t*)malloc(post_cmds_size);
     if(!cmd_tbl->post_cmds) {
       if(cmd_tbl->pre_cmds)
         free(cmd_tbl->pre_cmds);
@@ -777,7 +1425,7 @@
 
   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);
+    cmd_tbl->cell_cmds = (vm_cmd_t*)malloc(cell_cmds_size);
     if(!cmd_tbl->cell_cmds) {
       if(cmd_tbl->pre_cmds)
         free(cmd_tbl->pre_cmds);
@@ -814,7 +1462,7 @@
   }
 }
 
-static int ifoRead_PGC_PROGRAM_MAP(ifo_handle_t *ifofile,
+static int ifoRead_PGC_PROGRAM_MAP(ifo_handle_v_t *ifofile,
                                    pgc_program_map_t *program_map,
                                    unsigned int nr, unsigned int offset) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
@@ -829,7 +1477,7 @@
   return 1;
 }
 
-static int ifoRead_CELL_PLAYBACK_TBL(ifo_handle_t *ifofile,
+static int ifoRead_CELL_PLAYBACK_TBL(ifo_handle_v_t *ifofile,
                                      cell_playback_t *cell_playback,
                                      unsigned int nr, unsigned int offset) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
@@ -855,7 +1503,7 @@
 }
 
 
-static int ifoRead_CELL_POSITION_TBL(ifo_handle_t *ifofile,
+static int ifoRead_CELL_POSITION_TBL(ifo_handle_v_t *ifofile,
                                      cell_position_t *cell_position,
                                      unsigned int nr, unsigned int offset) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
@@ -876,7 +1524,7 @@
   return 1;
 }
 
-static int ifoRead_PGC(ifo_handle_t *ifofile, pgc_t *pgc, unsigned int offset) {
+static int ifoRead_PGC(ifo_handle_v_t *ifofile, pgc_t *pgc, unsigned int offset) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   unsigned int i;
 
@@ -927,7 +1575,7 @@
   }
 
   if(pgc->command_tbl_offset != 0) {
-    pgc->command_tbl = calloc(1, sizeof(pgc_command_tbl_t));
+    pgc->command_tbl = (pgc_command_tbl_t*)calloc(1, sizeof(pgc_command_tbl_t));
     if(!pgc->command_tbl)
       return 0;
 
@@ -940,7 +1588,7 @@
   }
 
   if(pgc->program_map_offset != 0 && pgc->nr_of_programs>0) {
-    pgc->program_map = calloc(pgc->nr_of_programs, sizeof(pgc_program_map_t));
+    pgc->program_map = (pgc_program_map_t*)calloc(pgc->nr_of_programs, sizeof(pgc_program_map_t));
     if(!pgc->program_map) {
       return 0;
     }
@@ -953,7 +1601,7 @@
   }
 
   if(pgc->cell_playback_offset != 0 && pgc->nr_of_cells>0) {
-    pgc->cell_playback = calloc(pgc->nr_of_cells, sizeof(cell_playback_t));
+    pgc->cell_playback = (cell_playback_t*)calloc(pgc->nr_of_cells, sizeof(cell_playback_t));
     if(!pgc->cell_playback) {
       return 0;
     }
@@ -967,7 +1615,7 @@
   }
 
   if(pgc->cell_position_offset != 0 && pgc->nr_of_cells>0) {
-    pgc->cell_position = calloc(pgc->nr_of_cells, sizeof(cell_position_t));
+    pgc->cell_position = (cell_position_t*)calloc(pgc->nr_of_cells, sizeof(cell_position_t));
     if(!pgc->cell_position) {
       return 0;
     }
@@ -983,7 +1631,7 @@
   return 1;
 }
 
-int ifoRead_FP_PGC(ifo_handle_t *ifofile) {
+int ifoRead_FP_PGC(ifo_handle_v_t *ifofile) {
 
   if(!ifofile)
     return 0;
@@ -996,7 +1644,7 @@
   if(!ifofile->vmgi_mat->first_play_pgc)
     return 1;
 
-  ifofile->first_play_pgc = calloc(1, sizeof(pgc_t));
+  ifofile->first_play_pgc = (pgc_t*)calloc(1, sizeof(pgc_t));
   if(!ifofile->first_play_pgc)
     return 0;
 
@@ -1026,7 +1674,7 @@
   }
 }
 
-void ifoFree_FP_PGC(ifo_handle_t *ifofile) {
+void ifoFree_FP_PGC(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -1036,7 +1684,7 @@
 }
 
 
-int ifoRead_TT_SRPT(ifo_handle_t *ifofile) {
+int ifoRead_TT_SRPT(ifo_handle_v_t *ifofile) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   tt_srpt_t *tt_srpt;
   unsigned int i;
@@ -1054,7 +1702,7 @@
   if(!DVDFileSeek_(ifop->file, ifofile->vmgi_mat->tt_srpt * DVD_BLOCK_LEN))
     return 0;
 
-  tt_srpt = calloc(1, sizeof(tt_srpt_t));
+  tt_srpt = (tt_srpt_t*)calloc(1, sizeof(tt_srpt_t));
   if(!tt_srpt)
     return 0;
 
@@ -1075,7 +1723,7 @@
   }
   info_length = tt_srpt->last_byte + 1 - TT_SRPT_SIZE;
 
-  tt_srpt->title = calloc(1, info_length);
+  tt_srpt->title = (title_info_t*)calloc(1, info_length);
   if(!tt_srpt->title) {
     free(tt_srpt);
     ifofile->tt_srpt = NULL;
@@ -1137,7 +1785,7 @@
 }
 
 
-void ifoFree_TT_SRPT(ifo_handle_t *ifofile) {
+void ifoFree_TT_SRPT(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -1150,7 +1798,7 @@
 }
 
 
-int ifoRead_VTS_PTT_SRPT(ifo_handle_t *ifofile) {
+int ifoRead_VTS_PTT_SRPT(ifo_handle_v_t *ifofile) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   vts_ptt_srpt_t *vts_ptt_srpt = NULL;
   int info_length, i, j;
@@ -1169,7 +1817,7 @@
                    ifofile->vtsi_mat->vts_ptt_srpt * DVD_BLOCK_LEN))
     return 0;
 
-  vts_ptt_srpt = calloc(1, sizeof(vts_ptt_srpt_t));
+  vts_ptt_srpt = (vts_ptt_srpt_t*)calloc(1, sizeof(vts_ptt_srpt_t));
   if(!vts_ptt_srpt)
     return 0;
 
@@ -1193,7 +1841,7 @@
     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);
+  data = (uint32_t*)calloc(1, info_length);
   if(!data)
     goto fail;
 
@@ -1231,7 +1879,7 @@
 
   vts_ptt_srpt->ttu_offset = data;
 
-  vts_ptt_srpt->title = calloc(vts_ptt_srpt->nr_of_srpts, sizeof(ttu_t));
+  vts_ptt_srpt->title = (ttu_t*)calloc(vts_ptt_srpt->nr_of_srpts, sizeof(ttu_t));
   if(!vts_ptt_srpt->title)
     goto fail;
 
@@ -1251,7 +1899,7 @@
     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));
+    vts_ptt_srpt->titlei.ptt = (ptt_info_t*)calloc(n / 4, sizeof(ptt_info_t));
     if(!vts_ptt_srpt->titlei.ptt) {
       for(n = 0; n < i; n++)
         free(vts_ptt_srpt->titlen.ptt);
@@ -1297,7 +1945,7 @@
 }
 
 
-void ifoFree_VTS_PTT_SRPT(ifo_handle_t *ifofile) {
+void ifoFree_VTS_PTT_SRPT(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -1313,7 +1961,7 @@
 }
 
 
-int ifoRead_PTL_MAIT(ifo_handle_t *ifofile) {
+int ifoRead_PTL_MAIT(ifo_handle_v_t *ifofile) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   ptl_mait_t *ptl_mait;
   int info_length;
@@ -1331,7 +1979,7 @@
   if(!DVDFileSeek_(ifop->file, ifofile->vmgi_mat->ptl_mait * DVD_BLOCK_LEN))
     return 0;
 
-  ptl_mait = calloc(1, sizeof(ptl_mait_t));
+  ptl_mait = (ptl_mait_t*)calloc(1, sizeof(ptl_mait_t));
   if(!ptl_mait)
     return 0;
 
@@ -1355,7 +2003,7 @@
               <= 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);
+  ptl_mait->countries = (ptl_mait_country_t*)calloc(1, info_length);
   if(!ptl_mait->countries) {
     free(ptl_mait);
     ifofile->ptl_mait = NULL;
@@ -1400,7 +2048,7 @@
       return 0;
     }
     info_length = (ptl_mait->nr_of_vtss + 1) * sizeof(pf_level_t);
-    pf_temp = calloc(1, info_length);
+    pf_temp = (uint16_t*)calloc(1, info_length);
     if(!pf_temp) {
       free_ptl_mait(ptl_mait, i);
       ifofile->ptl_mait = NULL;
@@ -1416,7 +2064,7 @@
     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);
+    ptl_mait->countriesi.pf_ptl_mai = (pf_level_t*)calloc(1, info_length);
     if(!ptl_mait->countriesi.pf_ptl_mai) {
       free(pf_temp);
       free_ptl_mait(ptl_mait, i);
@@ -1437,7 +2085,7 @@
   return 1;
 }
 
-void ifoFree_PTL_MAIT(ifo_handle_t *ifofile) {
+void ifoFree_PTL_MAIT(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -1453,7 +2101,7 @@
   }
 }
 
-int ifoRead_VTS_TMAPT(ifo_handle_t *ifofile) {
+int ifoRead_VTS_TMAPT(ifo_handle_v_t *ifofile) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   vts_tmapt_t *vts_tmapt;
   uint32_t *vts_tmap_srp;
@@ -1477,7 +2125,7 @@
   if(!DVDFileSeek_(ifop->file, offset))
     return 0;
 
-  vts_tmapt = calloc(1, sizeof(vts_tmapt_t));
+  vts_tmapt = (vts_tmapt_t*)calloc(1, sizeof(vts_tmapt_t));
   if(!vts_tmapt)
     return 0;
 
@@ -1497,7 +2145,7 @@
 
   info_length = vts_tmapt->nr_of_tmaps * 4;
 
-  vts_tmap_srp = calloc(1, info_length);
+  vts_tmap_srp = (uint32_t*)calloc(1, info_length);
   if(!vts_tmap_srp) {
     free(vts_tmapt);
     ifofile->vts_tmapt = NULL;
@@ -1521,7 +2169,7 @@
 
   info_length = vts_tmapt->nr_of_tmaps * sizeof(vts_tmap_t);
 
-  vts_tmapt->tmap = calloc(1, info_length);
+  vts_tmapt->tmap = (vts_tmap_t*)calloc(1, info_length);
   if(!vts_tmapt->tmap) {
     free(vts_tmap_srp);
     free(vts_tmapt);
@@ -1551,7 +2199,7 @@
 
     info_length = vts_tmapt->tmapi.nr_of_entries * sizeof(map_ent_t);
 
-    vts_tmapt->tmapi.map_ent = calloc(1, info_length);
+    vts_tmapt->tmapi.map_ent = (map_ent_t*)calloc(1, info_length);
     if(!vts_tmapt->tmapi.map_ent) {
       ifoFree_VTS_TMAPT(ifofile);
       return 0;
@@ -1570,7 +2218,7 @@
   return 1;
 }
 
-void ifoFree_VTS_TMAPT(ifo_handle_t *ifofile) {
+void ifoFree_VTS_TMAPT(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -1588,7 +2236,7 @@
 }
 
 
-int ifoRead_TITLE_C_ADT(ifo_handle_t *ifofile) {
+int ifoRead_TITLE_C_ADT(ifo_handle_v_t *ifofile) {
 
   if(!ifofile)
     return 0;
@@ -1599,7 +2247,7 @@
   if(ifofile->vtsi_mat->vts_c_adt == 0) /* mandatory */
     return 0;
 
-  ifofile->vts_c_adt = calloc(1, sizeof(c_adt_t));
+  ifofile->vts_c_adt = (c_adt_t*)calloc(1, sizeof(c_adt_t));
   if(!ifofile->vts_c_adt)
     return 0;
 
@@ -1613,7 +2261,7 @@
   return 1;
 }
 
-int ifoRead_C_ADT(ifo_handle_t *ifofile) {
+int ifoRead_C_ADT(ifo_handle_v_t *ifofile) {
   unsigned int sector;
 
   if(!ifofile)
@@ -1631,7 +2279,7 @@
     return 0;
   }
 
-  ifofile->menu_c_adt = calloc(1, sizeof(c_adt_t));
+  ifofile->menu_c_adt = (c_adt_t*)calloc(1, sizeof(c_adt_t));
   if(!ifofile->menu_c_adt)
     return 0;
 
@@ -1644,7 +2292,7 @@
   return 1;
 }
 
-static int ifoRead_C_ADT_internal(ifo_handle_t *ifofile,
+static int ifoRead_C_ADT_internal(ifo_handle_v_t *ifofile,
                                   c_adt_t *c_adt, unsigned int sector) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   size_t i, info_length;
@@ -1677,7 +2325,7 @@
     c_adt->nr_of_vobs = info_length / sizeof(cell_adr_t);
   }
 
-  c_adt->cell_adr_table = calloc(1, info_length);
+  c_adt->cell_adr_table = (cell_adr_t*)calloc(1, info_length);
   if(!c_adt->cell_adr_table)
     return 0;
 
@@ -1711,7 +2359,7 @@
   }
 }
 
-void ifoFree_C_ADT(ifo_handle_t *ifofile) {
+void ifoFree_C_ADT(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -1719,7 +2367,7 @@
   ifofile->menu_c_adt = NULL;
 }
 
-void ifoFree_TITLE_C_ADT(ifo_handle_t *ifofile) {
+void ifoFree_TITLE_C_ADT(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -1727,7 +2375,7 @@
   ifofile->vts_c_adt = NULL;
 }
 
-int ifoRead_TITLE_VOBU_ADMAP(ifo_handle_t *ifofile) {
+int ifoRead_TITLE_VOBU_ADMAP(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return 0;
 
@@ -1737,7 +2385,7 @@
   if(ifofile->vtsi_mat->vts_vobu_admap == 0) /* mandatory */
     return 0;
 
-  ifofile->vts_vobu_admap = calloc(1, sizeof(vobu_admap_t));
+  ifofile->vts_vobu_admap = (vobu_admap_t*)calloc(1, sizeof(vobu_admap_t));
   if(!ifofile->vts_vobu_admap)
     return 0;
 
@@ -1751,7 +2399,7 @@
   return 1;
 }
 
-int ifoRead_VOBU_ADMAP(ifo_handle_t *ifofile) {
+int ifoRead_VOBU_ADMAP(ifo_handle_v_t *ifofile) {
   unsigned int sector;
 
   if(!ifofile)
@@ -1769,7 +2417,7 @@
     return 0;
   }
 
-  ifofile->menu_vobu_admap = calloc(1, sizeof(vobu_admap_t));
+  ifofile->menu_vobu_admap = (vobu_admap_t*)calloc(1, sizeof(vobu_admap_t));
   if(!ifofile->menu_vobu_admap)
     return 0;
 
@@ -1782,7 +2430,7 @@
   return 1;
 }
 
-static int ifoRead_VOBU_ADMAP_internal(ifo_handle_t *ifofile,
+static int ifoRead_VOBU_ADMAP_internal(ifo_handle_v_t *ifofile,
                                        vobu_admap_t *vobu_admap,
                                        unsigned int sector) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
@@ -1803,7 +2451,7 @@
      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);
+  vobu_admap->vobu_start_sectors = (uint32_t*)calloc(1, info_length);
   if(!vobu_admap->vobu_start_sectors) {
     return 0;
   }
@@ -1828,7 +2476,7 @@
   }
 }
 
-void ifoFree_VOBU_ADMAP(ifo_handle_t *ifofile) {
+void ifoFree_VOBU_ADMAP(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -1836,7 +2484,7 @@
   ifofile->menu_vobu_admap = NULL;
 }
 
-void ifoFree_TITLE_VOBU_ADMAP(ifo_handle_t *ifofile) {
+void ifoFree_TITLE_VOBU_ADMAP(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -1844,7 +2492,7 @@
   ifofile->vts_vobu_admap = NULL;
 }
 
-int ifoRead_PGCIT(ifo_handle_t *ifofile) {
+int ifoRead_PGCIT(ifo_handle_v_t *ifofile) {
 
   if(!ifofile)
     return 0;
@@ -1855,7 +2503,7 @@
   if(ifofile->vtsi_mat->vts_pgcit == 0) /* mandatory */
     return 0;
 
-  ifofile->vts_pgcit = calloc(1, sizeof(pgcit_t));
+  ifofile->vts_pgcit = (pgcit_t*)calloc(1, sizeof(pgcit_t));
   if(!ifofile->vts_pgcit)
     return 0;
 
@@ -1881,7 +2529,7 @@
   return -1;
 }
 
-static int ifoRead_PGCIT_internal(ifo_handle_t *ifofile, pgcit_t *pgcit,
+static int ifoRead_PGCIT_internal(ifo_handle_v_t *ifofile, pgcit_t *pgcit,
                                   unsigned int offset) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   int i, info_length;
@@ -1902,8 +2550,13 @@
      Titles with 0 PTTs. */
   CHECK_VALUE(pgcit->nr_of_pgci_srp < 10000); /* ?? seen max of 1338 */
 
+  if (pgcit->nr_of_pgci_srp == 0) {
+    pgcit->pgci_srp = NULL;
+    return 1;
+  }
+
   info_length = pgcit->nr_of_pgci_srp * PGCI_SRP_SIZE;
-  data = calloc(1, info_length);
+  data = (uint8_t*)calloc(1, info_length);
   if(!data)
     return 0;
 
@@ -1912,7 +2565,7 @@
     return 0;
   }
 
-  pgcit->pgci_srp = calloc(pgcit->nr_of_pgci_srp, sizeof(pgci_srp_t));
+  pgcit->pgci_srp = (pgci_srp_t*)calloc(pgcit->nr_of_pgci_srp, sizeof(pgci_srp_t));
   if(!pgcit->pgci_srp) {
     free(data);
     return 0;
@@ -1936,7 +2589,7 @@
       pgcit->pgci_srpi.pgc->ref_count++;
       continue;
     }
-    pgcit->pgci_srpi.pgc = calloc(1, sizeof(pgc_t));
+    pgcit->pgci_srpi.pgc = (pgc_t*)calloc(1, sizeof(pgc_t));
     if(!pgcit->pgci_srpi.pgc) {
       int j;
       for(j = 0; j < i; j++) {
@@ -1948,7 +2601,7 @@
     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
+      //E-One releases provide bogus PGC, ie: out of bound start_byte
       free(pgcit->pgci_srpi.pgc);
       pgcit->pgci_srpi.pgc = NULL;
     }
@@ -1975,7 +2628,7 @@
     *pgcit = NULL;
 }
 
-void ifoFree_PGCIT(ifo_handle_t *ifofile) {
+void ifoFree_PGCIT(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -1995,7 +2648,7 @@
   return -1;
 }
 
-int ifoRead_PGCI_UT(ifo_handle_t *ifofile) {
+int ifoRead_PGCI_UT(ifo_handle_v_t *ifofile) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   pgci_ut_t *pgci_ut;
   unsigned int sector;
@@ -2018,7 +2671,7 @@
     return 0;
   }
 
-  ifofile->pgci_ut = calloc(1, sizeof(pgci_ut_t));
+  ifofile->pgci_ut = (pgci_ut_t*)calloc(1, sizeof(pgci_ut_t));
   if(!ifofile->pgci_ut)
     return 0;
 
@@ -2045,7 +2698,7 @@
   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);
+  data = (uint8_t*)calloc(1, info_length);
   if(!data) {
     free(pgci_ut);
     ifofile->pgci_ut = NULL;
@@ -2058,7 +2711,7 @@
     return 0;
   }
 
-  pgci_ut->lu = calloc(pgci_ut->nr_of_lus, sizeof(pgci_lu_t));
+  pgci_ut->lu = (pgci_lu_t*)calloc(pgci_ut->nr_of_lus, sizeof(pgci_lu_t));
   if(!pgci_ut->lu) {
     free(data);
     free(pgci_ut);
@@ -2094,7 +2747,7 @@
       pgci_ut->lui.pgcit->ref_count++;
       continue;
     }
-    pgci_ut->lui.pgcit = calloc(1, sizeof(pgcit_t));
+    pgci_ut->lui.pgcit = (pgcit_t*)calloc(1, sizeof(pgcit_t));
     if(!pgci_ut->lui.pgcit) {
       unsigned int j;
       for(j = 0; j < i; j++) {
@@ -2126,7 +2779,7 @@
 }
 
 
-void ifoFree_PGCI_UT(ifo_handle_t *ifofile) {
+void ifoFree_PGCI_UT(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -2142,7 +2795,7 @@
   }
 }
 
-static int ifoRead_VTS_ATTRIBUTES(ifo_handle_t *ifofile,
+static int ifoRead_VTS_ATTRIBUTES(ifo_handle_v_t *ifofile,
                                   vts_attributes_t *vts_attributes,
                                   unsigned int offset) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
@@ -2196,7 +2849,7 @@
 
 
 
-int ifoRead_VTS_ATRT(ifo_handle_t *ifofile) {
+int ifoRead_VTS_ATRT(ifo_handle_v_t *ifofile) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   vts_atrt_t *vts_atrt;
   unsigned int i, info_length, sector;
@@ -2215,7 +2868,7 @@
   if(!DVDFileSeek_(ifop->file, sector * DVD_BLOCK_LEN))
     return 0;
 
-  vts_atrt = calloc(1, sizeof(vts_atrt_t));
+  vts_atrt = (vts_atrt_t*)calloc(1, sizeof(vts_atrt_t));
   if(!vts_atrt)
     return 0;
 
@@ -2237,7 +2890,7 @@
               VTS_ATRT_SIZE < vts_atrt->last_byte + 1);
 
   info_length = vts_atrt->nr_of_vtss * sizeof(uint32_t);
-  data = calloc(1, info_length);
+  data = (uint32_t*)calloc(1, info_length);
   if(!data) {
     free(vts_atrt);
     ifofile->vts_atrt = NULL;
@@ -2259,7 +2912,7 @@
   }
 
   info_length = vts_atrt->nr_of_vtss * sizeof(vts_attributes_t);
-  vts_atrt->vts = calloc(1, info_length);
+  vts_atrt->vts = (vts_attributes_t*)calloc(1, info_length);
   if(!vts_atrt->vts) {
     free(data);
     free(vts_atrt);
@@ -2276,7 +2929,7 @@
       return 0;
     }
 
-    /* This assert cant be in ifoRead_VTS_ATTRIBUTES */
+    /* This assert can't be in ifoRead_VTS_ATTRIBUTES */
     CHECK_VALUE(offset + vts_atrt->vtsi.last_byte <= vts_atrt->last_byte + 1);
     /* Is this check correct? */
   }
@@ -2285,7 +2938,7 @@
 }
 
 
-void ifoFree_VTS_ATRT(ifo_handle_t *ifofile) {
+void ifoFree_VTS_ATRT(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -2297,8 +2950,9 @@
   }
 }
 
+#ifndef DVDREAD_NO_TXTDT
 
-int ifoRead_TXTDT_MGI(ifo_handle_t *ifofile) {
+int ifoRead_TXTDT_MGI(ifo_handle_v_t *ifofile) {
   struct ifo_handle_private_s *ifop = PRIV(ifofile);
   txtdt_mgi_t *txtdt_mgi;
 
@@ -2316,7 +2970,7 @@
                    ifofile->vmgi_mat->txtdt_mgi * DVD_BLOCK_LEN))
     return 0;
 
-  txtdt_mgi = calloc(1, sizeof(txtdt_mgi_t));
+  txtdt_mgi = (txtdt_mgi_t*)calloc(1, sizeof(txtdt_mgi_t));
   if(!txtdt_mgi) {
     return 0;
   }
@@ -2333,7 +2987,7 @@
   return 1;
 }
 
-void ifoFree_TXTDT_MGI(ifo_handle_t *ifofile) {
+void ifoFree_TXTDT_MGI(ifo_handle_v_t *ifofile) {
   if(!ifofile)
     return;
 
@@ -2342,3 +2996,5 @@
     ifofile->txtdt_mgi = NULL;
   }
 }
+
+#endif // DVDREAD_NO_TXTDT

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/ifo_read.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/ifo_read.h Changed

@@ -22,8 +22,9 @@
 #ifndef LIBDVDREAD_IFO_READ_H
 #define LIBDVDREAD_IFO_READ_H
 
-#include "ifo_types.h"
-#include "dvdread/dvd_reader.h"
+#include <dvdread/ifo_types.h>
+#include <dvdread/attributes.h>
+#include <dvdread/dvd_reader.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -36,34 +37,39 @@
  * 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 );
+DVDREAD_API 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.
+ * demand. If the dvd_reader opened an DVD-Audio Disc, this will open the AMGI
  */
-ifo_handle_t *ifoOpenVMGI(dvd_reader_t *);
+DVDREAD_API ifo_handle_v_t *ifoOpenVMGI(dvd_reader_t *);
+DVDREAD_API ifo_handle_t* ifoOpenXMGI(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.
+ * demand. If the dvd_reader opened an DVD-Audio Disc, this will open the ATSI
  */
-ifo_handle_t *ifoOpenVTSI(dvd_reader_t *, int);
+DVDREAD_API ifo_handle_v_t *ifoOpenVTSI(dvd_reader_t *, int);
+DVDREAD_API ifo_handle_t* ifoOpenXTSI(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 *);
+DVDREAD_API void ifoClose(ifo_handle_t *);
+
+void ifoCloseV(ifo_handle_v_t*);
 
 void ifoAddRef(ifo_handle_t *);
+void ifoAddRefV(ifo_handle_v_t*);
 
 /**
  * The following functions are for reading only part of the VMGI/VTSI files.
@@ -78,7 +84,7 @@
  * 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 *);
+DVDREAD_API int ifoRead_PTL_MAIT(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_VTS_ATRT(ifofile);
@@ -88,7 +94,7 @@
  * video manager information file.  This fills in the ifofile->vts_atrt
  * structure and all its substructures.
  */
-int ifoRead_VTS_ATRT(ifo_handle_t *);
+DVDREAD_API int ifoRead_VTS_ATRT(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_TT_SRPT(ifofile);
@@ -97,7 +103,7 @@
  * 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 *);
+DVDREAD_API int ifoRead_TT_SRPT(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_VTS_PTT_SRPT(ifofile);
@@ -107,7 +113,7 @@
  * 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 *);
+DVDREAD_API int ifoRead_VTS_PTT_SRPT(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_FP_PGC(ifofile);
@@ -116,7 +122,7 @@
  * 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 *);
+DVDREAD_API int ifoRead_FP_PGC(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_PGCIT(ifofile);
@@ -127,7 +133,7 @@
  * the video title set information file.  This structure is mandatory, and must
  * be included in the VTSI file.
  */
-int ifoRead_PGCIT(ifo_handle_t *);
+DVDREAD_API int ifoRead_PGCIT(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_PGCI_UT(ifofile);
@@ -139,17 +145,17 @@
  * 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 *);
+DVDREAD_API int ifoRead_PGCI_UT(ifo_handle_v_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
+ * and all its substructures.  When present enables VOBU level time-based
  * seeking for One_Sequential_PGC_Titles.
  */
-int ifoRead_VTS_TMAPT(ifo_handle_t *);
+DVDREAD_API int ifoRead_VTS_TMAPT(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_C_ADT(ifofile);
@@ -161,7 +167,7 @@
  * 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 *);
+DVDREAD_API int ifoRead_C_ADT(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_TITLE_C_ADT(ifofile);
@@ -171,7 +177,7 @@
  * 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 *);
+DVDREAD_API int ifoRead_TITLE_C_ADT(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_VOBU_ADMAP(ifofile);
@@ -183,7 +189,7 @@
  * 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 *);
+DVDREAD_API int ifoRead_VOBU_ADMAP(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_TITLE_VOBU_ADMAP(ifofile);
@@ -193,7 +199,7 @@
  * 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 *);
+DVDREAD_API int ifoRead_TITLE_VOBU_ADMAP(ifo_handle_v_t *);
 
 /**
  * okay = ifoRead_TXTDT_MGI(ifofile);
@@ -203,7 +209,26 @@
  * manager information file.  This structure is mandatory, and must be included
  * in the VMGI file.
  */
-int ifoRead_TXTDT_MGI(ifo_handle_t *);
+DVDREAD_API int ifoRead_TXTDT_MGI(ifo_handle_v_t *);
+
+/**
+ * okay = ifoRead_TT(ifofile);
+ *
+ * Reads the Title Track Table in ATS IFO's.
+ * This structure. This structure is mandatory, and must be included
+ * in the AMGI file.
+ */
+DVDREAD_API int ifoRead_TT(ifo_handle_a_t *);
+
+/**
+ * okay = ifoRead_TIF(ifofile);
+ *
+ * Reads either table in AUDIO_TS.IFO based on the sector offset given,
+ * either 1,2. The first table being one with video titles, the second one
+ * without. This structure. This structure is mandatory, and must be included
+ * in the AMGI file.
+ */
+DVDREAD_API int ifoRead_TIF(ifo_handle_a_t *, int);
 
 /**
  * The following functions are used for freeing parsed sections of the
@@ -211,19 +236,20 @@
  * 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 *);
+DVDREAD_API void ifoFree_PTL_MAIT(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_VTS_ATRT(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_TT_SRPT(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_VTS_PTT_SRPT(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_FP_PGC(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_PGCIT(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_PGCI_UT(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_VTS_TMAPT(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_C_ADT(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_TITLE_C_ADT(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_VOBU_ADMAP(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_TITLE_VOBU_ADMAP(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_TXTDT_MGI(ifo_handle_v_t *);
+DVDREAD_API void ifoFree_TT(ifo_handle_a_t *);
 
 #ifdef __cplusplus
 };

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/ifo_types.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/ifo_types.h Changed

@@ -23,18 +23,14 @@
 #define LIBDVDREAD_IFO_TYPES_H
 
 #include <inttypes.h>
-#include "dvdread/dvd_reader.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
+#if defined(__GNUC__) || defined(__clang__)
+#   define ATTRIBUTE_PACKED __attribute__ ((packed))
+#  define PRAGMA_PACK 0
 #endif
 
 #if !defined(ATTRIBUTE_PACKED)
@@ -64,6 +60,7 @@
   uint8_t second;
   uint8_t frame_u; /* The two high bits are the frame rate. */
 } ATTRIBUTE_PACKED dvd_time_t;
+#define DVD_TIME_SIZE 4U
 
 /**
  * Type to store per-command data.
@@ -92,6 +89,7 @@
   unsigned char letterboxed          : 1;
   unsigned char film_mode            : 1;
 } ATTRIBUTE_PACKED video_attr_t;
+#define VIDEO_ATTR_SIZE  2U
 
 /**
  * Audio Attributes.
@@ -125,37 +123,39 @@
     } surround;
   } ATTRIBUTE_PACKED app_info;
 } ATTRIBUTE_PACKED audio_attr_t;
+#define AUDIO_ATTR_SIZE  8U
 
 
 /**
  * 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;
+  unsigned char zero1      : 7;
+  unsigned char ach0_gme   : 1;
+
+  unsigned char zero2      : 7;
+  unsigned char ach1_gme   : 1;
+
+  unsigned char zero3      : 4;
+  unsigned char ach2_gv1e  : 1;
+  unsigned char ach2_gv2e  : 1;
+  unsigned char ach2_gm1e  : 1;
+  unsigned char ach2_gm2e  : 1;
+
+  unsigned char zero4      : 4;
+  unsigned char ach3_gv1e  : 1;
+  unsigned char ach3_gv2e  : 1;
+  unsigned char ach3_gmAe  : 1;
+  unsigned char ach3_se2e  : 1;
+
+  unsigned char zero5      : 4;
+  unsigned char ach4_gv1e  : 1;
+  unsigned char ach4_gv2e  : 1;
+  unsigned char ach4_gmBe  : 1;
+  unsigned char ach4_seBe  : 1;
   uint8_t zero619;
 } ATTRIBUTE_PACKED multichannel_ext_t;
+#define MULTICHANNEL_EXT_SIZE  24U
 
 
 /**
@@ -180,6 +180,7 @@
   uint8_t  lang_extension;
   uint8_t  code_extension;
 } ATTRIBUTE_PACKED subp_attr_t;
+#define SUBP_ATTR_SIZE  6U
 
 
 
@@ -190,11 +191,8 @@
   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;
+  uint16_t last_byte;
+} ATTRIBUTE_PACKED pgc_command_tbl_data_t;
 #define PGC_COMMAND_TBL_SIZE 8U
 
 /**
@@ -224,6 +222,7 @@
   uint32_t last_vobu_start_sector;
   uint32_t last_sector;
 } ATTRIBUTE_PACKED cell_playback_t;
+#define CELL_PLAYBACK_SIZE  24U
 
 #define BLOCK_TYPE_NONE         0x0
 #define BLOCK_TYPE_ANGLE_BLOCK  0x1
@@ -241,6 +240,7 @@
   uint8_t  zero_1;
   uint8_t  cell_nr;
 } ATTRIBUTE_PACKED cell_position_t;
+#define CELL_POSITION_SIZE 4U
 
 /**
  * User Operations.
@@ -276,6 +276,7 @@
   uint32_t chapter_search_or_play         : 1;
   uint32_t title_or_time_play             : 1; /* 0 */
 } ATTRIBUTE_PACKED user_ops_t;
+#define USER_OPS_SIZE  4U
 
 /**
  * Program Chain Information.
@@ -298,12 +299,7 @@
   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;
+} ATTRIBUTE_PACKED pgc_data_t;
 #define PGC_SIZE 236U
 
 /**
@@ -316,8 +312,7 @@
   uint8_t  zero_1   : 4;
   uint16_t ptl_id_mask;
   uint32_t pgc_start_byte;
-  pgc_t *pgc;
-} ATTRIBUTE_PACKED pgci_srp_t;
+} ATTRIBUTE_PACKED pgci_srp_data_t;
 #define PGCI_SRP_SIZE 8U
 
 /**
@@ -327,9 +322,7 @@
   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;
+} ATTRIBUTE_PACKED pgcit_data_t;
 #define PGCIT_SIZE 8U
 
 /**
@@ -340,8 +333,7 @@
   uint8_t  lang_extension;
   uint8_t  exists;
   uint32_t lang_start_byte;
-  pgcit_t *pgcit;
-} ATTRIBUTE_PACKED pgci_lu_t;
+} ATTRIBUTE_PACKED pgci_lu_data_t;
 #define PGCI_LU_SIZE 8U
 
 /**
@@ -351,8 +343,7 @@
   uint16_t nr_of_lus;
   uint16_t zero_1;
   uint32_t last_byte;
-  pgci_lu_t *lu;
-} ATTRIBUTE_PACKED pgci_ut_t;
+} ATTRIBUTE_PACKED pgci_ut_data_t;
 #define PGCI_UT_SIZE 8U
 
 /**
@@ -365,6 +356,7 @@
   uint32_t start_sector;
   uint32_t last_sector;
 } ATTRIBUTE_PACKED cell_adr_t;
+#define CELL_ADDR_SIZE  12U
 
 /**
  * Cell Address Table.
@@ -373,8 +365,7 @@
   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;
+} ATTRIBUTE_PACKED c_adt_data_t;
 #define C_ADT_SIZE 8U
 
 /**
@@ -382,13 +373,9 @@
  */
 typedef struct {
   uint32_t last_byte;
-  uint32_t *vobu_start_sectors;
-} ATTRIBUTE_PACKED vobu_admap_t;
+} ATTRIBUTE_PACKED vobu_admap_data_t;
 #define VOBU_ADMAP_SIZE 4U
 
-
-
-
 /**
  * VMGI
  *
@@ -437,6 +424,157 @@
   subp_attr_t  vmgm_subp_attr;
   subp_attr_t  zero_1027;  /* XXX: how much 'padding' here? */
 } ATTRIBUTE_PACKED vmgi_mat_t;
+#define VMGI_MAT_SIZE 510U
+
+/* Downmix coefficients can be used to reduce 5.1 channels to stereo in DVD-Audio Discs */
+/** Downmix equations
+ * Left_out  = Lf_left  * Lf
+ *           + Rf_left  * Rf
+ *           + C_left   * C
+ *           + LFE_left * LFE
+ *           + Ls_left  * Ls
+ *           + Rs_left  * Rs;
+ *
+ * Right_out = Lf_right  * Lf
+ *           + Rf_right  * Rf
+ *           + C_right   * C
+ *           + LFE_right * LFE
+ *           + Ls_right  * Ls
+ *           + Rs_right  * Rs;
+ *
+ * Where:
+ *   - Lf, Rf, C, LFE, Ls, Rs are the 5.1 input channels
+ *   - Left_out, Right_out are the stereo output channels
+ *   - Each coefficient (e.g. Lf_left, C_right) is an 8-bit gain factor
+ */
+
+typedef struct {
+  /* it seems each entry is started and ended with padding */
+  uint16_t zero_1;
+  /* each coefficient corresponds to stereo side for a channel in 5.1 */
+  uint8_t Lf_left;
+  uint8_t Lf_right;
+  uint8_t Rf_left;
+  uint8_t Rf_right;
+  uint8_t C_left;
+  uint8_t C_right;
+  uint8_t LFE_left;
+  uint8_t LFE_right;
+  uint8_t Ls_left;
+  uint8_t Ls_right;
+  uint8_t Rs_left;
+  uint8_t Rs_right;
+
+  uint16_t zero_2;
+} ATTRIBUTE_PACKED downmix_coeff_t;
+#define DOWNMIX_COEFF_SIZE 16U
+
+
+/**
+ * SAMG
+ *
+ * The following structures relate to the Simple Audio Manager, exclusive to DVD-Audio discs
+ */
+
+/**
+ * This is one of two of the DVD-A content managers, for simple audio dvd only players
+ */
+
+typedef struct {
+  uint16_t zero_1;
+  uint8_t  group_num;
+  uint8_t  chapter_num; /* chapter number within group*/
+  uint32_t timestamp_pts; /* this is MPEG time, Not DVD time */
+  uint32_t chapter_len;
+  uint32_t zero_2;
+  uint8_t  record_code;
+  uint8_t  bit_depth;
+  uint8_t  sampling_rate;
+  uint8_t  nr_channels;
+  /* some DVD's made with authoring software keep downmix coefficients here */
+  /* since I do not have samples of commercial discs that do this, I will not include it */
+  uint8_t  zero_320;
+  uint32_t start_sector_1; /*aob start sector*/
+  uint32_t start_sector_2; /*aob start sector is repeated again */
+  uint32_t end_sector;
+} ATTRIBUTE_PACKED samg_chapter_t;
+#define SAMG_CHAPTER_SIZE 52U
+
+typedef struct {
+  char           samg_identifier12;
+  uint16_t       nr_chapters;
+  uint16_t       specification_version;
+} ATTRIBUTE_PACKED samg_mat_data_t;
+#define SAMG_MAT_SIZE 16U
+
+/**
+ * AMGI
+ *
+ * The following structures relate to the Audio Manager, exclusive to DVD-Audio discs
+ */
+
+/**
+ * Audio Manager Information Management Table.
+ */
+typedef struct {
+  char     amg_identifier12;
+  uint32_t amg_start_sector;
+  uint8_t  zero_112;
+  uint32_t amgi_last_sector;
+  uint16_t specification_version;
+  uint8_t  zero_24;
+  uint16_t amg_nr_of_volumes;
+  uint16_t amg_this_volume_nr;
+  uint8_t  disc_side;
+  uint8_t  zero_34;
+  uint8_t  autoplay;
+  uint32_t audio_sv_ifo_relative_p;
+  uint16_t unknown_1; /* some discs have a value here, undocumented in DVD-Audio specs */
+  uint8_t  zero_48;
+  uint8_t  vmg_nr_of_title_sets;  /* Number of video titlesets in audio zone. */
+  uint8_t  amg_nr_of_title_sets;  /* Number of audio titlesets in audio zone. */
+  uint8_t  unknown_232; /* may be set to zeros */
+  uint8_t  unknown_38; /* may be set to zeros */
+  uint8_t  zero_524;
+  uint32_t amg_end_byte_address;
+  uint8_t  unknown_44; /* may be set to zeros */
+  uint8_t  zero_656;
+  uint16_t menu_prescence_1; /* may be set to zero, or some other value, optional field*/
+  uint8_t  unknown_54;
+  uint16_t unknown_6; /* should be 0x01 */
+  uint8_t  zero_72;
+  uint16_t amg_nr_of_zones; /* may be set to 0x02*/
+  uint8_t  zero_82;
+  uint16_t menu_prescence_2; /* may be set to 0x03*/
+  uint8_t  zero_948;
+  uint8_t  last_sector_audio_sys_space;
+  uint8_t  zero_1079;
+  uint8_t  menu_prescence_3; /* will be set to 0x01*/
+    /* XXX lots of padding after this to complete the sector*/
+} ATTRIBUTE_PACKED amgi_mat_t;
+#define AMGI_MAT_SIZE 337U
+
+/* Sector 2 may have video tracks, sector 3 will not. If there are no video tracks the tables will be the same*/
+
+/*this struct repeats for every audio or video track*/
+typedef struct {
+  uint8_t  type_and_rank; /*first nibble is type, second rank, from 1-9*/
+  uint8_t  nr_chapters_in_title;
+  uint8_t  nr_visible_chapters_in_vts_title; /* this will be zeros in an audio record */
+  uint8_t  zero_1;
+  uint32_t len_audio_zone_pts; /* this is MPEG time, Not DVD time */
+
+  uint8_t  group_property; /* in a video track, this is video titleset number, in audio its rank of group */
+  uint8_t  title_property; /* in video track this is title number , in audio track this is rank of title*/
+  uint32_t ts_pointer_relative_sector; /* for ats or vts*/
+} ATTRIBUTE_PACKED track_info_t;
+#define TRACK_INFO_SIZE 14U
+
+typedef struct {
+  uint16_t     nr_of_titles;
+  uint16_t     last_byte_in_table;
+} ATTRIBUTE_PACKED tracks_info_table_data_t;
+#define TRACKS_INFO_TABLE_SIZE 4U
 
 typedef struct {
   uint8_t zero_1                    : 1;
@@ -448,6 +586,7 @@
   uint8_t chapter_search_or_play    : 1; /* UOP 1 */
   uint8_t title_or_time_play        : 1; /* UOP 0 */
 } ATTRIBUTE_PACKED playback_type_t;
+#define PLAYBACK_TYPE_SIZE 1U
 
 /**
  * Title Information.
@@ -461,6 +600,7 @@
   uint8_t  vts_ttn;
   uint32_t title_set_sector;
 } ATTRIBUTE_PACKED title_info_t;
+#define TITLE_INFO_SIZE 12U
 
 /**
  * PartOfTitle Search Pointer Table.
@@ -469,11 +609,9 @@
   uint16_t nr_of_srpts;
   uint16_t zero_1;
   uint32_t last_byte;
-  title_info_t *title;
-} ATTRIBUTE_PACKED tt_srpt_t;
+} ATTRIBUTE_PACKED tt_srpt_data_t;
 #define TT_SRPT_SIZE 8U
 
-
 /**
  * Parental Management Information Unit Table.
  * Level 1 (US: G), ..., 7 (US: NC-17), 8
@@ -489,8 +627,7 @@
   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;
+} ATTRIBUTE_PACKED ptl_mait_country_data_t;
 #define PTL_MAIT_COUNTRY_SIZE 8U
 
 /**
@@ -500,8 +637,7 @@
   uint16_t nr_of_countries;
   uint16_t nr_of_vtss;
   uint32_t last_byte;
-  ptl_mait_country_t *countries;
-} ATTRIBUTE_PACKED ptl_mait_t;
+} ATTRIBUTE_PACKED ptl_mait_data_t;
 #define PTL_MAIT_SIZE 8U
 
 /**
@@ -543,9 +679,7 @@
   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;
+} ATTRIBUTE_PACKED vts_atrt_data_t;
 #define VTS_ATRT_SIZE 8U
 
 /**
@@ -562,13 +696,14 @@
   uint8_t unknown1;
   uint8_t unknown2;
   uint8_t unknown3;
-  uint8_t unknown4; /* ?? allways 0x30 language?, text format? */
+  uint8_t unknown4; /* ?? always 0x30 language?, text format? */
   uint8_t unknown5;
   uint16_t offset; /* from first */
 
   char text12; /* ended by 0x09 */
 #endif
 } ATTRIBUTE_PACKED txtdt_t;
+#define TXTDT_SIZE 204U
 
 /**
  * Text Data Language Unit. (Incomplete)
@@ -578,8 +713,7 @@
   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;
+} ATTRIBUTE_PACKED txtdt_lu_data_t;
 #define TXTDT_LU_SIZE 8U
 
 /**
@@ -587,14 +721,12 @@
  */
 typedef struct {
   char disc_name12;
-  uint16_t zero_1;
+  uint16_t unknown1;
   uint16_t nr_of_language_units;
   uint32_t last_byte;
-  txtdt_lu_t *lu;
-} ATTRIBUTE_PACKED txtdt_mgi_t;
+} ATTRIBUTE_PACKED txtdt_mgi_data_t;
 #define TXTDT_MGI_SIZE 20U
 
-
 /**
  * VTS
  *
@@ -657,6 +789,114 @@
   multichannel_ext_t vts_mu_audio_attr8;
   /* XXX: how much 'padding' here, if any? */
 } ATTRIBUTE_PACKED vtsi_mat_t;
+#define VTSI_MAT_SIZE 984U
+
+
+typedef struct {
+  /* 0x0000 for lpcm or 0x0100 for mlp, DTS seems to be 0x0500 and has different fields*/
+  uint8_t encoding;
+  uint8_t unknown1;
+  /* for stereo 0f 16 bit, 1f 20 bit, 2f 24 bit*/
+  /* f is a placeholder for the nibbles that is used for channel groups*/
+  /* otherwise if its 5.1 channels each nibble represents a channel group (G1, G2),*/
+  uint8_t  bitrate;
+  /* 8f 44khz, 0f 48khz, 1f 96khz, 2f 192khz*/
+  /* otherwise if its 5.1 channels each nibble represents a channel group (G1, G2)*/
+  uint8_t  sampling_frequency;
+  /* 00 1 channel, 01 2 channels, 11 5.1 channels*/
+  uint8_t  nr_channels;
+  uint8_t  unknown2;
+  uint8_t zero10;
+} ATTRIBUTE_PACKED atsi_record_t;
+#define ATSI_RECORD_SIZE 16U
+
+/**
+ * ATS
+ *
+ * Structures relating to the Audio Title Set (ATS).
+ */
+
+/**
+ * Audio Title Set Information Management Table. Exclusive to DVD-Audio discs
+ */
+#define ATSI_RECORD_MAX_SIZE 8
+#define DOWNMIX_COEFF_MAX_SIZE 16
+
+typedef struct {
+  char          ats_identifier12;
+  uint32_t      ats_last_sector; /* last sector of ATS_XX_0.BUP*/
+  uint8_t       zero_112;
+  uint32_t      atsi_last_sector; /* last sector of ATS_XX_0.IFO*/
+  uint16_t      specification_version;
+  uint32_t      unknown_1;
+  uint8_t       zero_290;
+  uint32_t      atsi_last_byte;
+  uint8_t       zero_360;
+  uint32_t      vtsm_vobs;       /* may be zeros */
+  uint32_t      atst_aobs;       /* atst or vtst */
+  uint32_t      vts_ptt_srpt;    /* may be zeros */
+  uint32_t      ats_pgci_ut;    /* sector */
+  uint32_t      vtsm_pgci_ut;    /* may be zeros */
+  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_424;
+  /* the majority, or even all of these entries may be zero*/
+  atsi_record_t atsi_recordATSI_RECORD_MAX_SIZE;
+  downmix_coeff_t downmix_coefficientsDOWNMIX_COEFF_MAX_SIZE;
+} ATTRIBUTE_PACKED atsi_mat_t;
+#define ATSI_MAT_SIZE 640U
+
+typedef struct {
+  uint16_t unknown_1; /* appears to be index, +0x100 for each iter*/
+  uint16_t unkown_2; /* either 0x0000 or 0x0100*/
+  uint32_t offset_record_table;
+} ATTRIBUTE_PACKED atsi_title_index_t;
+#define ATSI_TITLE_INDEX_SIZE 8U
+
+/* this will be repeated for each track in each title*/
+typedef struct {
+  uint16_t unknown_1; /* will be 0x0000*/
+  uint16_t unknown_2; /* will be 0x0000*/
+  uint8_t  track_number_in_title;
+  uint8_t  unknown_3; /* will be 0x00*/
+  uint32_t first_pts_of_track; /* this is MPEG time, Not DVD time */
+
+  uint32_t length_pts_of_track; /* this is MPEG time, Not DVD time */
+
+  uint8_t  zero6;
+} ATTRIBUTE_PACKED atsi_track_timestamp_t;
+#define ATSI_TRACK_TIMESTAMP_SIZE 20U
+
+/* this will come after all of the track timstamps, a set of 12byte sector pointer records. One for each track*/
+typedef struct {
+  uint32_t unknown_1; /* will be 0x01000000*/
+  uint32_t start_sector; /* relative to first AOB file*/
+  uint32_t end_sector; /* relative to first end of AOB file */
+} ATTRIBUTE_PACKED atsi_track_pointer_t;
+#define ATSI_TRACK_POINTER_SIZE 12U
+
+typedef struct {
+  uint16_t unknown_1; /* will be 0x0000*/
+  uint8_t  nr_tracks; /* unsure if this holds up for other files*/
+  uint8_t  nr_pointer_records; /* unsure if this holds up for other files*/
+  uint32_t length_pts; /* this is MPEG time, Not DVD time */
+
+  uint16_t unknown_3; /* will be 0x0000*/
+  uint16_t unknown_4; /* will be 0x0010*/
+  uint16_t start_sector_pointers_table; /* pointer to start of sector pointers table, relative to start of title record*/
+  uint16_t unknown_5; /* will be 0x0000*/
+} ATTRIBUTE_PACKED atsi_title_record_data_t;
+#define ATSI_TITLE_ROW_TABLE_SIZE 16U
+
+typedef struct {
+  uint16_t               nr_titles;
+  uint16_t               zero_1;
+  uint32_t               last_byte_address;
+} ATTRIBUTE_PACKED atsi_title_table_data_t;
+#define ATSI_TITLE_TABLE_SIZE 8U
 
 /**
  * PartOfTitle Unit Information.
@@ -665,14 +905,15 @@
   uint16_t pgcn;
   uint16_t pgn;
 } ATTRIBUTE_PACKED ptt_info_t;
+#define PTT_INFO_SIZE  4U
 
 /**
  * PartOfTitle Information.
  */
 typedef struct {
   uint16_t nr_of_ptts;
-  ptt_info_t *ptt;
-} ATTRIBUTE_PACKED ttu_t;
+} ATTRIBUTE_PACKED ttu_data_t;
+#define TTU_SIZE 2U
 
 /**
  * PartOfTitle Search Pointer Table.
@@ -681,12 +922,9 @@
   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;
+} ATTRIBUTE_PACKED vts_ptt_srpt_data_t;
 #define VTS_PTT_SRPT_SIZE 8U
 
-
 /**
  * Time Map Entry.
  */
@@ -700,8 +938,7 @@
   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;
+} ATTRIBUTE_PACKED vts_tmap_data_t;
 #define VTS_TMAP_SIZE 4U
 
 /**
@@ -711,16 +948,134 @@
   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;
+} ATTRIBUTE_PACKED vts_tmapt_data_t;
 #define VTS_TMAPT_SIZE 8U
 
-
 #if PRAGMA_PACK
 #pragma pack(pop)
 #endif
 
+struct pgc_command_tbl_t : pgc_command_tbl_data_t {
+    vm_cmd_t* pre_cmds;
+    vm_cmd_t* post_cmds;
+    vm_cmd_t* cell_cmds;
+};
+
+struct pgc_t : pgc_data_t
+{
+    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;
+};
+
+struct pgci_srp_t : pgci_srp_data_t
+{
+    pgc_t* pgc;
+};
+
+struct pgcit_t : pgcit_data_t
+{
+    pgci_srp_t* pgci_srp;
+    int      ref_count;
+};
+
+struct pgci_lu_t : pgci_lu_data_t
+{
+    pgcit_t* pgcit;
+};
+
+struct pgci_ut_t : pgci_ut_data_t
+{
+    pgci_lu_t* lu;
+};
+
+struct c_adt_t : c_adt_data_t
+{
+    cell_adr_t* cell_adr_table;  /* No explicit size given. */
+};
+
+struct vobu_admap_t : vobu_admap_data_t
+{
+    uint32_t* vobu_start_sectors;
+};
+
+struct tt_srpt_t : tt_srpt_data_t
+{
+    title_info_t* title;
+};
+
+struct ptl_mait_country_t : ptl_mait_country_data_t
+{
+    pf_level_t* pf_ptl_mai; /* table of (nr_of_vtss + 1), video_ts is first */
+};
+
+struct ptl_mait_t : ptl_mait_data_t
+{
+    ptl_mait_country_t* countries;
+};
+
+struct vts_atrt_t : vts_atrt_data_t
+{
+    vts_attributes_t* vts;
+    uint32_t* vts_atrt_offsets; /* offsets table for each vts_attributes */
+};
+
+struct txtdt_lu_t : txtdt_lu_data_t
+{
+    txtdt_t* txtdt;
+};
+
+struct txtdt_mgi_t : txtdt_mgi_data_t
+{
+    txtdt_lu_t* lu;
+};
+
+struct ttu_t : ttu_data_t
+{
+    ptt_info_t* ptt;
+};
+
+struct vts_ptt_srpt_t : vts_ptt_srpt_data_t
+{
+    ttu_t* title;
+    uint32_t* ttu_offset; /* offset table for each ttu */
+};
+
+struct vts_tmap_t : vts_tmap_data_t
+{
+    map_ent_t* map_ent;
+};
+
+struct vts_tmapt_t : vts_tmapt_data_t
+{
+    vts_tmap_t* tmap;
+    uint32_t* tmap_offset; /* offset table for each tmap */
+};
+
+struct samg_mat_t : samg_mat_data_t
+{
+    samg_chapter_t* samg_chapters;
+};
+
+struct tracks_info_table_t : tracks_info_table_data_t
+{
+    track_info_t* tracks_info;
+};
+
+struct atsi_title_record_t : atsi_title_record_data_t
+{
+    atsi_track_timestamp_t* atsi_track_timestamp_rows; /*length determined by nr_tracks*/
+    atsi_track_pointer_t* atsi_track_pointer_rows;
+};
+
+struct atsi_title_table_t : atsi_title_table_data_t
+{
+    atsi_title_index_t* atsi_index_rows;   /* length determined by nr_titles*/
+    atsi_title_record_t* atsi_title_row_tables;   /* length determined by nr_titles*/
+};
+
 
 /**
  * The following structure defines an IFO file.  The structure is divided into
@@ -728,29 +1083,63 @@
  * 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;
+typedef enum{
+    IFO_UNKNOWN,
+    IFO_VIDEO,
+    IFO_AUDIO
+} ifo_format_t;
+
+/* format type will be used in order to reduce ammount of code refactoring, hopefully add some
+ * detection mechanism later as well.
+ * */
+    struct ifo_handle_v_t {
+      /* 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;
+    };
+
+    struct ifo_handle_a_t {
+      /* SAMG */
+      samg_mat_t             *samg_mat;
+
+      /* AMGI */
+      amgi_mat_t             *amgi_mat;
+      tracks_info_table_t    *info_table_first_sector;
+      tracks_info_table_t    *info_table_second_sector;
+
+      /* ATSI */
+      atsi_mat_t             *atsi_mat;
+      atsi_title_table_t     *atsi_title_table;
+    };
 
-  /* 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;
 
+typedef struct {
+    union {
+        ifo_handle_v_t v;
+        ifo_handle_a_t a;
+    } u;
+
+  ifo_format_t ifo_format;
   int            refcount;
+
 } ifo_handle_t;
 
 #endif /* LIBDVDREAD_IFO_TYPES_H */

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/logger.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/logger.h Changed

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/nav_read.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/nav_read.h Changed

@@ -21,7 +21,8 @@
 #ifndef LIBDVDREAD_NAV_READ_H
 #define LIBDVDREAD_NAV_READ_H
 
-#include "nav_types.h"
+#include <dvdread/attributes.h>
+#include <dvdread/nav_types.h>
 
 /**
  * Parsing of NAV data, PCI and DSI parts.
@@ -35,17 +36,17 @@
  * 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.
+ * @param buffer Pointer to the buffer of the on disc PCI data.
  */
-void navRead_PCI(pci_t *, unsigned char *);
+DVDREAD_API 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.
+ * @param buffer Pointer to the buffer of the on disc DSI data.
  */
-void navRead_DSI(dsi_t *, unsigned char *);
+DVDREAD_API void navRead_DSI(dsi_t *, unsigned char *);
 
 #ifdef __cplusplus
 };

makemkv-oss-1.18.1.tar.gz/mmgpl/dvdread/nav_types.h -> makemkv-oss-1.18.2.tar.gz/mmgpl/dvdread/nav_types.h Changed

@@ -10,7 +10,7 @@
  * 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
+ * under the terms of the GNU General Public License version 2 or version 3 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.
@@ -29,7 +29,9 @@
 #define LIBDVDREAD_NAV_TYPES_H
 
 #include <inttypes.h>
-#include "ifo_types.h" /* only dvd_time_t, vm_cmd_t and user_ops_t */
+
+#include <dvdread/attributes.h>
+#include <dvdread/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
@@ -82,14 +84,14 @@
   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 */
+  unsigned char zero1 : 2;          /**< reserved */
+  unsigned char btngr_ns : 2;       /**< number of button groups 1, 2 or 3 with 36/18/12 buttons */
+  unsigned char zero2 : 1;          /**< reserved */
+  unsigned char btngr1_dsp_ty : 3;  /**< display type of subpic stream for button group 1 */
+  unsigned char zero3 : 1;          /**< reserved */
+  unsigned char btngr2_dsp_ty : 3;  /**< display type of subpic stream for button group 2 */
+  unsigned char zero4 : 1;          /**< reserved */
+  unsigned char 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 */
@@ -101,7 +103,7 @@
 
 /**
  * Button Color Information Table
- * Each entry beeing a 32bit word that contains the color indexs and alpha
+ * Each entry is a 32bit word that contains the color indices 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.

makemkv-sha-1.18.1.txt -> makemkv-sha-1.18.2.txt Changed

@@ -1,15 +1,15 @@
 -----BEGIN PGP SIGNED MESSAGE-----
 Hash: SHA256
 
-97a5e8688c5f57f57396750f7139cab35b5349e6138d1b6e00c6a9b1fcdf1517  Setup_MakeMKV_v1.18.1.exe
-b16576651eadec3585e817843a2a1a0ebcaa713b89dd1e020d8b1d056ddb2fd6  makemkv-bin-1.18.1.tar.gz
-dc47eefb1e68f7d539e4b079bb93ce64144104ad233de56818939810ecd03b7b  makemkv-oss-1.18.1.tar.gz
-83e696df93e9add8981d0a51f3b8f20804e6a1a3c4ce341705dcee64932c2a08  makemkv_v1.18.1_osx.dmg
+01e3f9455070c5097c602cb83c8204e2541c122d44d1e7c52080ad6559a82778  Setup_MakeMKV_v1.18.2.exe
+bfc4c7cebc0f00497671ffd56e6a34f0770a9e6af7eff2f0127efa143f28636e  makemkv-bin-1.18.2.tar.gz
+b9497f5555c257f5d3c7f18b6ab03c74cff3ea4437e80349d618d115bf5fa445  makemkv-oss-1.18.2.tar.gz
+aa0f3cdd936061846946b8e7ab3b735006287c27b8853b2b8b15d428789f981f  makemkv_v1.18.2_osx.dmg
 -----BEGIN PGP SIGNATURE-----
 Version: GnuPG v2
 
-iHUEAREIAB0WIQQuzyMwXx/AsyABZzOU4wg6GAQmlwUCZ/F4aAAKCRCU4wg6GAQm
-l3iPAP9lI0/4o7hzkVZZaCfLunZDoZOPvKlkSz25AI0DScypfQD+LEcPnYREC8u3
-KW3yHvJ5HHf+NDGED7hJexp0DqRYhTM=
-=omfy
+iHUEAREIAB0WIQQuzyMwXx/AsyABZzOU4wg6GAQmlwUCaNWtPAAKCRCU4wg6GAQm
+l9r0AP9ADkR68RJw484i9lDaRFqMD7/sBZmgKavh/OWtspjXawD+LEgOGokAY2pQ
+MqNzKxw9KmHWRnfPhgx2iSs3yN44tFQ=
+=ZCEy
 -----END PGP SIGNATURE-----

Build Results
RPM Lint

Refresh

Comments for request 6326 0

Request History

manfred-h created request 2 months ago

- Update to version 1.18.2
* Improved handling for discs with mastering errors
* Small improvements and bugfixes
- Remove now obsolete silence-return-type.patch

enzokiel accepted request about 2 months ago