From 8c3538f432c9ec7eddf3121eb0caf262f81ca9ef Mon Sep 17 00:00:00 2001 From: Laurent Aimar Date: Thu, 7 May 2009 23:56:13 +0200 Subject: [PATCH] Cosmetics. --- modules/packetizer/dirac.c | 115 ++++++++++++++++++------------------- 1 file changed, 56 insertions(+), 59 deletions(-) diff --git a/modules/packetizer/dirac.c b/modules/packetizer/dirac.c index af3f50f2e2..75f9ce5796 100644 --- a/modules/packetizer/dirac.c +++ b/modules/packetizer/dirac.c @@ -222,11 +222,11 @@ typedef struct { static dirac_block_encap_t *dirac_RemoveBlockEncap( block_t *p_block ) { fake_block_t *p_fake = (fake_block_t *)p_block; - dirac_block_encap_t *dbe = p_fake->p_priv; - if( !dbe ) return NULL; + dirac_block_encap_t *p_dbe = p_fake->p_priv; + if( !p_dbe ) return NULL; p_fake->p_priv = NULL; - dbe->pf_blk_release = NULL; - return dbe; + p_dbe->pf_blk_release = NULL; + return p_dbe; } static void dirac_ReleaseBlockAndEncap( block_t *p_block ) @@ -252,9 +252,9 @@ static void dirac_AddBlockEncap( block_t **pp_block, dirac_block_encap_t *p_dbe static dirac_block_encap_t *dirac_NewBlockEncap( block_t **pp_block ) { - dirac_block_encap_t *dbe = calloc( 1, sizeof( *dbe ) ); - if( dbe ) dirac_AddBlockEncap( pp_block, dbe ); - return dbe; + dirac_block_encap_t *p_dbe = calloc( 1, sizeof( *p_dbe ) ); + if( p_dbe ) dirac_AddBlockEncap( pp_block, p_dbe ); + return p_dbe; } static dirac_block_encap_t *dirac_GetBlockEncap( block_t *p_block ) @@ -275,19 +275,19 @@ static int block_ChainToArray( block_t *p_block, block_t ***ppp_array) if( !ppp_array ) return 0; - int num_blocks; - block_ChainProperties( p_block, &num_blocks, NULL, NULL ); + int i_num_blocks; + block_ChainProperties( p_block, &i_num_blocks, NULL, NULL ); - *ppp_array = malloc( sizeof( block_t* ) * num_blocks ); + *ppp_array = calloc( i_num_blocks, sizeof( block_t* ) ); if( !ppp_array ) return 0; - for( int i = 0; i < num_blocks; i++ ) + for( int i = 0; i < i_num_blocks; i++ ) { (*ppp_array)[i] = p_block; p_block = p_block->p_next; } - return num_blocks; + return i_num_blocks; } /** @@ -397,9 +397,8 @@ static void dirac_ReorderInit( struct dirac_reorder_buffer *p_rb ) p_rb->p_empty = p_rb->p_entries; p_rb->p_entries[31].p_next = NULL; - for( int i = 0; i < 31; i++ ) { + for( int i = 0; i < 31; i++ ) p_rb->p_entries[i].p_next = &p_rb->p_entries[i+1]; - } } /* simulate the dirac picture reorder buffer */ @@ -487,15 +486,14 @@ static bool dirac_UnpackParseInfo( parse_info_t *p_pi, block_bytestream_t *p_bs, static uint32_t dirac_uint( bs_t *p_bs ) { - uint32_t count = 0, value = 0; - while( !bs_eof( p_bs ) && !bs_read( p_bs, 1 ) ) - { - count++; - value <<= 1; - value |= bs_read( p_bs, 1 ); - } - - return (1 << count) - 1 + value; + uint32_t u_count = 0, u_value = 0; + while( !bs_eof( p_bs ) && !bs_read( p_bs, 1 ) ) + { + u_count++; + u_value <<= 1; + u_value |= bs_read( p_bs, 1 ); + } + return (1 << u_count) - 1 + u_value; } static int dirac_bool( bs_t *p_bs ) @@ -647,11 +645,11 @@ static bool dirac_UnpackSeqHdr( struct seq_hdr_t *p_sh, block_t *p_block ) static block_t *dirac_EmitEOS( decoder_t *p_dec, uint32_t i_prev_parse_offset ) { - const uint8_t eos[] = { 'B','B','C','D',0x10,0,0,0,13,0,0,0,0 }; + const uint8_t p_eos[] = { 'B','B','C','D',0x10,0,0,0,13,0,0,0,0 }; block_t *p_block = block_New( p_dec, 13 ); if( !p_block ) return NULL; - memcpy( p_block->p_buffer, eos, 13 ); + memcpy( p_block->p_buffer, p_eos, 13 ); SetDWBE( p_block->p_buffer + 9, i_prev_parse_offset ); @@ -675,7 +673,8 @@ static block_t *dirac_DoSync( decoder_t *p_dec ) do { switch( p_sys->i_state ) { - case NOT_SYNCED: { + case NOT_SYNCED: + { if( VLC_SUCCESS != block_FindStartcodeFromOffset( &p_sys->bytestream, &p_sys->i_offset, p_parsecode, 4 ) ) { @@ -734,18 +733,18 @@ static block_t *dirac_DoSync( decoder_t *p_dec ) /* attempt to syncronise backwards from pu.u_next_offset */ p_sys->i_offset = pu.u_next_offset; /* fall through */ - case TRY_SYNC: { /* -> SYNCED | NOT_SYNCED */ - if( !p_sys->i_offset ) { + case TRY_SYNC: /* -> SYNCED | NOT_SYNCED */ + { + if( !p_sys->i_offset ) goto sync_fail; /* if a is at start of bytestream, b can't be in buffer */ - } parse_info_t pu_a; bool a = dirac_UnpackParseInfo( &pu_a, &p_sys->bytestream, p_sys->i_offset ); - if( !a || (pu_a.u_prev_offset > p_sys->i_offset) ) { + if( !a || (pu_a.u_prev_offset > p_sys->i_offset) ) goto sync_fail; /* b lies beyond start of bytestream: can't sync */ - } - if( !pu_a.u_prev_offset ) { + if( !pu_a.u_prev_offset ) + { if( p_sys->i_state == TRY_SYNC ) { goto sync_fail; /* can't find different pu_b from pu_a */ @@ -758,7 +757,8 @@ static block_t *dirac_DoSync( decoder_t *p_dec ) parse_info_t *pu_b = &pu; bool b = dirac_UnpackParseInfo( pu_b, &p_sys->bytestream, p_sys->i_offset - pu_a.u_prev_offset ); - if( !b || (pu_b->u_next_offset && pu_a.u_prev_offset != pu_b->u_next_offset) ) { + if( !b || (pu_b->u_next_offset && pu_a.u_prev_offset != pu_b->u_next_offset) ) + { /* if pu_b->u_next_offset = 0, have to assume we've synced, ie, * just rely on finding a valid pu_b from pu_a. */ goto sync_fail; @@ -806,8 +806,8 @@ sync_fail: block_GetBytes( &p_sys->bytestream, p_block->p_buffer, p_block->i_buffer ); /* save parse offset in private area for later use */ - dirac_block_encap_t *dbe = dirac_NewBlockEncap( &p_block ); - if( dbe ) dbe->u_last_next_offset = pu.u_next_offset; + dirac_block_encap_t *p_dbe = dirac_NewBlockEncap( &p_block ); + if( p_dbe ) p_dbe->u_last_next_offset = pu.u_next_offset; return p_block; } @@ -874,12 +874,12 @@ static int dirac_InspectDataUnit( decoder_t *p_dec, block_t **pp_block, block_t * random access point flags are not set */ p_eu->i_flags &= ~BLOCK_FLAG_TYPE_I; } - dirac_block_encap_t *dbe = dirac_GetBlockEncap( p_block ); - if( dbe && p_block->i_buffer > 13+4 ) + dirac_block_encap_t *p_dbe = dirac_GetBlockEncap( p_block ); + if( p_dbe && p_block->i_buffer > 13+4 ) { /* record the picture number to save the time gen functions * from having to inspect the data for it */ - dbe->u_picture_number = GetDWBE( p_block->p_buffer + 13 ); + p_dbe->u_picture_number = GetDWBE( p_block->p_buffer + 13 ); } return DIRAC_DU_ENDS_EU; } @@ -906,8 +906,8 @@ static int dirac_InspectDataUnit( decoder_t *p_dec, block_t **pp_block, block_t , p_sys->seq_hdr.u_fps_num, p_sys->seq_hdr.u_fps_den, 0 ); /* when field coding, dts needs to be incremented in terms of field periods */ - int u_pics_per_sec = p_sys->seq_hdr.u_fps_num; - if (p_sys->seq_hdr.u_picture_coding_mode == DIRAC_FIELD_CODING) + unsigned u_pics_per_sec = p_sys->seq_hdr.u_fps_num; + if( p_sys->seq_hdr.u_picture_coding_mode == DIRAC_FIELD_CODING ) { u_pics_per_sec *= 2; } @@ -988,14 +988,14 @@ static block_t *dirac_BuildEncapsulationUnit( decoder_t *p_dec, block_t *p_block block_ChainLastAppend( &p_sys->pp_eu_last, p_block ); - dirac_block_encap_t *dbe = dirac_GetBlockEncap( p_block ); + dirac_block_encap_t *p_dbe = dirac_GetBlockEncap( p_block ); #ifdef SANITIZE_PREV_PARSE_OFFSET /* fixup prev_parse_offset to point to the last data unit * to arrive */ - if( dbe ) + if( p_dbe ) { SetDWBE( p_block->p_buffer + 9, p_sys->u_eu_last_npo ); - p_sys->u_eu_last_npo = dbe->u_last_next_offset; + p_sys->u_eu_last_npo = p_dbe->u_last_next_offset; } #endif @@ -1008,7 +1008,7 @@ static block_t *dirac_BuildEncapsulationUnit( decoder_t *p_dec, block_t *p_block /* gather up encapsulation unit, reassociating the final * private state with the gathered block */ block_t *p_eu_last = (block_t*) p_sys->pp_eu_last - offsetof( block_t, p_next ); - dbe = dirac_RemoveBlockEncap( p_eu_last ); + p_dbe = dirac_RemoveBlockEncap( p_eu_last ); uint8_t u_parse_code = p_block->p_buffer[4]; @@ -1017,9 +1017,9 @@ static block_t *dirac_BuildEncapsulationUnit( decoder_t *p_dec, block_t *p_block assert( p_block ); /* block_ChainGather doesn't define when it frees chain */ p_block->i_flags |= DIRAC_NON_DATED; - if( dbe ) + if( p_dbe ) { - dirac_AddBlockEncap( &p_block, dbe ); + dirac_AddBlockEncap( &p_block, p_dbe ); if( dirac_isPicture( u_parse_code ) ) p_block->i_flags &= ~DIRAC_NON_DATED; } p_sys->p_eu = NULL; @@ -1040,7 +1040,7 @@ static block_t *dirac_BuildEncapsulationUnit( decoder_t *p_dec, block_t *p_block static int dirac_TimeGenPush( decoder_t *p_dec, block_t *p_block_in ) { decoder_sys_t *p_sys = p_dec->p_sys; - dirac_block_encap_t *dbe; + dirac_block_encap_t *p_dbe; if( p_block_in->i_flags & BLOCK_FLAG_END_OF_SEQUENCE ) { @@ -1056,8 +1056,8 @@ static int dirac_TimeGenPush( decoder_t *p_dec, block_t *p_block_in ) return 0; } - dbe = dirac_GetBlockEncap( p_block_in ); - uint32_t u_picnum = dbe ? dbe->u_picture_number : 0; + p_dbe = dirac_GetBlockEncap( p_block_in ); + uint32_t u_picnum = p_dbe ? p_dbe->u_picture_number : 0; /* * Simple DTS regeneration: * - DTS values linearly increase in stream order. @@ -1152,8 +1152,8 @@ static int dirac_TimeGenPush( decoder_t *p_dec, block_t *p_block_in ) * the first packet is output -- interpolate the past and freewheel for * the future */ - dbe = dirac_GetBlockEncap( p_block ); - u_picnum = dbe ? dbe->u_picture_number : 0; + p_dbe = dirac_GetBlockEncap( p_block ); + u_picnum = p_dbe ? p_dbe->u_picture_number : 0; if( p_sys->b_tg_last_picnum ) { if( dirac_PictureNbeforeM( u_picnum, p_sys->u_tg_last_picnum ) ) @@ -1165,8 +1165,8 @@ static int dirac_TimeGenPush( decoder_t *p_dec, block_t *p_block_in ) * a discontinuity, some pictures will get stuck in the RoB. * flush the RoB. */ /* this could be a bit less indiscriminate */ - dbe = dirac_GetBlockEncap( p_sys->p_outqueue ); - uint32_t u_prev_parse_offset = dbe ? dbe->u_last_next_offset : 0; + p_dbe = dirac_GetBlockEncap( p_sys->p_outqueue ); + uint32_t u_prev_parse_offset = p_dbe ? p_dbe->u_last_next_offset : 0; block_ChainRelease( p_sys->p_outqueue ); p_sys->p_outqueue = dirac_EmitEOS( p_dec, u_prev_parse_offset ); if( p_sys->p_outqueue ) @@ -1319,12 +1319,9 @@ static block_t *Packetize( decoder_t *p_dec, block_t **pp_block ) * the output queue would grow bounded by the stream length. * If there are 10 data units in the output queue, assume this * has happened and purge all blocks that fail extraction criteria */ - unsigned count = 0; - for( p_block = p_sys->p_outqueue; p_block; p_block = p_block->p_next ) - { - count++; - } - if( count > 9 ) + int i_count; + block_ChainProperties( p_sys->p_outqueue, &i_count, NULL, NULL ); + if( i_count > 9 ) { p_block = p_sys->p_outqueue; while( p_block ) -- 2.39.2