sei.c

davinci avs.......................................................

		SEI_u_v( 1, "marker_bit", bitstream );
		if( sps->initial_dpb_output_delay_length > 16 )
		{
			initial_dpb_output_delay_lsb [HrdIdx] = SEI_u_v(16,                                        "initial_dpb_output_delay_lsb[HrdIdx]", bitstream);
			SEI_u_v( 1, "marker_bit", bitstream );
			initial_dpb_output_delay_msb [HrdIdx] = SEI_u_v(sps->initial_dpb_output_delay_length-16,   "initial_dpb_output_delay_msb[HrdIdx]", bitstream);
		}
		else
			initial_dpb_output_delay     [HrdIdx] = SEI_u_v(sps->initial_dpb_output_delay_length,      "initial_dpb_output_delay    [HrdIdx]", bitstream);
		SEI_u_v( 1, "marker_bit", bitstream );
#if TRACE //liuhui 0601
		if( HrdIdx == cpb_dpb_cnt_minus1  ) //read trailing_bits
		{
			i = size*8-bitstream->frame_bitoffset;
		    assert(i);
			SEI_u_v( i, "SEI: trailing_bits", bitstream);
		}
#endif

#ifdef PRINT_HRD
		printf("\nHrdIdx = %d	:\n",HrdIdx);
		printf("cpb_underflow_allowable_flag[HrdIdx]	:%d\n",cpb_underflow_allowable_flag[HrdIdx]);
		printf("bit_rate_value_minus1_lsb[HrdIdx]		:%d\n",bit_rate_value_minus1_lsb[HrdIdx]);
		printf("bit_rate_value_minus1_msb[HrdIdx]		:%d\n",bit_rate_value_minus1_msb[HrdIdx]);
		printf("cpb_size_value_minus1_lsb[HrdIdx]		:%d\n",cpb_size_value_minus1_lsb[HrdIdx]);
		printf("cpb_size_value_minus1_msb[HrdIdx]		:%d\n",cpb_size_value_minus1_msb[HrdIdx]);
		printf("dpb_size_value_minus1_lsb[HrdIdx]		:%d\n",dpb_size_value_minus1_lsb[HrdIdx]);
		printf("dpb_size_value_minus1_msb[HrdIdx]		:%d\n",dpb_size_value_minus1_msb[HrdIdx]);
		if(sps->initial_cpb_removal_delay_length>16)
		{
			printf("initial_cpb_removal_delay_lsb[HrdIdx]	:%d\n",initial_cpb_removal_delay_lsb[HrdIdx]);	
			printf("initial_cpb_removal_delay_msb[HrdIdx]	:%d\n",initial_cpb_removal_delay_msb[HrdIdx]);
		}
		else
			printf("initial_cpb_removal_delay[HrdIdx]	:%d\n",initial_cpb_removal_delay[HrdIdx]);
		if(sps->initial_dpb_output_delay_length>16)
		{
			printf("initial_dpb_output_delay_lsb[HrdIdx]	:%d\n",initial_dpb_output_delay_lsb[HrdIdx]);
			printf("initial_dpb_output_delay_msb[HrdIdx]	:%d\n",initial_dpb_output_delay_msb[HrdIdx]);
		}
		else
			printf("initial_dpb_output_delay[HrdIdx]	:%d\n",initial_dpb_output_delay[HrdIdx]);


    bit_rate=(bit_rate_value_minus1_lsb[HrdIdx]+1+(bit_rate_value_minus1_msb[HrdIdx]<<16))<<(6+sps->bit_rate_scale);
		cpb_size=(cpb_size_value_minus1_lsb[HrdIdx]+1+(cpb_size_value_minus1_msb[HrdIdx]<<16))<<(4+sps->cpb_size_scale);
		dpb_size=(dpb_size_value_minus1_lsb[HrdIdx]+1+(dpb_size_value_minus1_msb[HrdIdx]<<16))<<(4+sps->dpb_size_scale);
		if( sps->initial_cpb_removal_delay_length > 16 )
		{
			initCpbDelay=initial_cpb_removal_delay_lsb[HrdIdx]+(initial_cpb_removal_delay_msb[HrdIdx]<<16);
		}
		else
		{
            initCpbDelay=initial_cpb_removal_delay_lsb[HrdIdx];
		}
		if( sps->initial_dpb_output_delay_length > 16 )
		{
			initDpbDelay=initial_dpb_output_delay_lsb[HrdIdx]+(initial_dpb_output_delay_msb[HrdIdx]<<16);
		}
		else
		{
            initDpbDelay=initial_dpb_output_delay_lsb[HrdIdx];
		}
		fprintf(p_trace,"\nHrdIdx=%d	:\n",HrdIdx);
		fprintf(p_trace,"bit_rate		:%d\n",bit_rate);
		fprintf(p_trace,"cpb_size		:%d\n",cpb_size);
		fprintf(p_trace,"dpb_size		:%d\n",dpb_size);
		fprintf(p_trace,"initCpbDelay(1/90000 s)		:%d\n",initCpbDelay);

