* ifo.c: Functions for ifo parsing
*****************************************************************************
* Copyright (C) 1999-2001 VideoLAN
- * $Id: ifo.c,v 1.1 2002/08/04 17:23:41 sam Exp $
+ * $Id: ifo.c,v 1.6 2003/10/25 00:49:13 sam Exp $
*
* Authors: Stéphane Borel <stef@via.ecp.fr>
* German Tischler <tanis@gaspode.franken.de>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
-#elif defined( _MSC_VER ) && defined( _WIN32 )
-# include <io.h>
#endif
#include <string.h>
static int FreeCellInf ( cell_inf_t * );
static int FreeTitleSet ( vts_t * );
-static u8* FillBuffer ( ifo_t *, u8 *, int );
-static u8 ReadByte ( ifo_t *, u8 *, u8 ** );
-static void ReadBytes ( ifo_t *, u8 *, u8 **, u8 *, int );
-static void DumpBytes ( ifo_t *, u8 *, u8 **, int );
-static u16 ReadWord ( ifo_t *, u8 *, u8 ** );
-static u32 ReadDouble ( ifo_t *, u8 *, u8 ** );
-static u64 ReadQuad ( ifo_t *, u8 *, u8 ** );
+static uint8_t* FillBuffer ( ifo_t *, uint8_t *, int );
+static uint8_t ReadByte ( ifo_t *, uint8_t *, uint8_t ** );
+static void ReadBytes ( ifo_t *, uint8_t *, uint8_t **, uint8_t *, int );
+static void DumpBytes ( ifo_t *, uint8_t *, uint8_t **, int );
+static uint16_t ReadWord ( ifo_t *, uint8_t *, uint8_t ** );
+static uint32_t ReadDouble ( ifo_t *, uint8_t *, uint8_t ** );
+static uint64_t ReadQuad ( ifo_t *, uint8_t *, uint8_t ** );
/*
* IFO Management.
p_dvd->p_ifo = malloc( sizeof(ifo_t) );
if( p_dvd->p_ifo == NULL )
{
-//X intf_Err( p_input, "unable to allocate memory. aborting" );
return -1;
}
+ /* memset to 0 to avoid crashing on deallocation later */
+ memset( p_dvd->p_ifo, 0, sizeof(ifo_t) );
/* if we are here the dvd device has already been opened */
p_dvd->p_ifo->dvdhandle = p_dvd->dvdhandle;
*****************************************************************************/
int IfoInit( ifo_t * p_ifo )
{
- u8 p_buf[DVD_LB_SIZE];
- u8* p_tmp;
- u64 i_temp;
+ uint8_t p_buf[DVD_LB_SIZE];
+ uint8_t * p_tmp;
+ uint64_t i_temp;
int i, j, k;
int i_start;
if( !p_ifo->i_start ) return -1;
p_tmp = FillBuffer( p_ifo, p_buf, p_ifo->i_start );
- //i_start = p_ifo->i_pos;
+ /*i_start = p_ifo->i_pos; */
/*
* read the video manager information table
*/
#define MGINF p_ifo->vmg.manager_inf
- //fprintf( stderr, "VMGI\n" );
+ /*fprintf( stderr, "VMGI\n" ); */
ReadBytes( p_ifo, p_buf, &p_tmp, MGINF.psz_id, 12 );
MGINF.psz_id[12] = '\0';
DumpBytes( p_ifo, p_buf, &p_tmp, 2 );
DumpBytes( p_ifo, p_buf, &p_tmp, 1 );
MGINF.i_audio_nb = ReadByte( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "vmgi audio nb : %d\n", MGINF.i_audio_nb );
+ /*fprintf( stderr, "vmgi audio nb : %d\n", MGINF.i_audio_nb ); */
for( i = 0 ; i < 8 ; i++ )
{
DumpBytes( p_ifo, p_buf, &p_tmp, 17 );
MGINF.i_spu_nb = ReadByte( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "vmgi subpic nb : %d\n", MGINF.i_spu_nb );
+ /*fprintf( stderr, "vmgi subpic nb : %d\n", MGINF.i_spu_nb ); */
for( i = 0 ; i < MGINF.i_spu_nb ; i++ )
{
- ReadBytes( p_ifo, p_buf, &p_tmp, (u8*)(&i_temp), 6 );
+ ReadBytes( p_ifo, p_buf, &p_tmp, (uint8_t*)(&i_temp), 6 );
/* FIXME : take care of endianness */
}
/*
* read first play title.
*/
- //fprintf(stderr,"readtitle %i\n", MGINF.i_first_play_title_start_byte & 0x7ff );
+ /*fprintf(stderr,"readtitle %i\n", MGINF.i_first_play_title_start_byte & 0x7ff ); */
if( ReadTitle( p_ifo, &p_ifo->vmg.title, p_ifo->i_start
+ OFF2LB( MGINF.i_first_play_title_start_byte ),
MGINF.i_first_play_title_start_byte & 0x7ff ) < 0 )
{
p_tmp = FillBuffer( p_ifo, p_buf,
p_ifo->i_start + MGINF.i_title_inf_start_sector );
- //fprintf( stderr, "title inf %d\n", p_ifo->i_pos );
-
+ /*fprintf( stderr, "title inf %d\n", p_ifo->i_pos ); */
+
TITINF.i_title_nb = ReadWord( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "title_inf: TTU nb %d\n", TITINF.i_title_nb );
+ /*fprintf( stderr, "title_inf: TTU nb %d\n", TITINF.i_title_nb ); */
DumpBytes( p_ifo, p_buf, &p_tmp, 2 );
TITINF.i_last_byte = ReadDouble( p_ifo, p_buf, &p_tmp );
-
+
/* parsing of title attributes */
TITINF.p_attr = malloc( TITINF.i_title_nb *sizeof(title_attr_t) );
if( TITINF.p_attr == NULL )
{
-//X intf_Err( p_input, "out of memory in IfoInit" );
return -1;
}
-
+
for( i = 0 ; i < TITINF.i_title_nb ; i++ )
{
TITINF.p_attr[i].i_play_type = ReadByte( p_ifo, p_buf, &p_tmp );
TITINF.p_attr[i].i_title_set_num = ReadByte( p_ifo, p_buf, &p_tmp );
TITINF.p_attr[i].i_title_num = ReadByte( p_ifo, p_buf, &p_tmp );
TITINF.p_attr[i].i_start_sector = ReadDouble( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "title_inf: %d %d %d\n", TITINF.p_attr[i].i_chapter_nb, TITINF.p_attr[i].i_title_set_num, TITINF.p_attr[i].i_title_num );
+ /*fprintf( stderr, "title_inf: %d %d %d\n", TITINF.p_attr[i].i_chapter_nb, TITINF.p_attr[i].i_title_set_num, TITINF.p_attr[i].i_title_num ); */
}
}
else
MGINF.i_parental_inf_start_sector );
i_start = p_ifo->i_pos;
- //fprintf( stderr, "PTL\n" );
-
+ /*fprintf( stderr, "PTL\n" ); */
+
PARINF.i_country_nb = ReadWord( p_ifo, p_buf, &p_tmp );
PARINF.i_vts_nb = ReadWord( p_ifo, p_buf, &p_tmp );
PARINF.i_last_byte = ReadDouble( p_ifo, p_buf, &p_tmp );
-
+
PARINF.p_parental_desc = malloc( PARINF.i_country_nb
* sizeof(parental_desc_t) );
if( PARINF.p_parental_desc == NULL )
{
-//X intf_Err( p_input, "out of memory in IfoInit" );
return -1;
}
* sizeof(parental_mask_t) );
if( PARINF.p_parental_mask == NULL )
{
-//X intf_Err( p_input, "out of memory in IfoInit" );
return -1;
}
for( j = 0 ; j < 8 ; j++ )
{
PARINF.p_parental_mask[i].ppi_mask[j] =
- malloc( ( PARINF.i_vts_nb + 1 ) * sizeof(u16) );
+ malloc( ( PARINF.i_vts_nb + 1 ) * sizeof(uint16_t) );
if( PARINF.p_parental_mask[i].ppi_mask[j] == NULL )
{
-//X intf_Err( p_input, "out of memory in IfoInit" );
return -1;
}
#define VTSINF p_ifo->vmg.vts_inf
if( MGINF.i_vts_inf_start_sector )
{
- u64 i_temp;
+ uint64_t i_temp;
p_tmp = FillBuffer( p_ifo, p_buf, p_ifo->i_start +
MGINF.i_vts_inf_start_sector );
i_start = p_ifo->i_pos;
-
- //fprintf( stderr, "VTS ATTR\n" );
-
+
+ /*fprintf( stderr, "VTS ATTR\n" ); */
+
VTSINF.i_vts_nb = ReadWord( p_ifo, p_buf, &p_tmp );;
- //fprintf( stderr, "VTS ATTR Nb: %d\n", VTSINF.i_vts_nb );
+ /*fprintf( stderr, "VTS ATTR Nb: %d\n", VTSINF.i_vts_nb ); */
DumpBytes( p_ifo, p_buf, &p_tmp, 2 );
VTSINF.i_last_byte = ReadDouble( p_ifo, p_buf, &p_tmp );
VTSINF.pi_vts_attr_start_byte =
- malloc( VTSINF.i_vts_nb * sizeof(u32) );
+ malloc( VTSINF.i_vts_nb * sizeof(uint32_t) );
if( VTSINF.pi_vts_attr_start_byte == NULL )
{
-//X intf_Err( p_input, "out of memory in IfoInit" );
return -1;
}
VTSINF.p_vts_attr = malloc( VTSINF.i_vts_nb * sizeof(vts_attr_t) );
if( VTSINF.p_vts_attr == NULL )
{
-//X intf_Err( p_input, "out of memory in IfoInit" );
return -1;
}
DumpBytes( p_ifo, p_buf, &p_tmp, 1 );
VTSINF.p_vts_attr[i].i_vts_menu_audio_nb =
ReadByte( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "m audio nb : %d\n", VTSINF.p_vts_attr[i].i_vts_menu_audio_nb );
+ /*fprintf( stderr, "m audio nb : %d\n", VTSINF.p_vts_attr[i].i_vts_menu_audio_nb ); */
for( j = 0 ; j < 8 ; j++ )
{
DumpBytes( p_ifo, p_buf, &p_tmp, 17 );
VTSINF.p_vts_attr[i].i_vts_menu_spu_nb =
ReadByte( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "m subp nb : %d\n", VTSINF.p_vts_attr[i].i_vts_menu_spu_nb );
+ /*fprintf( stderr, "m subp nb : %d\n", VTSINF.p_vts_attr[i].i_vts_menu_spu_nb ); */
for( j = 0 ; j < 28 ; j++ )
{
/* FIXME : Fix endianness issue here */
- ReadBytes( p_ifo, p_buf, &p_tmp, (u8*)(&i_temp), 6 );
+ ReadBytes( p_ifo, p_buf, &p_tmp, (uint8_t*)(&i_temp), 6 );
}
DumpBytes( p_ifo, p_buf, &p_tmp, 2 );
DumpBytes( p_ifo, p_buf, &p_tmp, 1 );
VTSINF.p_vts_attr[i].i_vts_title_audio_nb =
ReadDouble( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "tt audio nb : %d\n", VTSINF.p_vts_attr[i].i_vts_title_audio_nb );
+ /*fprintf( stderr, "tt audio nb : %d\n", VTSINF.p_vts_attr[i].i_vts_title_audio_nb ); */
for( j = 0 ; j < 8 ; j++ )
{
DumpBytes( p_ifo, p_buf, &p_tmp, 17 );
VTSINF.p_vts_attr[i].i_vts_title_spu_nb =
ReadByte( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "tt subp nb : %d\n", VTSINF.p_vts_attr[i].i_vts_title_spu_nb );
+ /*fprintf( stderr, "tt subp nb : %d\n", VTSINF.p_vts_attr[i].i_vts_title_spu_nb ); */
for( j = 0 ; j < 28 /*VTSINF.p_vts_vts_inf[i].i_vtstt_subpic_nb*/ ; j++ )
{
/* FIXME : Fix endianness issue here */
- ReadBytes( p_ifo, p_buf, &p_tmp, (u8*)(&i_temp), 6 );
+ ReadBytes( p_ifo, p_buf, &p_tmp, (uint8_t*)(&i_temp), 6 );
}
}
}
p_ifo->vts.b_initialized = 0;
-//X intf_Warn( p_input, 2, "vmg initialized" );
-
return 0;
}
*****************************************************************************/
int IfoTitleSet( ifo_t * p_ifo, int i_title )
{
- u8 p_buf[DVD_LB_SIZE];
- u8 * p_tmp;
+ uint8_t p_buf[DVD_LB_SIZE];
+ uint8_t * p_tmp;
int i_off;
int i_start;
- u64 i_temp;
- u16 i_short;
+ uint64_t i_temp;
+ uint16_t i_short;
int i, j;
if( p_ifo->vts.b_initialized )
i_off = p_ifo->vmg.title_inf.p_attr[i_title-1].i_start_sector
+ p_ifo->i_start;
- //fprintf(stderr, "offset: %d\n" , i_off );
+ /*fprintf(stderr, "offset: %d\n" , i_off ); */
p_tmp = FillBuffer( p_ifo, p_buf, i_off );
- //i_start = p_ifo->i_pos;
+ /*i_start = p_ifo->i_pos; */
p_ifo->vts.i_pos = p_ifo->i_pos;
#define MGINF p_ifo->vts.manager_inf
/*
* read manager information
*/
- //fprintf( stderr, "VTSI\n" );
+ /*fprintf( stderr, "VTSI\n" ); */
ReadBytes( p_ifo, p_buf, &p_tmp, MGINF.psz_id , 12 );
MGINF.psz_id[12] = '\0';
for( i = 0 ; i < 28 ; i++ )
{
/* FIXME : take care of endianness */
- ReadBytes( p_ifo, p_buf, &p_tmp, (u8*)(&i_temp), 6 );
+ ReadBytes( p_ifo, p_buf, &p_tmp, (uint8_t*)(&i_temp), 6 );
}
DumpBytes( p_ifo, p_buf, &p_tmp, 2 );
DumpBytes( p_ifo, p_buf, &p_tmp, 1 );
MGINF.i_audio_nb = ReadByte( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "vtsi audio nb : %d\n", MGINF.i_audio_nb );
+ /*fprintf( stderr, "vtsi audio nb : %d\n", MGINF.i_audio_nb ); */
for( i = 0 ; i < 8 ; i++ )
{
i_temp = ReadQuad( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "Audio %d: %llx\n", i, i_temp );
+ /*fprintf( stderr, "Audio %d: "I64Fx"\n", i, i_temp ); */
i_temp >>= 8;
MGINF.p_audio_attr[i].i_bar = i_temp & 0xff;
i_temp >>= 8;
DumpBytes( p_ifo, p_buf, &p_tmp, 17 );
MGINF.i_spu_nb = ReadByte( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "vtsi subpic nb : %d\n", MGINF.i_spu_nb );
+ /*fprintf( stderr, "vtsi subpic nb : %d\n", MGINF.i_spu_nb ); */
for( i=0 ; i<MGINF.i_spu_nb ; i++ )
{
- ReadBytes( p_ifo, p_buf, &p_tmp, (u8*)(&i_temp), 6 );
+ ReadBytes( p_ifo, p_buf, &p_tmp, (uint8_t*)(&i_temp), 6 );
i_temp = hton64( i_temp ) >> 16;
- //fprintf( stderr, "Subpic %d: %llx\n", i, i_temp );
+ /*fprintf( stderr, "Subpic %d: "I64Fx"\n", i, i_temp ); */
MGINF.p_spu_attr[i].i_caption = i_temp & 0xff;
i_temp >>= 8;
MGINF.p_spu_attr[i].i_foo = i_temp & 0xff;
MGINF.i_title_inf_start_sector );
i_start = p_ifo->i_pos;
-
- //fprintf( stderr, "VTS PTR\n" );
-
+
+ /*fprintf( stderr, "VTS PTR\n" ); */
+
TITINF.i_title_nb = ReadWord( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "VTS title_inf nb: %d\n", TITINF.i_title_nb );
+ /*fprintf( stderr, "VTS title_inf nb: %d\n", TITINF.i_title_nb ); */
DumpBytes( p_ifo, p_buf, &p_tmp, 2 );
TITINF.i_last_byte = ReadDouble( p_ifo, p_buf, &p_tmp );
- TITINF.pi_start_byte = malloc( TITINF.i_title_nb * sizeof(u32) );
+ TITINF.pi_start_byte = malloc( TITINF.i_title_nb * sizeof(uint32_t) );
if( TITINF.pi_start_byte == NULL )
{
-//X intf_Err( p_input, "out of memory in IfoTitleSet" );
return -1;
}
* sizeof(title_start_t) );
if( TITINF.p_title_start == NULL )
{
-//X intf_Err( p_input, "out of memory in IfoTitleSet" );
return -1;
}
#define TIMINF p_ifo->vts.time_inf
if( MGINF.i_time_inf_start_sector )
{
- u8 p_buf[DVD_LB_SIZE];
+ uint8_t p_buf[DVD_LB_SIZE];
p_tmp = FillBuffer( p_ifo, p_buf, p_ifo->vts.i_pos +
MGINF.i_time_inf_start_sector );
- //fprintf( stderr, "TMAP\n" );
+ /*fprintf( stderr, "TMAP\n" ); */
TIMINF.i_nb = ReadWord( p_ifo, p_buf, &p_tmp );;
DumpBytes( p_ifo, p_buf, &p_tmp, 2 );
TIMINF.i_last_byte = ReadDouble( p_ifo, p_buf, &p_tmp );
- TIMINF.pi_start_byte = malloc( TIMINF.i_nb * sizeof(u32) );
+ TIMINF.pi_start_byte = malloc( TIMINF.i_nb * sizeof(uint32_t) );
if( TIMINF.pi_start_byte == NULL )
{
-//X intf_Err( p_input, "out of memory in IfoTitleSet" );
return -1;
}
for( i = 0 ; i < TIMINF.i_nb ; i++ )
- {
+ {
TIMINF.pi_start_byte[i] = ReadDouble( p_ifo, p_buf, &p_tmp );
}
TIMINF.p_time_map = malloc( TIMINF.i_nb * sizeof(time_map_t) );
if( TIMINF.p_time_map == NULL )
{
-//X intf_Err( p_input, "out of memory in IfoTitleSet" );
return -1;
}
for( i = 0 ; i < TIMINF.i_nb ; i++ )
- {
+ {
TIMINF.p_time_map[i].i_time_unit = ReadByte( p_ifo, p_buf, &p_tmp );
DumpBytes( p_ifo, p_buf, &p_tmp, 1 );
TIMINF.p_time_map[i].i_entry_nb = ReadWord( p_ifo, p_buf, &p_tmp );
if( TIMINF.p_time_map[i].i_entry_nb )
{
TIMINF.p_time_map[i].pi_sector =
- malloc( TIMINF.p_time_map[i].i_entry_nb * sizeof(u32) );
+ malloc( TIMINF.p_time_map[i].i_entry_nb * sizeof(uint32_t) );
if( TIMINF.p_time_map[i].pi_sector == NULL )
{
-//X msg_Err( p_input, "out of memory in IfoTitleSet" );
return -1;
}
}
#undef MGINF
-//X intf_Warn( p_input, 4, "vts %d initialized",
-//X p_ifo->vmg.title_inf.p_attr[i_title-1].i_title_set_num );
+#if 0
+ intf_Warn( p_input, 4, "vts %d initialized",
+ p_ifo->vmg.title_inf.p_attr[i_title-1].i_title_set_num );
+#endif
p_ifo->vts.b_initialized = 1;
}
p_vts->b_initialized = 0;
-
+
return 0;
}
{
for( j = 0 ; j < 8 ; j++ )
{
- free( p_ifo->vmg.parental_inf.p_parental_mask[i].ppi_mask[j] );
+ if ( p_ifo->vmg.parental_inf.p_parental_mask[i].ppi_mask[j] != NULL )
+ free( p_ifo->vmg.parental_inf.p_parental_mask[i].ppi_mask[j] );
}
}
- free( p_ifo->vmg.parental_inf.p_parental_mask );
- free( p_ifo->vmg.parental_inf.p_parental_desc );
+ if ( p_ifo->vmg.parental_inf.p_parental_mask != NULL )
+ free( p_ifo->vmg.parental_inf.p_parental_mask );
+ if ( p_ifo->vmg.parental_inf.p_parental_desc != NULL )
+ free( p_ifo->vmg.parental_inf.p_parental_desc );
}
if( p_ifo->vmg.manager_inf.i_title_unit_start_sector )
*****************************************************************************/
static int ReadTitle( ifo_t * p_ifo, title_t * p_title, int i_block, int i_bytes )
{
- u8 p_buf[DVD_LB_SIZE];
- u8 * p_tmp;
+ uint8_t p_buf[DVD_LB_SIZE];
+ uint8_t * p_tmp;
int i_start;
- u16 i_audio;
- u32 i_spu;
+ uint16_t i_audio;
+ uint32_t i_spu;
int i;
p_tmp = FillBuffer( p_ifo, p_buf, i_block ) + i_bytes;
i_start = p_ifo->i_pos;
- //fprintf( stderr, "PGC @ %d + %d\n", p_ifo->i_pos, i_bytes );
+ /*fprintf( stderr, "PGC @ %d + %d\n", p_ifo->i_pos, i_bytes ); */
DumpBytes( p_ifo, p_buf, &p_tmp, 2);
p_title->i_chapter_nb = ReadByte( p_ifo, p_buf, &p_tmp );
p_title->i_cell_nb = ReadByte( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "title: Prg: %d Cell: %d\n",p_title->i_chapter_nb,p_title->i_cell_nb );
+ /*fprintf( stderr, "title: Prg: %d Cell: %d\n",p_title->i_chapter_nb,p_title->i_cell_nb ); */
p_title->i_play_time = ReadDouble( p_ifo, p_buf, &p_tmp );
p_title->i_prohibited_user_op = ReadDouble( p_ifo, p_buf, &p_tmp );
if( p_title->command.p_pre_command == NULL )
{
-//X intf_Err( p_input, "out of memory in ReadTitle" );
return -1;
}
if( p_title->command.p_post_command == NULL )
{
-//X intf_Err( p_input, "out of memory in ReadTitle" );
return -1;
}
if( p_title->command.p_cell_command == NULL )
{
-//X intf_Err( p_input, "out of memory in ReadTitle" );
return -1;
}
p_ifo->i_pos = dvdcss_seek( p_ifo->dvdhandle,
OFF2LB( i_start + p_title->i_chapter_map_start_byte ),
DVDCSS_NOFLAGS );
-
+
p_title->chapter_map.pi_start_cell =
malloc( p_title->i_chapter_nb * sizeof(chapter_map_t) );
-
+
if( p_title->chapter_map.pi_start_cell == NULL )
{
-//X intf_Err( p_input, "out of memory in Read Title" );
return -1;
}
}
else
{
- p_title->chapter_map.pi_start_cell = NULL;
+ p_title->chapter_map.pi_start_cell = NULL;
}
/* parsing of cell_play_t */
p_title->p_cell_play = malloc( p_title->i_cell_nb
* sizeof(cell_play_t) );
-
+
if( p_title->p_cell_play == NULL )
{
-//X intf_Err( p_input, "out of memory in ReadTitle" );
return -1;
}
if( p_title->p_cell_pos == NULL )
{
-//X intf_Err( p_input, "out of memory" );
return -1;
}
DumpBytes( p_ifo, p_buf, &p_tmp, 1 );
p_title->p_cell_pos[i].i_cell_id = ReadByte( p_ifo, p_buf, &p_tmp );
}
- }
+ }
return 0;
}
static int ReadUnitInf( ifo_t * p_ifo, unit_inf_t * p_unit_inf,
int i_block, int i_bytes )
{
- u8 p_buf[DVD_LB_SIZE];
- u8 * p_tmp;
+ uint8_t p_buf[DVD_LB_SIZE];
+ uint8_t * p_tmp;
int i_start;
int i;
p_tmp = FillBuffer( p_ifo, p_buf, i_block ) + i_bytes;
i_start = p_ifo->i_pos;
- //fprintf( stderr, "Unit\n" );
+ /*fprintf( stderr, "Unit\n" ); */
p_unit_inf->i_title_nb = ReadWord( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "Unit nb: %d\n", p_unit_inf->i_title_nb );
+ /*fprintf( stderr, "Unit nb: %d\n", p_unit_inf->i_title_nb ); */
DumpBytes( p_ifo, p_buf, &p_tmp, 2 );
p_unit_inf->i_last_byte = ReadDouble( p_ifo, p_buf, &p_tmp );
malloc( p_unit_inf->i_title_nb * sizeof(unit_title_t) );
if( p_unit_inf->p_title == NULL )
{
-//X intf_Err( p_input, "out of memory in ReadUnit" );
return -1;
}
#define TITLE p_unit_inf->p_title[i]
TITLE.i_category_mask = ReadByte( p_ifo, p_buf, &p_tmp );
TITLE.i_category = ReadByte( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "cat mask %d: %x cat %x\n", i, TITLE.i_category_mask, TITLE.i_category );
+ /*fprintf( stderr, "cat mask %d: %x cat %x\n", i, TITLE.i_category_mask, TITLE.i_category ); */
TITLE.i_parental_mask = ReadWord( p_ifo, p_buf, &p_tmp );
TITLE.i_title_start_byte = ReadDouble( p_ifo, p_buf, &p_tmp );
#undef TITLE
for( i = 0 ; i < p_unit_inf->i_title_nb ; i++ )
{
- //fprintf( stderr, "Unit: PGC %d @ %d\n", i, p_ifo->i_pos );
+ /*fprintf( stderr, "Unit: PGC %d @ %d\n", i, p_ifo->i_pos ); */
ReadTitle( p_ifo, &p_unit_inf->p_title[i].title, i_start +
OFF2LB( p_unit_inf->p_title[i].i_title_start_byte + i_bytes ),
(p_unit_inf->p_title[i].i_title_start_byte+i_bytes) & 0x7ff );
/*****************************************************************************
* FreeUnitInf : frees a structure allocated by ReadUnit
- *****************************************************************************/
+ *****************************************************************************/
static int FreeUnitInf( unit_inf_t * p_unit_inf )
{
int i;
-
+
if( p_unit_inf->p_title != NULL )
{
for( i = 0 ; i < p_unit_inf->i_title_nb ; i++ )
{
FreeTitle( &p_unit_inf->p_title[i].title );
}
-
+
free( p_unit_inf->p_title );
}
static int ReadTitleUnit( ifo_t * p_ifo, title_unit_t * p_title_unit,
int i_block )
{
- u8 p_buf[DVD_LB_SIZE];
- u8 * p_tmp;
+ uint8_t p_buf[DVD_LB_SIZE];
+ uint8_t * p_tmp;
int i;
int i_start;
p_tmp = FillBuffer( p_ifo, p_buf, i_block );
i_start = p_ifo->i_pos;
- //fprintf( stderr, "Unit Table\n" );
+ /*fprintf( stderr, "Unit Table\n" ); */
p_title_unit->i_unit_nb = ReadWord( p_ifo, p_buf, &p_tmp );
DumpBytes( p_ifo, p_buf, &p_tmp, 2 );
p_title_unit->i_last_byte = ReadDouble( p_ifo, p_buf, &p_tmp );
- //fprintf(stderr, "Unit: nb %d last %d\n", p_title_unit->i_unit_nb, p_title_unit->i_last_byte );
+ /*fprintf(stderr, "Unit: nb %d last %d\n", p_title_unit->i_unit_nb, p_title_unit->i_last_byte ); */
p_title_unit->p_unit = malloc( p_title_unit->i_unit_nb * sizeof(unit_t) );
if( p_title_unit->p_unit == NULL )
{
-//X intf_Err( p_input, "out of memory in ReadTitleUnit" );
return -1;
}
for( i = 0 ; i < p_title_unit->i_unit_nb ; i++ )
{
- //ReadBytes( p_ifo, p_buf, &p_tmp, p_title_unit->p_unit[i].ps_lang_code, 2 );
+ /*ReadBytes( p_ifo, p_buf, &p_tmp, p_title_unit->p_unit[i].ps_lang_code, 2 ); */
p_title_unit->p_unit[i].i_lang_code = ReadWord( p_ifo, p_buf, &p_tmp );
- //fprintf( stderr, "lang %d %x\n", i,p_title_unit->p_unit[i].i_lang_code );
+ /*fprintf( stderr, "lang %d %x\n", i,p_title_unit->p_unit[i].i_lang_code ); */
DumpBytes( p_ifo, p_buf, &p_tmp, 1 );
p_title_unit->p_unit[i].i_existence_mask =
ReadByte( p_ifo, p_buf, &p_tmp );
malloc( p_title_unit->i_unit_nb * sizeof(unit_inf_t) );
if( p_title_unit->p_unit_inf == NULL )
{
-//X intf_Err( p_input, "out of memory in ReadTitleUnit" );
return -1;
}
*****************************************************************************/
static int ReadCellInf( ifo_t * p_ifo, cell_inf_t * p_cell_inf, int i_block )
{
- u8 p_buf[DVD_LB_SIZE];
- u8 * p_tmp;
+ uint8_t p_buf[DVD_LB_SIZE];
+ uint8_t * p_tmp;
int i_start;
int i;
p_tmp = FillBuffer( p_ifo, p_buf, i_block );
i_start = p_ifo->i_pos;
-// fprintf( stderr, "CELL ADD\n" );
+/* fprintf( stderr, "CELL ADD\n" ); */
p_cell_inf->i_vob_nb = ReadWord( p_ifo, p_buf, &p_tmp );
DumpBytes( p_ifo, p_buf, &p_tmp, 2 );
malloc( p_cell_inf->i_cell_nb *sizeof(cell_map_t) );
if( p_cell_inf->p_cell_map == NULL )
{
-//X intf_Err( p_input, "out of memory in ReadCellInf" );
return -1;
}
MAP.i_cell_id = ReadByte( p_ifo, p_buf, &p_tmp );
DumpBytes( p_ifo, p_buf, &p_tmp, 1 );
MAP.i_first_sector = ReadDouble( p_ifo, p_buf, &p_tmp );
-/* fprintf(stderr, "sector[%d] %d (%d)\n", i,ntohl(*(u32*)(p_tmp)), p_ifo->i_pos);*/
+/* fprintf(stderr, "sector[%d] %d (%d)\n", i,ntohl(*(uint32_t*)(p_tmp)), p_ifo->i_pos);*/
MAP.i_last_sector = ReadDouble( p_ifo, p_buf, &p_tmp );
#undef MAP
}
-
+
return 0;
}
*****************************************************************************/
static int ReadVobuMap( ifo_t * p_ifo, vobu_map_t * p_vobu_map, int i_block )
{
- u8 p_buf[DVD_LB_SIZE];
- u8 * p_tmp;
+ uint8_t p_buf[DVD_LB_SIZE];
+ uint8_t * p_tmp;
int i_start;
int i, i_max;
-
+
p_tmp = FillBuffer( p_ifo, p_buf, i_block );
i_start = p_ifo->i_pos;
- //fprintf( stderr, "VOBU ADMAP\n" );
+ /*fprintf( stderr, "VOBU ADMAP\n" ); */
p_vobu_map->i_last_byte = ReadDouble( p_ifo, p_buf, &p_tmp );
i_max = ( i_start + p_vobu_map->i_last_byte + 1 - p_ifo->i_pos )
- / sizeof(u32);
+ / sizeof(uint32_t);
- p_vobu_map->pi_vobu_start_sector = malloc( i_max * sizeof(u32) );
+ p_vobu_map->pi_vobu_start_sector = malloc( i_max * sizeof(uint32_t) );
if( p_vobu_map->pi_vobu_start_sector == NULL )
{
-//X intf_Err( p_input, "out of memory in ReadVobuMap" );
return -1;
}
static char math_op[][10] =
{
"none",
- "=",
- "<->", // swap
+ "=",
+ "<->", /* swap */
"+=",
"-=",
"*=",
"/=",
"%=",
- "rnd", // rnd
+ "rnd", /* rnd */
"&=",
"|=",
"^=",
- "??", // invalid
- "??", // invalid
- "??", // invalid
- "??" // invalid
+ "??", /* invalid */
+ "??", /* invalid */
+ "??", /* invalid */
+ "??" /* invalid */
};
return (char *) math_op[val & 0x0f];
return ifo_menu_id[index&0x07];
}
-static void IfoRegister( u16 i_data, u8 i_direct)
+static void IfoRegister( uint16_t i_data, uint8_t i_direct)
{
if( i_direct )
{
}
}
-static void IfoAdvanced( u8 *pi_code )
-{
- u8 i_cmd = pi_code[0];
+static void IfoAdvanced( uint8_t *pi_code ){
+ uint8_t i_cmd = pi_code[0];
printf(" { ");
printf( "ReSuME %d", pi_code[7] );
}
else if( ( i_cmd & 0x06) == 0x02 )
- { // XX01Y
+ { /* XX01Y */
printf ("Link to %s cell ", ( i_cmd & 0x01 ) ? "prev" : "next");
}
else
{
case 0x00:
printf( "to play first PGC" );
- break;
+ break;
case 0x01:
printf( "to VMG title menu (?)" );
break;
OP_VAL_8(2),
OP_VAL_8(1),
IfoMenuName( OP_VAL_8(3)&0xF ) );
- break;
+ break;
case 0x03:
printf( "vmg pgc 0x%04x (?)", ( OP_VAL_8(0)<<8) | OP_VAL_8(1) );
break;
break;
}
#else
- // OP_VAL_8(2) is number of cell
- // it is processed BEFORE switch
- // under some conditions, it is ignored
- // I don't understand exactly what it means
- printf( " ( spec cell 0x%02X ) ", OP_VAL_8(2) );
+ /* OP_VAL_8(2) is number of cell */
+ /* it is processed BEFORE switch */
+ /* under some conditions, it is ignored */
+ /* I don't understand exactly what it means */
+ printf( " ( spec cell 0x%02X ) ", OP_VAL_8(2) );
switch( OP_VAL_8(3)>>6 )
{
case 2:
printf( "to VTS menu \"%s\" (?)",
IfoMenuName(OP_VAL_8(3)&0xF) );
- break;
+ break;
case 3:
printf( "vmg pgc 0x%02x (?)", (OP_VAL_8(0)<<8)|OP_VAL_8(1) );
break;
- }
+ }
#endif
break;
}
static void IfoLnk( ifo_command_t com )
{
- u16 i_button=OP_VAL_8(4)>>2;
+ uint16_t i_button = OP_VAL_8(4)>>2;
printf ("lnk to ");
case 0x04:
printf( "PGC 0x%02x", OP_VAL_16(2) );
- break;
+ break;
case 0x05:
printf( "PTT 0x%02x", OP_VAL_16(2) );
- break;
+ break;
case 0x06:
printf( "Program 0x%02x this PGC", OP_VAL_8(5) );
{
printf( ", Highlight 0x%02x", OP_VAL_8(4)>>2 );
}
-
+
}
void IfoSetSystem( ifo_command_t com )
if(OP_VAL_8(1]&0x80)
printf ("s[%s] = 0x%02x;", reg_name[1], OP_VAL_8(1]&0xf);
if(OP_VAL_8(2)&0x80)
-//DENT: lwhat about 0x7f here ???
+/*DENT: lwhat about 0x7f here ??? */
printf ("s[%s] = 0x%02x;", reg_name[2], OP_VAL_8(2)&0x7f);
if(OP_VAL_8(3)&0x80)
printf ("s[%s] = 0x%02x;", reg_name[3], OP_VAL_8(3)&0xf);
printf( "s[%s] = r[0x%02x]", ifo_reg[9], OP_VAL_8(1)&0x0f );
}
- printf( "s[%s] = (s[%s]&0x7FFF)|0x%02x",
+ printf( "s[%s] = (s[%s]&0x7FFF)|0x%02x",
ifo_reg[10], ifo_reg[10], OP_VAL_16(1)&0x8000);
break;
case 3:
}
break;
case 4:
- //actually only bits 00011100 00011100 are set
+ /*actually only bits 00011100 00011100 are set */
if( com.i_direct )
{
printf ("s[%s] = 0x%02x", ifo_reg[11], OP_VAL_16(1));
}
break;
case 6:
- //actually,
- //s[%s]=(r[%s]&0x3FF) | (0x%02x << 0xA);
- //but it is way too ugly
+ /*actually, */
+ /*s[%s]=(r[%s]&0x3FF) | (0x%02x << 0xA); */
+ /*but it is way too ugly */
if( com.i_direct )
{
printf( "s[%s] = 0x%02x", ifo_reg[8], OP_VAL_8(2)>>2 );
*****************************************************************************/
void CommandRead( ifo_command_t com )
{
- u8* pi_code = (u8*)(&com);
+ uint8_t * pi_code = (uint8_t*)(&com);
switch( com.i_type )
{
IfoRegister (OP_VAL_16(1), com.i_dir_cmp);
printf (") ");
}
-
+
/* Sub command */
switch( com.i_sub_cmd )
{
case 1:
printf( "goto Line 0x%02x", OP_VAL_16(2) );
break;
-
+
case 2:
printf( "stop VM" );
break;
-
+
case 3:
printf( "Set Parental Level To %s and goto Line 0x%02x",
ifo_parental[OP_VAL_8(4)&0x7],
OP_VAL_8(5) );
break;
-
+
default:
printf( "Illegal" );
break;
IfoJmp( com );
}
else
- {
+ {
if( com.i_cmp )
{
printf( "if (r[0x%02x] %s ", OP_VAL_8(1)&0x0f,
}
break;
- /*
+ /*
* math command on r[opcode[1]] and
* direct?be2me_16(OP_VAL_8(0)):reg[OP_VAL_8(1)] is executed
* ( unless command is swap; then r[opcode[1]] and r[OP_VAL_8(1)]
else
{
printf( "r[0x%X]", OP_VAL_8(3)&0x1F);
- // 0x1F is either not a mistake,
- // or Microsoft programmer's mistake!!!
+ /* 0x1F is either not a mistake, */
+ /* or Microsoft programmer's mistake!!! */
}
}
printf( "r[0x%X] ", pi_code[1] & 0xF );
printf( " %s ", IfoMath( com.i_cmd ) );
- if( com.i_cmd == 0x02 ) // swap
+ if( com.i_cmd == 0x02 ) /* swap */
{
printf("r[0x%X] ", OP_VAL_8(0)&0x1F);
}
/*****************************************************************************
* ReadByte and so
*****************************************************************************/
-static u8* FillBuffer( ifo_t* p_ifo, u8* p_buf, int i_pos )
+static uint8_t* FillBuffer( ifo_t* p_ifo, uint8_t* p_buf, int i_pos )
{
p_ifo->i_pos = dvdcss_seek( p_ifo->dvdhandle, i_pos, DVDCSS_NOFLAGS );
dvdcss_read( p_ifo->dvdhandle, p_buf, 1, DVDCSS_NOFLAGS );
return p_buf;
}
-static void ReadBytes( ifo_t* p_ifo, u8* p_buf, u8** pp_tmp,
- u8* pi_dest, int i_nb )
+static void ReadBytes( ifo_t* p_ifo, uint8_t* p_buf, uint8_t** pp_tmp,
+ uint8_t* pi_dest, int i_nb )
{
if( i_nb > DVD_LB_SIZE )
{
-//X intf_Err( p_input, "excessive ReadBytes call (%i)", i_nb );
+#if 0
+ intf_Err( p_input, "excessive ReadBytes call (%i)", i_nb );
+#endif
}
if( *pp_tmp + i_nb >= p_buf + DVD_LB_SIZE )
return;
}
-static void DumpBytes( ifo_t* p_ifo, u8* p_buf, u8** pp_tmp, int i_nb )
+static void DumpBytes( ifo_t* p_ifo, uint8_t* p_buf, uint8_t** pp_tmp, int i_nb )
{
if( i_nb > DVD_LB_SIZE )
{
-//X intf_Err( p_input, "excessive DumpBytes call (%i)", i_nb );
+#if 0
+ intf_Err( p_input, "excessive DumpBytes call (%i)", i_nb );
+#endif
}
*pp_tmp += i_nb;
} \
i_ret <<= 8; i_ret |= **pp_tmp; (*pp_tmp)++;
-static u8 ReadByte( ifo_t * p_ifo, u8* p_buf, u8** pp_tmp )
+static uint8_t ReadByte( ifo_t * p_ifo, uint8_t* p_buf, uint8_t** pp_tmp )
{
- u8 i_ret = 0;
+ uint8_t i_ret = 0;
ADDBYTE;
return i_ret;
}
-static u16 ReadWord( ifo_t * p_ifo, u8* p_buf, u8** pp_tmp )
+static uint16_t ReadWord( ifo_t * p_ifo, uint8_t* p_buf, uint8_t** pp_tmp )
{
- u16 i_ret = 0;
+ uint16_t i_ret = 0;
ADDBYTE; ADDBYTE;
return i_ret;
}
-static u32 ReadDouble( ifo_t * p_ifo, u8* p_buf, u8** pp_tmp )
+static uint32_t ReadDouble( ifo_t * p_ifo, uint8_t* p_buf, uint8_t** pp_tmp )
{
- u32 i_ret = 0;
+ uint32_t i_ret = 0;
ADDBYTE; ADDBYTE; ADDBYTE; ADDBYTE;
return i_ret;
}
-static u64 ReadQuad( ifo_t * p_ifo, u8* p_buf, u8** pp_tmp )
+static uint64_t ReadQuad( ifo_t * p_ifo, uint8_t* p_buf, uint8_t** pp_tmp )
{
- u64 i_ret = 0;
+ uint64_t i_ret = 0;
ADDBYTE; ADDBYTE; ADDBYTE; ADDBYTE; ADDBYTE; ADDBYTE; ADDBYTE; ADDBYTE;
return i_ret;
}
projects / vlc / blobdiff