/*!
************************************************************************
* \brief
* This function opens the output files and generates the
* appropriate sequence header
************************************************************************
*/
int rewrite_paramsets()
{
int i,len=0, total_pps = (input->GenerateMultiplePPS) ? 3 : 1;
NALU_t *nalu;
//! As a sequence header, here we write the both sequence and picture
//! parameter sets. As soon as IDR is implemented, this should go to the
//! IDR part, as both parsets have to be transmitted as part of an IDR.
//! An alternative may be to consider this function the IDR start function.
nalu = NULL;
nalu = GenerateSeq_parameter_set_NALU ();
len += WriteNALU (nalu);
FreeNALU (nalu);
//! Lets write now the Picture Parameter sets. Output will be equal to the total number of bits spend here.
for (i=0;i<total_pps;i++)
{
len = write_PPS(len, i);
}
if (input->Generate_SEIVUI)
{
nalu = NULL;
nalu = GenerateSEImessage_NALU();
len += WriteNALU (nalu);
FreeNALU (nalu);
}
stats->bit_ctr_parametersets_n = len;
return 0;
}
/*!
************************************************************************
* \brief
* This function opens the output files and generates the
* appropriate sequence header
************************************************************************
*/
int start_sequence()
{
int i,len=0, total_pps = (input->GenerateMultiplePPS) ? 3 : 1;
NALU_t *nalu;
switch(input->of_mode)
{
case PAR_OF_ANNEXB:
OpenAnnexbFile (input->outfile);
WriteNALU = WriteAnnexbNALU;
break;
case PAR_OF_RTP:
OpenRTPFile (input->outfile);
WriteNALU = WriteRTPNALU;
break;
default:
snprintf(errortext, ET_SIZE, "Output File Mode %d not supported", input->of_mode);
error(errortext,1);
return 1;
}
//! As a sequence header, here we write the both sequence and picture
//! parameter sets. As soon as IDR is implemented, this should go to the
//! IDR part, as both parsets have to be transmitted as part of an IDR.
//! An alternative may be to consider this function the IDR start function.
nalu = NULL;
nalu = GenerateSeq_parameter_set_NALU ();
len += WriteNALU (nalu);
FreeNALU (nalu);
//! Lets write now the Picture Parameter sets. Output will be equal to the total number of bits spend here.
for (i=0;i<total_pps;i++)
{
len = write_PPS(len, i);
}
if (input->Generate_SEIVUI)
{
nalu = NULL;
nalu = GenerateSEImessage_NALU();
len += WriteNALU (nalu);
FreeNALU (nalu);
}
stats->bit_ctr_parametersets_n = len;
return 0;
}
int Write_AUD_NALU( VideoParameters *p_Vid )
{
int RBSPlen = 0;
int len;
byte rbsp[MAXRBSPSIZE];
NALU_t *nalu = AllocNALU( MAXNALUSIZE );
switch( p_Vid->type )
{
case I_SLICE:
p_Vid->primary_pic_type = 0;
break;
case P_SLICE:
p_Vid->primary_pic_type = 1;
break;
case B_SLICE:
p_Vid->primary_pic_type = 2;
break;
}
RBSPlen = 1;
rbsp[0] = (byte) (p_Vid->primary_pic_type << 5);
rbsp[0] |= (1 << 4);
// write RBSP into NALU
RBSPtoNALU( rbsp, nalu, RBSPlen, NALU_TYPE_AUD, NALU_PRIORITY_DISPOSABLE, 1 );
// write NALU into bitstream
len = p_Vid->WriteNALU( p_Vid, nalu, p_Vid->f_out );
FreeNALU( nalu );
return len;
}
int Write_Filler_Data_NALU( VideoParameters *p_Vid, int num_bytes )
{
int RBSPlen = num_bytes - 1;
int len, bytes_written = 0;
byte rbsp[MAXRBSPSIZE];
byte filler_byte = (byte)0xFF;
byte trailing_byte = (byte)0x80;
NALU_t *nalu = AllocNALU( MAXNALUSIZE );
num_bytes = iClip3( 1, (MAXRBSPSIZE - 2), num_bytes );
assert( num_bytes > 0 && num_bytes < (MAXRBSPSIZE - 1) );
num_bytes = imax( 2, num_bytes ); // one byte for the NAL header and one for the rbsp trailing byte
if ( RBSPlen > 1 )
{
while ( bytes_written < (RBSPlen - 1) )
{
rbsp[ bytes_written++ ] = filler_byte;
}
}
rbsp[ bytes_written++ ] = trailing_byte; // rbsp_trailing_bits
assert( num_bytes == (bytes_written + 1) );
// write RBSP into NALU
RBSPtoNALU( rbsp, nalu, RBSPlen, NALU_TYPE_FILL, NALU_PRIORITY_DISPOSABLE, 1 );
// write NALU into bitstream
len = p_Vid->WriteNALU( p_Vid, nalu, p_Vid->f_out );
p_Vid->bytes_in_picture += (nalu->len + 1);
FreeNALU( nalu );
return len;
}
/*!
***********************************************************************
* \brief
* Free the Image structure
* \par Input:
* Image Parameters VideoParameters *p_Vid
***********************************************************************
*/
static void free_img( VideoParameters *p_Vid)
{
int i;
if (p_Vid != NULL)
{
if ( p_Vid->p_Inp->FileFormat == PAR_OF_ANNEXB )
{
free_annex_b (&p_Vid->annex_b);
}
// Free new dpb layers
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++)
{
if(p_Vid->p_EncodePar[i])
{
free(p_Vid->p_EncodePar[i]);
p_Vid->p_EncodePar[i] = NULL;
}
}
if (p_Vid->snr != NULL)
{
free (p_Vid->snr);
p_Vid->snr = NULL;
}
if (p_Vid->old_slice != NULL)
{
free (p_Vid->old_slice);
p_Vid->old_slice = NULL;
}
if(p_Vid->pNextSlice)
{
free_slice(p_Vid->pNextSlice);
p_Vid->pNextSlice=NULL;
}
if(p_Vid->ppSliceList)
{
int i;
for(i=0; i<p_Vid->iNumOfSlicesAllocated; i++)
if(p_Vid->ppSliceList[i])
free_slice(p_Vid->ppSliceList[i]);
free(p_Vid->ppSliceList);
}
if(p_Vid->nalu)
{
FreeNALU(p_Vid->nalu);
p_Vid->nalu=NULL;
}
//free memory;
//FreeDecPicList(p_Vid->pDecOuputPic);
if(p_Vid->pNextPPS)
{
FreePPS(p_Vid->pNextPPS);
p_Vid->pNextPPS = NULL;
}
free (p_Vid);
p_Vid = NULL;
}
}
/*!
************************************************************************
* \brief
* This function generates and writes the PPS
*
************************************************************************
*/
int write_PPS(int len, int PPS_id)
{
NALU_t *nalu;
nalu = NULL;
nalu = GeneratePic_parameter_set_NALU (PPS_id);
len += WriteNALU (nalu);
FreeNALU (nalu);
return len;
}
int main(int argc, char **argv)
{
int Flag = TRUE;
//long ftell_position;//, expected_slice_type;
//int ret;
NALU_t *nalu;
h264_decoder* dec_params;
char *ptr;
ptr = ( char*)malloc(10 * sizeof(char));
if ((dec_params = ( h264_decoder*)h264_malloc(1 * sizeof(h264_decoder)))==NULL)
// if ((dec_params = ( h264_decoder*)h264_malloc(1 * 100))==NULL)
{
Flag=FALSE;
}
if ((dec_params->input = (InputParameters *)h264_malloc(1 * sizeof(InputParameters)))==NULL)
{
printf("main: input");
exit(0);
}
if ((dec_params->img = (ImageParameters *)h264_malloc(1 * sizeof(ImageParameters)))==NULL)
{
printf("main: img");
exit(0);
}
////////// ADDED INITIALIZATIONS //////
dec_params->active_sps = NULL;
dec_params->active_pps = NULL;
dec_params->Co_located = NULL;
dec_params->dec_picture = NULL;
dec_params->global_init_done = 0;
dec_params->dpb.init_done = 0;
dec_params->img->DeblockCall = 0;
// dec_params->img->structure = 0;
dec_params->MapUnitToSliceGroupMap = NULL;
dec_params->MbToSliceGroupMap = NULL;
dec_params->img->errorConcealmentFlag = 0; // ERROR CONCEALMENT FLAG SET TO ZERO , NO ERROR CONCEALMENT
dec_params->img->no_output_of_prior_pics_flag = -1;
///////////////////////////////////////
Initializations(dec_params);
Configure ( argc, argv,dec_params );
init_old_slice(dec_params);
switch (dec_params->input->FileFormat)
{
case 0:
OpenBitstreamFile (dec_params->input->infile,dec_params);
break;
case 1:
OpenRTPFile (dec_params->input->infile,dec_params);
break;
default:
printf ("Unsupported file format %d, exit\n", dec_params->input->FileFormat);
}
// Allocate Slice data struct
malloc_slice(dec_params->input,dec_params->img,dec_params);
init(dec_params->img,dec_params);
dec_params->dec_picture = NULL;
dec_params->dpb.init_done = 0;
//dec_params->g_nFrame = 0;
// init_out_buffer(dec_params);
//dec_params->img->idr_psnr_number=dec_params->input->ref_offset;
//dec_params->img->psnr_number=0;
dec_params->img->number=0;
dec_params->img->type = I_SLICE;
dec_params->img->dec_ref_pic_marking_buffer = NULL;
// B pictures
dec_params->Bframe_ctr=0;
// time for total decoding session
dec_params->tot_time = 0;
dec_params->nalu = AllocNALU(MAX_CODED_FRAME_SIZE,dec_params);
nalu = dec_params->nalu;
dec_params->dp = AllocPartition(1, dec_params,1024);
dec_params->sps = AllocSPS();
dec_params->pps = AllocPPS();
{
while ( decode_one_frame( dec_params ) != EOS );
}
//report( dec_params->input, dec_params->img, dec_params->snr,dec_params,);
report( dec_params->input, dec_params->img,dec_params);
free_slice( dec_params->input,dec_params->img);
FreeNALU(dec_params->nalu);
FreePartition (dec_params->dp, 1);
FreeSPS (dec_params->sps);
if (dec_params->PicParSet[dec_params->pps->pic_parameter_set_id].Valid == TRUE && dec_params->PicParSet[dec_params->pps->pic_parameter_set_id].slice_group_id != NULL)
{
h264_free (dec_params->PicParSet[dec_params->pps->pic_parameter_set_id].slice_group_id);
dec_params->PicParSet[dec_params->pps->pic_parameter_set_id].slice_group_id = NULL;
}
// IF FMO PRESENT
if (dec_params->active_pps->num_slice_groups_minus1)
{
FmoFinit(dec_params);
}
FreePPS (dec_params->pps);
free_global_buffers_baseline(dec_params);
flush_dpb(dec_params);
#ifdef PAIR_FIELDS_IN_OUTPUT
flush_pending_output(dec_params->p_out);
#endif
CloseBitstreamFile(dec_params);
//close(dec_params->p_out);
fclose (dec_params->f_out);
// fclose(p_out2);
#if TRACE
fclose(p_trace);
#endif
//ercClose(dec_params->erc_errorVar,dec_params);
ercClose(dec_params);
free_dpb(dec_params);
// uninit_out_buffer(dec_params);
free_colocated(dec_params);
if(dec_params->dec_picture != NULL)
{
free (dec_params->dec_picture);
dec_params->dec_picture = NULL;
}
if(dec_params->input != NULL)
{
h264_free (dec_params->input);
dec_params->input = NULL;
}
if(dec_params->img != NULL)
{
h264_free (dec_params->img);
dec_params->img = NULL;
}
if(dec_params != NULL)
{
h264_free (dec_params);
dec_params = NULL;
}
return 0;
}
/********************************************************************************************************************
退出 RTP 协议
1.锁销毁
2.释放分配的内存
*********************************************************************************************************************/
void rtb_build_uninit()
{
FreeNALU(g_audio_puiNalBuf);
return;
}
/*!
***********************************************************************
* \brief
* Free the Image structure
* \par Input:
* Image Parameters VideoParameters *p_Vid
***********************************************************************
*/
static void free_img( VideoParameters *p_Vid)
{
int i;
if (p_Vid != NULL)
{
if ( p_Vid->p_Inp->FileFormat == PAR_OF_ANNEXB )
{
free_annex_b (&p_Vid->annex_b);
}
#if (ENABLE_OUTPUT_TONEMAPPING)
if (p_Vid->seiToneMapping != NULL)
{
free (p_Vid->seiToneMapping);
p_Vid->seiToneMapping = NULL;
}
#endif
// Free new dpb layers
for (i = 0; i < MAX_NUM_DPB_LAYERS; i++)
{
if (p_Vid->p_Dpb_layer[i] != NULL)
{
free (p_Vid->p_Dpb_layer[i]);
p_Vid->p_Dpb_layer[i] = NULL;
}
if(p_Vid->p_EncodePar[i])
{
free(p_Vid->p_EncodePar[i]);
p_Vid->p_EncodePar[i] = NULL;
}
if(p_Vid->p_LayerPar[i])
{
free(p_Vid->p_LayerPar[i]);
p_Vid->p_LayerPar[i] = NULL;
}
}
if (p_Vid->snr != NULL)
{
free (p_Vid->snr);
p_Vid->snr = NULL;
}
if (p_Vid->old_slice != NULL)
{
free (p_Vid->old_slice);
p_Vid->old_slice = NULL;
}
if(p_Vid->pNextSlice)
{
free_slice(p_Vid->pNextSlice);
p_Vid->pNextSlice=NULL;
}
if(p_Vid->ppSliceList)
{
int i;
for(i=0; i<p_Vid->iNumOfSlicesAllocated; i++)
if(p_Vid->ppSliceList[i])
free_slice(p_Vid->ppSliceList[i]);
free(p_Vid->ppSliceList);
}
if(p_Vid->nalu)
{
FreeNALU(p_Vid->nalu);
p_Vid->nalu=NULL;
}
//free memory;
FreeDecPicList(p_Vid->pDecOuputPic);
if(p_Vid->pNextPPS)
{
FreePPS(p_Vid->pNextPPS);
p_Vid->pNextPPS = NULL;
}
// clear decoder statistics
#if ENABLE_DEC_STATS
delete_dec_stats(p_Vid->dec_stats);
free (p_Vid->dec_stats);
#endif
free (p_Vid);
p_Vid = NULL;
}
}
/*!
************************************************************************
* \brief
* Reads new slice from bit_stream
************************************************************************
*/
int read_new_slice()
{
NALU_t *nalu = AllocNALU(MAX_CODED_FRAME_SIZE);
int current_header;
int ret;
int BitsUsedByHeader;
Slice *currSlice = img->currentSlice;
Bitstream *currStream;
int newframe;
int slice_id_a, slice_id_b, slice_id_c;
int redundant_pic_cnt_a, redundant_pic_cnt_b, redundant_pic_cnt_c;
long ftell_position, expected_slice_type;
// int i;
expected_slice_type = NALU_TYPE_DPA;
while (1)
{
ftell_position = ftell(bits);
if (input->FileFormat == PAR_OF_ANNEXB)
ret=GetAnnexbNALU (nalu);
else
ret=GetRTPNALU (nalu);
NALUtoRBSP(nalu);
// printf ("nalu->len %d\n", nalu->len);
if (ret < 0)
printf ("Error while getting the NALU in file format %s, exit\n", input->FileFormat==PAR_OF_ANNEXB?"Annex B":"RTP");
if (ret == 0)
{
// printf ("read_new_slice: returning %s\n", "EOS");
if(expected_slice_type != NALU_TYPE_DPA)
{
/* oops... we found the next slice, go back! */
fseek(bits, ftell_position, SEEK_SET);
FreeNALU(nalu);
return current_header;
}
else
return EOS;
}
// Got a NALU
if (nalu->forbidden_bit)
{
printf ("Found NALU w/ forbidden_bit set, bit error? Let's try...\n");
}
switch (nalu->nal_unit_type)
{
case NALU_TYPE_SLICE:
case NALU_TYPE_IDR:
img->idr_flag = (nalu->nal_unit_type == NALU_TYPE_IDR);
img->nal_reference_idc = nalu->nal_reference_idc;
img->disposable_flag = (nalu->nal_reference_idc == NALU_PRIORITY_DISPOSABLE);
currSlice->dp_mode = PAR_DP_1;
currSlice->max_part_nr = 1;
currSlice->ei_flag = 0;
currStream = currSlice->partArr[0].bitstream;
currStream->ei_flag = 0;
currStream->frame_bitoffset = currStream->read_len = 0;
memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
// Some syntax of the Slice Header depends on the parameter set, which depends on
// the parameter set ID of the SLice header. Hence, read the pic_parameter_set_id
// of the slice header first, then setup the active parameter sets, and then read
// the rest of the slice header
BitsUsedByHeader = FirstPartOfSliceHeader();
UseParameterSet (currSlice->pic_parameter_set_id);
BitsUsedByHeader+= RestOfSliceHeader ();
FmoInit (active_pps, active_sps);
init_lists(img->type, img->currentSlice->structure);
reorder_lists (img->type, img->currentSlice);
/* if (img->frame_num==1) // write a reference list
{
count ++;
if (count==1)
for (i=0; i<listXsize[0]; i++)
write_picture(listX[0][i], p_out2);
}
*/
if (img->MbaffFrameFlag)
{
init_mbaff_lists();
}
if (img->currentSlice->structure!=0)
{
img->height /=2 ;
img->height_cr /=2;
}
// From here on, active_sps, active_pps and the slice header are valid
img->current_mb_nr = currSlice->start_mb_nr;
if (img->tr_old != img->ThisPOC)
{
newframe=1;
img->tr_old = img->ThisPOC;
}
else
newframe = 0;
if (newframe)
current_header = SOP;
else
current_header = SOS;
if(img->structure != img->structure_old)
newframe |= 1;
img->structure_old = img->structure;
//! new stuff StW
if(newframe || g_new_frame)
{
current_header = SOP;
g_new_frame=0;
}
else
current_header = SOS;
if (active_pps->entropy_coding_mode_flag)
{
int ByteStartPosition = currStream->frame_bitoffset/8;
if (currStream->frame_bitoffset%8 != 0)
{
ByteStartPosition++;
}
arideco_start_decoding (&currSlice->partArr[0].de_cabac, currStream->streamBuffer, ByteStartPosition, &currStream->read_len, img->type);
}
// printf ("read_new_slice: returning %s\n", current_header == SOP?"SOP":"SOS");
FreeNALU(nalu);
return current_header;
break;
case NALU_TYPE_DPA:
//! The state machine here should follow the same ideas as the old readSliceRTP()
//! basically:
//! work on DPA (as above)
//! read and process all following SEI/SPS/PPS/PD/Filler NALUs
//! if next video NALU is dpB,
//! then read and check whether it belongs to DPA, if yes, use it
//! else
//! ; // nothing
//! read and process all following SEI/SPS/PPS/PD/Filler NALUs
//! if next video NALU is dpC
//! then read and check whether it belongs to DPA (and DPB, if present), if yes, use it, done
//! else
//! use the DPA (and the DPB if present)
/*
LC: inserting the code related to DP processing, mainly copying some of the parts
related to NALU_TYPE_SLICE, NALU_TYPE_IDR.
*/
if(expected_slice_type != NALU_TYPE_DPA)
{
/* oops... we found the next slice, go back! */
fseek(bits, ftell_position, SEEK_SET);
FreeNALU(nalu);
return current_header;
}
img->idr_flag = (nalu->nal_unit_type == NALU_TYPE_IDR);
img->nal_reference_idc = nalu->nal_reference_idc;
img->disposable_flag = (nalu->nal_reference_idc == NALU_PRIORITY_DISPOSABLE);
currSlice->dp_mode = PAR_DP_3;
currSlice->max_part_nr = 3;
currSlice->ei_flag = 0;
currStream = currSlice->partArr[0].bitstream;
currStream->ei_flag = 0;
currStream->frame_bitoffset = currStream->read_len = 0;
memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
BitsUsedByHeader = FirstPartOfSliceHeader();
UseParameterSet (currSlice->pic_parameter_set_id);
BitsUsedByHeader += RestOfSliceHeader ();
FmoInit (active_pps, active_sps);
init_lists(img->type, img->currentSlice->structure);
reorder_lists (img->type, img->currentSlice);
if (img->MbaffFrameFlag)
{
init_mbaff_lists();
}
if (img->currentSlice->structure!=0)
{
img->height /=2 ;
img->height_cr /=2;
}
// From here on, active_sps, active_pps and the slice header are valid
img->current_mb_nr = currSlice->start_mb_nr;
if (img->tr_old != img->ThisPOC)
{
newframe=1;
img->tr_old = img->ThisPOC;
}
else
newframe = 0;
if (newframe)
current_header = SOP;
else
current_header = SOS;
if(img->structure != img->structure_old)
newframe |= 1;
img->structure_old = img->structure;
//! new stuff StW
if(newframe || g_new_frame)
{
current_header = SOP;
g_new_frame=0;
}
else
current_header = SOS;
/*
LC:
Now I need to read the slice ID, which depends on the value of
redundant_pic_cnt_present_flag (pag.49).
*/
slice_id_a = ue_v("NALU:SLICE_A slice_idr", currStream);
if (active_pps->redundant_pic_cnt_present_flag)
redundant_pic_cnt_a = ue_v("NALU:SLICE_A redudand_pic_cnt", currStream);
else
redundant_pic_cnt_a = 0;
if (active_pps->entropy_coding_mode_flag)
{
int ByteStartPosition = currStream->frame_bitoffset/8;
if (currStream->frame_bitoffset%8 != 0)
{
ByteStartPosition++;
}
arideco_start_decoding (&currSlice->partArr[0].de_cabac, currStream->streamBuffer, ByteStartPosition, &currStream->read_len, img->type);
}
// printf ("read_new_slice: returning %s\n", current_header == SOP?"SOP":"SOS");
break;
case NALU_TYPE_DPB:
/* LC: inserting the code related to DP processing */
currStream = currSlice->partArr[1].bitstream;
currStream->ei_flag = 0;
currStream->frame_bitoffset = currStream->read_len = 0;
memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
slice_id_b = ue_v("NALU:SLICE_B slice_idr", currStream);
if (active_pps->redundant_pic_cnt_present_flag)
redundant_pic_cnt_b = ue_v("NALU:SLICE_B redudand_pic_cnt", currStream);
else
redundant_pic_cnt_b = 0;
/* LC: Initializing CABAC for the current data stream. */
if (active_pps->entropy_coding_mode_flag)
{
int ByteStartPosition = currStream->frame_bitoffset/8;
if (currStream->frame_bitoffset % 8 != 0)
ByteStartPosition++;
arideco_start_decoding (&currSlice->partArr[1].de_cabac, currStream->streamBuffer,
ByteStartPosition, &currStream->read_len, img->type);
}
/* LC: resilience code to be inserted */
/* FreeNALU(nalu); */
/* return current_header; */
break;
case NALU_TYPE_DPC:
/* LC: inserting the code related to DP processing */
currStream = currSlice->partArr[2].bitstream;
currStream->ei_flag = 0;
currStream->frame_bitoffset = currStream->read_len = 0;
memcpy (currStream->streamBuffer, &nalu->buf[1], nalu->len-1);
currStream->code_len = currStream->bitstream_length = RBSPtoSODB(currStream->streamBuffer, nalu->len-1);
slice_id_c = ue_v("NALU:SLICE_C slice_idr", currStream);
if (active_pps->redundant_pic_cnt_present_flag)
redundant_pic_cnt_c = ue_v("NALU:SLICE_C redudand_pic_cnt", currStream);
else
redundant_pic_cnt_c = 0;
/* LC: Initializing CABAC for the current data stream. */
if (active_pps->entropy_coding_mode_flag)
{
int ByteStartPosition = currStream->frame_bitoffset/8;
if (currStream->frame_bitoffset % 8 != 0)
ByteStartPosition++;
arideco_start_decoding (&currSlice->partArr[2].de_cabac, currStream->streamBuffer,
ByteStartPosition, &currStream->read_len, img->type);
}
/* LC: resilience code to be inserted */
FreeNALU(nalu);
return current_header;
break;
case NALU_TYPE_SEI:
printf ("read_new_slice: Found NALU_TYPE_SEI, len %d\n", nalu->len);
InterpretSEIMessage(nalu->buf,nalu->len,img);
break;
case NALU_TYPE_PPS:
ProcessPPS(nalu);
break;
case NALU_TYPE_SPS:
ProcessSPS(nalu);
break;
case NALU_TYPE_PD:
// printf ("read_new_slice: Found 'Access Unit Delimiter' NAL unit, len %d, ignored\n", nalu->len);
break;
case NALU_TYPE_EOSEQ:
// printf ("read_new_slice: Found 'End of Sequence' NAL unit, len %d, ignored\n", nalu->len);
break;
case NALU_TYPE_EOSTREAM:
// printf ("read_new_slice: Found 'End of Stream' NAL unit, len %d, ignored\n", nalu->len);
break;
case NALU_TYPE_FILL:
printf ("read_new_slice: Found NALU_TYPE_FILL, len %d\n", nalu->len);
printf ("Skipping these filling bits, proceeding w/ next NALU\n");
break;
default:
printf ("Found NALU type %d, len %d undefined, ignore NALU, moving on\n", nalu->nal_unit_type, nalu->len);
}
}
FreeNALU(nalu);
return current_header;
}
/*!
***********************************************************************
* \brief
* Free the Image structure
* \par Input:
* Image Parameters VideoParameters *p_Vid
***********************************************************************
*/
static void free_img( VideoParameters *p_Vid)
{
//free_mem3Dint(p_Vid->fcf );
if (p_Vid != NULL)
{
free_annex_b (p_Vid);
#if (ENABLE_OUTPUT_TONEMAPPING)
if (p_Vid->seiToneMapping != NULL)
{
free (p_Vid->seiToneMapping);
p_Vid->seiToneMapping = NULL;
}
#endif
if (p_Vid->bitsfile != NULL)
{
free (p_Vid->bitsfile);
p_Vid->bitsfile = NULL;
}
if (p_Vid->p_Dpb != NULL)
{
free (p_Vid->p_Dpb);
p_Vid->p_Dpb = NULL;
}
if (p_Vid->snr != NULL)
{
free (p_Vid->snr);
p_Vid->snr = NULL;
}
if (p_Vid->old_slice != NULL)
{
free (p_Vid->old_slice);
p_Vid->old_slice = NULL;
}
if(p_Vid->pNextSlice)
{
free_slice(p_Vid->pNextSlice);
p_Vid->pNextSlice=NULL;
}
if(p_Vid->ppSliceList)
{
int i;
for(i=0; i<p_Vid->iNumOfSlicesAllocated; i++)
if(p_Vid->ppSliceList[i])
free_slice(p_Vid->ppSliceList[i]);
free(p_Vid->ppSliceList);
}
if(p_Vid->nalu)
{
FreeNALU(p_Vid->nalu);
p_Vid->nalu=NULL;
}
//free memory;
FreeDecPicList(p_Vid->pDecOuputPic);
if(p_Vid->pNextPPS)
{
FreePPS(p_Vid->pNextPPS);
p_Vid->pNextPPS = NULL;
}
free (p_Vid);
p_Vid = NULL;
}
}
