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 25 h264_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 70 h264_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 ////////////////////////////////////////////////// 140 h264_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 216 h264_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 268 void 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 290 void h264_init_img(h264_Info* pInfo) 291 { 292 h264_memset(&(pInfo->img), 0x0, sizeof(h264_img_par) ); 293 294 295 return; 296 } 297 298 299 void 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 336 void 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 393 void 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 468 int32_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 513 int32_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 ////////////////////////////////////////////////////////////// 563 void 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 ////////////////////////////////////////////////////////////////////////////// 611 void 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 670 void 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
