void FreePartition (DataPartition *dp, int n)
{
int i;
assert (dp != NULL);
assert (dp->bitstream != NULL);
assert (dp->bitstream->streamBuffer != NULL);
for (i=0; i<n; i++)
{
//h264_free (dp[i].bitstream->streamBuffer);
h264_free (dp[i].bitstream);
}
h264_free (dp);
}
/*!
************************************************************************
* \brief
* free 2D memory array
* which was alocated with get_mem2Dint()
*-----------------------------------------------------------------------
* Function Argument List Changed [Removing Global Variables]
* Input parameters added are
* - h264_decoder* dec_params
*
* <*****@*****.**>
************************************************************************
*/
void free_mem2Dint(int **array2D)
{
if (array2D)
{
if (array2D[0])
{
h264_free (array2D[0]);
}
else
{
printf("free_mem2Dint: trying to free unused memory");
}
h264_free (array2D);
}
else
{
printf("free_mem2Dint: trying to free unused memory");
}
}
/*!
************************************************************************
* \brief
* free 2D memory array
* which was alocated with get_mem2Dint64()
*-----------------------------------------------------------------------
* Function Argument List Changed [Removing Global Variables]
* Input parameters added are
* - h264_decoder* dec_params
*
* <*****@*****.**>
************************************************************************
*/
void free_mem2Dint64(int64 **array2D)
{
if (array2D)
{
if (array2D[0])
{
h264_free (array2D[0]);
}
else
{
printf("free_mem2Dint64: trying to free unused memory");
}
h264_free (array2D);
}
else
{
printf("free_mem2Dint64: trying to free unused memory");
exit(0);
}
}
/*!
************************************************************************
* \brief
* free 2D memory array
* which was alocated with get_mem2Dpel()
*-----------------------------------------------------------------------
* Function Argument List Changed [Removing Global Variables]
* Input parameters added are
* - h264_decoder* dec_params
*
* <*****@*****.**>
************************************************************************
*/
void free_mem2Dpel(imgpel **array2D)
{
if (array2D)
{
if (array2D[0])
h264_free (array2D[0]);
else
{
printf("free_mem2Dpel: trying to free unused memory",100);
exit(0);
}
h264_free (array2D);
}
else
{
printf("free_mem2Dpel: trying to free unused memory");
exit(0);
}
}
/*!
************************************************************************
* \brief
* Memory frees of the Slice structure and of its dependent
* data structures
*
* \par Input:
* Input Parameters struct inp_par *inp, struct img_par *img
************************************************************************
*/
void free_slice(InputParameters *inp,ImageParameters *img)
{
Slice *currSlice = img->currentSlice;
//FreePartition (currSlice->partArr, 3);
FreePartition (currSlice->partArr, currSlice->max_part_nr);
// if (inp->symbol_mode == CABAC)
if (1)
{
// delete all context models
//delete_contexts_MotionInfo(currSlice->mot_ctx);
//delete_contexts_TextureInfo(currSlice->tex_ctx);
}
h264_free(img->currentSlice);
currSlice = NULL;
}
/*!
************************************************************************
* \brief
* free 4D short memory array
* which was allocated with get_mem4Dshort()
*-----------------------------------------------------------------------
* Function Argument List Changed [Removing Global Variables]
* Input parameters added are
* - h264_decoder* dec_params
*
* <*****@*****.**>
************************************************************************
*/
void free_mem4Dshort(short ****array4D, int idx, int frames )
{
int j;
if (array4D)
{
for(j=0;j<idx;j++)
{
free_mem3Dshort( array4D[j], frames) ;
}
h264_free (array4D);
}
else
{
printf("free_mem4Dshort: trying to free unused memory");
exit(0);
}
}
/*!
************************************************************************
* \brief
* free 3D short memory array
* which was allocated with get_mem3Dshort()
*-----------------------------------------------------------------------
* Function Argument List Changed [Removing Global Variables]
* Input parameters added are
* - h264_decoder* dec_params
*
* <*****@*****.**>
************************************************************************
*/
void free_mem3Dshort(short ***array3D, int frames)
{
int i;
if (array3D)
{
for (i=0;i<frames;i++)
{
free_mem2Dshort(array3D[i]);
}
h264_free (array3D);
}
else
{
printf("free_mem3Dshort: trying to free unused memory");
exit(0);
}
}
static void ProcessSpsNalu(unsigned char* data, int length) {
const char naluHeader[] = {0x00, 0x00, 0x00, 0x01};
h264_stream_t* stream = h264_new();
// Read the old NALU
read_nal_unit(stream, &data[sizeof(naluHeader)], length-sizeof(naluHeader));
// Fixup the SPS to what OS X needs to use hardware acceleration
stream->sps->num_ref_frames = 1;
stream->sps->vui.max_dec_frame_buffering = 1;
// Copy the NALU prefix over from the original SPS
memcpy(s_LastSps, naluHeader, sizeof(naluHeader));
// Copy the modified NALU data
s_LastSpsLength = sizeof(naluHeader) + write_nal_unit(stream,
&s_LastSps[sizeof(naluHeader)],
sizeof(s_LastSps)-sizeof(naluHeader));
h264_free(stream);
}
//自己写的，解析NAL数据的函数
char* probe_nal_unit(char* filename,int data_offset,int data_lenth){
//清空字符串-----------------
memset(outputstr,'\0',100000);
//tempstr=(char *)malloc(10000);
//outputstr=(char *)malloc(100000);
//内存用于存放NAL（包含起始码）
uint8_t *nal_temp=(uint8_t *)malloc(data_lenth);
//从文件读取
FILE *fp=fopen(filename,"rb");
fseek(fp,data_offset,SEEK_SET);
fread(nal_temp,data_lenth,1,fp);
// read some H264 data into buf
int nal_start,nal_end;
h264_stream_t* h = h264_new();
find_nal_unit(nal_temp, data_lenth, &nal_start, &nal_end);
read_nal_unit(h, &nal_temp[nal_start], nal_end - nal_start);
debug_nal(h,h->nal);
free(nal_temp);
fclose(fp);
h264_free(h);
return outputstr;
}
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;
}
/*!
************************************************************************
* \brief
* Free allocated memory of frame size related global buffers
* buffers are defined in global.h, allocated memory is allocated in
* int init_global_buffers()
*
* \par Input:
* Input Parameters struct inp_par *inp, Image Parameters struct img_par *img
*
* \par Output:
* none
*
*-----------------------------------------------------------------------
* Function Argument List Changed [Removing Global Variables]
* Input parameters added are
* - h264_decoder* dec_params
*
* <*****@*****.**>
************************************************************************
*/
void free_global_buffers_baseline( h264_decoder* dec_params )
{
ImageParameters* img = dec_params->img;
// h264_free (dec_params->img->nz_coeff);
h264_free (dec_params->img->nz_coeff1);
// free mem, allocated for structure img
// if (img->mb_data != NULL)
// h264_free(img->mb_data);
// faisal
h264_free(img->slice_nr);
h264_free(img->ei_flag);
///////////////////////////////////////////////////////////////////////////////////
// memory deallocation for the new mb_data structure in the ImageParam structure //
///////////////////////////////////////////////////////////////////////////////////
h264_free(img->mb_data1.cbp_blk);
h264_free(img->mb_data1.LFAlphaC0Offset);
h264_free(img->mb_data1.LFBetaOffset);
h264_free(img->mb_data1.LFDisableIdc);
h264_free(img->mb_data1.mb_type);
h264_free(img->mb_data1.partition);
h264_free(img->mb_data1.mbAvailA);
h264_free(img->mb_data1.mbAvailB);
h264_free(img->mb_data1.NoMbPartLessThan8x8Flag);
h264_free(img->mb_data1.qp);
///////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////
h264_free (dec_params->img->intra_block);
free_mem2D ( (byte **) dec_params->img->ipredmode);
free_mem3Dint(dec_params->img->wp_weight, 2);
free_mem3Dint(dec_params->img->wp_offset, 6);
free_mem4Dint(dec_params->img->wbp_weight, 6, MAX_REFERENCE_PICTURES);
/* End of Change*/
// h264_free (dec_params->img->quad);
delete_contexts_MotionInfo(dec_params->mot_ctx);
delete_contexts_TextureInfo(dec_params->tex_ctx);
dec_params->global_init_done = 0;
}
int main(int argc, char *argv[])
{
FILE* infile;
uint8_t* buf = (uint8_t*)malloc( BUFSIZE );
h264_stream_t* h = h264_new();
if (argc < 2) { usage(); return EXIT_FAILURE; }
int opt_verbose = 1;
int opt_probe = 0;
#ifdef HAVE_GETOPT_LONG
int c;
int long_options_index;
extern char* optarg;
extern int optind;
while ( ( c = getopt_long( argc, argv, "o:p:hv", long_options, &long_options_index) ) != -1 )
{
switch ( c )
{
case 'o':
if (h264_dbgfile == NULL) { h264_dbgfile = fopen( optarg, "wt"); }
break;
case 'p':
opt_probe = 1;
opt_verbose = 0;
break;
case 'v':
opt_verbose = atoi( optarg );
break;
case 'h':
default:
usage( );
return 1;
}
}
infile = fopen(argv[optind], "rb");
#else
infile = fopen(argv[1], "rb");
#endif
if (infile == NULL) { fprintf( stderr, "!! Error: could not open file: %s \n", strerror(errno)); exit(EXIT_FAILURE); }
if (h264_dbgfile == NULL) { h264_dbgfile = stdout; }
size_t rsz = 0;
size_t sz = 0;
int64_t off = 0;
uint8_t* p = buf;
int nal_start, nal_end;
while (1)
{
rsz = fread(buf + sz, 1, BUFSIZE - sz, infile);
if (rsz == 0)
{
if (ferror(infile)) { fprintf( stderr, "!! Error: read failed: %s \n", strerror(errno)); break; }
break; // if (feof(infile))
}
sz += rsz;
while (find_nal_unit(p, sz, &nal_start, &nal_end) > 0)
{
if ( opt_verbose > 0 )
{
fprintf( h264_dbgfile, "!! Found NAL at offset %lld (0x%04llX), size %lld (0x%04llX) \n",
(long long int)(off + (p - buf) + nal_start),
(long long int)(off + (p - buf) + nal_start),
(long long int)(nal_end - nal_start),
(long long int)(nal_end - nal_start) );
}
p += nal_start;
read_nal_unit(h, p, nal_end - nal_start);
if ( opt_probe && h->nal->nal_unit_type == NAL_UNIT_TYPE_SPS )
{
// print codec parameter, per RFC 6381.
int constraint_byte = h->sps->constraint_set0_flag << 7;
constraint_byte = h->sps->constraint_set1_flag << 6;
constraint_byte = h->sps->constraint_set2_flag << 5;
constraint_byte = h->sps->constraint_set3_flag << 4;
constraint_byte = h->sps->constraint_set4_flag << 3;
constraint_byte = h->sps->constraint_set4_flag << 3;
fprintf( h264_dbgfile, "codec: avc1.%02X%02X%02X\n",h->sps->profile_idc, constraint_byte, h->sps->level_idc );
// TODO: add more, move to h264_stream (?)
break; // we've seen enough, bailing out.
}
if ( opt_verbose > 0 )
{
fprintf( h264_dbgfile, "XX ");
debug_bytes(p-4, nal_end - nal_start + 4 >= 16 ? 16: nal_end - nal_start + 4);
debug_nal(h, h->nal);
}
p += (nal_end - nal_start);
sz -= nal_end;
}
// if no NALs found in buffer, discard it
if (p == buf)
{
fprintf( stderr, "!! Did not find any NALs between offset %lld (0x%04llX), size %lld (0x%04llX), discarding \n",
(long long int)off,
(long long int)off,
(long long int)off + sz,
(long long int)off + sz);
p = buf + sz;
sz = 0;
}
memmove(buf, p, sz);
off += p - buf;
p = buf;
}
h264_free(h);
free(buf);
fclose(h264_dbgfile);
fclose(infile);
return 0;
}
int main(int argc, char *argv[])
{
uint8_t* buf = (uint8_t*)malloc(BUFSIZE);
h264_stream_t* h = h264_new();
if (argc < 2)
{
printf("h264_analyze, version 0.1.6\n");
printf("Usage: \n");
printf(" h264_analyze stream.h264\n");
printf("where stream.h264 is a raw H264 stream, as produced by JM or x264\n");
}
int fd = open(argv[1], O_RDONLY);
if (fd == -1) { perror("could not open file"); exit(0); }
int rsz = 0;
int sz = 0;
int64_t off = 0;
uint8_t* p = buf;
int nal_start, nal_end;
while ((rsz = read(fd, buf + sz, BUFSIZE - sz)))
{
sz += rsz;
while (find_nal_unit(p, sz, &nal_start, &nal_end) > 0)
{
printf("!! Found NAL at offset %"PRId64" (0x%04"PRIX64"), size %"PRId64" (0x%04"PRIX64") \n",
(int64_t)(off + (p - buf) + nal_start),
(int64_t)(off + (p - buf) + nal_start),
(int64_t)(nal_end - nal_start),
(int64_t)(nal_end - nal_start) );
p += nal_start;
read_nal_unit(h, p, nal_end - nal_start);
debug_nal(h, h->nal);
p += (nal_end - nal_start);
sz -= nal_end;
}
// if no NALs found in buffer, discard it
if (p == buf)
{
printf("!! Did not find any NALs between offset %"PRId64" (0x%04"PRIX64"), size %"PRId64" (0x%04"PRIX64"), discarding \n",
(int64_t)off,
(int64_t)off,
(int64_t)off + sz,
(int64_t)off + sz);
p = buf + sz;
sz = 0;
}
memmove(buf, p, sz);
off += p - buf;
p = buf;
}
h264_free(h);
free(buf);
}
/* Main Routine to verify HRD compliance */
void calc_buffer(InputParameters *inp)
{
unsigned long NumberLeakyBuckets, *Rmin, *Bmin, *Fmin;
float B_interp, F_interp;
unsigned long iBucket;
float dnr, frac1, frac2;
unsigned long R_decoder, B_decoder, F_decoder;
FILE *outf;
if ((outf=fopen(inp->LeakyBucketParamFile,"rb"))==NULL)
{
snprintf(dec_params->errortext, ET_SIZE, "Error open file %s \n",inp->LeakyBucketParamFile);
error(dec_params->errortext,1,dec_outputs);
}
NumberLeakyBuckets = GetBigDoubleWord(outf);
printf(" Number Leaky Buckets: %8ld \n\n", NumberLeakyBuckets);
Rmin = h264_calloc(sizeof(unsigned long), NumberLeakyBuckets);
Bmin = h264_calloc(sizeof(unsigned long), NumberLeakyBuckets);
Fmin = h264_calloc(sizeof(unsigned long), NumberLeakyBuckets);
for(iBucket =0; iBucket < NumberLeakyBuckets; iBucket++)
{
Rmin[iBucket] = GetBigDoubleWord(outf);
Bmin[iBucket] = GetBigDoubleWord(outf);
Fmin[iBucket] = GetBigDoubleWord(outf);
printf(" %8ld %8ld %8ld \n", Rmin[iBucket], Bmin[iBucket], Fmin[iBucket]);
}
fclose(outf);
R_decoder = inp->R_decoder;
F_decoder = inp->F_decoder;
B_decoder = inp->B_decoder;
for( iBucket =0; iBucket < NumberLeakyBuckets; iBucket++)
{
if(R_decoder < Rmin[iBucket])
{
break;
}
}
printf("\n");
if(iBucket > 0 )
{
if(iBucket < NumberLeakyBuckets)
{
dnr = (float) (Rmin[iBucket] - Rmin[iBucket-1]);
frac1 = (float) (R_decoder - Rmin[iBucket-1]);
frac2 = (float) (Rmin[iBucket] - R_decoder);
B_interp = (float) (Bmin[iBucket] * frac1 + Bmin[iBucket-1] * frac2) /dnr;
F_interp = (float) (Fmin[iBucket] * frac1 + Fmin[iBucket-1] * frac2) /dnr;
}
else
{
B_interp = (float) Bmin[iBucket-1];
F_interp = (float) Fmin[iBucket-1];
}
printf(" Min.buffer %8.2f Decoder buffer size %ld \n Minimum Delay %8.2f DecoderDelay %ld \n", B_interp, B_decoder, F_interp, F_decoder);
if(B_decoder > B_interp && F_decoder > F_interp)
{
printf(" HRD Compliant \n");
}
else
{
printf(" HRD Non Compliant \n");
}
}
else
{ // (iBucket = 0)
printf(" Decoder Rate is too small; HRD cannot be verified \n");
}
h264_free(Rmin);
h264_free(Bmin);
h264_free(Fmin);
return;
}
void dec_ref_pic_marking(Bitstream *currStream, h264_decoder* dec_params)
{
int val;
DecRefPicMarking_t *tmp_drpm,*tmp_drpm2;
// free old buffer content
while (dec_params->img->dec_ref_pic_marking_buffer)
{
tmp_drpm=dec_params->img->dec_ref_pic_marking_buffer;
dec_params->img->dec_ref_pic_marking_buffer=tmp_drpm->Next;
h264_free (tmp_drpm);
}
if (dec_params->img->idr_flag)
{
dec_params->img->no_output_of_prior_pics_flag = u_1("SH: no_output_of_prior_pics_flag", currStream,dec_params);
dec_params->img->long_term_reference_flag = u_1("SH: long_term_reference_flag", currStream,dec_params);
}
else
{
dec_params->img->adaptive_ref_pic_buffering_flag = u_1("SH: adaptive_ref_pic_buffering_flag", currStream,dec_params);
if (dec_params->img->adaptive_ref_pic_buffering_flag)
{
// read Memory Management Control Operation
do
{
tmp_drpm=(DecRefPicMarking_t*) h264_malloc (1*sizeof (DecRefPicMarking_t));
tmp_drpm->Next=NULL;
val = tmp_drpm->memory_management_control_operation = ue_v("SH: memory_management_control_operation", currStream,dec_params);
if ((val==1)||(val==3))
{
tmp_drpm->difference_of_pic_nums_minus1 = ue_v("SH: difference_of_pic_nums_minus1", currStream,dec_params);
}
if (val==2)
{
tmp_drpm->long_term_pic_num = ue_v("SH: long_term_pic_num", currStream,dec_params);
}
if ((val==3)||(val==6))
{
tmp_drpm->long_term_frame_idx = ue_v("SH: long_term_frame_idx", currStream,dec_params);
}
if (val==4)
{
tmp_drpm->max_long_term_frame_idx_plus1 = ue_v("SH: max_long_term_pic_idx_plus1", currStream,dec_params);
}
// add command
if (dec_params->img->dec_ref_pic_marking_buffer==NULL)
{
dec_params->img->dec_ref_pic_marking_buffer=tmp_drpm;
}
else
{
tmp_drpm2=dec_params->img->dec_ref_pic_marking_buffer;
while (tmp_drpm2->Next!=NULL) tmp_drpm2=tmp_drpm2->Next;
tmp_drpm2->Next=tmp_drpm;
}
}while (val != 0);
}
}
}
