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