#endif


#ifdef _PRINT_
		printf("\nHrdIdx = %d	:\n",HrdIdx);
		printf("cpb_underflow_allowable_flag[HrdIdx]	:%d\n",cpb_underflow_allowable_flag[HrdIdx]);
		printf("bit_rate_value_minus1[HrdIdx]		:%d\n",bit_rate_value_minus1[HrdIdx]);
		printf("cpb_size_value_minus1[HrdIdx]		:%d\n",cpb_size_value_minus1[HrdIdx]);
		printf("dpb_size_value_minus1[HrdIdx]		:%d\n",dpb_size_value_minus1[HrdIdx]);
		printf("initial_cpb_removal_delay[HrdIdx]	:%d\n",initial_cpb_removal_delay[HrdIdx]);
		printf("initial_dpb_output_delay[HrdIdx]	:%d\n\n",initial_dpb_output_delay[HrdIdx]);
#endif

	}

	free(bitstream->streamBuffer);
	free(bitstream);
}
#endif //_HRD_
/*!
 ************************************************************************
 *  \brief
 *     Interpret the gradual random access SEI message
 *  \param payload
 *     a pointer that point to the sei payload
 *  \param size
 *     the size of the sei message
 *  \param img
 *     the image pointer
 *    
 ************************************************************************
 */
void interpret_gradual_random_access( byte* payload, int size, Image *img )
{
	int i, recovery_frame_cnt;
	Bitstream *bitstream = AllocBitstream();
	for(i = 0; i < size; i++)
		bitstream->streamBuffer[i] = payload[i];
	bitstream->frame_bitoffset = 0;
	bitstream->bitstream_length = size;

	recovery_frame_cnt = SEI_ue_v("recovery_frame_cnt", bitstream );
	assert( recovery_frame_cnt <= 31 && recovery_frame_cnt >= 0 );

#if TRACE //liuhui 0601
	{
	    i = size*8 - bitstream->frame_bitoffset;
		assert(i);
		SEI_u_v(i, "SEI: trailing_bits", bitstream);
	}
#endif

	printf("-----     GRADUAL_RANDOM_ACCESS SEI    -----\n");
	printf("recovery_frame_cnt       = %d\n", recovery_frame_cnt);
	printf("\n");

}

/*!
 ************************************************************************
 *  \brief
 *     Interpret the Reserved SEI message
 *  \param payload
 *     a pointer that point to the sei payload
 *  \param size
 *     the size of the sei message
 *  \param img
 *     the image pointer
 *    
 ************************************************************************
 */
void interpret_reserved( byte* payload, int size, Image *img )
{
	byte uiReserved;
    int i;
	Bitstream *bitstream = AllocBitstream();
	for(i = 0; i < size; i++)
		bitstream->streamBuffer[i] = payload[i];
	bitstream->frame_bitoffset = 0;
	bitstream->bitstream_length = size;

#ifdef PRINT_RESERVED
	printf("-----           RESERVED SEI           -----\n");
#endif

	for( i = 0; i < size*8/17; i++)
	{
    uiReserved = SEI_u_v(8, "Reserved byte", bitstream);
		putchar(uiReserved);
		uiReserved = SEI_u_v(8, "Reserved byte", bitstream);
		putchar(uiReserved);
		uiReserved = SEI_u_v(1, "market_bit",  bitstream);
	}
    if(((size*8)%17) > 8)
	{
		uiReserved = SEI_u_v(8, "Reserved byte", bitstream);
		putchar(uiReserved);
	}
	printf("\n");

#if TRACE
	{
	  i = 8*size - bitstream->frame_bitoffset;
		assert(i);
		SEI_u_v(i, "SEI: trailing_bits", bitstream);
	}
#endif
}


/*!
 ************************************************************************
 *  \brief
 *     SEI coding function like GetVLCSymbol(),different only at writing bitstream
 *  \param info
 *     refer to param in GetVLCSymbol()
 *  \param bitstream
 *     store the coded bit-stream of SEI
 ************************************************************************
 */
