dvdread/ifo_read.c

   1 /*
   2  * Copyright (C) 2000, 2001, 2002, 2003
   3  *               Björn Englund <d4bjorn@dtek.chalmers.se>,
   4  *               Håkan Hjort <d95hjort@dtek.chalmers.se>
   5  *
   6  * Modified for use with MPlayer, changes contained in libdvdread_changes.diff.
   7  * detailed changelog at http://svn.mplayerhq.hu/mplayer/trunk/
   8  * $Id$
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  23  */
  24
  25 #include "config.h"
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <inttypes.h>
  30 #include <string.h>
  31
  32 #include "bswap.h"
  33 #include "ifo_types.h"
  34 #include "ifo_read.h"
  35 #include "dvd_reader.h"
  36 #include "dvdread_internal.h"
  37
  38 #ifndef DVD_BLOCK_LEN
  39 #define DVD_BLOCK_LEN 2048
  40 #endif
  41
  42 #ifndef NDEBUG
  43 #define CHECK_ZERO0(arg) \
  44   if(arg != 0) { \
  45     fprintf(stderr, "*** Zero check failed in %s:%i\n    for %s = 0x%x\n", \
  46             __FILE__, __LINE__, # arg, arg); \
  47   }
  48 #define CHECK_ZERO(arg) \
  49   if(memcmp(my_friendly_zeros, &arg, sizeof(arg))) { \
  50     unsigned int i_CZ; \
  51     fprintf(stderr, "*** Zero check failed in %s:%i\n    for %s = 0x", \
  52             __FILE__, __LINE__, # arg ); \
  53     for(i_CZ = 0; i_CZ < sizeof(arg); i_CZ++) \
  54       fprintf(stderr, "%02x", *((uint8_t *)&arg + i_CZ)); \
  55     fprintf(stderr, "\n"); \
  56   }
  57 static const uint8_t my_friendly_zeros[2048];
  58 #else
  59 #define CHECK_ZERO0(arg) (void)(arg)
  60 #define CHECK_ZERO(arg) (void)(arg)
  61 #endif
  62
  63
  64 /* Prototypes for internal functions */
  65 static int ifoRead_VMG(ifo_handle_t *ifofile);
  66 static int ifoRead_VTS(ifo_handle_t *ifofile);
  67 static int ifoRead_PGC(ifo_handle_t *ifofile, pgc_t *pgc, unsigned int offset);
  68 static int ifoRead_PGC_COMMAND_TBL(ifo_handle_t *ifofile,
  69                                    pgc_command_tbl_t *cmd_tbl,
  70                                    unsigned int offset);
  71 static int ifoRead_PGC_PROGRAM_MAP(ifo_handle_t *ifofile,
  72                                    pgc_program_map_t *program_map,
  73                                    unsigned int nr, unsigned int offset);
  74 static int ifoRead_CELL_PLAYBACK_TBL(ifo_handle_t *ifofile,
  75                                      cell_playback_t *cell_playback,
  76                                      unsigned int nr, unsigned int offset);
  77 static int ifoRead_CELL_POSITION_TBL(ifo_handle_t *ifofile,
  78                                      cell_position_t *cell_position,
  79                                      unsigned int nr, unsigned int offset);
  80 static int ifoRead_VTS_ATTRIBUTES(ifo_handle_t *ifofile,
  81                                   vts_attributes_t *vts_attributes,
  82                                   unsigned int offset);
  83 static int ifoRead_C_ADT_internal(ifo_handle_t *ifofile, c_adt_t *c_adt,
  84                                   unsigned int sector);
  85 static int ifoRead_VOBU_ADMAP_internal(ifo_handle_t *ifofile,
  86                                        vobu_admap_t *vobu_admap,
  87                                        unsigned int sector);
  88 static int ifoRead_PGCIT_internal(ifo_handle_t *ifofile, pgcit_t *pgcit,
  89                                   unsigned int offset);
  90
  91 static void ifoFree_PGC(pgc_t *pgc);
  92 static void ifoFree_PGC_COMMAND_TBL(pgc_command_tbl_t *cmd_tbl);
  93 static void ifoFree_PGCIT_internal(pgcit_t *pgcit);
  94
  95
  96 static inline int DVDFileSeek_( dvd_file_t *dvd_file, uint32_t offset ) {
  97   return (DVDFileSeek(dvd_file, (int)offset) == (int)offset);
  98 }
  99
 100
 101 ifo_handle_t *ifoOpen(dvd_reader_t *dvd, int title) {
 102   ifo_handle_t *ifofile;
 103
 104   ifofile = malloc(sizeof(ifo_handle_t));
 105   if(!ifofile)
 106     return 0;
 107
 108   memset(ifofile, 0, sizeof(ifo_handle_t));
 109
 110   ifofile->file = DVDOpenFile(dvd, title, DVD_READ_INFO_FILE);
 111   if(!ifofile->file) /* Should really catch any error and try to fallback */
 112     ifofile->file = DVDOpenFile(dvd, title, DVD_READ_INFO_BACKUP_FILE);
 113   if(!ifofile->file) {
 114     if(title) {
 115       fprintf(stderr, "libdvdread: Can't open file VTS_%02d_0.IFO.\n", title);
 116     } else {
 117       fprintf(stderr, "libdvdread: Can't open file VIDEO_TS.IFO.\n");
 118     }
 119     free(ifofile);
 120     return 0;
 121   }
 122
 123   /* First check if this is a VMGI file. */
 124   if(ifoRead_VMG(ifofile)) {
 125
 126     /* These are both mandatory. */
 127     if(!ifoRead_FP_PGC(ifofile) || !ifoRead_TT_SRPT(ifofile)) {
 128       fprintf(stderr, "libdvdread: Invalid main menu IFO (VIDEO_TS.IFO).\n");
 129       ifoClose(ifofile);
 130       return 0;
 131     }
 132
 133     ifoRead_PGCI_UT(ifofile);
 134     ifoRead_PTL_MAIT(ifofile);
 135
 136     /* This is also mandatory. */
 137     if(!ifoRead_VTS_ATRT(ifofile)) {
 138       fprintf(stderr, "libdvdread: Invalid main menu IFO (VIDEO_TS.IFO).\n");
 139       ifoClose(ifofile);
 140       return 0;
 141     }
 142
 143     ifoRead_TXTDT_MGI(ifofile);
 144     ifoRead_C_ADT(ifofile);
 145     ifoRead_VOBU_ADMAP(ifofile);
 146
 147     return ifofile;
 148   }
 149
 150   if(ifoRead_VTS(ifofile)) {
 151
 152     if(!ifoRead_VTS_PTT_SRPT(ifofile) || !ifoRead_PGCIT(ifofile)) {
 153       fprintf(stderr, "libdvdread: Invalid title IFO (VTS_%02d_0.IFO).\n",
 154               title);
 155       ifoClose(ifofile);
 156       return 0;
 157     }
 158
 159
 160     ifoRead_PGCI_UT(ifofile);
 161     ifoRead_VTS_TMAPT(ifofile);
 162     ifoRead_C_ADT(ifofile);
 163     ifoRead_VOBU_ADMAP(ifofile);
 164
 165     if(!ifoRead_TITLE_C_ADT(ifofile) || !ifoRead_TITLE_VOBU_ADMAP(ifofile)) {
 166       fprintf(stderr, "libdvdread: Invalid title IFO (VTS_%02d_0.IFO).\n",
 167               title);
 168       ifoClose(ifofile);
 169       return 0;
 170     }
 171
 172     return ifofile;
 173   }
 174
 175   if(title) {
 176     fprintf(stderr, "libdvdread: Invalid IFO for title %d (VTS_%02d_0.IFO).\n",
 177             title, title);
 178   } else {
 179     fprintf(stderr, "libdvdread: Invalid IFO for VMGM (VIDEO_TS.IFO).\n");
 180   }
 181   ifoClose(ifofile);
 182   return 0;
 183 }
 184
 185
 186 ifo_handle_t *ifoOpenVMGI(dvd_reader_t *dvd) {
 187   ifo_handle_t *ifofile;
 188
 189   ifofile = malloc(sizeof(ifo_handle_t));
 190   if(!ifofile)
 191     return 0;
 192
 193   memset(ifofile, 0, sizeof(ifo_handle_t));
 194
 195   ifofile->file = DVDOpenFile(dvd, 0, DVD_READ_INFO_FILE);
 196   if(!ifofile->file) /* Should really catch any error and try to fallback */
 197     ifofile->file = DVDOpenFile(dvd, 0, DVD_READ_INFO_BACKUP_FILE);
 198   if(!ifofile->file) {
 199     fprintf(stderr, "libdvdread: Can't open file VIDEO_TS.IFO.\n");
 200     free(ifofile);
 201     return 0;
 202   }
 203
 204   if(ifoRead_VMG(ifofile))
 205     return ifofile;
 206
 207   fprintf(stderr, "libdvdread: Invalid main menu IFO (VIDEO_TS.IFO).\n");
 208   ifoClose(ifofile);
 209   return 0;
 210 }
 211
 212
 213 ifo_handle_t *ifoOpenVTSI(dvd_reader_t *dvd, int title) {
 214   ifo_handle_t *ifofile;
 215
 216   ifofile = malloc(sizeof(ifo_handle_t));
 217   if(!ifofile)
 218     return 0;
 219
 220   memset(ifofile, 0, sizeof(ifo_handle_t));
 221
 222   if(title <= 0 || title > 99) {
 223     fprintf(stderr, "libdvdread: ifoOpenVTSI invalid title (%d).\n", title);
 224     free(ifofile);
 225     return 0;
 226   }
 227
 228   ifofile->file = DVDOpenFile(dvd, title, DVD_READ_INFO_FILE);
 229   if(!ifofile->file) /* Should really catch any error and try to fallback */
 230     ifofile->file = DVDOpenFile(dvd, title, DVD_READ_INFO_BACKUP_FILE);
 231   if(!ifofile->file) {
 232     fprintf(stderr, "libdvdread: Can't open file VTS_%02d_0.IFO.\n", title);
 233     free(ifofile);
 234     return 0;
 235   }
 236
 237   ifoRead_VTS(ifofile);
 238   if(ifofile->vtsi_mat)
 239     return ifofile;
 240
 241   fprintf(stderr, "libdvdread: Invalid IFO for title %d (VTS_%02d_0.IFO).\n",
 242           title, title);
 243   ifoClose(ifofile);
 244   return 0;
 245 }
 246
 247
 248 void ifoClose(ifo_handle_t *ifofile) {
 249   if(!ifofile)
 250     return;
 251
 252   ifoFree_VOBU_ADMAP(ifofile);
 253   ifoFree_TITLE_VOBU_ADMAP(ifofile);
 254   ifoFree_C_ADT(ifofile);
 255   ifoFree_TITLE_C_ADT(ifofile);
 256   ifoFree_TXTDT_MGI(ifofile);
 257   ifoFree_VTS_ATRT(ifofile);
 258   ifoFree_PTL_MAIT(ifofile);
 259   ifoFree_PGCI_UT(ifofile);
 260   ifoFree_TT_SRPT(ifofile);
 261   ifoFree_FP_PGC(ifofile);
 262   ifoFree_PGCIT(ifofile);
 263   ifoFree_VTS_PTT_SRPT(ifofile);
 264
 265   if(ifofile->vmgi_mat)
 266     free(ifofile->vmgi_mat);
 267
 268   if(ifofile->vtsi_mat)
 269     free(ifofile->vtsi_mat);
 270
 271   DVDCloseFile(ifofile->file);
 272   ifofile->file = 0;
 273   free(ifofile);
 274   ifofile = 0;
 275 }
 276
 277
 278 static int ifoRead_VMG(ifo_handle_t *ifofile) {
 279   vmgi_mat_t *vmgi_mat;
 280
 281   vmgi_mat = malloc(sizeof(vmgi_mat_t));
 282   if(!vmgi_mat)
 283     return 0;
 284
 285   ifofile->vmgi_mat = vmgi_mat;
 286
 287   if(!DVDFileSeek_(ifofile->file, 0)) {
 288     free(ifofile->vmgi_mat);
 289     ifofile->vmgi_mat = 0;
 290     return 0;
 291   }
 292
 293   if(!DVDReadBytes(ifofile->file, vmgi_mat, sizeof(vmgi_mat_t))) {
 294     free(ifofile->vmgi_mat);
 295     ifofile->vmgi_mat = 0;
 296     return 0;
 297   }
 298
 299   if(strncmp("DVDVIDEO-VMG", vmgi_mat->vmg_identifier, 12) != 0) {
 300     free(ifofile->vmgi_mat);
 301     ifofile->vmgi_mat = 0;
 302     return 0;
 303   }
 304
 305   B2N_32(vmgi_mat->vmg_last_sector);
 306   B2N_32(vmgi_mat->vmgi_last_sector);
 307   B2N_32(vmgi_mat->vmg_category);
 308   B2N_16(vmgi_mat->vmg_nr_of_volumes);
 309   B2N_16(vmgi_mat->vmg_this_volume_nr);
 310   B2N_16(vmgi_mat->vmg_nr_of_title_sets);
 311   B2N_64(vmgi_mat->vmg_pos_code);
 312   B2N_32(vmgi_mat->vmgi_last_byte);
 313   B2N_32(vmgi_mat->first_play_pgc);
 314   B2N_32(vmgi_mat->vmgm_vobs);
 315   B2N_32(vmgi_mat->tt_srpt);
 316   B2N_32(vmgi_mat->vmgm_pgci_ut);
 317   B2N_32(vmgi_mat->ptl_mait);
 318   B2N_32(vmgi_mat->vts_atrt);
 319   B2N_32(vmgi_mat->txtdt_mgi);
 320   B2N_32(vmgi_mat->vmgm_c_adt);
 321   B2N_32(vmgi_mat->vmgm_vobu_admap);
 322   B2N_16(vmgi_mat->vmgm_audio_attr.lang_code);
 323   B2N_16(vmgi_mat->vmgm_subp_attr.lang_code);
 324
 325
 326   CHECK_ZERO(vmgi_mat->zero_1);
 327   CHECK_ZERO(vmgi_mat->zero_2);
 328   CHECK_ZERO(vmgi_mat->zero_3);
 329   CHECK_ZERO(vmgi_mat->zero_4);
 330   CHECK_ZERO(vmgi_mat->zero_5);
 331   CHECK_ZERO(vmgi_mat->zero_6);
 332   CHECK_ZERO(vmgi_mat->zero_7);
 333   CHECK_ZERO(vmgi_mat->zero_8);
 334   CHECK_ZERO(vmgi_mat->zero_9);
 335   CHECK_ZERO(vmgi_mat->zero_10);
 336   CHECK_VALUE(vmgi_mat->vmg_last_sector != 0);
 337   CHECK_VALUE(vmgi_mat->vmgi_last_sector != 0);
 338   CHECK_VALUE(vmgi_mat->vmgi_last_sector * 2 <= vmgi_mat->vmg_last_sector);
 339   CHECK_VALUE(vmgi_mat->vmgi_last_sector * 2 <= vmgi_mat->vmg_last_sector);
 340   CHECK_VALUE(vmgi_mat->vmg_nr_of_volumes != 0);
 341   CHECK_VALUE(vmgi_mat->vmg_this_volume_nr != 0);
 342   CHECK_VALUE(vmgi_mat->vmg_this_volume_nr <= vmgi_mat->vmg_nr_of_volumes);
 343   CHECK_VALUE(vmgi_mat->disc_side == 1 || vmgi_mat->disc_side == 2);
 344   CHECK_VALUE(vmgi_mat->vmg_nr_of_title_sets != 0);
 345   CHECK_VALUE(vmgi_mat->vmgi_last_byte >= 341);
 346   CHECK_VALUE(vmgi_mat->vmgi_last_byte / DVD_BLOCK_LEN <=
 347          vmgi_mat->vmgi_last_sector);
 348   /* It seems that first_play_pgc is optional. */
 349   CHECK_VALUE(vmgi_mat->first_play_pgc < vmgi_mat->vmgi_last_byte);
 350   CHECK_VALUE(vmgi_mat->vmgm_vobs == 0 ||
 351         (vmgi_mat->vmgm_vobs > vmgi_mat->vmgi_last_sector &&
 352          vmgi_mat->vmgm_vobs < vmgi_mat->vmg_last_sector));
 353   CHECK_VALUE(vmgi_mat->tt_srpt <= vmgi_mat->vmgi_last_sector);
 354   CHECK_VALUE(vmgi_mat->vmgm_pgci_ut <= vmgi_mat->vmgi_last_sector);
 355   CHECK_VALUE(vmgi_mat->ptl_mait <= vmgi_mat->vmgi_last_sector);
 356   CHECK_VALUE(vmgi_mat->vts_atrt <= vmgi_mat->vmgi_last_sector);
 357   CHECK_VALUE(vmgi_mat->txtdt_mgi <= vmgi_mat->vmgi_last_sector);
 358   CHECK_VALUE(vmgi_mat->vmgm_c_adt <= vmgi_mat->vmgi_last_sector);
 359   CHECK_VALUE(vmgi_mat->vmgm_vobu_admap <= vmgi_mat->vmgi_last_sector);
 360
 361   CHECK_VALUE(vmgi_mat->nr_of_vmgm_audio_streams <= 1);
 362   CHECK_VALUE(vmgi_mat->nr_of_vmgm_subp_streams <= 1);
 363
 364   return 1;
 365 }
 366
 367
 368 static int ifoRead_VTS(ifo_handle_t *ifofile) {
 369   vtsi_mat_t *vtsi_mat;
 370   int i;
 371
 372   vtsi_mat = malloc(sizeof(vtsi_mat_t));
 373   if(!vtsi_mat)
 374     return 0;
 375
 376   ifofile->vtsi_mat = vtsi_mat;
 377
 378   if(!DVDFileSeek_(ifofile->file, 0)) {
 379     free(ifofile->vtsi_mat);
 380     ifofile->vtsi_mat = 0;
 381     return 0;
 382   }
 383
 384   if(!(DVDReadBytes(ifofile->file, vtsi_mat, sizeof(vtsi_mat_t)))) {
 385     free(ifofile->vtsi_mat);
 386     ifofile->vtsi_mat = 0;
 387     return 0;
 388   }
 389
 390   if(strncmp("DVDVIDEO-VTS", vtsi_mat->vts_identifier, 12) != 0) {
 391     free(ifofile->vtsi_mat);
 392     ifofile->vtsi_mat = 0;
 393     return 0;
 394   }
 395
 396   B2N_32(vtsi_mat->vts_last_sector);
 397   B2N_32(vtsi_mat->vtsi_last_sector);
 398   B2N_32(vtsi_mat->vts_category);
 399   B2N_32(vtsi_mat->vtsi_last_byte);
 400   B2N_32(vtsi_mat->vtsm_vobs);
 401   B2N_32(vtsi_mat->vtstt_vobs);
 402   B2N_32(vtsi_mat->vts_ptt_srpt);
 403   B2N_32(vtsi_mat->vts_pgcit);
 404   B2N_32(vtsi_mat->vtsm_pgci_ut);
 405   B2N_32(vtsi_mat->vts_tmapt);
 406   B2N_32(vtsi_mat->vtsm_c_adt);
 407   B2N_32(vtsi_mat->vtsm_vobu_admap);
 408   B2N_32(vtsi_mat->vts_c_adt);
 409   B2N_32(vtsi_mat->vts_vobu_admap);
 410   B2N_16(vtsi_mat->vtsm_audio_attr.lang_code);
 411   B2N_16(vtsi_mat->vtsm_subp_attr.lang_code);
 412   for(i = 0; i < 8; i++)
 413     B2N_16(vtsi_mat->vts_audio_attr[i].lang_code);
 414   for(i = 0; i < 32; i++)
 415     B2N_16(vtsi_mat->vts_subp_attr[i].lang_code);
 416
 417
 418   CHECK_ZERO(vtsi_mat->zero_1);
 419   CHECK_ZERO(vtsi_mat->zero_2);
 420   CHECK_ZERO(vtsi_mat->zero_3);
 421   CHECK_ZERO(vtsi_mat->zero_4);
 422   CHECK_ZERO(vtsi_mat->zero_5);
 423   CHECK_ZERO(vtsi_mat->zero_6);
 424   CHECK_ZERO(vtsi_mat->zero_7);
 425   CHECK_ZERO(vtsi_mat->zero_8);
 426   CHECK_ZERO(vtsi_mat->zero_9);
 427   CHECK_ZERO(vtsi_mat->zero_10);
 428   CHECK_ZERO(vtsi_mat->zero_11);
 429   CHECK_ZERO(vtsi_mat->zero_12);
 430   CHECK_ZERO(vtsi_mat->zero_13);
 431   CHECK_ZERO(vtsi_mat->zero_14);
 432   CHECK_ZERO(vtsi_mat->zero_15);
 433   CHECK_ZERO(vtsi_mat->zero_16);
 434   CHECK_ZERO(vtsi_mat->zero_17);
 435   CHECK_ZERO(vtsi_mat->zero_18);
 436   CHECK_ZERO(vtsi_mat->zero_19);
 437   CHECK_ZERO(vtsi_mat->zero_20);
 438   CHECK_ZERO(vtsi_mat->zero_21);
 439   CHECK_VALUE(vtsi_mat->vtsi_last_sector*2 <= vtsi_mat->vts_last_sector);
 440   CHECK_VALUE(vtsi_mat->vtsi_last_byte/DVD_BLOCK_LEN <= vtsi_mat->vtsi_last_sector);
 441   CHECK_VALUE(vtsi_mat->vtsm_vobs == 0 ||
 442        (vtsi_mat->vtsm_vobs > vtsi_mat->vtsi_last_sector &&
 443          vtsi_mat->vtsm_vobs < vtsi_mat->vts_last_sector));
 444   CHECK_VALUE(vtsi_mat->vtstt_vobs == 0 ||
 445         (vtsi_mat->vtstt_vobs > vtsi_mat->vtsi_last_sector &&
 446          vtsi_mat->vtstt_vobs < vtsi_mat->vts_last_sector));
 447   CHECK_VALUE(vtsi_mat->vts_ptt_srpt <= vtsi_mat->vtsi_last_sector);
 448   CHECK_VALUE(vtsi_mat->vts_pgcit <= vtsi_mat->vtsi_last_sector);
 449   CHECK_VALUE(vtsi_mat->vtsm_pgci_ut <= vtsi_mat->vtsi_last_sector);
 450   CHECK_VALUE(vtsi_mat->vts_tmapt <= vtsi_mat->vtsi_last_sector);
 451   CHECK_VALUE(vtsi_mat->vtsm_c_adt <= vtsi_mat->vtsi_last_sector);
 452   CHECK_VALUE(vtsi_mat->vtsm_vobu_admap <= vtsi_mat->vtsi_last_sector);
 453   CHECK_VALUE(vtsi_mat->vts_c_adt <= vtsi_mat->vtsi_last_sector);
 454   CHECK_VALUE(vtsi_mat->vts_vobu_admap <= vtsi_mat->vtsi_last_sector);
 455
 456   CHECK_VALUE(vtsi_mat->nr_of_vtsm_audio_streams <= 1);
 457   CHECK_VALUE(vtsi_mat->nr_of_vtsm_subp_streams <= 1);
 458
 459   CHECK_VALUE(vtsi_mat->nr_of_vts_audio_streams <= 8);
 460   for(i = vtsi_mat->nr_of_vts_audio_streams; i < 8; i++)
 461     CHECK_ZERO(vtsi_mat->vts_audio_attr[i]);
 462
 463   CHECK_VALUE(vtsi_mat->nr_of_vts_subp_streams <= 32);
 464   for(i = vtsi_mat->nr_of_vts_subp_streams; i < 32; i++)
 465     CHECK_ZERO(vtsi_mat->vts_subp_attr[i]);
 466
 467   for(i = 0; i < 8; i++) {
 468     CHECK_ZERO0(vtsi_mat->vts_mu_audio_attr[i].zero1);
 469     CHECK_ZERO0(vtsi_mat->vts_mu_audio_attr[i].zero2);
 470     CHECK_ZERO0(vtsi_mat->vts_mu_audio_attr[i].zero3);
 471     CHECK_ZERO0(vtsi_mat->vts_mu_audio_attr[i].zero4);
 472     CHECK_ZERO0(vtsi_mat->vts_mu_audio_attr[i].zero5);
 473     CHECK_ZERO(vtsi_mat->vts_mu_audio_attr[i].zero6);
 474   }
 475
 476   return 1;
 477 }
 478
 479
 480 static int ifoRead_PGC_COMMAND_TBL(ifo_handle_t *ifofile,
 481                                    pgc_command_tbl_t *cmd_tbl,
 482                                    unsigned int offset) {
 483
 484   memset(cmd_tbl, 0, sizeof(pgc_command_tbl_t));
 485
 486   if(!DVDFileSeek_(ifofile->file, offset))
 487     return 0;
 488
 489   if(!(DVDReadBytes(ifofile->file, cmd_tbl, PGC_COMMAND_TBL_SIZE)))
 490     return 0;
 491
 492   B2N_16(cmd_tbl->nr_of_pre);
 493   B2N_16(cmd_tbl->nr_of_post);
 494   B2N_16(cmd_tbl->nr_of_cell);
 495
 496   CHECK_VALUE(cmd_tbl->nr_of_pre + cmd_tbl->nr_of_post + cmd_tbl->nr_of_cell<= 255);
 497
 498   if(cmd_tbl->nr_of_pre != 0) {
 499     unsigned int pre_cmds_size  = cmd_tbl->nr_of_pre * COMMAND_DATA_SIZE;
 500     cmd_tbl->pre_cmds = malloc(pre_cmds_size);
 501     if(!cmd_tbl->pre_cmds)
 502       return 0;
 503
 504     if(!(DVDReadBytes(ifofile->file, cmd_tbl->pre_cmds, pre_cmds_size))) {
 505       free(cmd_tbl->pre_cmds);
 506       return 0;
 507     }
 508   }
 509
 510   if(cmd_tbl->nr_of_post != 0) {
 511     unsigned int post_cmds_size = cmd_tbl->nr_of_post * COMMAND_DATA_SIZE;
 512     cmd_tbl->post_cmds = malloc(post_cmds_size);
 513     if(!cmd_tbl->post_cmds) {
 514       if(cmd_tbl->pre_cmds)
 515         free(cmd_tbl->pre_cmds);
 516       return 0;
 517     }
 518     if(!(DVDReadBytes(ifofile->file, cmd_tbl->post_cmds, post_cmds_size))) {
 519       if(cmd_tbl->pre_cmds)
 520         free(cmd_tbl->pre_cmds);
 521       free(cmd_tbl->post_cmds);
 522       return 0;
 523     }
 524   }
 525
 526   if(cmd_tbl->nr_of_cell != 0) {
 527     unsigned int cell_cmds_size = cmd_tbl->nr_of_cell * COMMAND_DATA_SIZE;
 528     cmd_tbl->cell_cmds = malloc(cell_cmds_size);
 529     if(!cmd_tbl->cell_cmds) {
 530       if(cmd_tbl->pre_cmds)
 531         free(cmd_tbl->pre_cmds);
 532       if(cmd_tbl->post_cmds)
 533         free(cmd_tbl->post_cmds);
 534       return 0;
 535     }
 536     if(!(DVDReadBytes(ifofile->file, cmd_tbl->cell_cmds, cell_cmds_size))) {
 537       if(cmd_tbl->pre_cmds)
 538         free(cmd_tbl->pre_cmds);
 539       if(cmd_tbl->post_cmds)
 540         free(cmd_tbl->post_cmds);
 541       free(cmd_tbl->cell_cmds);
 542       return 0;
 543     }
 544   }
 545
 546   /*
 547    * Make a run over all the commands and see that we can interpret them all?
 548    */
 549   return 1;
 550 }
 551
 552
 553 static void ifoFree_PGC_COMMAND_TBL(pgc_command_tbl_t *cmd_tbl) {
 554   if(cmd_tbl) {
 555     if(cmd_tbl->nr_of_pre && cmd_tbl->pre_cmds)
 556       free(cmd_tbl->pre_cmds);
 557     if(cmd_tbl->nr_of_post && cmd_tbl->post_cmds)
 558       free(cmd_tbl->post_cmds);
 559     if(cmd_tbl->nr_of_cell && cmd_tbl->cell_cmds)
 560       free(cmd_tbl->cell_cmds);
 561     free(cmd_tbl);
 562   }
 563 }
 564
 565 static int ifoRead_PGC_PROGRAM_MAP(ifo_handle_t *ifofile,
 566                                    pgc_program_map_t *program_map,
 567                                    unsigned int nr, unsigned int offset) {
 568   unsigned int size = nr * sizeof(pgc_program_map_t);
 569
 570   if(!DVDFileSeek_(ifofile->file, offset))
 571     return 0;
 572
 573   if(!(DVDReadBytes(ifofile->file, program_map, size)))
 574     return 0;
 575
 576   return 1;
 577 }
 578
 579 static int ifoRead_CELL_PLAYBACK_TBL(ifo_handle_t *ifofile,
 580                                      cell_playback_t *cell_playback,
 581                                      unsigned int nr, unsigned int offset) {
 582   unsigned int i;
 583   unsigned int size = nr * sizeof(cell_playback_t);
 584
 585   if(!DVDFileSeek_(ifofile->file, offset))
 586     return 0;
 587
 588   if(!(DVDReadBytes(ifofile->file, cell_playback, size)))
 589     return 0;
 590
 591   for(i = 0; i < nr; i++) {
 592     B2N_32(cell_playback[i].first_sector);
 593     B2N_32(cell_playback[i].first_ilvu_end_sector);
 594     B2N_32(cell_playback[i].last_vobu_start_sector);
 595     B2N_32(cell_playback[i].last_sector);
 596
 597     /* Changed < to <= because this was false in the movie 'Pi'. */
 598     CHECK_VALUE(cell_playback[i].last_vobu_start_sector <=
 599            cell_playback[i].last_sector);
 600     CHECK_VALUE(cell_playback[i].first_sector <=
 601            cell_playback[i].last_vobu_start_sector);
 602   }
 603
 604   return 1;
 605 }
 606
 607
 608 static int ifoRead_CELL_POSITION_TBL(ifo_handle_t *ifofile,
 609                                      cell_position_t *cell_position,
 610                                      unsigned int nr, unsigned int offset) {
 611   unsigned int i;
 612   unsigned int size = nr * sizeof(cell_position_t);
 613
 614   if(!DVDFileSeek_(ifofile->file, offset))
 615     return 0;
 616
 617   if(!(DVDReadBytes(ifofile->file, cell_position, size)))
 618     return 0;
 619
 620   for(i = 0; i < nr; i++) {
 621     B2N_16(cell_position[i].vob_id_nr);
 622     CHECK_ZERO(cell_position[i].zero_1);
 623   }
 624
 625   return 1;
 626 }
 627
 628 static int ifoRead_PGC(ifo_handle_t *ifofile, pgc_t *pgc, unsigned int offset) {
 629   unsigned int i;
 630
 631   if(!DVDFileSeek_(ifofile->file, offset))
 632     return 0;
 633
 634   if(!(DVDReadBytes(ifofile->file, pgc, PGC_SIZE)))
 635     return 0;
 636
 637   B2N_16(pgc->next_pgc_nr);
 638   B2N_16(pgc->prev_pgc_nr);
 639   B2N_16(pgc->goup_pgc_nr);
 640   B2N_16(pgc->command_tbl_offset);
 641   B2N_16(pgc->program_map_offset);
 642   B2N_16(pgc->cell_playback_offset);
 643   B2N_16(pgc->cell_position_offset);
 644
 645   for(i = 0; i < 16; i++)
 646     B2N_32(pgc->palette[i]);
 647
 648   CHECK_ZERO(pgc->zero_1);
 649   CHECK_VALUE(pgc->nr_of_programs <= pgc->nr_of_cells);
 650
 651   /* verify time (look at print_time) */
 652   for(i = 0; i < 8; i++)
 653     if(!pgc->audio_control[i].present)
 654       CHECK_ZERO(pgc->audio_control[i]);
 655   for(i = 0; i < 32; i++)
 656     if(!pgc->subp_control[i].present)
 657       CHECK_ZERO(pgc->subp_control[i]);
 658
 659   /* Check that time is 0:0:0:0 also if nr_of_programs == 0 */
 660   if(pgc->nr_of_programs == 0) {
 661     CHECK_ZERO(pgc->still_time);
 662     CHECK_ZERO(pgc->pg_playback_mode); // ??
 663     CHECK_VALUE(pgc->program_map_offset == 0);
 664     CHECK_VALUE(pgc->cell_playback_offset == 0);
 665     CHECK_VALUE(pgc->cell_position_offset == 0);
 666   } else {
 667     CHECK_VALUE(pgc->program_map_offset != 0);
 668     CHECK_VALUE(pgc->cell_playback_offset != 0);
 669     CHECK_VALUE(pgc->cell_position_offset != 0);
 670   }
 671
 672   if(pgc->command_tbl_offset != 0) {
 673     pgc->command_tbl = malloc(sizeof(pgc_command_tbl_t));
 674     if(!pgc->command_tbl)
 675       return 0;
 676
 677     if(!ifoRead_PGC_COMMAND_TBL(ifofile, pgc->command_tbl,
 678                                 offset + pgc->command_tbl_offset)) {
 679       free(pgc->command_tbl);
 680       return 0;
 681     }
 682   } else {
 683     pgc->command_tbl = NULL;
 684   }
 685
 686   if(pgc->program_map_offset != 0) {
 687     pgc->program_map = malloc(pgc->nr_of_programs * sizeof(pgc_program_map_t));
 688     if(!pgc->program_map) {
 689       ifoFree_PGC_COMMAND_TBL(pgc->command_tbl);
 690       return 0;
 691     }
 692     if(!ifoRead_PGC_PROGRAM_MAP(ifofile, pgc->program_map,pgc->nr_of_programs,
 693                                 offset + pgc->program_map_offset)) {
 694       ifoFree_PGC_COMMAND_TBL(pgc->command_tbl);
 695       free(pgc->program_map);
 696       return 0;
 697     }
 698   } else {
 699     pgc->program_map = NULL;
 700   }
 701
 702   if(pgc->cell_playback_offset != 0) {
 703     pgc->cell_playback = malloc(pgc->nr_of_cells * sizeof(cell_playback_t));
 704     if(!pgc->cell_playback) {
 705       ifoFree_PGC_COMMAND_TBL(pgc->command_tbl);
 706       if(pgc->program_map)
 707         free(pgc->program_map);
 708       return 0;
 709     }
 710     if(!ifoRead_CELL_PLAYBACK_TBL(ifofile, pgc->cell_playback,
 711                                   pgc->nr_of_cells,
 712                                   offset + pgc->cell_playback_offset)) {
 713       ifoFree_PGC_COMMAND_TBL(pgc->command_tbl);
 714       if(pgc->program_map)
 715         free(pgc->program_map);
 716       free(pgc->cell_playback);
 717       return 0;
 718     }
 719   } else {
 720     pgc->cell_playback = NULL;
 721   }
 722
 723   if(pgc->cell_position_offset != 0) {
 724     pgc->cell_position = malloc(pgc->nr_of_cells * sizeof(cell_position_t));
 725     if(!pgc->cell_position) {
 726       ifoFree_PGC(pgc);
 727       return 0;
 728     }
 729     if(!ifoRead_CELL_POSITION_TBL(ifofile, pgc->cell_position,
 730                                   pgc->nr_of_cells,
 731                                   offset + pgc->cell_position_offset)) {
 732       ifoFree_PGC(pgc);
 733       return 0;
 734     }
 735   } else {
 736     pgc->cell_position = NULL;
 737   }
 738
 739   return 1;
 740 }
 741
 742 int ifoRead_FP_PGC(ifo_handle_t *ifofile) {
 743
 744   if(!ifofile)
 745     return 0;
 746
 747   if(!ifofile->vmgi_mat)
 748     return 0;
 749
 750   /* It seems that first_play_pgc is optional after all. */
 751   ifofile->first_play_pgc = 0;
 752   if(ifofile->vmgi_mat->first_play_pgc == 0)
 753     return 1;
 754
 755   ifofile->first_play_pgc = malloc(sizeof(pgc_t));
 756   if(!ifofile->first_play_pgc)
 757     return 0;
 758
 759   if(!ifoRead_PGC(ifofile, ifofile->first_play_pgc,
 760                   ifofile->vmgi_mat->first_play_pgc)) {
 761     free(ifofile->first_play_pgc);
 762     ifofile->first_play_pgc = 0;
 763     return 0;
 764   }
 765
 766   return 1;
 767 }
 768
 769 static void ifoFree_PGC(pgc_t *pgc) {
 770   if(pgc) {
 771     ifoFree_PGC_COMMAND_TBL(pgc->command_tbl);
 772     if(pgc->program_map)
 773       free(pgc->program_map);
 774     if(pgc->cell_playback)
 775       free(pgc->cell_playback);
 776     if(pgc->cell_position)
 777       free(pgc->cell_position);
 778   }
 779 }
 780
 781 void ifoFree_FP_PGC(ifo_handle_t *ifofile) {
 782   if(!ifofile)
 783     return;
 784
 785   if(ifofile->first_play_pgc) {
 786     ifoFree_PGC(ifofile->first_play_pgc);
 787     free(ifofile->first_play_pgc);
 788     ifofile->first_play_pgc = 0;
 789   }
 790 }
 791
 792
 793 int ifoRead_TT_SRPT(ifo_handle_t *ifofile) {
 794   tt_srpt_t *tt_srpt;
 795   int i, info_length;
 796
 797   if(!ifofile)
 798     return 0;
 799
 800   if(!ifofile->vmgi_mat)
 801     return 0;
 802
 803   if(ifofile->vmgi_mat->tt_srpt == 0) /* mandatory */
 804     return 0;
 805
 806   if(!DVDFileSeek_(ifofile->file, ifofile->vmgi_mat->tt_srpt * DVD_BLOCK_LEN))
 807     return 0;
 808
 809   tt_srpt = malloc(sizeof(tt_srpt_t));
 810   if(!tt_srpt)
 811     return 0;
 812
 813   ifofile->tt_srpt = tt_srpt;
 814
 815   if(!(DVDReadBytes(ifofile->file, tt_srpt, TT_SRPT_SIZE))) {
 816     fprintf(stderr, "libdvdread: Unable to read read TT_SRPT.\n");
 817     free(tt_srpt);
 818     return 0;
 819   }
 820
 821   B2N_16(tt_srpt->nr_of_srpts);
 822   B2N_32(tt_srpt->last_byte);
 823
 824   info_length = tt_srpt->last_byte + 1 - TT_SRPT_SIZE;
 825
 826   tt_srpt->title = malloc(info_length);
 827   if(!tt_srpt->title) {
 828     free(tt_srpt);
 829     ifofile->tt_srpt = 0;
 830     return 0;
 831   }
 832   if(!(DVDReadBytes(ifofile->file, tt_srpt->title, info_length))) {
 833     fprintf(stderr, "libdvdread: Unable to read read TT_SRPT.\n");
 834     ifoFree_TT_SRPT(ifofile);
 835     return 0;
 836   }
 837
 838   for(i =  0; i < tt_srpt->nr_of_srpts; i++) {
 839     B2N_16(tt_srpt->title[i].nr_of_ptts);
 840     B2N_16(tt_srpt->title[i].parental_id);
 841     B2N_32(tt_srpt->title[i].title_set_sector);
 842   }
 843
 844
 845   CHECK_ZERO(tt_srpt->zero_1);
 846   CHECK_VALUE(tt_srpt->nr_of_srpts != 0);
 847   CHECK_VALUE(tt_srpt->nr_of_srpts < 100); // ??
 848   CHECK_VALUE((int)tt_srpt->nr_of_srpts * sizeof(title_info_t) <= info_length);
 849
 850   for(i = 0; i < tt_srpt->nr_of_srpts; i++) {
 851     CHECK_VALUE(tt_srpt->title[i].pb_ty.zero_1 == 0);
 852     CHECK_VALUE(tt_srpt->title[i].nr_of_angles != 0);
 853     CHECK_VALUE(tt_srpt->title[i].nr_of_angles < 10);
 854     //CHECK_VALUE(tt_srpt->title[i].nr_of_ptts != 0);
 855     // XXX: this assertion breaks Ghostbusters:
 856     CHECK_VALUE(tt_srpt->title[i].nr_of_ptts < 1000); // ??
 857     CHECK_VALUE(tt_srpt->title[i].title_set_nr != 0);
 858     CHECK_VALUE(tt_srpt->title[i].title_set_nr < 100); // ??
 859     CHECK_VALUE(tt_srpt->title[i].vts_ttn != 0);
 860     CHECK_VALUE(tt_srpt->title[i].vts_ttn < 100); // ??
 861     //CHECK_VALUE(tt_srpt->title[i].title_set_sector != 0);
 862   }
 863
 864   // Make this a function
 865 #if 0
 866   if(memcmp((uint8_t *)tt_srpt->title +
 867             tt_srpt->nr_of_srpts * sizeof(title_info_t),
 868             my_friendly_zeros,
 869             info_length - tt_srpt->nr_of_srpts * sizeof(title_info_t))) {
 870     fprintf(stderr, "VMG_PTT_SRPT slack is != 0, ");
 871     hexdump((uint8_t *)tt_srpt->title +
 872             tt_srpt->nr_of_srpts * sizeof(title_info_t),
 873             info_length - tt_srpt->nr_of_srpts * sizeof(title_info_t));
 874   }
 875 #endif
 876
 877   return 1;
 878 }
 879
 880
 881 void ifoFree_TT_SRPT(ifo_handle_t *ifofile) {
 882   if(!ifofile)
 883     return;
 884
 885   if(ifofile->tt_srpt) {
 886     free(ifofile->tt_srpt->title);
 887     free(ifofile->tt_srpt);
 888     ifofile->tt_srpt = 0;
 889   }
 890 }
 891
 892
 893 int ifoRead_VTS_PTT_SRPT(ifo_handle_t *ifofile) {
 894   vts_ptt_srpt_t *vts_ptt_srpt;
 895   int info_length, i, j;
 896   uint32_t *data;
 897
 898   if(!ifofile)
 899     return 0;
 900
 901   if(!ifofile->vtsi_mat)
 902     return 0;
 903
 904   if(ifofile->vtsi_mat->vts_ptt_srpt == 0) /* mandatory */
 905     return 0;
 906
 907   if(!DVDFileSeek_(ifofile->file,
 908                    ifofile->vtsi_mat->vts_ptt_srpt * DVD_BLOCK_LEN))
 909     return 0;
 910
 911   vts_ptt_srpt = malloc(sizeof(vts_ptt_srpt_t));
 912   if(!vts_ptt_srpt)
 913     return 0;
 914
 915   ifofile->vts_ptt_srpt = vts_ptt_srpt;
 916
 917   if(!(DVDReadBytes(ifofile->file, vts_ptt_srpt, VTS_PTT_SRPT_SIZE))) {
 918     fprintf(stderr, "libdvdread: Unable to read PTT search table.\n");
 919     free(vts_ptt_srpt);
 920     return 0;
 921   }
 922
 923   B2N_16(vts_ptt_srpt->nr_of_srpts);
 924   B2N_32(vts_ptt_srpt->last_byte);
 925
 926   CHECK_ZERO(vts_ptt_srpt->zero_1);
 927   CHECK_VALUE(vts_ptt_srpt->nr_of_srpts != 0);
 928   CHECK_VALUE(vts_ptt_srpt->nr_of_srpts < 100); // ??
 929
 930   info_length = vts_ptt_srpt->last_byte + 1 - VTS_PTT_SRPT_SIZE;
 931
 932   data = malloc(info_length);
 933   if(!data) {
 934     free(vts_ptt_srpt);
 935     ifofile->vts_ptt_srpt = 0;
 936     return 0;
 937   }
 938   if(!(DVDReadBytes(ifofile->file, data, info_length))) {
 939     fprintf(stderr, "libdvdread: Unable to read PTT search table.\n");
 940     free(vts_ptt_srpt);
 941     free(data);
 942     ifofile->vts_ptt_srpt = 0;
 943     return 0;
 944   }
 945
 946   for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) {
 947     B2N_32(data[i]);
 948     /* assert(data[i] + sizeof(ptt_info_t) <= vts_ptt_srpt->last_byte + 1);
 949        Magic Knight Rayearth Daybreak is mastered very strange and has
 950        Titles with 0 PTTs. They all have a data[i] offsets beyond the end of
 951        of the vts_ptt_srpt structure. */
 952     CHECK_VALUE(data[i] + sizeof(ptt_info_t) <= vts_ptt_srpt->last_byte + 1 + 4);
 953   }
 954
 955   vts_ptt_srpt->ttu_offset = data;
 956
 957   vts_ptt_srpt->title = malloc(vts_ptt_srpt->nr_of_srpts * sizeof(ttu_t));
 958   if(!vts_ptt_srpt->title) {
 959     free(vts_ptt_srpt);
 960     free(data);
 961     ifofile->vts_ptt_srpt = 0;
 962     return 0;
 963   }
 964   for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) {
 965     int n;
 966     if(i < vts_ptt_srpt->nr_of_srpts - 1)
 967       n = (data[i+1] - data[i]);
 968     else
 969       n = (vts_ptt_srpt->last_byte + 1 - data[i]);
 970     /* assert(n > 0 && (n % 4) == 0);
 971        Magic Knight Rayearth Daybreak is mastered very strange and has
 972        Titles with 0 PTTs. */
 973     if(n < 0) n = 0;
 974     CHECK_VALUE(n % 4 == 0);
 975
 976     vts_ptt_srpt->title[i].nr_of_ptts = n / 4;
 977     vts_ptt_srpt->title[i].ptt = malloc(n * sizeof(ptt_info_t));
 978     if(!vts_ptt_srpt->title[i].ptt) {
 979       for(n = 0; n < i; n++)
 980         free(vts_ptt_srpt->title[n].ptt);
 981       free(vts_ptt_srpt);
 982       free(data);
 983       ifofile->vts_ptt_srpt = 0;
 984       return 0;
 985     }
 986     for(j = 0; j < vts_ptt_srpt->title[i].nr_of_ptts; j++) {
 987       /* The assert placed here because of Magic Knight Rayearth Daybreak */
 988       CHECK_VALUE(data[i] + sizeof(ptt_info_t) <= vts_ptt_srpt->last_byte + 1);
 989       vts_ptt_srpt->title[i].ptt[j].pgcn
 990         = *(uint16_t*)(((char *)data) + data[i] + 4*j - VTS_PTT_SRPT_SIZE);
 991       vts_ptt_srpt->title[i].ptt[j].pgn
 992         = *(uint16_t*)(((char *)data) + data[i] + 4*j + 2 - VTS_PTT_SRPT_SIZE);
 993     }
 994   }
 995
 996   for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) {
 997     for(j = 0; j < vts_ptt_srpt->title[i].nr_of_ptts; j++) {
 998       B2N_16(vts_ptt_srpt->title[i].ptt[j].pgcn);
 999       B2N_16(vts_ptt_srpt->title[i].ptt[j].pgn);
1000     }
1001   }
1002
1003   for(i = 0; i < vts_ptt_srpt->nr_of_srpts; i++) {
1004     CHECK_VALUE(vts_ptt_srpt->title[i].nr_of_ptts < 1000); // ??
1005     for(j = 0; j < vts_ptt_srpt->title[i].nr_of_ptts; j++) {
1006       CHECK_VALUE(vts_ptt_srpt->title[i].ptt[j].pgcn != 0 );
1007       CHECK_VALUE(vts_ptt_srpt->title[i].ptt[j].pgcn < 1000); // ??
1008       CHECK_VALUE(vts_ptt_srpt->title[i].ptt[j].pgn != 0);
1009       CHECK_VALUE(vts_ptt_srpt->title[i].ptt[j].pgn < 100); // ??
1010     }
1011   }
1012
1013   return 1;
1014 }
1015
1016
1017 void ifoFree_VTS_PTT_SRPT(ifo_handle_t *ifofile) {
1018   if(!ifofile)
1019     return;
1020
1021   if(ifofile->vts_ptt_srpt) {
1022     int i;
1023     for(i = 0; i < ifofile->vts_ptt_srpt->nr_of_srpts; i++)
1024       free(ifofile->vts_ptt_srpt->title[i].ptt);
1025     free(ifofile->vts_ptt_srpt->ttu_offset);
1026     free(ifofile->vts_ptt_srpt->title);
1027     free(ifofile->vts_ptt_srpt);
1028     ifofile->vts_ptt_srpt = 0;
1029   }
1030 }
1031
1032
1033 int ifoRead_PTL_MAIT(ifo_handle_t *ifofile) {
1034   ptl_mait_t *ptl_mait;
1035   int info_length;
1036   unsigned int i, j;
1037
1038   if(!ifofile)
1039     return 0;
1040
1041   if(!ifofile->vmgi_mat)
1042     return 0;
1043
1044   if(ifofile->vmgi_mat->ptl_mait == 0)
1045     return 1;
1046
1047   if(!DVDFileSeek_(ifofile->file, ifofile->vmgi_mat->ptl_mait * DVD_BLOCK_LEN))
1048     return 0;
1049
1050   ptl_mait = malloc(sizeof(ptl_mait_t));
1051   if(!ptl_mait)
1052     return 0;
1053
1054   ifofile->ptl_mait = ptl_mait;
1055
1056   if(!(DVDReadBytes(ifofile->file, ptl_mait, PTL_MAIT_SIZE))) {
1057     free(ptl_mait);
1058     ifofile->ptl_mait = 0;
1059     return 0;
1060   }
1061
1062   B2N_16(ptl_mait->nr_of_countries);
1063   B2N_16(ptl_mait->nr_of_vtss);
1064   B2N_32(ptl_mait->last_byte);
1065
1066   CHECK_VALUE(ptl_mait->nr_of_countries != 0);
1067   CHECK_VALUE(ptl_mait->nr_of_countries < 100); // ??
1068   CHECK_VALUE(ptl_mait->nr_of_vtss != 0);
1069   CHECK_VALUE(ptl_mait->nr_of_vtss < 100); // ??
1070   CHECK_VALUE(ptl_mait->nr_of_countries * PTL_MAIT_COUNTRY_SIZE
1071               <= ptl_mait->last_byte + 1 - PTL_MAIT_SIZE);
1072
1073   info_length = ptl_mait->nr_of_countries * sizeof(ptl_mait_country_t);
1074   ptl_mait->countries = malloc(info_length);
1075   if(!ptl_mait->countries) {
1076     free(ptl_mait);
1077     ifofile->ptl_mait = 0;
1078     return 0;
1079   }
1080
1081   for(i = 0; i < ptl_mait->nr_of_countries; i++) {
1082     if(!(DVDReadBytes(ifofile->file, &ptl_mait->countries[i], PTL_MAIT_COUNTRY_SIZE))) {
1083       fprintf(stderr, "libdvdread: Unable to read PTL_MAIT.\n");
1084       free(ptl_mait->countries);
1085       free(ptl_mait);
1086       ifofile->ptl_mait = 0;
1087       return 0;
1088     }
1089   }
1090
1091   for(i = 0; i < ptl_mait->nr_of_countries; i++) {
1092     B2N_16(ptl_mait->countries[i].country_code);
1093     B2N_16(ptl_mait->countries[i].pf_ptl_mai_start_byte);
1094   }
1095
1096   for(i = 0; i < ptl_mait->nr_of_countries; i++) {
1097     CHECK_ZERO(ptl_mait->countries[i].zero_1);
1098     CHECK_ZERO(ptl_mait->countries[i].zero_2);
1099     CHECK_VALUE(ptl_mait->countries[i].pf_ptl_mai_start_byte
1100                 + 8*2 * (ptl_mait->nr_of_vtss + 1) <= ptl_mait->last_byte + 1);
1101   }
1102
1103   for(i = 0; i < ptl_mait->nr_of_countries; i++) {
1104     uint16_t *pf_temp;
1105
1106     if(!DVDFileSeek_(ifofile->file,
1107                      ifofile->vmgi_mat->ptl_mait * DVD_BLOCK_LEN
1108                      + ptl_mait->countries[i].pf_ptl_mai_start_byte)) {
1109       fprintf(stderr, "libdvdread: Unable to seak PTL_MAIT table.\n");
1110       free(ptl_mait->countries);
1111       free(ptl_mait);
1112       return 0;
1113     }
1114     info_length = (ptl_mait->nr_of_vtss + 1) * sizeof(pf_level_t);
1115     pf_temp = malloc(info_length);
1116     if(!pf_temp) {
1117       for(j = 0; j < i ; j++) {
1118          free(ptl_mait->countries[j].pf_ptl_mai);
1119       }
1120       free(ptl_mait->countries);
1121       free(ptl_mait);
1122       return 0;
1123     }
1124     if(!(DVDReadBytes(ifofile->file, pf_temp, info_length))) {
1125        fprintf(stderr, "libdvdread: Unable to read PTL_MAIT table.\n");
1126        free(pf_temp);
1127        for(j = 0; j < i ; j++) {
1128           free(ptl_mait->countries[j].pf_ptl_mai);
1129        }
1130        free(ptl_mait->countries);
1131        free(ptl_mait);
1132        return 0;
1133     }
1134     for (j = 0; j < ((ptl_mait->nr_of_vtss + 1) * 8); j++) {
1135         B2N_16(pf_temp[j]);
1136     }
1137     ptl_mait->countries[i].pf_ptl_mai = malloc(info_length);
1138     if(!ptl_mait->countries[i].pf_ptl_mai) {
1139       free(pf_temp);
1140       for(j = 0; j < i ; j++) {
1141         free(ptl_mait->countries[j].pf_ptl_mai);
1142       }
1143       free(ptl_mait->countries);
1144       free(ptl_mait);
1145       return 0;
1146     }
1147     { /* Transpose the array so we can use C indexing. */
1148       int level, vts;
1149       for(level = 0; level < 8; level++) {
1150         for(vts = 0; vts <= ptl_mait->nr_of_vtss; vts++) {
1151           ptl_mait->countries[i].pf_ptl_mai[vts][level] =
1152             pf_temp[(7-level)*(ptl_mait->nr_of_vtss+1) + vts];
1153         }
1154       }
1155       free(pf_temp);
1156     }
1157   }
1158   return 1;
1159 }
1160
1161 void ifoFree_PTL_MAIT(ifo_handle_t *ifofile) {
1162   unsigned int i;
1163
1164   if(!ifofile)
1165     return;
1166
1167   if(ifofile->ptl_mait) {
1168     for(i = 0; i < ifofile->ptl_mait->nr_of_countries; i++) {
1169        free(ifofile->ptl_mait->countries[i].pf_ptl_mai);
1170     }
1171     free(ifofile->ptl_mait->countries);
1172     free(ifofile->ptl_mait);
1173     ifofile->ptl_mait = 0;
1174   }
1175 }
1176
1177 int ifoRead_VTS_TMAPT(ifo_handle_t *ifofile) {
1178   vts_tmapt_t *vts_tmapt;
1179   uint32_t *vts_tmap_srp;
1180   unsigned int offset;
1181   int info_length;
1182   unsigned int i, j;
1183
1184   if(!ifofile)
1185     return 0;
1186
1187   if(!ifofile->vtsi_mat)
1188     return 0;
1189
1190   if(ifofile->vtsi_mat->vts_tmapt == 0) { /* optional(?) */
1191     ifofile->vts_tmapt = NULL;
1192     fprintf(stderr,"Please send bug report - no VTS_TMAPT ?? \n");
1193     return 1;
1194   }
1195
1196   offset = ifofile->vtsi_mat->vts_tmapt * DVD_BLOCK_LEN;
1197
1198   if(!DVDFileSeek_(ifofile->file, offset))
1199     return 0;
1200
1201   vts_tmapt = malloc(sizeof(vts_tmapt_t));
1202   if(!vts_tmapt)
1203     return 0;
1204
1205   ifofile->vts_tmapt = vts_tmapt;
1206
1207   if(!(DVDReadBytes(ifofile->file, vts_tmapt, VTS_TMAPT_SIZE))) {
1208     fprintf(stderr, "libdvdread: Unable to read VTS_TMAPT.\n");
1209     free(vts_tmapt);
1210     ifofile->vts_tmapt = NULL;
1211     return 0;
1212   }
1213
1214   B2N_16(vts_tmapt->nr_of_tmaps);
1215   B2N_32(vts_tmapt->last_byte);
1216
1217   CHECK_ZERO(vts_tmapt->zero_1);
1218
1219   info_length = vts_tmapt->nr_of_tmaps * 4;
1220
1221   vts_tmap_srp = malloc(info_length);
1222   if(!vts_tmap_srp) {
1223     free(vts_tmapt);
1224     ifofile->vts_tmapt = NULL;
1225     return 0;
1226   }
1227
1228   vts_tmapt->tmap_offset = vts_tmap_srp;
1229
1230   if(!(DVDReadBytes(ifofile->file, vts_tmap_srp, info_length))) {
1231     fprintf(stderr, "libdvdread: Unable to read VTS_TMAPT.\n");
1232     free(vts_tmap_srp);
1233     free(vts_tmapt);
1234     ifofile->vts_tmapt = NULL;
1235     return 0;
1236   }
1237
1238   for (i = 0; i < vts_tmapt->nr_of_tmaps; i++) {
1239      B2N_32(vts_tmap_srp[i]);
1240   }
1241
1242
1243   info_length = vts_tmapt->nr_of_tmaps * sizeof(vts_tmap_t);
1244
1245   vts_tmapt->tmap = malloc(info_length);
1246   if(!vts_tmapt->tmap) {
1247     free(vts_tmap_srp);
1248     free(vts_tmapt);
1249     ifofile->vts_tmapt = NULL;
1250     return 0;
1251   }
1252
1253   memset(vts_tmapt->tmap, 0, info_length); /* So ifoFree_VTS_TMAPT works. */
1254
1255   for(i = 0; i < vts_tmapt->nr_of_tmaps; i++) {
1256     if(!DVDFileSeek_(ifofile->file, offset + vts_tmap_srp[i])) {
1257       ifoFree_VTS_TMAPT(ifofile);
1258       return 0;
1259     }
1260
1261     if(!(DVDReadBytes(ifofile->file, &vts_tmapt->tmap[i], VTS_TMAP_SIZE))) {
1262       fprintf(stderr, "libdvdread: Unable to read VTS_TMAP.\n");
1263       ifoFree_VTS_TMAPT(ifofile);
1264       return 0;
1265     }
1266
1267     B2N_16(vts_tmapt->tmap[i].nr_of_entries);
1268     CHECK_ZERO(vts_tmapt->tmap[i].zero_1);
1269
1270     if(vts_tmapt->tmap[i].nr_of_entries == 0) { /* Early out if zero entries */
1271       vts_tmapt->tmap[i].map_ent = NULL;
1272       continue;
1273     }
1274
1275     info_length = vts_tmapt->tmap[i].nr_of_entries * sizeof(map_ent_t);
1276
1277     vts_tmapt->tmap[i].map_ent = malloc(info_length);
1278     if(!vts_tmapt->tmap[i].map_ent) {
1279       ifoFree_VTS_TMAPT(ifofile);
1280       return 0;
1281     }
1282
1283     if(!(DVDReadBytes(ifofile->file, vts_tmapt->tmap[i].map_ent, info_length))) {
1284       fprintf(stderr, "libdvdread: Unable to read VTS_TMAP_ENT.\n");
1285       ifoFree_VTS_TMAPT(ifofile);
1286       return 0;
1287     }
1288
1289     for(j = 0; j < vts_tmapt->tmap[i].nr_of_entries; j++)
1290       B2N_32(vts_tmapt->tmap[i].map_ent[j]);
1291   }
1292
1293   return 1;
1294 }
1295
1296 void ifoFree_VTS_TMAPT(ifo_handle_t *ifofile) {
1297   unsigned int i;
1298
1299   if(!ifofile)
1300     return;
1301
1302   if(ifofile->vts_tmapt) {
1303     for(i = 0; i < ifofile->vts_tmapt->nr_of_tmaps; i++)
1304       if(ifofile->vts_tmapt->tmap[i].map_ent)
1305         free(ifofile->vts_tmapt->tmap[i].map_ent);
1306     free(ifofile->vts_tmapt->tmap);
1307     free(ifofile->vts_tmapt->tmap_offset);
1308     free(ifofile->vts_tmapt);
1309     ifofile->vts_tmapt = NULL;
1310   }
1311 }
1312
1313
1314 int ifoRead_TITLE_C_ADT(ifo_handle_t *ifofile) {
1315
1316   if(!ifofile)
1317     return 0;
1318
1319   if(!ifofile->vtsi_mat)
1320     return 0;
1321
1322   if(ifofile->vtsi_mat->vts_c_adt == 0) /* mandatory */
1323     return 0;
1324
1325   ifofile->vts_c_adt = malloc(sizeof(c_adt_t));
1326   if(!ifofile->vts_c_adt)
1327     return 0;
1328
1329   if(!ifoRead_C_ADT_internal(ifofile, ifofile->vts_c_adt,
1330                              ifofile->vtsi_mat->vts_c_adt)) {
1331     free(ifofile->vts_c_adt);
1332     ifofile->vts_c_adt = 0;
1333     return 0;
1334   }
1335
1336   return 1;
1337 }
1338
1339 int ifoRead_C_ADT(ifo_handle_t *ifofile) {
1340   unsigned int sector;
1341
1342   if(!ifofile)
1343     return 0;
1344
1345   if(ifofile->vmgi_mat) {
1346     if(ifofile->vmgi_mat->vmgm_c_adt == 0)
1347       return 1;
1348     sector = ifofile->vmgi_mat->vmgm_c_adt;
1349   } else if(ifofile->vtsi_mat) {
1350     if(ifofile->vtsi_mat->vtsm_c_adt == 0)
1351       return 1;
1352     sector = ifofile->vtsi_mat->vtsm_c_adt;
1353   } else {
1354     return 0;
1355   }
1356
1357   ifofile->menu_c_adt = malloc(sizeof(c_adt_t));
1358   if(!ifofile->menu_c_adt)
1359     return 0;
1360
1361   if(!ifoRead_C_ADT_internal(ifofile, ifofile->menu_c_adt, sector)) {
1362     free(ifofile->menu_c_adt);
1363     ifofile->menu_c_adt = 0;
1364     return 0;
1365   }
1366
1367   return 1;
1368 }
1369
1370 static int ifoRead_C_ADT_internal(ifo_handle_t *ifofile,
1371                                   c_adt_t *c_adt, unsigned int sector) {
1372   int i, info_length;
1373
1374   if(!DVDFileSeek_(ifofile->file, sector * DVD_BLOCK_LEN))
1375     return 0;
1376
1377   if(!(DVDReadBytes(ifofile->file, c_adt, C_ADT_SIZE)))
1378     return 0;
1379
1380   B2N_16(c_adt->nr_of_vobs);
1381   B2N_32(c_adt->last_byte);
1382
1383   info_length = c_adt->last_byte + 1 - C_ADT_SIZE;
1384
1385   CHECK_ZERO(c_adt->zero_1);
1386   /* assert(c_adt->nr_of_vobs > 0);
1387      Magic Knight Rayearth Daybreak is mastered very strange and has
1388      Titles with a VOBS that has no cells. */
1389   CHECK_VALUE(info_length % sizeof(cell_adr_t) == 0);
1390
1391   /* assert(info_length / sizeof(cell_adr_t) >= c_adt->nr_of_vobs);
1392      Enemy of the State region 2 (de) has Titles where nr_of_vobs field
1393      is to high, they high ones are never referenced though. */
1394   if(info_length / sizeof(cell_adr_t) < c_adt->nr_of_vobs) {
1395     fprintf(stderr, "libdvdread: *C_ADT nr_of_vobs > avaiable info entries\n");
1396     c_adt->nr_of_vobs = info_length / sizeof(cell_adr_t);
1397   }
1398
1399   c_adt->cell_adr_table = malloc(info_length);
1400   if(!c_adt->cell_adr_table)
1401     return 0;
1402
1403   if(info_length &&
1404      !(DVDReadBytes(ifofile->file, c_adt->cell_adr_table, info_length))) {
1405     free(c_adt->cell_adr_table);
1406     return 0;
1407   }
1408
1409   for(i = 0; i < info_length/sizeof(cell_adr_t); i++) {
1410     B2N_16(c_adt->cell_adr_table[i].vob_id);
1411     B2N_32(c_adt->cell_adr_table[i].start_sector);
1412     B2N_32(c_adt->cell_adr_table[i].last_sector);
1413
1414     CHECK_ZERO(c_adt->cell_adr_table[i].zero_1);
1415     CHECK_VALUE(c_adt->cell_adr_table[i].vob_id > 0);
1416     CHECK_VALUE(c_adt->cell_adr_table[i].vob_id <= c_adt->nr_of_vobs);
1417     CHECK_VALUE(c_adt->cell_adr_table[i].cell_id > 0);
1418     CHECK_VALUE(c_adt->cell_adr_table[i].start_sector <
1419            c_adt->cell_adr_table[i].last_sector);
1420   }
1421
1422   return 1;
1423 }
1424
1425
1426 static void ifoFree_C_ADT_internal(c_adt_t *c_adt) {
1427   if(c_adt) {
1428     free(c_adt->cell_adr_table);
1429     free(c_adt);
1430   }
1431 }
1432
1433 void ifoFree_C_ADT(ifo_handle_t *ifofile) {
1434   if(!ifofile)
1435     return;
1436
1437   ifoFree_C_ADT_internal(ifofile->menu_c_adt);
1438   ifofile->menu_c_adt = 0;
1439 }
1440
1441 void ifoFree_TITLE_C_ADT(ifo_handle_t *ifofile) {
1442   if(!ifofile)
1443     return;
1444
1445   ifoFree_C_ADT_internal(ifofile->vts_c_adt);
1446   ifofile->vts_c_adt = 0;
1447 }
1448
1449 int ifoRead_TITLE_VOBU_ADMAP(ifo_handle_t *ifofile) {
1450   if(!ifofile)
1451     return 0;
1452
1453   if(!ifofile->vtsi_mat)
1454     return 0;
1455
1456   if(ifofile->vtsi_mat->vts_vobu_admap == 0) /* mandatory */
1457     return 0;
1458
1459   ifofile->vts_vobu_admap = malloc(sizeof(vobu_admap_t));
1460   if(!ifofile->vts_vobu_admap)
1461     return 0;
1462
1463   if(!ifoRead_VOBU_ADMAP_internal(ifofile, ifofile->vts_vobu_admap,
1464                                   ifofile->vtsi_mat->vts_vobu_admap)) {
1465     free(ifofile->vts_vobu_admap);
1466     ifofile->vts_vobu_admap = 0;
1467     return 0;
1468   }
1469
1470   return 1;
1471 }
1472
1473 int ifoRead_VOBU_ADMAP(ifo_handle_t *ifofile) {
1474   unsigned int sector;
1475
1476   if(!ifofile)
1477     return 0;
1478
1479   if(ifofile->vmgi_mat) {
1480     if(ifofile->vmgi_mat->vmgm_vobu_admap == 0)
1481       return 1;
1482     sector = ifofile->vmgi_mat->vmgm_vobu_admap;
1483   } else if(ifofile->vtsi_mat) {
1484     if(ifofile->vtsi_mat->vtsm_vobu_admap == 0)
1485       return 1;
1486     sector = ifofile->vtsi_mat->vtsm_vobu_admap;
1487   } else {
1488     return 0;
1489   }
1490
1491   ifofile->menu_vobu_admap = malloc(sizeof(vobu_admap_t));
1492   if(!ifofile->menu_vobu_admap)
1493     return 0;
1494
1495   if(!ifoRead_VOBU_ADMAP_internal(ifofile, ifofile->menu_vobu_admap, sector)) {
1496     free(ifofile->menu_vobu_admap);
1497     ifofile->menu_vobu_admap = 0;
1498     return 0;
1499   }
1500
1501   return 1;
1502 }
1503
1504 static int ifoRead_VOBU_ADMAP_internal(ifo_handle_t *ifofile,
1505                                        vobu_admap_t *vobu_admap,
1506                                        unsigned int sector) {
1507   unsigned int i;
1508   int info_length;
1509
1510   if(!DVDFileSeek_(ifofile->file, sector * DVD_BLOCK_LEN))
1511     return 0;
1512
1513   if(!(DVDReadBytes(ifofile->file, vobu_admap, VOBU_ADMAP_SIZE)))
1514     return 0;
1515
1516   B2N_32(vobu_admap->last_byte);
1517
1518   info_length = vobu_admap->last_byte + 1 - VOBU_ADMAP_SIZE;
1519   /* assert(info_length > 0);
1520      Magic Knight Rayearth Daybreak is mastered very strange and has
1521      Titles with a VOBS that has no VOBUs. */
1522   CHECK_VALUE(info_length % sizeof(uint32_t) == 0);
1523
1524   vobu_admap->vobu_start_sectors = malloc(info_length);
1525   if(!vobu_admap->vobu_start_sectors) {
1526     return 0;
1527   }
1528   if(info_length &&
1529      !(DVDReadBytes(ifofile->file,
1530                     vobu_admap->vobu_start_sectors, info_length))) {
1531     free(vobu_admap->vobu_start_sectors);
1532     return 0;
1533   }
1534
1535   for(i = 0; i < info_length/sizeof(uint32_t); i++)
1536     B2N_32(vobu_admap->vobu_start_sectors[i]);
1537
1538   return 1;
1539 }
1540
1541
1542 static void ifoFree_VOBU_ADMAP_internal(vobu_admap_t *vobu_admap) {
1543   if(vobu_admap) {
1544     free(vobu_admap->vobu_start_sectors);
1545     free(vobu_admap);
1546   }
1547 }
1548
1549 void ifoFree_VOBU_ADMAP(ifo_handle_t *ifofile) {
1550   if(!ifofile)
1551     return;
1552
1553   ifoFree_VOBU_ADMAP_internal(ifofile->menu_vobu_admap);
1554   ifofile->menu_vobu_admap = 0;
1555 }
1556
1557 void ifoFree_TITLE_VOBU_ADMAP(ifo_handle_t *ifofile) {
1558   if(!ifofile)
1559     return;
1560
1561   ifoFree_VOBU_ADMAP_internal(ifofile->vts_vobu_admap);
1562   ifofile->vts_vobu_admap = 0;
1563 }
1564
1565 int ifoRead_PGCIT(ifo_handle_t *ifofile) {
1566
1567   if(!ifofile)
1568     return 0;
1569
1570   if(!ifofile->vtsi_mat)
1571     return 0;
1572
1573   if(ifofile->vtsi_mat->vts_pgcit == 0) /* mandatory */
1574     return 0;
1575
1576   ifofile->vts_pgcit = malloc(sizeof(pgcit_t));
1577   if(!ifofile->vts_pgcit)
1578     return 0;
1579
1580   if(!ifoRead_PGCIT_internal(ifofile, ifofile->vts_pgcit,
1581                              ifofile->vtsi_mat->vts_pgcit * DVD_BLOCK_LEN)) {
1582     free(ifofile->vts_pgcit);
1583     ifofile->vts_pgcit = 0;
1584     return 0;
1585   }
1586
1587   return 1;
1588 }
1589
1590 static int ifoRead_PGCIT_internal(ifo_handle_t *ifofile, pgcit_t *pgcit,
1591                                   unsigned int offset) {
1592   int i, info_length;
1593   uint8_t *data, *ptr;
1594
1595   if(!DVDFileSeek_(ifofile->file, offset))
1596     return 0;
1597
1598   if(!(DVDReadBytes(ifofile->file, pgcit, PGCIT_SIZE)))
1599     return 0;
1600
1601   B2N_16(pgcit->nr_of_pgci_srp);
1602   B2N_32(pgcit->last_byte);
1603
1604   CHECK_ZERO(pgcit->zero_1);
1605   /* assert(pgcit->nr_of_pgci_srp != 0);
1606      Magic Knight Rayearth Daybreak is mastered very strange and has
1607      Titles with 0 PTTs. */
1608   CHECK_VALUE(pgcit->nr_of_pgci_srp < 10000); // ?? seen max of 1338
1609
1610   info_length = pgcit->nr_of_pgci_srp * PGCI_SRP_SIZE;
1611   data = malloc(info_length);
1612   if(!data)
1613     return 0;
1614
1615   if(info_length && !(DVDReadBytes(ifofile->file, data, info_length))) {
1616     free(data);
1617     return 0;
1618   }
1619
1620   pgcit->pgci_srp = malloc(pgcit->nr_of_pgci_srp * sizeof(pgci_srp_t));
1621   if(!pgcit->pgci_srp) {
1622     free(data);
1623     return 0;
1624   }
1625   ptr = data;
1626   for(i = 0; i < pgcit->nr_of_pgci_srp; i++) {
1627     memcpy(&pgcit->pgci_srp[i], ptr, PGCI_LU_SIZE);
1628     ptr += PGCI_LU_SIZE;
1629     B2N_16(pgcit->pgci_srp[i].ptl_id_mask);
1630     B2N_32(pgcit->pgci_srp[i].pgc_start_byte);
1631     CHECK_VALUE(pgcit->pgci_srp[i].unknown1 == 0);
1632   }
1633   free(data);
1634
1635   for(i = 0; i < pgcit->nr_of_pgci_srp; i++)
1636     CHECK_VALUE(pgcit->pgci_srp[i].pgc_start_byte + PGC_SIZE <= pgcit->last_byte+1);
1637
1638   for(i = 0; i < pgcit->nr_of_pgci_srp; i++) {
1639     pgcit->pgci_srp[i].pgc = malloc(sizeof(pgc_t));
1640     if(!pgcit->pgci_srp[i].pgc) {
1641       int j;
1642       for(j = 0; j < i; j++) {
1643         ifoFree_PGC(pgcit->pgci_srp[j].pgc);
1644         free(pgcit->pgci_srp[j].pgc);
1645       }
1646       return 0;
1647     }
1648     if(!ifoRead_PGC(ifofile, pgcit->pgci_srp[i].pgc,
1649                     offset + pgcit->pgci_srp[i].pgc_start_byte)) {
1650       int j;
1651       for(j = 0; j < i; j++) {
1652         ifoFree_PGC(pgcit->pgci_srp[j].pgc);
1653         free(pgcit->pgci_srp[j].pgc);
1654       }
1655       free(pgcit->pgci_srp);
1656       return 0;
1657     }
1658   }
1659
1660   return 1;
1661 }
1662
1663 static void ifoFree_PGCIT_internal(pgcit_t *pgcit) {
1664   if(pgcit) {
1665     int i;
1666     for(i = 0; i < pgcit->nr_of_pgci_srp; i++)
1667       ifoFree_PGC(pgcit->pgci_srp[i].pgc);
1668     free(pgcit->pgci_srp);
1669   }
1670 }
1671
1672 void ifoFree_PGCIT(ifo_handle_t *ifofile) {
1673   if(!ifofile)
1674     return;
1675
1676   if(ifofile->vts_pgcit) {
1677     ifoFree_PGCIT_internal(ifofile->vts_pgcit);
1678     free(ifofile->vts_pgcit);
1679     ifofile->vts_pgcit = 0;
1680   }
1681 }
1682
1683
1684 int ifoRead_PGCI_UT(ifo_handle_t *ifofile) {
1685   pgci_ut_t *pgci_ut;
1686   unsigned int sector;
1687   unsigned int i;
1688   int info_length;
1689   uint8_t *data, *ptr;
1690
1691   if(!ifofile)
1692     return 0;
1693
1694   if(ifofile->vmgi_mat) {
1695     if(ifofile->vmgi_mat->vmgm_pgci_ut == 0)
1696       return 1;
1697     sector = ifofile->vmgi_mat->vmgm_pgci_ut;
1698   } else if(ifofile->vtsi_mat) {
1699     if(ifofile->vtsi_mat->vtsm_pgci_ut == 0)
1700       return 1;
1701     sector = ifofile->vtsi_mat->vtsm_pgci_ut;
1702   } else {
1703     return 0;
1704   }
1705
1706   ifofile->pgci_ut = malloc(sizeof(pgci_ut_t));
1707   if(!ifofile->pgci_ut)
1708     return 0;
1709
1710   if(!DVDFileSeek_(ifofile->file, sector * DVD_BLOCK_LEN)) {
1711     free(ifofile->pgci_ut);
1712     ifofile->pgci_ut = 0;
1713     return 0;
1714   }
1715
1716   if(!(DVDReadBytes(ifofile->file, ifofile->pgci_ut, PGCI_UT_SIZE))) {
1717     free(ifofile->pgci_ut);
1718     ifofile->pgci_ut = 0;
1719     return 0;
1720   }
1721
1722   pgci_ut = ifofile->pgci_ut;
1723
1724   B2N_16(pgci_ut->nr_of_lus);
1725   B2N_32(pgci_ut->last_byte);
1726
1727   CHECK_ZERO(pgci_ut->zero_1);
1728   CHECK_VALUE(pgci_ut->nr_of_lus != 0);
1729   CHECK_VALUE(pgci_ut->nr_of_lus < 100); // ?? 3-4 ?
1730   CHECK_VALUE((uint32_t)pgci_ut->nr_of_lus * PGCI_LU_SIZE < pgci_ut->last_byte);
1731
1732   info_length = pgci_ut->nr_of_lus * PGCI_LU_SIZE;
1733   data = malloc(info_length);
1734   if(!data) {
1735     free(pgci_ut);
1736     ifofile->pgci_ut = 0;
1737     return 0;
1738   }
1739   if(!(DVDReadBytes(ifofile->file, data, info_length))) {
1740     free(data);
1741     free(pgci_ut);
1742     ifofile->pgci_ut = 0;
1743     return 0;
1744   }
1745
1746   pgci_ut->lu = malloc(pgci_ut->nr_of_lus * sizeof(pgci_lu_t));
1747   if(!pgci_ut->lu) {
1748     free(data);
1749     free(pgci_ut);
1750     ifofile->pgci_ut = 0;
1751    return 0;
1752   }
1753   ptr = data;
1754   for(i = 0; i < pgci_ut->nr_of_lus; i++) {
1755     memcpy(&pgci_ut->lu[i], ptr, PGCI_LU_SIZE);
1756     ptr += PGCI_LU_SIZE;
1757     B2N_16(pgci_ut->lu[i].lang_code);
1758     B2N_32(pgci_ut->lu[i].lang_start_byte);
1759   }
1760   free(data);
1761
1762   for(i = 0; i < pgci_ut->nr_of_lus; i++) {
1763     // Maybe this is only defined for v1.1 and later titles?
1764     /* If the bits in 'lu[i].exists' are enumerated abcd efgh then:
1765             VTS_x_yy.IFO        VIDEO_TS.IFO
1766        a == 0x83 "Root"         0x82 "Title"
1767        b == 0x84 "Subpicture"
1768        c == 0x85 "Audio"
1769        d == 0x86 "Angle"
1770        e == 0x87 "PTT"
1771     */
1772     CHECK_VALUE((pgci_ut->lu[i].exists & 0x07) == 0);
1773   }
1774
1775   for(i = 0; i < pgci_ut->nr_of_lus; i++) {
1776     pgci_ut->lu[i].pgcit = malloc(sizeof(pgcit_t));
1777     if(!pgci_ut->lu[i].pgcit) {
1778       unsigned int j;
1779       for(j = 0; j < i; j++) {
1780         ifoFree_PGCIT_internal(pgci_ut->lu[j].pgcit);
1781         free(pgci_ut->lu[j].pgcit);
1782       }
1783       free(pgci_ut->lu);
1784       free(pgci_ut);
1785       ifofile->pgci_ut = 0;
1786       return 0;
1787     }
1788     if(!ifoRead_PGCIT_internal(ifofile, pgci_ut->lu[i].pgcit,
1789                                sector * DVD_BLOCK_LEN
1790                                + pgci_ut->lu[i].lang_start_byte)) {
1791       unsigned int j;
1792       for(j = 0; j < i; j++) {
1793         ifoFree_PGCIT_internal(pgci_ut->lu[j].pgcit);
1794         free(pgci_ut->lu[j].pgcit);
1795       }
1796       free(pgci_ut->lu[i].pgcit);
1797       free(pgci_ut->lu);
1798       free(pgci_ut);
1799       ifofile->pgci_ut = 0;
1800       return 0;
1801     }
1802     // FIXME: Iterate and verify that all menus that should exists accordingly
1803     //        to pgci_ut->lu[i].exists really do?
1804   }
1805
1806   return 1;
1807 }
1808
1809
1810 void ifoFree_PGCI_UT(ifo_handle_t *ifofile) {
1811   unsigned int i;
1812
1813   if(!ifofile)
1814     return;
1815
1816   if(ifofile->pgci_ut) {
1817     for(i = 0; i < ifofile->pgci_ut->nr_of_lus; i++) {
1818       ifoFree_PGCIT_internal(ifofile->pgci_ut->lu[i].pgcit);
1819       free(ifofile->pgci_ut->lu[i].pgcit);
1820     }
1821     free(ifofile->pgci_ut->lu);
1822     free(ifofile->pgci_ut);
1823     ifofile->pgci_ut = 0;
1824   }
1825 }
1826
1827 static int ifoRead_VTS_ATTRIBUTES(ifo_handle_t *ifofile,
1828                                   vts_attributes_t *vts_attributes,
1829                                   unsigned int offset) {
1830   unsigned int i;
1831
1832   if(!DVDFileSeek_(ifofile->file, offset))
1833     return 0;
1834
1835   if(!(DVDReadBytes(ifofile->file, vts_attributes, sizeof(vts_attributes_t))))
1836     return 0;
1837
1838   B2N_32(vts_attributes->last_byte);
1839   B2N_32(vts_attributes->vts_cat);
1840   B2N_16(vts_attributes->vtsm_audio_attr.lang_code);
1841   B2N_16(vts_attributes->vtsm_subp_attr.lang_code);
1842   for(i = 0; i < 8; i++)
1843     B2N_16(vts_attributes->vtstt_audio_attr[i].lang_code);
1844   for(i = 0; i < 32; i++)
1845     B2N_16(vts_attributes->vtstt_subp_attr[i].lang_code);
1846
1847   CHECK_ZERO(vts_attributes->zero_1);
1848   CHECK_ZERO(vts_attributes->zero_2);
1849   CHECK_ZERO(vts_attributes->zero_3);
1850   CHECK_ZERO(vts_attributes->zero_4);
1851   CHECK_ZERO(vts_attributes->zero_5);
1852   CHECK_ZERO(vts_attributes->zero_6);
1853   CHECK_ZERO(vts_attributes->zero_7);
1854   CHECK_VALUE(vts_attributes->nr_of_vtsm_audio_streams <= 1);
1855   CHECK_VALUE(vts_attributes->nr_of_vtsm_subp_streams <= 1);
1856   CHECK_VALUE(vts_attributes->nr_of_vtstt_audio_streams <= 8);
1857   for(i = vts_attributes->nr_of_vtstt_audio_streams; i < 8; i++)
1858     CHECK_ZERO(vts_attributes->vtstt_audio_attr[i]);
1859   CHECK_VALUE(vts_attributes->nr_of_vtstt_subp_streams <= 32);
1860   {
1861     unsigned int nr_coded;
1862     CHECK_VALUE(vts_attributes->last_byte + 1 >= VTS_ATTRIBUTES_MIN_SIZE);
1863     nr_coded = (vts_attributes->last_byte + 1 - VTS_ATTRIBUTES_MIN_SIZE)/6;
1864     // This is often nr_coded = 70, how do you know how many there really are?
1865     if(nr_coded > 32) { // We haven't read more from disk/file anyway
1866       nr_coded = 32;
1867     }
1868     CHECK_VALUE(vts_attributes->nr_of_vtstt_subp_streams <= nr_coded);
1869     for(i = vts_attributes->nr_of_vtstt_subp_streams; i < nr_coded; i++)
1870       CHECK_ZERO(vts_attributes->vtstt_subp_attr[i]);
1871   }
1872
1873   return 1;
1874 }
1875
1876
1877
1878 int ifoRead_VTS_ATRT(ifo_handle_t *ifofile) {
1879   vts_atrt_t *vts_atrt;
1880   unsigned int i, info_length, sector;
1881   uint32_t *data;
1882
1883   if(!ifofile)
1884     return 0;
1885
1886   if(!ifofile->vmgi_mat)
1887     return 0;
1888
1889   if(ifofile->vmgi_mat->vts_atrt == 0) /* mandatory */
1890     return 0;
1891
1892   sector = ifofile->vmgi_mat->vts_atrt;
1893   if(!DVDFileSeek_(ifofile->file, sector * DVD_BLOCK_LEN))
1894     return 0;
1895
1896   vts_atrt = malloc(sizeof(vts_atrt_t));
1897   if(!vts_atrt)
1898     return 0;
1899
1900   ifofile->vts_atrt = vts_atrt;
1901
1902   if(!(DVDReadBytes(ifofile->file, vts_atrt, VTS_ATRT_SIZE))) {
1903     free(vts_atrt);
1904     ifofile->vts_atrt = 0;
1905     return 0;
1906   }
1907
1908   B2N_16(vts_atrt->nr_of_vtss);
1909   B2N_32(vts_atrt->last_byte);
1910
1911   CHECK_ZERO(vts_atrt->zero_1);
1912   CHECK_VALUE(vts_atrt->nr_of_vtss != 0);
1913   CHECK_VALUE(vts_atrt->nr_of_vtss < 100); //??
1914   CHECK_VALUE((uint32_t)vts_atrt->nr_of_vtss * (4 + VTS_ATTRIBUTES_MIN_SIZE) +
1915          VTS_ATRT_SIZE < vts_atrt->last_byte + 1);
1916
1917   info_length = vts_atrt->nr_of_vtss * sizeof(uint32_t);
1918   data = malloc(info_length);
1919   if(!data) {
1920     free(vts_atrt);
1921     ifofile->vts_atrt = 0;
1922     return 0;
1923   }
1924
1925   vts_atrt->vts_atrt_offsets = data;
1926
1927   if(!(DVDReadBytes(ifofile->file, data, info_length))) {
1928     free(data);
1929     free(vts_atrt);
1930     ifofile->vts_atrt = 0;
1931     return 0;
1932   }
1933
1934   for(i = 0; i < vts_atrt->nr_of_vtss; i++) {
1935     B2N_32(data[i]);
1936     CHECK_VALUE(data[i] + VTS_ATTRIBUTES_MIN_SIZE < vts_atrt->last_byte + 1);
1937   }
1938
1939   info_length = vts_atrt->nr_of_vtss * sizeof(vts_attributes_t);
1940   vts_atrt->vts = malloc(info_length);
1941   if(!vts_atrt->vts) {
1942     free(data);
1943     free(vts_atrt);
1944     ifofile->vts_atrt = 0;
1945     return 0;
1946   }
1947   for(i = 0; i < vts_atrt->nr_of_vtss; i++) {
1948     unsigned int offset = data[i];
1949     if(!ifoRead_VTS_ATTRIBUTES(ifofile, &(vts_atrt->vts[i]),
1950                                (sector * DVD_BLOCK_LEN) + offset)) {
1951       free(data);
1952       free(vts_atrt);
1953       ifofile->vts_atrt = 0;
1954       return 0;
1955     }
1956
1957     // This assert cant be in ifoRead_VTS_ATTRIBUTES
1958     CHECK_VALUE(offset + vts_atrt->vts[i].last_byte <= vts_atrt->last_byte + 1);
1959     // Is this check correct?
1960   }
1961
1962   return 1;
1963 }
1964
1965
1966 void ifoFree_VTS_ATRT(ifo_handle_t *ifofile) {
1967   if(!ifofile)
1968     return;
1969
1970   if(ifofile->vts_atrt) {
1971     free(ifofile->vts_atrt->vts);
1972     free(ifofile->vts_atrt->vts_atrt_offsets);
1973     free(ifofile->vts_atrt);
1974     ifofile->vts_atrt = 0;
1975   }
1976 }
1977
1978
1979 int ifoRead_TXTDT_MGI(ifo_handle_t *ifofile) {
1980   txtdt_mgi_t *txtdt_mgi;
1981
1982   if(!ifofile)
1983     return 0;
1984
1985   if(!ifofile->vmgi_mat)
1986     return 0;
1987
1988   /* Return successfully if there is nothing to read. */
1989   if(ifofile->vmgi_mat->txtdt_mgi == 0)
1990     return 1;
1991
1992   if(!DVDFileSeek_(ifofile->file,
1993                    ifofile->vmgi_mat->txtdt_mgi * DVD_BLOCK_LEN))
1994     return 0;
1995
1996   txtdt_mgi = malloc(sizeof(txtdt_mgi_t));
1997   if(!txtdt_mgi) {
1998     return 0;
1999   }
2000   ifofile->txtdt_mgi = txtdt_mgi;
2001
2002   if(!(DVDReadBytes(ifofile->file, txtdt_mgi, TXTDT_MGI_SIZE))) {
2003     fprintf(stderr, "libdvdread: Unable to read TXTDT_MGI.\n");
2004     free(txtdt_mgi);
2005     ifofile->txtdt_mgi = 0;
2006     return 0;
2007   }
2008
2009   // fprintf(stderr, "-- Not done yet --\n");
2010   return 1;
2011 }
2012
2013 void ifoFree_TXTDT_MGI(ifo_handle_t *ifofile) {
2014   if(!ifofile)
2015     return;
2016
2017   if(ifofile->txtdt_mgi) {
2018     free(ifofile->txtdt_mgi);
2019     ifofile->txtdt_mgi = 0;
2020   }
2021 }
2022