From cf9e7c61acc9b4ddb2de61766f40610c72d2b22c Mon Sep 17 00:00:00 2001 From: Jean-Marc Dressler Date: Sat, 15 Jan 2000 14:26:29 +0000 Subject: [PATCH] Le debuggage du parser avance ... lentement. --- include/video_parser.h | 6 +- include/vpar_headers.h | 18 ++-- src/video_parser/video_parser.c | 6 ++ src/video_parser/vpar_blocks.c | 153 +++++++++++++++++++------------- src/video_parser/vpar_headers.c | 31 ++++--- src/video_parser/vpar_synchro.c | 2 +- 6 files changed, 129 insertions(+), 87 deletions(-) diff --git a/include/video_parser.h b/include/video_parser.h index d35a1bc46b..5c95bde1bb 100644 --- a/include/video_parser.h +++ b/include/video_parser.h @@ -68,11 +68,11 @@ typedef struct vpar_thread_s /* tables for macroblock types 0=P 1=B */ lookup_t ppl_mb_type[2][64]; /* table for coded_block_pattern */ - lookup_t pl_coded_pattern[512]; + lookup_t * pl_coded_pattern; /* variable length codes for the structure dct_dc_size for intra blocks */ - lookup_t pppl_dct_dc_size[2][2][32]; + lookup_t * pppl_dct_dc_size[2][2]; /* structure to store the tables B14 & B15 */ - dct_lookup_t * pppl_dct_coef[2][65536]; + dct_lookup_t * pppl_dct_coef[2][65536]; #ifdef STATS /* Statistics */ diff --git a/include/vpar_headers.h b/include/vpar_headers.h index 6a9a20a9d7..621d0a5e56 100644 --- a/include/vpar_headers.h +++ b/include/vpar_headers.h @@ -116,15 +116,15 @@ typedef struct slice_parsing_s /***************************************************************************** * Standard codes *****************************************************************************/ -#define PICTURE_START_CODE 0x100 -#define SLICE_START_CODE_MIN 0x101 -#define SLICE_START_CODE_MAX 0x1AF -#define USER_DATA_START_CODE 0x1B2 -#define SEQUENCE_HEADER_CODE 0x1B3 -#define SEQUENCE_ERROR_CODE 0x1B4 -#define EXTENSION_START_CODE 0x1B5 -#define SEQUENCE_END_CODE 0x1B7 -#define GROUP_START_CODE 0x1B8 +#define PICTURE_START_CODE 0x100L +#define SLICE_START_CODE_MIN 0x101L +#define SLICE_START_CODE_MAX 0x1AFL +#define USER_DATA_START_CODE 0x1B2L +#define SEQUENCE_HEADER_CODE 0x1B3L +#define SEQUENCE_ERROR_CODE 0x1B4L +#define EXTENSION_START_CODE 0x1B5L +#define SEQUENCE_END_CODE 0x1B7L +#define GROUP_START_CODE 0x1B8L /* extension start code IDs */ #define SEQUENCE_EXTENSION_ID 1 diff --git a/src/video_parser/video_parser.c b/src/video_parser/video_parser.c index 75613f6e78..5362c994bb 100644 --- a/src/video_parser/video_parser.c +++ b/src/video_parser/video_parser.c @@ -58,6 +58,9 @@ static void EndThread ( vpar_thread_t *p_vpar ); * Following configuration properties are used: * ?? *******************************************************************************/ +#include "main.h" +#include "interface.h" +extern main_t* p_main; vpar_thread_t * vpar_CreateThread( /* video_cfg_t *p_cfg, */ input_thread_t *p_input /*, vout_thread_t *p_vout, int *pi_status */ ) { @@ -93,6 +96,9 @@ vpar_thread_t * vpar_CreateThread( /* video_cfg_t *p_cfg, */ input_thread_t *p_i p_vpar->bit_stream.fifo.buffer = 0; p_vpar->bit_stream.fifo.i_available = 0; +/* FIXME !!!! */ +p_vpar->p_vout = p_main->p_intf->p_vout; + /* Spawn the video parser thread */ if ( vlc_thread_create(&p_vpar->thread_id, "video parser", (vlc_thread_func_t)RunThread, (void *)p_vpar) ) { diff --git a/src/video_parser/vpar_blocks.c b/src/video_parser/vpar_blocks.c index 6e2227cac8..05937fb16c 100644 --- a/src/video_parser/vpar_blocks.c +++ b/src/video_parser/vpar_blocks.c @@ -394,7 +394,7 @@ void __inline__ FillMbAddrIncTable( vpar_thread_t * p_vpar, p_vpar->pl_mb_addr_inc[i_dummy + i_dummy2].i_value = * pi_value; p_vpar->pl_mb_addr_inc[i_dummy + i_dummy2].i_length = i_length; } - (*pi_value)--; + (*pi_value)--; } } @@ -403,6 +403,7 @@ void InitMbAddrInc( vpar_thread_t * p_vpar ) { int i_dummy; int i_value; + for( i_dummy = 0 ; i_dummy < 8 ; i_dummy++ ) { p_vpar->pl_mb_addr_inc[i_dummy].i_value = MB_ERROR; @@ -426,15 +427,17 @@ void InitMbAddrInc( vpar_thread_t * p_vpar ) p_vpar->pl_mb_addr_inc[i_dummy].i_value = MB_ERROR; p_vpar->pl_mb_addr_inc[i_dummy].i_length = 0; } + i_value = 33; - FillMbAddrIncTable( p_vpar, 1024, 2048, 1024, &i_value, 1 ); - FillMbAddrIncTable( p_vpar, 512, 1024, 256, &i_value, 3 ); - FillMbAddrIncTable( p_vpar, 256, 512, 128, &i_value, 4 ); - FillMbAddrIncTable( p_vpar, 128, 256, 64, &i_value, 5 ); - FillMbAddrIncTable( p_vpar, 96, 128, 16, &i_value, 7 ); - FillMbAddrIncTable( p_vpar, 48, 96, 8, &i_value, 8 ); - FillMbAddrIncTable( p_vpar, 36, 48, 2, &i_value, 10 ); + FillMbAddrIncTable( p_vpar, 24, 36, 1, &i_value, 11 ); + FillMbAddrIncTable( p_vpar, 36, 48, 2, &i_value, 10 ); + FillMbAddrIncTable( p_vpar, 48, 96, 8, &i_value, 8 ); + FillMbAddrIncTable( p_vpar, 96, 128, 16, &i_value, 7 ); + FillMbAddrIncTable( p_vpar, 128, 256, 64, &i_value, 5 ); + FillMbAddrIncTable( p_vpar, 256, 512, 128, &i_value, 4 ); + FillMbAddrIncTable( p_vpar, 512, 1024, 256, &i_value, 3 ); + FillMbAddrIncTable( p_vpar, 1024, 2048, 1024, &i_value, 1 ); } /***************************************************************************** @@ -502,7 +505,7 @@ void InitBMBType( vpar_thread_t * p_vpar ) *****************************************************************************/ void InitCodedPattern( vpar_thread_t * p_vpar ) { - p_vpar->pl_coded_pattern = pl_coded_pattern_init_table; + p_vpar->pl_coded_pattern = (lookup_t*) pl_coded_pattern_init_table; } /***************************************************************************** @@ -513,11 +516,12 @@ void InitCodedPattern( vpar_thread_t * p_vpar ) /* First fonction for filling the table */ static void __inline__ FillDCTTable( vpar_thread_t * p_vpar, dct_lookup_t * pl_DCT_tab, - int i_intra, int i_dec, int i_off ) + int i_size, int i_intra, int i_dec, int i_off ) { int i_dummy, i_dummy2; int i_end; - i_end = sizeof(pl_DCT_tab) / sizeof(dct_lookup_t); + + i_end = i_size / sizeof(dct_lookup_t); for( i_dummy = 0; i_dummy < i_end; i_dummy++ ) { for( i_dummy2 = 0; i_dummy2 < ( 1 << i_dec ); i_dummy2++ ) @@ -543,25 +547,24 @@ void InitDCTTables( vpar_thread_t * p_vpar ) /* For table B14 & B15, we have a pointer to tables */ /* We fill the table thanks to the fonction defined above */ - FillDCTTable( p_vpar, pl_DCT_tab_dc, 0, 12, 4 ); - FillDCTTable( p_vpar, pl_DCT_tab_ac, 0, 12, 4 ); - FillDCTTable( p_vpar, pl_DCT_tab0, 0, 8, 4 ); - FillDCTTable( p_vpar, pl_DCT_tab1, 0, 6, 8 ); - FillDCTTable( p_vpar, pl_DCT_tab2, 0, 4, 16 ); - FillDCTTable( p_vpar, pl_DCT_tab3, 0, 3, 16 ); - FillDCTTable( p_vpar, pl_DCT_tab4, 0, 2, 16 ); - FillDCTTable( p_vpar, pl_DCT_tab5, 0, 1, 16 ); - FillDCTTable( p_vpar, pl_DCT_tab6, 0, 0, 16 ); - FillDCTTable( p_vpar, pl_DCT_tab_dc, 1, 12, 4 ); - FillDCTTable( p_vpar, pl_DCT_tab_ac, 1, 12, 4 ); - FillDCTTable( p_vpar, pl_DCT_tab0a, 1, 8, 4 ); - FillDCTTable( p_vpar, pl_DCT_tab1a, 1, 6, 8); - FillDCTTable( p_vpar, pl_DCT_tab2, 1, 4, 16 ); - FillDCTTable( p_vpar, pl_DCT_tab3, 1, 3, 16 ); - FillDCTTable( p_vpar, pl_DCT_tab4, 1, 2, 16 ); - FillDCTTable( p_vpar, pl_DCT_tab5, 1, 1, 16 ); - FillDCTTable( p_vpar, pl_DCT_tab6, 1, 0, 16 ); - + FillDCTTable( p_vpar, pl_DCT_tab_dc, sizeof(pl_DCT_tab_dc),0, 12, 4 ); + FillDCTTable( p_vpar, pl_DCT_tab_ac, sizeof(pl_DCT_tab_ac), 0, 12, 4 ); + FillDCTTable( p_vpar, pl_DCT_tab0, sizeof(pl_DCT_tab0), 0, 8, 4 ); + FillDCTTable( p_vpar, pl_DCT_tab1, sizeof(pl_DCT_tab1), 0, 6, 8 ); + FillDCTTable( p_vpar, pl_DCT_tab2, sizeof(pl_DCT_tab2), 0, 4, 16 ); + FillDCTTable( p_vpar, pl_DCT_tab3, sizeof(pl_DCT_tab3), 0, 3, 16 ); + FillDCTTable( p_vpar, pl_DCT_tab4, sizeof(pl_DCT_tab4), 0, 2, 16 ); + FillDCTTable( p_vpar, pl_DCT_tab5, sizeof(pl_DCT_tab5), 0, 1, 16 ); + FillDCTTable( p_vpar, pl_DCT_tab6, sizeof(pl_DCT_tab6), 0, 0, 16 ); + FillDCTTable( p_vpar, pl_DCT_tab_dc, sizeof(pl_DCT_tab_dc), 1, 12, 4 ); + FillDCTTable( p_vpar, pl_DCT_tab_ac, sizeof(pl_DCT_tab_ac), 1, 12, 4 ); + FillDCTTable( p_vpar, pl_DCT_tab0a, sizeof(pl_DCT_tab0a), 1, 8, 4 ); + FillDCTTable( p_vpar, pl_DCT_tab1a, sizeof(pl_DCT_tab1a), 1, 6, 8); + FillDCTTable( p_vpar, pl_DCT_tab2, sizeof(pl_DCT_tab2), 1, 4, 16 ); + FillDCTTable( p_vpar, pl_DCT_tab3, sizeof(pl_DCT_tab3), 1, 3, 16 ); + FillDCTTable( p_vpar, pl_DCT_tab4, sizeof(pl_DCT_tab4), 1, 2, 16 ); + FillDCTTable( p_vpar, pl_DCT_tab5, sizeof(pl_DCT_tab5), 1, 1, 16 ); + FillDCTTable( p_vpar, pl_DCT_tab6, sizeof(pl_DCT_tab6), 1, 0, 16 ); } /* @@ -590,8 +593,22 @@ void vpar_ParseMacroblock( vpar_thread_t * p_vpar, int * pi_mb_address, elem_t * p_data1; elem_t * p_data2; - *pi_mb_address += MacroblockAddressIncrement( p_vpar ); + /************* DEBUG *************/ + static i_count = 0; + int i_inc; + + i_inc = MacroblockAddressIncrement( p_vpar ); + *pi_mb_address += i_inc; + //*pi_mb_address += MacroblockAddressIncrement( p_vpar ); + fprintf( stderr, "inc : %d (%d)\n", *pi_mb_address, i_inc ); + /* +if( i_count > 4 ) +{ + while(1); +} +i_count++; + */ for( i_mb = i_mb_previous; i_mb < *pi_mb_address; i_mb++ ) { /* Skipped macroblock (ISO/IEC 13818-2 7.6.6). */ @@ -633,11 +650,8 @@ void vpar_ParseMacroblock( vpar_thread_t * p_vpar, int * pi_mb_address, /* Set the field we use for motion compensation */ p_mb->ppi_field_select[0][0] = p_mb->ppi_field_select[0][1] = ( p_vpar->picture.i_current_structure == BOTTOM_FIELD ); - - /* Predict from field of same parity. */ - /* ??? */ } - +fprintf(stderr, "MB1\n"); /* Get a macroblock structure. */ if( (p_mb = p_vpar->picture.pp_mb[i_mb_base + *pi_mb_address] = vpar_NewMacroblock( &p_vpar->vfifo )) == NULL ) @@ -659,11 +673,13 @@ void vpar_ParseMacroblock( vpar_thread_t * p_vpar, int * pi_mb_address, if( p_vpar->mb.i_mb_type & MB_MOTION_FORWARD ) { +fprintf( stderr, "motion !\n" ); (*p_vpar->sequence.pf_decode_mv)( p_vpar, p_mb, 0 ); } if( p_vpar->mb.i_mb_type & MB_MOTION_BACKWARD ) { +fprintf( stderr, "motion2 !\n" ); (*p_vpar->sequence.pf_decode_mv)( p_vpar, p_mb, 1 ); } @@ -689,7 +705,7 @@ void vpar_ParseMacroblock( vpar_thread_t * p_vpar, int * pi_mb_address, /* * Effectively decode blocks. */ - +fprintf(stderr, "MB2\n"); i_mask = 1 << (3 + 2*p_vpar->sequence.i_chroma_nb_blocks); /* luminance */ @@ -730,14 +746,15 @@ void vpar_ParseMacroblock( vpar_thread_t * p_vpar, int * pi_mb_address, + (p_mb->i_c_x >> pi_chroma_hor[p_vpar->sequence.i_chroma_format]) + (p_mb->i_c_y >> pi_chroma_ver[p_vpar->sequence.i_chroma_format]) * (p_vpar->sequence.i_chroma_width); - - for( i_b = 4; i_b < 4 + 2*p_vpar->sequence.i_chroma_nb_blocks; + + for( i_b = 4; i_b < 4 + p_vpar->sequence.i_chroma_nb_blocks; i_b++, i_mask >>= 1 ) { elem_t * pp_data[2] = {p_data1, p_data2}; if( p_vpar->mb.i_coded_block_pattern & i_mask ) { + fprintf( stderr, "Merde !!!!\n" ); memset( p_mb->ppi_blocks[i_b], 0, 64*sizeof(elem_t) ); (*pppf_decode_block[p_vpar->sequence.b_mpeg2] [p_vpar->mb.i_mb_type & MB_INTRA]) @@ -819,11 +836,10 @@ static __inline__ void InitMacroblock( vpar_thread_t * p_vpar, *****************************************************************************/ static __inline__ int MacroblockAddressIncrement( vpar_thread_t * p_vpar ) { + int i_addr_inc = 0; /* Index in the lookup table mb_addr_inc */ - int i_index = ShowBits( &p_vpar->bit_stream, 11 ); - - int i_addr_inc = 0; - + int i_index = ShowBits( &p_vpar->bit_stream, 11 ); + /* Test the presence of the escape character */ while( i_index == 8 ) { @@ -856,11 +872,32 @@ static __inline__ void MacroblockModes( vpar_thread_t * p_vpar, /* Get macroblock_type. */ p_vpar->mb.i_mb_type = (p_vpar->picture.pf_macroblock_type)( p_vpar ); p_mb->i_mb_type = p_vpar->mb.i_mb_type; + +fprintf( stderr, "MB type : %d\n", p_mb->i_mb_type ); /* SCALABILITY : warning, we don't know if spatial_temporal_weight_code * has to be dropped, take care if you use scalable streams. */ /* DumpBits( &p_vpar->bit_stream, 2 ); */ + if( !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD | MB_MOTION_BACKWARD)) ) + { + /* If mb_type has neither MOTION_FORWARD nor MOTION_BACKWARD, this + * is useless, but also harmless. */ + p_vpar->mb.i_motion_type = MOTION_FRAME; + } + else + { + if( p_vpar->picture.i_structure == FRAME_STRUCTURE + && p_vpar->picture.b_frame_pred_frame_dct ) + { + p_vpar->mb.i_motion_type = MOTION_FRAME; + } + else + { + p_vpar->mb.i_motion_type = GetBits( &p_vpar->bit_stream, 2 ); + } + } + if( p_mb->b_P_coding_type && !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD|MB_INTRA)) ) { /* Special No-MC macroblock in P pictures (7.6.3.5). */ @@ -870,17 +907,6 @@ static __inline__ void MacroblockModes( vpar_thread_t * p_vpar, p_vpar->mb.i_motion_type = MOTION_FRAME; p_mb->ppi_field_select[0][0] = ( p_vpar->picture.i_current_structure == BOTTOM_FIELD ); } - else if( !(p_vpar->mb.i_mb_type & (MB_MOTION_FORWARD | MB_MOTION_BACKWARD)) - || p_vpar->picture.b_frame_pred_frame_dct ) - { - /* If mb_type has neither MOTION_FORWARD nor MOTION_BACKWARD, this - * is useless, but also harmless. */ - p_vpar->mb.i_motion_type = MOTION_FRAME; - } - else - { - p_vpar->mb.i_motion_type = GetBits( &p_vpar->bit_stream, 2 ); - } if( p_vpar->mb.i_mb_type & MB_INTRA ) { @@ -903,17 +929,17 @@ static __inline__ void MacroblockModes( vpar_thread_t * p_vpar, (!p_vpar->picture.b_frame_pred_frame_dct) && (p_vpar->mb.i_mb_type & (MB_PATTERN|MB_INTRA)) ) { - if( p_vpar->mb.b_dct_type = GetBits( &p_vpar->bit_stream, 1 ) ) + if( (p_vpar->mb.b_dct_type = GetBits( &p_vpar->bit_stream, 1 )) ) { /* The DCT is coded on fields. Jump one line between each * sample. */ p_mb->i_addb_l_stride <<= 1; - p_mb->i_addb_l_stride += 8; + p_mb->i_addb_l_stride += 8; /* With CHROMA_420, the DCT is necessarily frame-coded. */ if( p_vpar->sequence.i_chroma_format != CHROMA_420 ) { - p_mb->i_addb_c_stride <<= 1; - p_mb->i_addb_c_stride += 8; + p_mb->i_addb_c_stride <<= 1; + p_mb->i_addb_c_stride += 8; } } } @@ -934,7 +960,7 @@ int vpar_IMBType( vpar_thread_t * p_vpar ) {MB_QUANT|MB_INTRA, 2}, {MB_INTRA, 1}, {MB_INTRA, 1} }; - +fprintf( stderr, "i_type : %d\n", i_type ); /* Dump the good number of bits */ DumpBits( &p_vpar->bit_stream, pl_mb_Itype[i_type].i_length ); return pl_mb_Itype[i_type].i_value; @@ -1152,12 +1178,14 @@ static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, /* Lookup Table for the chromatic component */ static int pi_cc_index[12] = { 0, 0, 0, 0, 1, 2, 1, 2, 1, 2 }; + +fprintf( stderr, "%x\n", ShowBits( &p_vpar->bit_stream, 32 ) ); i_cc = pi_cc_index[i_b]; /* Determine whether it is luminance or not (chrominance) */ i_type = ( i_cc + 1 ) >> 1; - +//fprintf( stderr, "MPEG2\n" ); /* Decoding of the DC intra coefficient */ /* The nb of bits to parse depends on i_type */ i_code = ShowBits( &p_vpar->bit_stream, 9 + i_type ); @@ -1167,7 +1195,7 @@ static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, i_code5 = i_code >> 4; /* Shall we lookup in the first or in the second table ? */ - i_select = ( i_code5 - 1 ) / 31; + i_select = ( i_code5 == 31 ); /* Offset value for looking in the second table */ i_offset = 0x1f0 + ( i_type * 0x1f0 ); i_pos = ( i_code5 * ( ! i_select ) ) + ( ( i_code - i_offset ) * i_select ); @@ -1190,7 +1218,7 @@ static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, ( 11 - p_vpar->picture.i_intra_dc_precision ) ); i_nc = ( p_vpar->slice.pi_dc_dct_pred[i_cc] != 0 ); #endif - +//fprintf( stderr, "coucou\n" ); /* Decoding of the AC coefficients */ i_coef = 0; @@ -1198,9 +1226,11 @@ static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, for( i_dummy = 1; i_dummy < 64; i_dummy++ ) { i_code = ShowBits( &p_vpar->bit_stream, 16 ); +fprintf( stderr, "b_intra : %d\ni_code : %d\n", b_intra, i_code ); i_run = (*p_vpar->pppl_dct_coef[b_intra][i_code]).i_run; DumpBits( &p_vpar->bit_stream, (*p_vpar->pppl_dct_coef[b_intra][i_code]).i_length ); +//fprintf( stderr, "glop\n" ); switch( i_run ) { case DCT_ESCAPE: @@ -1234,4 +1264,5 @@ static void vpar_DecodeMPEG2Intra( vpar_thread_t * p_vpar, macroblock_t * p_mb, { p_mb->pf_idct[i_b] = vdec_IDCT; } +//fprintf( stderr, "MPEG2 end\n" ); } diff --git a/src/video_parser/vpar_headers.c b/src/video_parser/vpar_headers.c index 169afb700d..84a0eebb0c 100644 --- a/src/video_parser/vpar_headers.c +++ b/src/video_parser/vpar_headers.c @@ -164,11 +164,10 @@ static __inline__ void NextStartCode( vpar_thread_t * p_vpar ) /* Re-align the buffer on an 8-bit boundary */ RealignBits( &p_vpar->bit_stream ); - while( ShowBits( &p_vpar->bit_stream, 16 ) != 0 && !p_vpar->b_die ) + while( ShowBits( &p_vpar->bit_stream, 24 ) != 0x01L && !p_vpar->b_die ) { DumpBits( &p_vpar->bit_stream, 8 ); } - DumpBits( &p_vpar->bit_stream, 16 ); } /***************************************************************************** @@ -263,8 +262,9 @@ int vpar_NextSequenceHeader( vpar_thread_t * p_vpar ) while( !p_vpar->b_die ) { NextStartCode( p_vpar ); - if( ShowBits( &p_vpar->bit_stream, 16 ) == SEQUENCE_HEADER_CODE ) + if( ShowBits( &p_vpar->bit_stream, 32 ) == SEQUENCE_HEADER_CODE ) return 0; + DumpBits( &p_vpar->bit_stream, 8 ); } return 1; } @@ -294,9 +294,7 @@ int vpar_ParseHeader( vpar_thread_t * p_vpar ) break; case PICTURE_START_CODE: - fprintf( stderr, "begin picture\n" ); PictureHeader( p_vpar ); - fprintf( stderr, "end picture\n" ); return 0; break; @@ -513,8 +511,8 @@ static void GroupHeader( vpar_thread_t * p_vpar ) *****************************************************************************/ static void PictureHeader( vpar_thread_t * p_vpar ) { - static f_macroblock_type_t ppf_macroblock_type[4] = - {vpar_IMBType, vpar_PMBType, + static f_macroblock_type_t ppf_macroblock_type[5] = {NULL, + vpar_IMBType, vpar_PMBType, vpar_BMBType, vpar_DMBType}; int i_structure; @@ -544,7 +542,7 @@ static void PictureHeader( vpar_thread_t * p_vpar ) /* * Picture Coding Extension */ - fprintf( stderr, "picture1\n" ); + NextStartCode( p_vpar ); if( ShowBits( &p_vpar->bit_stream, 16 ) == EXTENSION_START_CODE ) { @@ -616,7 +614,7 @@ static void PictureHeader( vpar_thread_t * p_vpar ) p_vpar->picture.i_current_structure = 0; - intf_DbgMsg("vpar debug: odd number of field picture."); + intf_DbgMsg("vpar debug: odd number of field picture.\n"); } if( p_vpar->picture.i_current_structure ) @@ -657,6 +655,7 @@ static void PictureHeader( vpar_thread_t * p_vpar ) return; } + fprintf(stderr, "begin picture\n"); /* OK, now we are sure we will decode the picture. */ #define P_picture p_vpar->picture.p_picture @@ -722,9 +721,9 @@ static void PictureHeader( vpar_thread_t * p_vpar ) DumpBits32( &p_vpar->bit_stream ); /* Decode slice data. */ - SliceHeader( p_vpar, &i_mb_address, i_mb_base, i_dummy & 255 ); + p_vpar->sequence.pf_slice_header( p_vpar, &i_mb_address, i_mb_base, i_dummy & 255 ); } - + /* Link referenced pictures for the decoder * They are unlinked in vpar_ReleaseMacroblock() & vpar_DestroyMacroblock() */ if( p_vpar->sequence.p_forward != NULL ) @@ -739,6 +738,7 @@ static void PictureHeader( vpar_thread_t * p_vpar ) if( p_vpar->picture.b_error ) { /* Trash picture. */ +fprintf(stderr, "Image trashee\n"); for( i_mb = 0; p_vpar->picture.pp_mb[i_mb]; i_mb++ ) { vpar_DestroyMacroblock( &p_vpar->vfifo, p_vpar->picture.pp_mb[i_mb] ); @@ -759,9 +759,12 @@ static void PictureHeader( vpar_thread_t * p_vpar ) /* Prepare context for the next picture. */ P_picture = NULL; + if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE ) + p_vpar->picture.i_current_structure = 0; } else if( p_vpar->picture.i_current_structure == FRAME_STRUCTURE ) { +fprintf(stderr, "Image decodee\n"); /* Frame completely parsed. */ P_picture->i_deccount = p_vpar->sequence.i_mb_size; for( i_mb = 0; i_mb < p_vpar->sequence.i_mb_size; i_mb++ ) @@ -771,6 +774,7 @@ static void PictureHeader( vpar_thread_t * p_vpar ) /* Prepare context for the next picture. */ P_picture = NULL; + p_vpar->picture.i_current_structure = 0; } #undef P_picture } @@ -786,7 +790,7 @@ static __inline__ void SliceHeader( vpar_thread_t * p_vpar, static int pi_dc_dct_reinit[4] = {128,256,512,1024}; int i_mb_address_save = *pi_mb_address; - + /* slice_vertical_position_extension and priority_breakpoint already done */ LoadQuantizerScale( p_vpar ); @@ -818,7 +822,8 @@ static __inline__ void SliceHeader( vpar_thread_t * p_vpar, i_mb_base ); i_mb_address_save = *pi_mb_address; } - while( !ShowBits( &p_vpar->bit_stream, 23 ) ); + while( ShowBits( &p_vpar->bit_stream, 23 ) ); + NextStartCode( p_vpar ); } /***************************************************************************** diff --git a/src/video_parser/vpar_synchro.c b/src/video_parser/vpar_synchro.c index 4398003865..bb1a42595a 100644 --- a/src/video_parser/vpar_synchro.c +++ b/src/video_parser/vpar_synchro.c @@ -49,7 +49,7 @@ boolean_t vpar_SynchroChoose( vpar_thread_t * p_vpar, int i_coding_type, int i_structure ) { - + return( i_coding_type == I_CODING_TYPE ); } /*****************************************************************************