1/* ///////////////////////////////////////////////////////////////////////
2//
3//               INTEL CORPORATION PROPRIETARY INFORMATION
4//  This software is supplied under the terms of a license agreement or
5//  nondisclosure agreement with Intel Corporation and may not be copied
6//  or disclosed except in accordance with the terms of that agreement.
7//        Copyright (c) 2001-2006 Intel Corporation. All Rights Reserved.
8//
9//  Description:    h264 parser
10//
11///////////////////////////////////////////////////////////////////////*/
12
13
14#include "h264.h"
15#include "h264parse.h"
16#include "h264parse_dpb.h"
17
18
19/* ------------------------------------------------------------------------------------------ */
20/* ------------------------------------------------------------------------------------------ */
21/* ------------------------------------------------------------------------------------------ */
22
23
24
25h264_Status h264_Scaling_List(void *parent, uint8_t *scalingList, int32_t sizeOfScalingList, uint8_t *UseDefaultScalingMatrix, h264_Info* pInfo)
26{
27	int32_t j, scanj;
28	int32_t delta_scale, lastScale, nextScale;
29
30#if 0
31	const uint8_t ZZ_SCAN[16]  =
32	{  0,  1,  4,  8,  5,  2,  3,  6,  9, 12, 13, 10,  7, 11, 14, 15
33	};
34
35	const uint8_t ZZ_SCAN8[64] =
36	{  0,  1,  8, 16,  9,  2,  3, 10, 17, 24, 32, 25, 18, 11,  4,  5,
37		12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13,  6,  7, 14, 21, 28,
38		35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51,
39		58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63
40	};
41#endif
42
43	lastScale      = 8;
44	nextScale      = 8;
45   scanj = 0;
46
47	for(j=0; j<sizeOfScalingList; j++)
48	{
49		//scanj = (sizeOfScalingList==16)?ZZ_SCAN[j]:ZZ_SCAN8[j];
50
51		if(nextScale!=0)
52		{
53		  delta_scale = h264_GetVLCElement(parent, pInfo, true);
54		  nextScale = (lastScale + delta_scale + 256) % 256;
55		  *UseDefaultScalingMatrix = (uint8_t) (scanj==0 && nextScale==0);
56		}
57
58		scalingList[scanj] = (nextScale==0) ? lastScale:nextScale;
59		lastScale = scalingList[scanj];
60      scanj ++;
61	}
62
63	return H264_STATUS_OK;
64}
65
66/* ------------------------------------------------------------------------------------------ */
67/* ------------------------------------------------------------------------------------------ */
68/* ------------------------------------------------------------------------------------------ */
69
70h264_Status h264_active_par_set(h264_Info*pInfo,h264_Slice_Header_t* SliceHeader)
71{
72	//h264_Slice_Header_t* SliceHeader = &pInfo->SliceHeader;
73
74	///////////////////////////////////////////////////
75	// Reload SPS/PPS while
76	// 1) Start of Frame (in case of context switch)
77	// 2) PPS id changed
78	///////////////////////////////////////////////////
79	if((SliceHeader->first_mb_in_slice == 0) || (SliceHeader->pic_parameter_id != pInfo->active_PPS.pic_parameter_set_id))
80	{
81#ifndef WIN32
82		h264_Parse_Copy_Pps_From_DDR(pInfo, &pInfo->active_PPS, SliceHeader->pic_parameter_id);
83
84		if(pInfo->active_PPS.seq_parameter_set_id >= MAX_NUM_SPS)
85		{
86			return H264_PPS_INVALID_PIC_ID;			/// Invalid PPS detected
87		}
88
89      if(pInfo->active_PPS.seq_parameter_set_id != pInfo->active_SPS.seq_parameter_set_id)
90      {
91         pInfo->Is_SPS_updated =1;
92		 h264_Parse_Copy_Sps_From_DDR(pInfo, &pInfo->active_SPS, pInfo->active_PPS.seq_parameter_set_id);
93		 h264_Parse_Clear_Sps_Updated_Flag(pInfo, pInfo->active_PPS.seq_parameter_set_id);
94      }
95	  else
96	  {
97	     if(h264_Parse_Check_Sps_Updated_Flag(pInfo, pInfo->active_PPS.seq_parameter_set_id))
98	     {
99	        pInfo->Is_SPS_updated =1;
100		    h264_Parse_Copy_Sps_From_DDR(pInfo, &pInfo->active_SPS, pInfo->active_PPS.seq_parameter_set_id);
101			h264_Parse_Clear_Sps_Updated_Flag(pInfo, pInfo->active_PPS.seq_parameter_set_id);
102	     }
103	  }
104
105#else
106		pInfo->active_PPS = PPS_GL[SliceHeader->pic_parameter_id];
107		pInfo->active_SPS = SPS_GL[pInfo->active_PPS.seq_parameter_set_id];
108#endif
109
110		if(pInfo->active_SPS.seq_parameter_set_id >= MAX_NUM_SPS)
111		{
112			return H264_PPS_INVALID_PIC_ID;			//// Invalid SPS detected
113		}
114	}
115	else {
116		if((pInfo->active_PPS.seq_parameter_set_id >= MAX_NUM_SPS)  || (pInfo->active_SPS.seq_parameter_set_id >= MAX_NUM_SPS))
117		{
118			return H264_PPS_INVALID_PIC_ID;			/// Invalid PPS detected
119		}
120	}
121
122
123	pInfo->img.PicWidthInMbs    = (pInfo->active_SPS.sps_disp.pic_width_in_mbs_minus1 + 1);
124	//pInfo->img.PicHeightInMapUnits = (pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1);
125	pInfo->img.FrameHeightInMbs = pInfo->active_SPS.sps_disp.frame_mbs_only_flag?				\
126								(pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1):	\
127								((pInfo->active_SPS.sps_disp.pic_height_in_map_units_minus1 + 1)<<1);
128
129
130	return H264_STATUS_OK;
131};   //// End of h264_active_par_set
132
133/* ------------------------------------------------------------------------------------------ */
134/* ------------------------------------------------------------------------------------------ */
135/* ------------------------------------------------------------------------------------------ */
136
137//////////////////////////////////////////////////
138// Parse slice header info
139//////////////////////////////////////////////////
140h264_Status h264_Parse_Slice_Layer_Without_Partitioning_RBSP(void *parent, h264_Info* pInfo, h264_Slice_Header_t *SliceHeader)
141{
142	h264_Status retStatus = H264_STATUS_ERROR;
143
144	////////////////////////////////////////////////////
145	//// Parse slice header info
146	//// Part1: not depend on the active PPS/SPS
147	//// Part2/3: depend on the active parset
148	//////////////////////////////////////////////////
149
150	//retStatus = h264_Parse_Slice_Header_1(pInfo);
151
152	SliceHeader->sh_error = 0;
153
154	if(h264_Parse_Slice_Header_1(parent, pInfo, SliceHeader) == H264_STATUS_OK)
155	{
156		//////////////////////////////////////////
157		//// Active parameter set for this slice
158		//////////////////////////////////////////
159		retStatus = h264_active_par_set(pInfo, SliceHeader);
160	}
161
162	if(retStatus == H264_STATUS_OK) {
163		switch(pInfo->active_SPS.profile_idc)
164		{
165			case h264_ProfileBaseline:
166			case h264_ProfileMain:
167			case h264_ProfileExtended:
168				pInfo->active_PPS.transform_8x8_mode_flag=0;
169				pInfo->active_PPS.pic_scaling_matrix_present_flag =0;
170				pInfo->active_PPS.second_chroma_qp_index_offset = pInfo->active_PPS.chroma_qp_index_offset;
171
172			default:
173				break;
174		}
175
176		if( h264_Parse_Slice_Header_2(parent, pInfo, SliceHeader) != H264_STATUS_OK)
177		{
178			SliceHeader->sh_error |= 2;
179		}
180		else	if( h264_Parse_Slice_Header_3(parent, pInfo, SliceHeader) != H264_STATUS_OK)
181		{
182			SliceHeader->sh_error |= 4;
183		}
184
185	} else 	{
186		SliceHeader->sh_error |= 1;
187	}
188
189
190	//if(SliceHeader->sh_error) {
191		//pInfo->wl_err_flag |= VIDDEC_FW_WORKLOAD_ERR_NOTDECODABLE;
192	//}
193
194
195
196	//////////////////////////////////
197	//// Parse slice data (MB loop)
198	//////////////////////////////////
199	//retStatus = h264_Parse_Slice_Data(pInfo);
200	{
201		//uint32_t data = 0;
202		//if( viddec_pm_peek_bits(parent, &data, 32) == -1)
203			//retStatus = H264_STATUS_ERROR;
204	}
205	//h264_Parse_rbsp_trailing_bits(pInfo);
206
207	return retStatus;
208}
209
210
211
212/* ------------------------------------------------------------------------------------------ */
213/* ------------------------------------------------------------------------------------------ */
214/* ------------------------------------------------------------------------------------------ */
215
216h264_Status h264_Parse_NAL_Unit(void *parent, h264_Info* pInfo, uint8_t *nal_ref_idc)
217{
218	h264_Status ret = H264_STATUS_ERROR;
219
220	//h264_NAL_Unit_t* NAL = &pInfo->NAL;
221	uint32_t code;
222#if 0
223	viddec_pm_get_bits(void * parent,uint32_t * data,uint32_t num_bits)(parent, &code, 24);
224	viddec_pm_get_bits(parent, &code, 1);   //forbidden_zero_bit
225
226	viddec_pm_get_bits(parent, &code, 2);
227	SliceHeader->nal_ref_idc = (uint8_t)code;
228
229	viddec_pm_get_bits(parent, &code, 5);
230	pInfo->nal_unit_type = (uint8_t)code;
231#else
232#ifdef VBP
233	if( viddec_pm_get_bits(parent, &code, 8) != -1)
234#else
235	//// 24bit SC, 1 bit: forbidden_zero_bit, 2 bitrs: nal_ref_idc, 5 bits: nal_unit_type
236	if( viddec_pm_get_bits(parent, &code, 32) != -1)
237#endif
238	{
239		*nal_ref_idc = (uint8_t)((code>>5)&0x3);
240		pInfo->nal_unit_type = (uint8_t)((code>>0)&0x1f);
241		ret = H264_STATUS_OK;
242	}
243#endif
244
245	return ret;
246}
247
248
249/* ------------------------------------------------------------------------------------------ */
250/* ------------------------------------------------------------------------------------------ */
251/* ------------------------------------------------------------------------------------------ */
252
253/*!
254 ************************************************************************
255 * \brief
256 *    set defaults for old_slice
257 *    NAL unit of a picture"
258 ************************************************************************
259 */
260#ifndef INT_MAX
261#define INT_MAX 0xFFFFFFFF
262#endif
263
264#ifndef UINT_MAX
265#define UINT_MAX 0x7FFFFFFF
266#endif
267
268void h264_init_old_slice(h264_Info* pInfo)
269{
270	pInfo->SliceHeader.field_pic_flag = 0;
271
272	pInfo->SliceHeader.pic_parameter_id = 0xFF;
273
274	pInfo->SliceHeader.frame_num = INT_MAX;
275
276	pInfo->SliceHeader.nal_ref_idc = 0xFF;
277
278	pInfo->SliceHeader.idr_flag = 0;
279
280	pInfo->SliceHeader.pic_order_cnt_lsb          = UINT_MAX;
281	pInfo->SliceHeader.delta_pic_order_cnt_bottom = INT_MAX;
282
283	pInfo->SliceHeader.delta_pic_order_cnt[0] = INT_MAX;
284	pInfo->SliceHeader.delta_pic_order_cnt[1] = INT_MAX;
285
286	return;
287}
288
289
290void h264_init_img(h264_Info* pInfo)
291{
292   h264_memset(&(pInfo->img), 0x0, sizeof(h264_img_par) );
293
294
295   return;
296}
297
298
299void h264_init_sps_pps(struct h264_viddec_parser* parser, uint32_t *persist_mem)
300{
301    int32_t i;
302
303    h264_Info * pInfo = &(parser->info);
304
305    parser->sps_pps_ddr_paddr = (uint32_t)persist_mem;
306
307    pInfo->SPS_PADDR_GL = parser->sps_pps_ddr_paddr;
308    pInfo->PPS_PADDR_GL = pInfo->SPS_PADDR_GL + MAX_NUM_SPS * sizeof(seq_param_set_all);
309    pInfo->OFFSET_REF_FRAME_PADDR_GL = pInfo->PPS_PADDR_GL + MAX_NUM_PPS * sizeof(pic_param_set);
310    pInfo->TMP_OFFSET_REFFRM_PADDR_GL = pInfo->OFFSET_REF_FRAME_PADDR_GL +
311        MAX_NUM_SPS * sizeof(int32_t) * MAX_NUM_REF_FRAMES_IN_PIC_ORDER_CNT_CYCLE;
312
313    h264_memset( &(pInfo->active_SPS), 0x0, sizeof(seq_param_set_used) );
314    h264_memset( &(pInfo->active_PPS), 0x0, sizeof(pic_param_set) );
315
316    /* Global for SPS   & PPS */
317    for(i=0;i<MAX_NUM_SPS;i++)
318    {
319        pInfo->active_SPS.seq_parameter_set_id = 0xff;
320        h264_Parse_Copy_Sps_To_DDR (pInfo, &(pInfo->active_SPS), i);
321    }
322    for(i=0;i<MAX_NUM_PPS;i++)
323    {
324        pInfo->active_PPS.seq_parameter_set_id = 0xff;
325        h264_Parse_Copy_Pps_To_DDR (pInfo, &(pInfo->active_PPS), i);
326    }
327
328    pInfo->active_SPS.seq_parameter_set_id = 0xff;
329    pInfo->sps_valid = 0;
330    pInfo->got_start = 0;
331
332    return;
333}
334
335
336void h264_init_Info_under_sps_pps_level(h264_Info* pInfo)
337{
338    int32_t i=0;
339
340    h264_memset( &(pInfo->dpb), 0x0, sizeof(h264_DecodedPictureBuffer) );
341    h264_memset( &(pInfo->SliceHeader), 0x0, sizeof(h264_Slice_Header_t) );
342    h264_memset( &(pInfo->old_slice), 0x0, sizeof(OldSliceParams) );
343    h264_memset( &(pInfo->sei_information), 0x0, sizeof(sei_info) );
344    h264_memset( &(pInfo->img), 0x0, sizeof(h264_img_par) );
345
346    pInfo->h264_list_replacement = 0;
347
348    pInfo->h264_pwt_start_byte_offset = 0;
349    pInfo->h264_pwt_start_bit_offset = 0;
350    pInfo->h264_pwt_end_byte_offset = 0;
351    pInfo->h264_pwt_end_bit_offset = 0;
352    pInfo->h264_pwt_enabled = 0;
353
354    for(i=0;i<32;i++)
355    {
356        pInfo->slice_ref_list0[i] = 0;
357        pInfo->slice_ref_list1[i] = 0;
358    }
359
360    pInfo->qm_present_list = 0;
361
362    pInfo->nal_unit_type = 0;
363    pInfo->old_nal_unit_type = 0xff;
364
365    pInfo->push_to_cur = 0;
366    pInfo->Is_first_frame_in_stream = 1;
367    pInfo->Is_SPS_updated = 0;
368    pInfo->number_of_first_au_info_nal_before_first_slice = 0;
369
370    pInfo->is_frame_boundary_detected_by_non_slice_nal = 0;
371    pInfo->is_frame_boundary_detected_by_slice_nal = 0;
372    pInfo->is_current_workload_done = 0;
373
374    pInfo->sei_rp_received = 0;
375    pInfo->last_I_frame_idc = 255;
376    pInfo->wl_err_curr = 0;
377    pInfo->wl_err_next = 0;
378
379    pInfo->primary_pic_type_plus_one = 0;
380	pInfo->sei_b_state_ready = 0;
381
382    /* Init old slice structure  */
383    h264_init_old_slice(pInfo);
384
385    /* init_dpb */
386    h264_init_dpb(&(pInfo->dpb));
387
388    /* init_sei	*/
389    h264_sei_stream_initialise(pInfo);
390
391}
392
393void h264_init_Info(h264_Info* pInfo)
394{
395    h264_memset(pInfo, 0x0, sizeof(h264_Info));
396
397    pInfo->old_nal_unit_type = 0xff;
398
399    pInfo->Is_first_frame_in_stream =1;
400    pInfo->img.frame_count = 0;
401    pInfo->last_I_frame_idc = 255;
402
403    return;
404}
405
406 /* ------------------------------------------------------------------------------------------ */
407/* ------------------------------------------------------------------------------------------ */
408/* ------------------------------------------------------------------------------------------ */
409
410/////////////////////////////////////////////////////
411//
412// Judge whether it is the first VCL of a new picture
413//
414/////////////////////////////////////////////////////
415 int32_t h264_is_second_field(h264_Info * pInfo)
416 {
417    h264_Slice_Header_t cur_slice = pInfo->SliceHeader;
418    OldSliceParams old_slice = pInfo->old_slice;
419
420    int result = 0;
421
422    //pInfo->img.second_field = 0;
423
424    /// is it second field?
425
426    //OS_INFO( "xxx is_used = %d\n", pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].is_used);
427
428    if (cur_slice.structure != FRAME)
429    {
430       if( ( MPD_DPB_FS_NULL_IDC != pInfo->dpb.fs_dec_idc)&&(3 != viddec_h264_get_is_used(&(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc])) )
431         &&(0 != viddec_h264_get_is_used(&(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc])) ))
432       {
433          if ((cur_slice.frame_num == old_slice.frame_num)||(cur_slice.idr_flag))
434          {
435
436             if(old_slice.structure != cur_slice.structure)
437             {
438
439                if (((cur_slice.structure == TOP_FIELD &&old_slice.structure == BOTTOM_FIELD) || // Condition 1:
440                      (old_slice.structure == TOP_FIELD && cur_slice.structure == BOTTOM_FIELD)) &&    \
441                   ((old_slice.nal_ref_idc ==0 && cur_slice.nal_ref_idc == 0)              || // Condition 2:
442                      (old_slice.nal_ref_idc !=0 &&cur_slice.nal_ref_idc != 0)))
443                {
444                   //pInfo->img.second_field = 1;
445                   result = 1;
446                }
447             }
448          }
449
450
451       }
452
453
454    }
455
456
457
458    return result;
459
460 } //// End of h264_is_second_field
461
462
463
464/* ------------------------------------------------------------------------------------------ */
465/* ------------------------------------------------------------------------------------------ */
466/* ------------------------------------------------------------------------------------------ */
467
468int32_t h264_is_new_picture_start(h264_Info * pInfo, h264_Slice_Header_t cur_slice, h264_Slice_Header_t old_slice)
469{
470	int result = 0;
471
472    if(pInfo->number_of_first_au_info_nal_before_first_slice)
473    {
474       pInfo->number_of_first_au_info_nal_before_first_slice = 0;
475       return 1;
476    }
477
478
479
480	result |= (old_slice.pic_parameter_id != cur_slice.pic_parameter_id);
481	result |= (old_slice.frame_num != cur_slice.frame_num);
482	result |= (old_slice.field_pic_flag != cur_slice.field_pic_flag);
483	if(cur_slice.field_pic_flag && old_slice.field_pic_flag)
484	{
485		result |= (old_slice.bottom_field_flag != cur_slice.bottom_field_flag);
486	}
487
488	result |= (old_slice.nal_ref_idc != cur_slice.nal_ref_idc) && \
489			 ((old_slice.nal_ref_idc == 0) || (cur_slice.nal_ref_idc == 0));
490	result |= ( old_slice.idr_flag != cur_slice.idr_flag);
491
492	if (cur_slice.idr_flag && old_slice.idr_flag)
493	{
494		result |= (old_slice.idr_pic_id != cur_slice.idr_pic_id);
495	}
496
497	if (pInfo->active_SPS.pic_order_cnt_type == 0)
498	{
499		result |=  (old_slice.pic_order_cnt_lsb          != cur_slice.pic_order_cnt_lsb);
500		result |=  (old_slice.delta_pic_order_cnt_bottom != cur_slice.delta_pic_order_cnt_bottom);
501	}
502
503	if (pInfo->active_SPS.pic_order_cnt_type == 1)
504	{
505		result |= (old_slice.delta_pic_order_cnt[0] != cur_slice.delta_pic_order_cnt[0]);
506		result |= (old_slice.delta_pic_order_cnt[1] != cur_slice.delta_pic_order_cnt[1]);
507	}
508
509   return result;
510}
511
512
513int32_t h264_check_previous_frame_end(h264_Info * pInfo)
514{
515	int result = 0;
516
517	if( (h264_NAL_UNIT_TYPE_SLICE==pInfo->old_nal_unit_type)||(h264_NAL_UNIT_TYPE_IDR==pInfo->old_nal_unit_type) )
518	{
519
520		switch ( pInfo->nal_unit_type )
521		{
522			case h264_NAL_UNIT_TYPE_Acc_unit_delimiter:
523			case h264_NAL_UNIT_TYPE_SPS:
524			case h264_NAL_UNIT_TYPE_PPS:
525			case h264_NAL_UNIT_TYPE_SEI:
526			case h264_NAL_UNIT_TYPE_EOSeq:
527			case h264_NAL_UNIT_TYPE_EOstream:
528			case h264_NAL_UNIT_TYPE_Reserved1:
529			case h264_NAL_UNIT_TYPE_Reserved2:
530			case h264_NAL_UNIT_TYPE_Reserved3:
531			case h264_NAL_UNIT_TYPE_Reserved4:
532			case h264_NAL_UNIT_TYPE_Reserved5:
533			{
534				pInfo->img.current_slice_num = 0;
535
536				if((pInfo->img.structure == FRAME) || (pInfo->img.second_field)) {
537					pInfo->is_frame_boundary_detected_by_non_slice_nal =1;
538					pInfo->is_current_workload_done=1;
539					result=1;
540				}
541				break;
542			}
543			default:
544				break;
545		}
546
547	}
548
549	return result;
550
551}
552
553
554
555
556/* ------------------------------------------------------------------------------------------ */
557/* ------------------------------------------------------------------------------------------ */
558/* ------------------------------------------------------------------------------------------ */
559
560//////////////////////////////////////////////////////////////
561// 1) Update old slice structure for frame boundary detection
562//////////////////////////////////////////////////////////////
563void h264_update_old_slice(h264_Info * pInfo,h264_Slice_Header_t next_SliceHeader)
564{
565	pInfo->old_slice.pic_parameter_id = pInfo->SliceHeader.pic_parameter_id;
566
567	pInfo->old_slice.frame_num = pInfo->SliceHeader.frame_num;
568
569	pInfo->old_slice.field_pic_flag = pInfo->SliceHeader.field_pic_flag;
570
571	if(pInfo->SliceHeader.field_pic_flag)
572	{
573		pInfo->old_slice.bottom_field_flag = pInfo->SliceHeader.bottom_field_flag;
574	}
575
576	pInfo->old_slice.nal_ref_idc   = pInfo->SliceHeader.nal_ref_idc;
577
578	pInfo->old_slice.structure = pInfo->SliceHeader.structure;
579
580	pInfo->old_slice.idr_flag = pInfo->SliceHeader.idr_flag;
581	if (pInfo->SliceHeader.idr_flag)
582	{
583		pInfo->old_slice.idr_pic_id = pInfo->SliceHeader.idr_pic_id;
584	}
585
586	if (pInfo->active_SPS.pic_order_cnt_type == 0)
587	{
588		pInfo->old_slice.pic_order_cnt_lsb          = pInfo->SliceHeader.pic_order_cnt_lsb;
589		pInfo->old_slice.delta_pic_order_cnt_bottom = pInfo->SliceHeader.delta_pic_order_cnt_bottom;
590	}
591
592	if (pInfo->active_SPS.pic_order_cnt_type == 1)
593	{
594		pInfo->old_slice.delta_pic_order_cnt[0] = pInfo->SliceHeader.delta_pic_order_cnt[0];
595		pInfo->old_slice.delta_pic_order_cnt[1] = pInfo->SliceHeader.delta_pic_order_cnt[1];
596	}
597
598	////////////////////////////// Next to current
599	memcpy(&pInfo->SliceHeader, &next_SliceHeader, sizeof(h264_Slice_Header_t));
600
601	return;
602}
603
604/* ------------------------------------------------------------------------------------------ */
605/* ------------------------------------------------------------------------------------------ */
606/* ------------------------------------------------------------------------------------------ */
607
608//////////////////////////////////////////////////////////////////////////////
609// Initialization for new picture
610//////////////////////////////////////////////////////////////////////////////
611void h264_update_img_info(h264_Info * pInfo )
612{
613	h264_DecodedPictureBuffer *p_dpb = &pInfo->dpb;
614
615	pInfo->img.frame_num = pInfo->SliceHeader.frame_num;
616	pInfo->img.structure = pInfo->SliceHeader.structure;
617
618	pInfo->img.field_pic_flag = pInfo->SliceHeader.field_pic_flag;
619	pInfo->img.bottom_field_flag = pInfo->SliceHeader.bottom_field_flag;
620
621	pInfo->img.MbaffFrameFlag  = pInfo->active_SPS.sps_disp.mb_adaptive_frame_field_flag & (!(pInfo->SliceHeader.field_pic_flag));
622	pInfo->img.pic_order_cnt_type = pInfo->active_SPS.pic_order_cnt_type;
623
624	if(pInfo->img.pic_order_cnt_type == 1) {
625		pInfo->img.num_ref_frames_in_pic_order_cnt_cycle = pInfo->active_SPS.num_ref_frames_in_pic_order_cnt_cycle;
626		pInfo->img.delta_pic_order_always_zero_flag = pInfo->active_SPS.delta_pic_order_always_zero_flag;
627		pInfo->img.offset_for_non_ref_pic = pInfo->active_SPS.offset_for_non_ref_pic;
628		pInfo->img.offset_for_top_to_bottom_field = pInfo->active_SPS.offset_for_top_to_bottom_field;
629	}
630
631	pInfo->img.pic_order_cnt_lsb = pInfo->SliceHeader.pic_order_cnt_lsb;
632	//pInfo->img.pic_order_cnt_msb = pInfo->SliceHeader.pic_order_cnt_msb;
633	pInfo->img.delta_pic_order_cnt_bottom = pInfo->SliceHeader.delta_pic_order_cnt_bottom;
634	pInfo->img.delta_pic_order_cnt[0] = pInfo->SliceHeader.delta_pic_order_cnt[0];
635	pInfo->img.delta_pic_order_cnt[1] = pInfo->SliceHeader.delta_pic_order_cnt[1];
636
637
638	pInfo->img.PreviousFrameNum = pInfo->old_slice.frame_num;
639
640	pInfo->img.no_output_of_prior_pics_flag = pInfo->SliceHeader.sh_dec_refpic.no_output_of_prior_pics_flag;
641
642	////////////////////////////////////////////////// Check SEI recovery point
643	if (pInfo->sei_information.recovery_point) {
644		int32_t MaxFrameNum = 1 << (pInfo->active_SPS.log2_max_frame_num_minus4 + 4);
645		pInfo->sei_information.recovery_frame_num = (pInfo->img.frame_num + pInfo->sei_information.recovery_frame_cnt) % MaxFrameNum;
646	}
647
648	if (pInfo->SliceHeader.idr_flag)
649		pInfo->sei_information.recovery_frame_num = pInfo->img.frame_num;
650
651
652
653	/////////////////////////////////////////////////Resolution Change
654	pInfo->img.curr_has_mmco_5 = 0;
655
656	if ( (pInfo->img.PicWidthInMbs != p_dpb->PicWidthInMbs)||
657	   (pInfo->img.FrameHeightInMbs != p_dpb->FrameHeightInMbs) )
658	{
659		int32_t no_output_old_pics = (pInfo->SliceHeader.idr_flag)? pInfo->img.no_output_of_prior_pics_flag : 0;
660
661		// If resolution changed, reset the soft DPB here
662		h264_dpb_reset_dpb(pInfo, pInfo->img.PicWidthInMbs, pInfo->img.FrameHeightInMbs, 1, no_output_old_pics);
663	}
664
665	return;
666
667} ///// End of init new frame
668
669
670void h264_update_frame_type(h264_Info * pInfo )
671{
672
673//update frame type
674   if(pInfo->img.structure == FRAME)
675   {
676      if(pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR)
677      {
678         pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (0x1 << FRAME_TYPE_STRUCTRUE_OFFSET)|(FRAME_TYPE_IDR << FRAME_TYPE_FRAME_OFFSET);
679         //pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = 0xff;
680         //pInfo->dpb.fs[0].pic_type = pInfo->dpb.fs_dec_idc;
681
682      }
683      else
684      {
685      #if 1
686         switch(pInfo->SliceHeader.slice_type)
687         {
688            case h264_PtypeB:
689               pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (0x1 << FRAME_TYPE_STRUCTRUE_OFFSET)|(FRAME_TYPE_B << FRAME_TYPE_FRAME_OFFSET);
690            	break;
691            case h264_PtypeSP:
692            case h264_PtypeP:
693	            if( ((pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type) & (0x7 << FRAME_TYPE_FRAME_OFFSET))>>FRAME_TYPE_FRAME_OFFSET != FRAME_TYPE_B)
694	               pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (0x1 << FRAME_TYPE_STRUCTRUE_OFFSET)|(FRAME_TYPE_P << FRAME_TYPE_FRAME_OFFSET);
695	            break;
696            case h264_PtypeI:
697            case h264_PtypeSI:
698	            if( ((pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type) & (0x7 << FRAME_TYPE_FRAME_OFFSET))>>FRAME_TYPE_FRAME_OFFSET == FRAME_TYPE_INVALID)
699	            {
700	               pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (0x1 << FRAME_TYPE_STRUCTRUE_OFFSET)|(FRAME_TYPE_I << FRAME_TYPE_FRAME_OFFSET);
701	            }
702				pInfo->last_I_frame_idc = pInfo->dpb.fs_dec_idc;
703
704	            break;
705            default:
706            	break;
707
708         }
709      #endif
710
711      }
712
713   }
714   else if(pInfo->img.structure == TOP_FIELD)
715   {
716      if(pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR)
717      {
718         pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (FRAME_TYPE_IDR << FRAME_TYPE_TOP_OFFSET)|(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type & (0x7 << FRAME_TYPE_BOTTOM_OFFSET));;
719      }
720      else
721      {
722         switch(pInfo->SliceHeader.slice_type)
723         {
724            case h264_PtypeB:
725               pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (FRAME_TYPE_B << FRAME_TYPE_TOP_OFFSET)|(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type & (0x7 << FRAME_TYPE_BOTTOM_OFFSET));
726            break;
727            case h264_PtypeSP:
728            case h264_PtypeP:
729            if( ((pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type) & (0x7 << FRAME_TYPE_TOP_OFFSET))>>FRAME_TYPE_TOP_OFFSET != FRAME_TYPE_B)
730               pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (FRAME_TYPE_P << FRAME_TYPE_TOP_OFFSET)|(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type & (0x7 << FRAME_TYPE_BOTTOM_OFFSET));
731            break;
732            case h264_PtypeI:
733            case h264_PtypeSI:
734            if( ((pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type) & (0x7 << FRAME_TYPE_TOP_OFFSET))>>FRAME_TYPE_TOP_OFFSET == FRAME_TYPE_INVALID)
735            {
736               pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (FRAME_TYPE_I << FRAME_TYPE_TOP_OFFSET)|(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type & (0x7 << FRAME_TYPE_BOTTOM_OFFSET));
737            }
738            break;
739            default:
740            break;
741
742         }
743
744      }
745
746
747   }else if(pInfo->img.structure == BOTTOM_FIELD)
748   {
749      if(pInfo->nal_unit_type == h264_NAL_UNIT_TYPE_IDR)
750      {
751         pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (FRAME_TYPE_IDR << FRAME_TYPE_BOTTOM_OFFSET)|(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type & (0x7 << FRAME_TYPE_TOP_OFFSET));;
752      }
753      else
754      {
755         switch(pInfo->SliceHeader.slice_type)
756         {
757            case h264_PtypeB:
758               pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (FRAME_TYPE_B << FRAME_TYPE_BOTTOM_OFFSET)|(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type & (0x7 << FRAME_TYPE_TOP_OFFSET));
759            break;
760            case h264_PtypeSP:
761            case h264_PtypeP:
762            if( ((pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type) & (0x7 << FRAME_TYPE_BOTTOM_OFFSET))>>FRAME_TYPE_BOTTOM_OFFSET != FRAME_TYPE_B)
763               pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (FRAME_TYPE_P << FRAME_TYPE_BOTTOM_OFFSET)|(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type & (0x7 << FRAME_TYPE_TOP_OFFSET));
764            break;
765            case h264_PtypeI:
766            case h264_PtypeSI:
767            if( ((pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type) & (0x7 << FRAME_TYPE_BOTTOM_OFFSET))>>FRAME_TYPE_BOTTOM_OFFSET == FRAME_TYPE_INVALID)
768            {
769               pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type = (FRAME_TYPE_I << FRAME_TYPE_BOTTOM_OFFSET)|(pInfo->dpb.fs[pInfo->dpb.fs_dec_idc].pic_type & (0x7 << FRAME_TYPE_TOP_OFFSET));
770            }
771            break;
772            default:
773            break;
774
775         }
776
777      }
778
779   }
780   return;
781
782}
783
784
785//////#endif ///////////// IFDEF H264_PARSE_C///////////////////
786
787