int SEI_GetVLCSymbol (int *info, Bitstream *bitstream)
{
	
	register int inf;
	long byteoffset;      // byte from start of buffer
	int bitoffset;      // bit from start of byte
	int ctr_bit=0;      // control bit for current bit posision
	int bitcounter=1;
	int len;
	int info_bit;
	byte *buffer = bitstream->streamBuffer;
	int bytecount = bitstream->bitstream_length;
	int totbitoffset = bitstream->frame_bitoffset;
	byteoffset= totbitoffset/8;
	bitoffset= 7-(totbitoffset%8);
	ctr_bit = (buffer[byteoffset] & (0x01<<bitoffset));   // set up control bit	
	len=1;
	while (ctr_bit==0)
	{                 // find leading 1 bit
		len++;
		bitoffset-=1;           
		bitcounter++;
		if (bitoffset<0)
		{                 // finish with current byte ?
			bitoffset=bitoffset+8;
			byteoffset++;
		}
		ctr_bit=buffer[byteoffset] & (0x01<<(bitoffset));
	}
	
	// make infoword
	inf=0;                          // shortest possible code is 1, then info is always 0
	for(info_bit=0;(info_bit<(len-1)); info_bit++)
	{
		bitcounter++;
		bitoffset-=1;
		if (bitoffset<0)
		{   
			// finished with current byte ?
			bitoffset=bitoffset+8;
			byteoffset++;
		}
		if (byteoffset > bytecount)
		{
			error("parse error", -1);
			return -1;
		}
		inf=(inf<<1);
		if(buffer[byteoffset] & (0x01<<(bitoffset)))
			inf |=1;
	}	
	*info = inf;	
	bitstream->frame_bitoffset += bitcounter;
	return bitcounter;           // return absolute offset in bit from start of frame
}

/*!
 ************************************************************************
 *  \brief
 *     SEI coding function like read_VLC(),different only at writing bitstream
 *  \param info
 *     refer to param in read_VLC()
 *  \param bitstream
 *     store the coded bit-stream of SEI
 ************************************************************************
 */
int SEI_read_VLC(SyntaxElement *sym, Bitstream *bitstream)
{
	int frame_bitoffset = bitstream->frame_bitoffset;
	byte *buf = bitstream->streamBuffer;
	int BitstreamLengthInBytes = bitstream->bitstream_length;	
	sym->len =  SEI_GetVLCSymbol (&(sym->inf), bitstream);	
	if (sym->len == -1)
		return -1;	
	sym->mapping(sym->len,sym->inf,&(sym->value1));	
#if TRACE //liuhui 0601
  tracebits(sym->tracestring, sym->len, sym->inf, sym->value1);
#endif	
	return 1;
}

/*!
 ************************************************************************
 *  \brief
 *     SEI coding function like read_FLC(),different only at writing bitstream
 *  \param info
 *     refer to param in read_FLC()
 *  \param bitstream
 *     store the coded bit-stream of SEI
 ************************************************************************
 */
int SEI_read_FLC(SyntaxElement *sym, Bitstream *bitstream)
{
	int frame_bitoffset = bitstream->frame_bitoffset;
	byte *buf = bitstream->streamBuffer;
	int BitstreamLengthInBytes = bitstream->bitstream_length;	
	if ((GetBits(buf, frame_bitoffset, &(sym->inf), BitstreamLengthInBytes, sym->len)) < 0)
		return -1;	
	bitstream->frame_bitoffset += sym->len; // move bitstream pointer
	sym->value1 = sym->inf;
#if TRACE //liuhui 0601
    tracebits2(sym->tracestring, sym->len, sym->inf);
#endif	
	return 1;
}


/*!
 ************************************************************************
 *  \brief
 *     SEI coding function like ue_v(),different only at writing bitstream
 *  \param info
 *     refer to param in ue_v()
 *  \param bitstream
 *     store the coded bit-stream of SEI
 ************************************************************************
 */
int SEI_ue_v(char *tracestring, Bitstream *bitstream)
{
	SyntaxElement symbol, *sym=&symbol;
	
	assert (bitstream->streamBuffer != NULL);
	sym->mapping = mapping_ue;   // Mapping rule
#if TRACE
	strncpy(sym->tracestring,tracestring,TRACESTRING_SIZE);
#endif
	SEI_read_VLC (sym, bitstream);
	
	return sym->value1;
}

/*!
 ************************************************************************
 *  \brief
 *     SEI coding function like u_v(),different only at writing bitstream
 *  \param info
 *     refer to param in u_v()
 *  \param bitstream
 *     store the coded bit-stream of SEI
 ************************************************************************
 */
int SEI_u_v(int LenInBits, char* tracestring, Bitstream *bitstream)
{
	SyntaxElement symbol, *sym=&symbol;
	
	assert (bitstream->streamBuffer != NULL);
	//sym->type = SE_HEADER;
	sym->mapping = mapping_ue;   // Mapping rule
	sym->len = LenInBits;
#if TRACE
	strncpy(sym->tracestring, tracestring, TRACESTRING_SIZE);
#endif
	SEI_read_FLC (sym, bitstream);
	
	return sym->inf;
}

/*!
 ************************************************************************
 *  \brief
 *     SEI coding function like u_1(),different only at writing bitstream
 *  \param info
 *     refer to param in u_1()
 *  \param bitstream
 *     store the coded bit-stream of SEI
 ************************************************************************
 */
int SEI_u_1 (char *tracestring, Bitstream *bitstream)
{
	return SEI_u_v (1, tracestring, bitstream);
}