1 /****************************************************************************** 2 * 3 * Copyright (C) 2015 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ***************************************************************************** 18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore 19 */ 20 /*! 21 ************************************************************************** 22 * \file ih264d_parse_slice.c 23 * 24 * \brief 25 * Contains routines that decodes a slice NAL unit 26 * 27 * \date 28 * 19/12/2002 29 * 30 * \author AI 31 ************************************************************************** 32 */ 33 #include <string.h> 34 #include "ih264_typedefs.h" 35 #include "ih264_macros.h" 36 #include "ih264_platform_macros.h" 37 #include "ithread.h" 38 #include "ih264d_structs.h" 39 #include "ih264d_debug.h" 40 #include "ih264d_bitstrm.h" 41 #include "ih264d_parse_mb_header.h" 42 #include "ih264d_process_bslice.h" 43 #include "ih264d_process_pslice.h" 44 #include "ih264d_parse_cavlc.h" 45 #include "ih264d_utils.h" 46 #include "ih264d_deblocking.h" 47 #include "ih264d_defs.h" 48 #include "ih264d_error_handler.h" 49 #include "ih264d_tables.h" 50 #include "ih264d_defs.h" 51 #include "ih264d_mem_request.h" 52 #include "ih264d_parse_islice.h" 53 #include "ih264d_parse_slice.h" 54 #include "ih264d_mvpred.h" 55 #include "ih264d_mb_utils.h" 56 57 #include "ih264d_defs.h" 58 #include "ih264d_quant_scaling.h" 59 60 #include "ih264d_inter_pred.h" 61 62 #include "ih264d_sei.h" 63 #include "ih264d.h" 64 #include "ih264_error.h" 65 #include "ih264_disp_mgr.h" 66 #include "ih264_buf_mgr.h" 67 68 #include "ih264d_thread_parse_decode.h" 69 #include "ih264d_thread_compute_bs.h" 70 #include "ih264d_dpb_manager.h" 71 #include <assert.h> 72 #include "ih264d_parse_islice.h" 73 #define RET_LAST_SKIP 0x80000000 74 75 WORD32 check_app_out_buf_size(dec_struct_t *ps_dec); 76 /*! 77 ************************************************************************** 78 * \if Function name : ih264d_form_pred_weight_matrix \endif 79 * 80 * \brief 81 * Forms pred weight matrix. 82 * 83 * \return 84 * None 85 * 86 ************************************************************************** 87 */ 88 89 void ih264d_form_pred_weight_matrix(dec_struct_t *ps_dec) 90 { 91 dec_slice_params_t *ps_cur_slice; 92 UWORD8 uc_num_ref_idx_l0_active, uc_num_ref_idx_l1_active; 93 UWORD8 i, j; 94 UWORD32 *pu4_mat_iwt_ofst; 95 UWORD16 i2_idx; 96 UWORD32 *pui32_weight_offset_l0, *pui32_weight_offset_l1; 97 UWORD32 u4_temp; 98 99 ps_cur_slice = ps_dec->ps_cur_slice; 100 uc_num_ref_idx_l0_active = ps_cur_slice->u1_num_ref_idx_lx_active[0]; 101 uc_num_ref_idx_l1_active = ps_cur_slice->u1_num_ref_idx_lx_active[1]; 102 103 pu4_mat_iwt_ofst = ps_dec->pu4_wts_ofsts_mat; 104 105 if(ps_cur_slice->u1_slice_type == B_SLICE) 106 { 107 for(i = 0; i < uc_num_ref_idx_l0_active; i++) 108 { 109 pui32_weight_offset_l0 = ps_cur_slice->u4_wt_ofst_lx[0][i]; 110 for(j = 0; j < uc_num_ref_idx_l1_active; j++) 111 { 112 pui32_weight_offset_l1 = ps_cur_slice->u4_wt_ofst_lx[1][j]; 113 i2_idx = i * uc_num_ref_idx_l0_active + j; 114 i2_idx = X3(i2_idx); 115 /* u4_temp = (pui32_weight_offset_l0[0] | (pui32_weight_offset_l1[0] << 16)); 116 pu4_mat_iwt_ofst[0] = u4_temp; 117 u4_temp = (pui32_weight_offset_l0[1] | (pui32_weight_offset_l1[1] << 16)); 118 pu4_mat_iwt_ofst[1] = u4_temp; 119 u4_temp = (pui32_weight_offset_l0[2] | (pui32_weight_offset_l1[2] << 16)); 120 pu4_mat_iwt_ofst[2] = u4_temp; 121 pu4_mat_iwt_ofst += 3;*/ 122 pu4_mat_iwt_ofst[0] = pui32_weight_offset_l0[0]; 123 pu4_mat_iwt_ofst[1] = pui32_weight_offset_l1[0]; 124 pu4_mat_iwt_ofst[2] = pui32_weight_offset_l0[1]; 125 pu4_mat_iwt_ofst[3] = pui32_weight_offset_l1[1]; 126 pu4_mat_iwt_ofst[4] = pui32_weight_offset_l0[2]; 127 pu4_mat_iwt_ofst[5] = pui32_weight_offset_l1[2]; 128 pu4_mat_iwt_ofst += 6; 129 } 130 } 131 } 132 else 133 { 134 for(i = 0; i < uc_num_ref_idx_l0_active; i++) 135 { 136 pui32_weight_offset_l0 = ps_cur_slice->u4_wt_ofst_lx[0][i]; 137 i2_idx = X3(i); 138 u4_temp = (UWORD32)pui32_weight_offset_l0[0]; 139 pu4_mat_iwt_ofst[0] = u4_temp; 140 u4_temp = (UWORD32)pui32_weight_offset_l0[1]; 141 pu4_mat_iwt_ofst[2] = u4_temp; 142 u4_temp = (UWORD32)pui32_weight_offset_l0[2]; 143 pu4_mat_iwt_ofst[4] = u4_temp; 144 pu4_mat_iwt_ofst += 6; 145 } 146 } 147 } 148 149 150 /*! 151 ************************************************************************** 152 * \if Function name : init_firstSliceParam \endif 153 * 154 * \brief 155 * Initialize the Parameter required for all the slices for a picture 156 * 157 * \return : Nothing 158 * 159 ************************************************************************** 160 */ 161 162 WORD32 ih264d_start_of_pic(dec_struct_t *ps_dec, 163 WORD32 i4_poc, 164 pocstruct_t *ps_temp_poc, 165 UWORD16 u2_frame_num, 166 dec_pic_params_t *ps_pps) 167 { 168 pocstruct_t *ps_prev_poc = &ps_dec->s_cur_pic_poc; 169 pocstruct_t *ps_cur_poc = ps_temp_poc; 170 171 pic_buffer_t *pic_buf; 172 173 ivd_video_decode_op_t * ps_dec_output = 174 (ivd_video_decode_op_t *)ps_dec->pv_dec_out; 175 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice; 176 dec_seq_params_t *ps_seq = ps_pps->ps_sps; 177 UWORD8 u1_bottom_field_flag = ps_cur_slice->u1_bottom_field_flag; 178 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag; 179 /* high profile related declarations */ 180 high_profile_tools_t s_high_profile; 181 WORD32 ret; 182 183 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex); 184 185 /* check output buffer size given by the application */ 186 if(check_app_out_buf_size(ps_dec) != IV_SUCCESS) 187 return IVD_DISP_FRM_ZERO_OP_BUF_SIZE; 188 189 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb; 190 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb; 191 ps_prev_poc->i4_delta_pic_order_cnt_bottom = 192 ps_cur_poc->i4_delta_pic_order_cnt_bottom; 193 ps_prev_poc->i4_delta_pic_order_cnt[0] = 194 ps_cur_poc->i4_delta_pic_order_cnt[0]; 195 ps_prev_poc->i4_delta_pic_order_cnt[1] = 196 ps_cur_poc->i4_delta_pic_order_cnt[1]; 197 ps_prev_poc->u1_bot_field = ps_dec->ps_cur_slice->u1_bottom_field_flag; 198 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst; 199 ps_prev_poc->u2_frame_num = u2_frame_num; 200 ps_dec->i1_prev_mb_qp_delta = 0; 201 ps_dec->i1_next_ctxt_idx = 0; 202 203 204 ps_dec->u4_nmb_deblk = 0; 205 if(ps_dec->u4_num_cores == 1) 206 ps_dec->u4_nmb_deblk = 1; 207 208 209 210 if(ps_seq->u1_mb_aff_flag == 1) 211 { 212 ps_dec->u4_nmb_deblk = 0; 213 if(ps_dec->u4_num_cores > 2) 214 ps_dec->u4_num_cores = 2; 215 } 216 217 ps_dec->u4_use_intrapred_line_copy = 0; 218 219 220 221 if (ps_seq->u1_mb_aff_flag == 0) 222 { 223 ps_dec->u4_use_intrapred_line_copy = 1; 224 } 225 226 ps_dec->u4_app_disable_deblk_frm = 0; 227 /* If degrade is enabled, set the degrade flags appropriately */ 228 if(ps_dec->i4_degrade_type && ps_dec->i4_degrade_pics) 229 { 230 WORD32 degrade_pic; 231 ps_dec->i4_degrade_pic_cnt++; 232 degrade_pic = 0; 233 234 /* If degrade is to be done in all frames, then do not check further */ 235 switch(ps_dec->i4_degrade_pics) 236 { 237 case 4: 238 { 239 degrade_pic = 1; 240 break; 241 } 242 case 3: 243 { 244 if(ps_cur_slice->u1_slice_type != I_SLICE) 245 degrade_pic = 1; 246 247 break; 248 } 249 case 2: 250 { 251 252 /* If pic count hits non-degrade interval or it is an islice, then do not degrade */ 253 if((ps_cur_slice->u1_slice_type != I_SLICE) 254 && (ps_dec->i4_degrade_pic_cnt 255 != ps_dec->i4_nondegrade_interval)) 256 degrade_pic = 1; 257 258 break; 259 } 260 case 1: 261 { 262 /* Check if the current picture is non-ref */ 263 if(0 == ps_cur_slice->u1_nal_ref_idc) 264 { 265 degrade_pic = 1; 266 } 267 break; 268 } 269 270 } 271 if(degrade_pic) 272 { 273 if(ps_dec->i4_degrade_type & 0x2) 274 ps_dec->u4_app_disable_deblk_frm = 1; 275 276 /* MC degrading is done only for non-ref pictures */ 277 if(0 == ps_cur_slice->u1_nal_ref_idc) 278 { 279 if(ps_dec->i4_degrade_type & 0x4) 280 ps_dec->i4_mv_frac_mask = 0; 281 282 if(ps_dec->i4_degrade_type & 0x8) 283 ps_dec->i4_mv_frac_mask = 0; 284 } 285 } 286 else 287 ps_dec->i4_degrade_pic_cnt = 0; 288 } 289 290 { 291 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status; 292 if((ps_cur_slice->u1_slice_type == I_SLICE) 293 || (ps_cur_slice->u1_slice_type == SI_SLICE)) 294 ps_err->u1_cur_pic_type = PIC_TYPE_I; 295 else 296 ps_err->u1_cur_pic_type = PIC_TYPE_UNKNOWN; 297 298 if(ps_err->u1_pic_aud_i == PIC_TYPE_I) 299 { 300 ps_err->u1_cur_pic_type = PIC_TYPE_I; 301 ps_err->u1_pic_aud_i = PIC_TYPE_UNKNOWN; 302 } 303 304 if(ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL) 305 { 306 if(ps_err->u1_err_flag) 307 ih264d_reset_ref_bufs(ps_dec->ps_dpb_mgr); 308 ps_err->u1_err_flag = ACCEPT_ALL_PICS; 309 } 310 } 311 312 if(ps_dec->u1_init_dec_flag && ps_dec->s_prev_seq_params.u1_eoseq_pending) 313 { 314 /* Reset the decoder picture buffers */ 315 WORD32 j; 316 for(j = 0; j < MAX_DISP_BUFS_NEW; j++) 317 { 318 319 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 320 j, 321 BUF_MGR_REF); 322 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 323 ps_dec->au1_pic_buf_id_mv_buf_id_map[j], 324 BUF_MGR_REF); 325 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 326 j, 327 BUF_MGR_IO); 328 } 329 330 /* reset the decoder structure parameters related to buffer handling */ 331 ps_dec->u1_second_field = 0; 332 ps_dec->i4_cur_display_seq = 0; 333 334 /********************************************************************/ 335 /* indicate in the decoder output i4_status that some frames are being */ 336 /* dropped, so that it resets timestamp and wait for a new sequence */ 337 /********************************************************************/ 338 339 ps_dec->s_prev_seq_params.u1_eoseq_pending = 0; 340 } 341 ret = ih264d_init_pic(ps_dec, u2_frame_num, i4_poc, ps_pps); 342 if(ret != OK) 343 return ret; 344 345 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_pic_tu_coeff_data; 346 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_pic_tu_coeff_data; 347 ps_dec->ps_nmb_info = ps_dec->ps_frm_mb_info; 348 if(ps_dec->u1_separate_parse) 349 { 350 UWORD16 pic_wd; 351 UWORD16 pic_ht; 352 UWORD32 num_mbs; 353 354 pic_wd = ps_dec->u2_pic_wd; 355 pic_ht = ps_dec->u2_pic_ht; 356 num_mbs = (pic_wd * pic_ht) >> 8; 357 358 if(ps_dec->pu1_dec_mb_map) 359 { 360 memset((void *)ps_dec->pu1_dec_mb_map, 0, num_mbs); 361 } 362 363 if(ps_dec->pu1_recon_mb_map) 364 { 365 366 memset((void *)ps_dec->pu1_recon_mb_map, 0, num_mbs); 367 } 368 369 if(ps_dec->pu2_slice_num_map) 370 { 371 memset((void *)ps_dec->pu2_slice_num_map, 0, 372 (num_mbs * sizeof(UWORD16))); 373 } 374 375 } 376 377 ps_dec->ps_parse_cur_slice = &(ps_dec->ps_dec_slice_buf[0]); 378 ps_dec->ps_decode_cur_slice = &(ps_dec->ps_dec_slice_buf[0]); 379 ps_dec->ps_computebs_cur_slice = &(ps_dec->ps_dec_slice_buf[0]); 380 ps_dec->u2_cur_slice_num = 0; 381 382 /* Initialize all the HP toolsets to zero */ 383 ps_dec->s_high_profile.u1_scaling_present = 0; 384 ps_dec->s_high_profile.u1_transform8x8_present = 0; 385 386 /* Get Next Free Picture */ 387 if(1 == ps_dec->u4_share_disp_buf) 388 { 389 UWORD32 i; 390 /* Free any buffer that is in the queue to be freed */ 391 for(i = 0; i < MAX_DISP_BUFS_NEW; i++) 392 { 393 if(0 == ps_dec->u4_disp_buf_to_be_freed[i]) 394 continue; 395 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, i, 396 BUF_MGR_IO); 397 ps_dec->u4_disp_buf_to_be_freed[i] = 0; 398 ps_dec->u4_disp_buf_mapping[i] = 0; 399 400 } 401 } 402 if(!(u1_field_pic_flag && 0 != ps_dec->u1_top_bottom_decoded)) //ps_dec->u1_second_field)) 403 { 404 pic_buffer_t *ps_cur_pic; 405 WORD32 cur_pic_buf_id, cur_mv_buf_id; 406 col_mv_buf_t *ps_col_mv; 407 while(1) 408 { 409 ps_cur_pic = (pic_buffer_t *)ih264_buf_mgr_get_next_free( 410 (buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 411 &cur_pic_buf_id); 412 if(ps_cur_pic == NULL) 413 { 414 ps_dec->i4_error_code = ERROR_UNAVAIL_PICBUF_T; 415 return ERROR_UNAVAIL_PICBUF_T; 416 } 417 if(0 == ps_dec->u4_disp_buf_mapping[cur_pic_buf_id]) 418 { 419 break; 420 } 421 422 } 423 ps_col_mv = (col_mv_buf_t *)ih264_buf_mgr_get_next_free((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 424 &cur_mv_buf_id); 425 if(ps_col_mv == NULL) 426 { 427 ps_dec->i4_error_code = ERROR_UNAVAIL_MVBUF_T; 428 return ERROR_UNAVAIL_MVBUF_T; 429 } 430 431 ps_dec->ps_cur_pic = ps_cur_pic; 432 ps_dec->u1_pic_buf_id = cur_pic_buf_id; 433 ps_cur_pic->u4_ts = ps_dec->u4_ts; 434 435 436 ps_cur_pic->u1_mv_buf_id = cur_mv_buf_id; 437 ps_dec->au1_pic_buf_id_mv_buf_id_map[cur_pic_buf_id] = cur_mv_buf_id; 438 439 ps_cur_pic->pu1_col_zero_flag = (UWORD8 *)ps_col_mv->pv_col_zero_flag; 440 ps_cur_pic->ps_mv = (mv_pred_t *)ps_col_mv->pv_mv; 441 ps_dec->au1_pic_buf_ref_flag[cur_pic_buf_id] = 0; 442 443 { 444 /*make first entry of list0 and list1 point to cur pic, 445 *so that if first slice is in error, ref pic struct will have valid entries*/ 446 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_init_dpb[0]; 447 ps_dec->ps_ref_pic_buf_lx[1] = ps_dec->ps_dpb_mgr->ps_init_dpb[1]; 448 *(ps_dec->ps_dpb_mgr->ps_init_dpb[0][0]) = *ps_cur_pic; 449 /* Initialize for field reference as well */ 450 *(ps_dec->ps_dpb_mgr->ps_init_dpb[0][MAX_REF_BUFS]) = *ps_cur_pic; 451 452 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[0][0]) = *ps_cur_pic; 453 /* Initialize for field reference as well */ 454 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[0][MAX_REF_BUFS]) = *ps_cur_pic; 455 *(ps_dec->ps_dpb_mgr->ps_init_dpb[1][0]) = *ps_cur_pic; 456 /* Initialize for field reference as well */ 457 *(ps_dec->ps_dpb_mgr->ps_init_dpb[1][MAX_REF_BUFS]) = *ps_cur_pic; 458 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[1][0]) = *ps_cur_pic; 459 /* Initialize for field reference as well */ 460 *(ps_dec->ps_dpb_mgr->ps_mod_dpb[1][MAX_REF_BUFS]) = *ps_cur_pic; 461 } 462 463 if(!ps_dec->ps_cur_pic) 464 { 465 WORD32 j; 466 H264_DEC_DEBUG_PRINT("------- Display Buffers Reset --------\n"); 467 for(j = 0; j < MAX_DISP_BUFS_NEW; j++) 468 { 469 470 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 471 j, 472 BUF_MGR_REF); 473 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 474 ps_dec->au1_pic_buf_id_mv_buf_id_map[j], 475 BUF_MGR_REF); 476 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 477 j, 478 BUF_MGR_IO); 479 } 480 481 ps_dec->i4_cur_display_seq = 0; 482 ps_dec->i4_prev_max_display_seq = 0; 483 ps_dec->i4_max_poc = 0; 484 485 ps_cur_pic = (pic_buffer_t *)ih264_buf_mgr_get_next_free( 486 (buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 487 &cur_pic_buf_id); 488 if(ps_cur_pic == NULL) 489 { 490 ps_dec->i4_error_code = ERROR_UNAVAIL_PICBUF_T; 491 return ERROR_UNAVAIL_PICBUF_T; 492 } 493 494 ps_col_mv = (col_mv_buf_t *)ih264_buf_mgr_get_next_free((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 495 &cur_mv_buf_id); 496 if(ps_col_mv == NULL) 497 { 498 ps_dec->i4_error_code = ERROR_UNAVAIL_MVBUF_T; 499 return ERROR_UNAVAIL_MVBUF_T; 500 } 501 502 ps_dec->ps_cur_pic = ps_cur_pic; 503 ps_dec->u1_pic_buf_id = cur_pic_buf_id; 504 ps_cur_pic->u4_ts = ps_dec->u4_ts; 505 ps_dec->apv_buf_id_pic_buf_map[cur_pic_buf_id] = (void *)ps_cur_pic; 506 507 ps_cur_pic->u1_mv_buf_id = cur_mv_buf_id; 508 ps_dec->au1_pic_buf_id_mv_buf_id_map[cur_pic_buf_id] = cur_mv_buf_id; 509 510 ps_cur_pic->pu1_col_zero_flag = (UWORD8 *)ps_col_mv->pv_col_zero_flag; 511 ps_cur_pic->ps_mv = (mv_pred_t *)ps_col_mv->pv_mv; 512 ps_dec->au1_pic_buf_ref_flag[cur_pic_buf_id] = 0; 513 514 } 515 516 ps_dec->ps_cur_pic->u1_picturetype = u1_field_pic_flag; 517 ps_dec->ps_cur_pic->u4_pack_slc_typ = SKIP_NONE; 518 H264_DEC_DEBUG_PRINT("got a buffer\n"); 519 } 520 else 521 { 522 H264_DEC_DEBUG_PRINT("did not get a buffer\n"); 523 } 524 525 ps_dec->u4_pic_buf_got = 1; 526 527 ps_dec->ps_cur_pic->i4_poc = i4_poc; 528 ps_dec->ps_cur_pic->i4_frame_num = u2_frame_num; 529 ps_dec->ps_cur_pic->i4_pic_num = u2_frame_num; 530 ps_dec->ps_cur_pic->i4_top_field_order_cnt = ps_pps->i4_top_field_order_cnt; 531 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt = 532 ps_pps->i4_bottom_field_order_cnt; 533 ps_dec->ps_cur_pic->i4_avg_poc = ps_pps->i4_avg_poc; 534 ps_dec->ps_cur_pic->u4_time_stamp = ps_dec->u4_pts; 535 536 ps_dec->s_cur_pic = *(ps_dec->ps_cur_pic); 537 if(u1_field_pic_flag && u1_bottom_field_flag) 538 { 539 WORD32 i4_temp_poc; 540 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc; 541 /* Point to odd lines, since it's bottom field */ 542 ps_dec->s_cur_pic.pu1_buf1 += ps_dec->s_cur_pic.u2_frm_wd_y; 543 ps_dec->s_cur_pic.pu1_buf2 += ps_dec->s_cur_pic.u2_frm_wd_uv; 544 ps_dec->s_cur_pic.pu1_buf3 += ps_dec->s_cur_pic.u2_frm_wd_uv; 545 ps_dec->s_cur_pic.ps_mv += 546 ((ps_dec->u2_pic_ht * ps_dec->u2_pic_wd) >> 5); 547 ps_dec->s_cur_pic.pu1_col_zero_flag += ((ps_dec->u2_pic_ht 548 * ps_dec->u2_pic_wd) >> 5); 549 ps_dec->ps_cur_pic->u1_picturetype |= BOT_FLD; 550 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt; 551 i4_bot_field_order_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt; 552 i4_temp_poc = MIN(i4_top_field_order_poc, 553 i4_bot_field_order_poc); 554 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc; 555 } 556 557 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag 558 && (!u1_field_pic_flag); 559 560 ps_dec->ps_cur_pic->u1_picturetype |= (ps_cur_slice->u1_mbaff_frame_flag 561 << 2); 562 563 ps_dec->ps_cur_mb_row = ps_dec->ps_nbr_mb_row; //[0]; 564 //Increment by 2 ,so that left mb (mbaff decrements by 2) will always be valid 565 ps_dec->ps_cur_mb_row += 2; 566 ps_dec->ps_top_mb_row = ps_dec->ps_nbr_mb_row; 567 ps_dec->ps_top_mb_row += ((ps_dec->u2_frm_wd_in_mbs + 2) << (1 - ps_dec->ps_cur_sps->u1_frame_mbs_only_flag)); 568 //Increment by 2 ,so that left mb (mbaff decrements by 2) will always be valid 569 ps_dec->ps_top_mb_row += 2; 570 571 /* CHANGED CODE */ 572 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv; 573 ps_dec->ps_mv_top = ps_dec->ps_mv_top_p[0]; 574 /* CHANGED CODE */ 575 ps_dec->u1_mv_top_p = 0; 576 ps_dec->u1_mb_idx = 0; 577 /* CHANGED CODE */ 578 ps_dec->ps_mv_left = ps_dec->s_cur_pic.ps_mv; 579 ps_dec->u2_total_mbs_coded = 0; 580 ps_dec->i4_submb_ofst = -(SUB_BLK_SIZE); 581 ps_dec->u4_pred_info_idx = 0; 582 ps_dec->u4_pred_info_pkd_idx = 0; 583 ps_dec->u4_dma_buf_idx = 0; 584 ps_dec->ps_mv = ps_dec->s_cur_pic.ps_mv; 585 ps_dec->ps_mv_bank_cur = ps_dec->s_cur_pic.ps_mv; 586 ps_dec->pu1_col_zero_flag = ps_dec->s_cur_pic.pu1_col_zero_flag; 587 ps_dec->ps_part = ps_dec->ps_parse_part_params; 588 ps_dec->i2_prev_slice_mbx = -1; 589 ps_dec->i2_prev_slice_mby = 0; 590 ps_dec->u2_mv_2mb[0] = 0; 591 ps_dec->u2_mv_2mb[1] = 0; 592 ps_dec->u1_last_pic_not_decoded = 0; 593 594 ps_dec->u2_cur_slice_num_dec_thread = 0; 595 ps_dec->u2_cur_slice_num_bs = 0; 596 ps_dec->u4_intra_pred_line_ofst = 0; 597 ps_dec->pu1_cur_y_intra_pred_line = ps_dec->pu1_y_intra_pred_line; 598 ps_dec->pu1_cur_u_intra_pred_line = ps_dec->pu1_u_intra_pred_line; 599 ps_dec->pu1_cur_v_intra_pred_line = ps_dec->pu1_v_intra_pred_line; 600 601 ps_dec->pu1_cur_y_intra_pred_line_base = ps_dec->pu1_y_intra_pred_line; 602 ps_dec->pu1_cur_u_intra_pred_line_base = ps_dec->pu1_u_intra_pred_line; 603 ps_dec->pu1_cur_v_intra_pred_line_base = ps_dec->pu1_v_intra_pred_line; 604 605 606 607 608 609 ps_dec->pu1_prev_y_intra_pred_line = ps_dec->pu1_y_intra_pred_line 610 + (ps_dec->u2_frm_wd_in_mbs * MB_SIZE); 611 612 ps_dec->pu1_prev_u_intra_pred_line = ps_dec->pu1_u_intra_pred_line 613 + ps_dec->u2_frm_wd_in_mbs * BLK8x8SIZE * YUV420SP_FACTOR; 614 ps_dec->pu1_prev_v_intra_pred_line = ps_dec->pu1_v_intra_pred_line 615 + ps_dec->u2_frm_wd_in_mbs * BLK8x8SIZE; 616 617 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic; 618 /* Initialize The Function Pointer Depending Upon the Entropy and MbAff Flag */ 619 { 620 if(ps_cur_slice->u1_mbaff_frame_flag) 621 { 622 ps_dec->pf_compute_bs = ih264d_compute_bs_mbaff; 623 ps_dec->pf_mvpred = ih264d_mvpred_mbaff; 624 } 625 else 626 { 627 ps_dec->pf_compute_bs = ih264d_compute_bs_non_mbaff; 628 ps_dec->u1_cur_mb_fld_dec_flag = ps_cur_slice->u1_field_pic_flag; 629 } 630 } 631 /* Set up the Parameter for DMA transfer */ 632 { 633 UWORD8 u1_field_pic_flag = ps_dec->ps_cur_slice->u1_field_pic_flag; 634 635 UWORD8 u1_mbaff = ps_cur_slice->u1_mbaff_frame_flag; 636 637 UWORD8 uc_lastmbs = (((ps_dec->u2_pic_wd) >> 4) 638 % (ps_dec->u1_recon_mb_grp >> u1_mbaff)); 639 UWORD16 ui16_lastmbs_widthY = 640 (uc_lastmbs ? (uc_lastmbs << 4) : ((ps_dec->u1_recon_mb_grp 641 >> u1_mbaff) << 4)); 642 UWORD16 ui16_lastmbs_widthUV = 643 uc_lastmbs ? (uc_lastmbs << 3) : ((ps_dec->u1_recon_mb_grp 644 >> u1_mbaff) << 3); 645 646 ps_dec->s_tran_addrecon.pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1; 647 ps_dec->s_tran_addrecon.pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2; 648 ps_dec->s_tran_addrecon.pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3; 649 650 ps_dec->s_tran_addrecon.u2_frm_wd_y = ps_dec->u2_frm_wd_y 651 << u1_field_pic_flag; 652 ps_dec->s_tran_addrecon.u2_frm_wd_uv = ps_dec->u2_frm_wd_uv 653 << u1_field_pic_flag; 654 655 if(u1_field_pic_flag) 656 { 657 ui16_lastmbs_widthY += ps_dec->u2_frm_wd_y; 658 ui16_lastmbs_widthUV += ps_dec->u2_frm_wd_uv; 659 } 660 661 /* Normal Increment of Pointer */ 662 ps_dec->s_tran_addrecon.u4_inc_y[0] = ((ps_dec->u1_recon_mb_grp << 4) 663 >> u1_mbaff); 664 ps_dec->s_tran_addrecon.u4_inc_uv[0] = ((ps_dec->u1_recon_mb_grp << 4) 665 >> u1_mbaff); 666 667 /* End of Row Increment */ 668 ps_dec->s_tran_addrecon.u4_inc_y[1] = (ui16_lastmbs_widthY 669 + (PAD_LEN_Y_H << 1) 670 + ps_dec->s_tran_addrecon.u2_frm_wd_y 671 * ((15 << u1_mbaff) + u1_mbaff)); 672 ps_dec->s_tran_addrecon.u4_inc_uv[1] = (ui16_lastmbs_widthUV 673 + (PAD_LEN_UV_H << 2) 674 + ps_dec->s_tran_addrecon.u2_frm_wd_uv 675 * ((15 << u1_mbaff) + u1_mbaff)); 676 677 /* Assign picture numbers to each frame/field */ 678 /* only once per picture. */ 679 ih264d_assign_pic_num(ps_dec); 680 ps_dec->s_tran_addrecon.u2_mv_top_left_inc = (ps_dec->u1_recon_mb_grp 681 << 2) - 1 - (u1_mbaff << 2); 682 ps_dec->s_tran_addrecon.u2_mv_left_inc = ((ps_dec->u1_recon_mb_grp 683 >> u1_mbaff) - 1) << (4 + u1_mbaff); 684 } 685 /**********************************************************************/ 686 /* High profile related initialization at pictrue level */ 687 /**********************************************************************/ 688 if(ps_seq->u1_profile_idc == HIGH_PROFILE_IDC) 689 { 690 if((ps_seq->i4_seq_scaling_matrix_present_flag) 691 || (ps_pps->i4_pic_scaling_matrix_present_flag)) 692 { 693 ret = ih264d_form_scaling_matrix_picture(ps_seq, ps_pps, ps_dec); 694 ps_dec->s_high_profile.u1_scaling_present = 1; 695 } 696 else 697 { 698 ret = ih264d_form_default_scaling_matrix(ps_dec); 699 } 700 701 if(ps_pps->i4_transform_8x8_mode_flag) 702 { 703 ps_dec->s_high_profile.u1_transform8x8_present = 1; 704 } 705 } 706 else 707 { 708 ret = ih264d_form_default_scaling_matrix(ps_dec); 709 } 710 711 if(ret != OK) 712 return ret; 713 714 /* required while reading the transform_size_8x8 u4_flag */ 715 ps_dec->s_high_profile.u1_direct_8x8_inference_flag = 716 ps_seq->u1_direct_8x8_inference_flag; 717 ps_dec->s_high_profile.s_cavlc_ctxt = ps_dec->s_cavlc_ctxt; 718 719 ps_dec->i1_recon_in_thread3_flag = 1; 720 ps_dec->ps_frame_buf_ip_recon = &ps_dec->s_tran_addrecon; 721 if(ps_dec->u1_separate_parse) 722 { 723 memcpy(&ps_dec->s_tran_addrecon_parse, &ps_dec->s_tran_addrecon, 724 sizeof(tfr_ctxt_t)); 725 if(ps_dec->u4_num_cores >= 3 && ps_dec->i1_recon_in_thread3_flag) 726 { 727 memcpy(&ps_dec->s_tran_iprecon, &ps_dec->s_tran_addrecon, 728 sizeof(tfr_ctxt_t)); 729 ps_dec->ps_frame_buf_ip_recon = &ps_dec->s_tran_iprecon; 730 } 731 } 732 733 734 ih264d_init_deblk_tfr_ctxt(ps_dec,&(ps_dec->s_pad_mgr), &(ps_dec->s_tran_addrecon), 735 ps_dec->u2_frm_wd_in_mbs, 0); 736 737 ps_dec->ps_cur_deblk_mb = ps_dec->ps_deblk_pic; 738 ps_dec->u4_cur_deblk_mb_num = 0; 739 740 ps_dec->u4_deblk_mb_x = 0; 741 ps_dec->u4_deblk_mb_y = 0; 742 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat; 743 744 ps_dec->u4_first_slice_in_pic = 0; 745 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex); 746 return OK; 747 } 748 749 /*! 750 ************************************************************************** 751 * \if Function name : ih264d_deblock_display \endif 752 * 753 * \brief : The function callls the deblocking routine and manages 754 : the Recon buffers and displays . 755 * \return : Nothing 756 * 757 ************************************************************************** 758 */ 759 WORD32 ih264d_end_of_pic_dispbuf_mgr(dec_struct_t * ps_dec) 760 { 761 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice; 762 UWORD8 u1_num_of_users = 0; 763 WORD32 ret; 764 765 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex); 766 if(1) 767 { 768 769 { 770 ih264d_delete_nonref_nondisplay_pics(ps_dec->ps_dpb_mgr); 771 if(ps_cur_slice->u1_mmco_equalto5 772 || (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL)) 773 { 774 ps_dec->ps_cur_pic->i4_poc = 0; 775 if(ps_dec->u2_total_mbs_coded 776 == (ps_dec->ps_cur_sps->u2_max_mb_addr + 1)) 777 ih264d_reset_ref_bufs(ps_dec->ps_dpb_mgr); 778 ih264d_release_display_bufs(ps_dec); 779 } 780 if(IVD_DECODE_FRAME_OUT != ps_dec->e_frm_out_mode) 781 { 782 ret = ih264d_assign_display_seq(ps_dec); 783 if(ret != OK) 784 return ret; 785 } 786 } 787 788 if(ps_cur_slice->u1_nal_ref_idc) 789 { 790 /* Mark pic buf as needed for reference */ 791 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 792 ps_dec->u1_pic_buf_id, 793 BUF_MGR_REF); 794 /* Mark mv buf as needed for reference */ 795 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 796 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id], 797 BUF_MGR_REF); 798 ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] = 1; 799 } 800 801 /* 420 consumer */ 802 /* Increment the number of users by 1 for display based upon */ 803 /*the SEEK KEY FRAME control sent to decoder */ 804 if(((0 == ps_dec->u1_last_pic_not_decoded) 805 && (0 806 == (ps_dec->ps_cur_pic->u4_pack_slc_typ 807 & ps_dec->u4_skip_frm_mask))) 808 || (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL)) 809 { 810 /* Mark pic buf as needed for display */ 811 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 812 ps_dec->u1_pic_buf_id, 813 BUF_MGR_IO); 814 815 } 816 817 if(!ps_cur_slice->u1_field_pic_flag 818 || ((TOP_FIELD_ONLY | BOT_FIELD_ONLY) 819 != ps_dec->u1_top_bottom_decoded)) 820 { 821 pic_buffer_t *ps_cur_pic = ps_dec->ps_cur_pic; 822 ps_cur_pic->u2_disp_width = ps_dec->u2_disp_width; 823 ps_cur_pic->u2_disp_height = ps_dec->u2_disp_height >> 1; 824 825 ps_cur_pic->u2_crop_offset_y = ps_dec->u2_crop_offset_y; 826 ps_cur_pic->u2_crop_offset_uv = ps_dec->u2_crop_offset_uv; 827 ps_cur_pic->u1_pic_type = 0; 828 829 ret = ih264d_insert_pic_in_display_list( 830 ps_dec->ps_dpb_mgr, 831 ps_dec->u1_pic_buf_id, 832 ps_dec->i4_prev_max_display_seq 833 + ps_dec->ps_cur_pic->i4_poc, 834 ps_dec->ps_cur_pic->i4_frame_num); 835 if(ret != OK) 836 return ret; 837 838 { 839 ivd_video_decode_op_t * ps_dec_output = 840 (ivd_video_decode_op_t *)ps_dec->pv_dec_out; 841 842 ps_dec_output->u4_frame_decoded_flag = 1; 843 } 844 if(ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] == 0) 845 { 846 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 847 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id], 848 BUF_MGR_REF); 849 ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] = 0; 850 851 } 852 } 853 else 854 { 855 H264_DEC_DEBUG_PRINT("pic not inserted display %d %d\n", 856 ps_cur_slice->u1_field_pic_flag, 857 ps_dec->u1_second_field); 858 } 859 860 if(!ps_cur_slice->u1_field_pic_flag 861 || ((TOP_FIELD_ONLY | BOT_FIELD_ONLY) 862 == ps_dec->u1_top_bottom_decoded)) 863 { 864 if(IVD_DECODE_FRAME_OUT == ps_dec->e_frm_out_mode) 865 { 866 ret = ih264d_assign_display_seq(ps_dec); 867 if(ret != OK) 868 return ret; 869 } 870 } 871 } 872 873 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex); 874 875 return OK; 876 } 877 878 void ih264d_err_pic_dispbuf_mgr(dec_struct_t *ps_dec) 879 { 880 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice; 881 ivd_video_decode_op_t * ps_dec_output = 882 (ivd_video_decode_op_t *)ps_dec->pv_dec_out; 883 884 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 885 ps_dec->u1_pic_buf_id, 886 BUF_MGR_REF); 887 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 888 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id], 889 BUF_MGR_REF); 890 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 891 ps_dec->u1_pic_buf_id, 892 BUF_MGR_IO); 893 } 894 895 void ih264d_deblock_picture(void *ptr) 896 { 897 dec_struct_t *ps_dec = (dec_struct_t *)ptr; 898 899 { 900 /*Deblock picture only if all the mb's in the frame have been decoded*/ 901 if(ps_dec->u1_pic_decode_done == 1) 902 { 903 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag 904 || ps_dec->ps_cur_slice->u1_field_pic_flag) 905 { 906 ps_dec->p_DeblockPicture[ps_dec->ps_cur_slice->u1_mbaff_frame_flag]( 907 ps_dec); 908 } 909 else 910 911 { 912 913 ih264d_deblock_picture_progressive(ps_dec); 914 } 915 916 } 917 } 918 919 } 920 921 /*! 922 ************************************************************************** 923 * \if Function name : ih264d_deblock_display \endif 924 * 925 * \brief : The function callls the deblocking routine and manages 926 : the Recon buffers and displays . 927 * \return : Nothing 928 * 929 ************************************************************************** 930 */ 931 WORD32 ih264d_deblock_display(dec_struct_t *ps_dec) 932 { 933 WORD32 ret; 934 /* Call deblocking */ 935 ih264d_deblock_picture(ps_dec); 936 937 ret = ih264d_end_of_pic_dispbuf_mgr(ps_dec); 938 if(ret != OK) 939 return ret; 940 941 return OK; 942 } 943 944 /* 945 *! 946 ************************************************************************** 947 * \if Function name : EndofPoc \endif 948 * 949 * \brief 950 * EndofPoc Processing 951 * 952 * \return 953 * 0 on Success and Error code otherwise 954 ************************************************************************** 955 */ 956 957 WORD32 ih264d_end_of_pic(dec_struct_t *ps_dec) 958 { 959 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice; 960 WORD32 ret; 961 962 { 963 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status; 964 if(ps_err->u1_err_flag & REJECT_CUR_PIC) 965 { 966 ih264d_err_pic_dispbuf_mgr(ps_dec); 967 return ERROR_NEW_FRAME_EXPECTED; 968 } 969 } 970 971 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex); 972 ret = ih264d_end_of_pic_processing(ps_dec); 973 if(ret != OK) 974 return ret; 975 /*--------------------------------------------------------------------*/ 976 /* ih264d_decode_pic_order_cnt - calculate the Pic Order Cnt */ 977 /* Needed to detect end of picture */ 978 /*--------------------------------------------------------------------*/ 979 980 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex); 981 982 return OK; 983 } 984 985 986 /*! 987 ************************************************************************** 988 * \if Function name : ih264d_fix_error_in_dpb \endif 989 * 990 * \brief 991 * fix error in DPB 992 * 993 * \return 994 * Number of node(s) deleted 995 ************************************************************************** 996 */ 997 998 WORD32 ih264d_fix_error_in_dpb(dec_struct_t *ps_dec) 999 { 1000 /*--------------------------------------------------------------------*/ 1001 /* If there is common node in lt_list and st_list then delete it from */ 1002 /* st_list */ 1003 /*--------------------------------------------------------------------*/ 1004 UWORD8 no_of_nodes_deleted = 0; 1005 UWORD8 lt_ref_num = ps_dec->ps_dpb_mgr->u1_num_lt_ref_bufs; 1006 struct dpb_info_t *ps_lt_curr_dpb = ps_dec->ps_dpb_mgr->ps_dpb_ht_head; 1007 while(lt_ref_num && ps_lt_curr_dpb) 1008 { 1009 if(ps_dec->ps_dpb_mgr->ps_dpb_st_head 1010 && ((ps_lt_curr_dpb->s_bot_field.u1_reference_info 1011 | ps_lt_curr_dpb->s_top_field.u1_reference_info) 1012 == (IS_SHORT_TERM | IS_LONG_TERM))) 1013 { 1014 struct dpb_info_t *ps_st_next_dpb = ps_dec->ps_dpb_mgr->ps_dpb_st_head; 1015 struct dpb_info_t *ps_st_curr_dpb = ps_dec->ps_dpb_mgr->ps_dpb_st_head; 1016 UWORD8 st_ref_num = ps_dec->ps_dpb_mgr->u1_num_st_ref_bufs; 1017 while(st_ref_num && ps_st_curr_dpb) 1018 { 1019 if(ps_st_curr_dpb == ps_lt_curr_dpb) 1020 { 1021 if(st_ref_num == ps_dec->ps_dpb_mgr->u1_num_st_ref_bufs) 1022 { 1023 ps_dec->ps_dpb_mgr->ps_dpb_st_head = 1024 ps_dec->ps_dpb_mgr->ps_dpb_st_head->ps_prev_short; 1025 ps_st_curr_dpb = ps_dec->ps_dpb_mgr->ps_dpb_st_head; 1026 } 1027 else 1028 { 1029 ps_st_next_dpb->ps_prev_short = ps_st_curr_dpb->ps_prev_short; 1030 } 1031 ps_dec->ps_dpb_mgr->u1_num_st_ref_bufs--; 1032 ps_dec->ps_dpb_mgr->u1_num_lt_ref_bufs++; 1033 no_of_nodes_deleted++; 1034 break; 1035 } 1036 ps_st_next_dpb = ps_st_curr_dpb; 1037 ps_st_curr_dpb = ps_st_curr_dpb->ps_prev_short; 1038 st_ref_num--; 1039 } 1040 } 1041 ps_lt_curr_dpb = ps_lt_curr_dpb->ps_prev_long; 1042 lt_ref_num--; 1043 } 1044 return no_of_nodes_deleted; 1045 } 1046 1047 1048 /*! 1049 ************************************************************************** 1050 * \if Function name : DecodeSlice \endif 1051 * 1052 * \brief 1053 * Parses a slice 1054 * 1055 * \return 1056 * 0 on Success and Error code otherwise 1057 ************************************************************************** 1058 */ 1059 1060 WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice, 1061 UWORD8 u1_nal_ref_idc, 1062 dec_struct_t *ps_dec /* Decoder parameters */ 1063 ) 1064 { 1065 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm; 1066 dec_pic_params_t *ps_pps; 1067 dec_seq_params_t *ps_seq; 1068 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice; 1069 pocstruct_t s_tmp_poc = {0}; 1070 WORD32 i_delta_poc[2]; 1071 WORD32 i4_poc = 0; 1072 UWORD16 u2_first_mb_in_slice, u2_frame_num; 1073 UWORD8 u1_field_pic_flag, u1_redundant_pic_cnt = 0, u1_slice_type; 1074 UWORD32 u4_idr_pic_id = 0; 1075 UWORD8 u1_bottom_field_flag, u1_pic_order_cnt_type; 1076 1077 UWORD8 u1_nal_unit_type; 1078 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1079 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst; 1080 WORD8 i1_is_end_of_poc; 1081 1082 WORD32 ret, end_of_frame; 1083 WORD32 prev_slice_err, num_mb_skipped; 1084 UWORD8 u1_mbaff; 1085 pocstruct_t *ps_cur_poc; 1086 1087 UWORD32 u4_temp; 1088 WORD32 i_temp; 1089 UWORD32 u4_call_end_of_pic = 0; 1090 1091 /* read FirstMbInSlice and slice type*/ 1092 ps_dec->ps_dpb_cmds->u1_dpb_commands_read_slc = 0; 1093 u2_first_mb_in_slice = ih264d_uev(pu4_bitstrm_ofst, 1094 pu4_bitstrm_buf); 1095 if(u2_first_mb_in_slice 1096 > (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)) 1097 { 1098 1099 return ERROR_CORRUPTED_SLICE; 1100 } 1101 1102 /*we currently don not support ASO*/ 1103 if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) 1104 <= ps_dec->u2_cur_mb_addr) && (ps_dec->u4_first_slice_in_pic == 0)) 1105 { 1106 return ERROR_CORRUPTED_SLICE; 1107 } 1108 1109 COPYTHECONTEXT("SH: first_mb_in_slice",u2_first_mb_in_slice); 1110 1111 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 1112 1113 if(u4_temp > 9) 1114 return ERROR_INV_SLC_TYPE_T; 1115 1116 u1_slice_type = u4_temp; 1117 COPYTHECONTEXT("SH: slice_type",(u1_slice_type)); 1118 /* Find Out the Slice Type is 5 to 9 or not then Set the Flag */ 1119 /* u1_sl_typ_5_9 = 1 .Which tells that all the slices in the Pic*/ 1120 /* will be of same type of current */ 1121 if(u1_slice_type > 4) 1122 { 1123 u1_slice_type -= 5; 1124 } 1125 1126 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 1127 if(u4_temp & MASK_ERR_PIC_SET_ID) 1128 return ERROR_INV_SLICE_HDR_T; 1129 /* discard slice if pic param is invalid */ 1130 COPYTHECONTEXT("SH: pic_parameter_set_id", u4_temp); 1131 ps_pps = &ps_dec->ps_pps[u4_temp]; 1132 if(FALSE == ps_pps->u1_is_valid) 1133 { 1134 return ERROR_INV_SLICE_HDR_T; 1135 } 1136 ps_seq = ps_pps->ps_sps; 1137 if(!ps_seq) 1138 return ERROR_INV_SLICE_HDR_T; 1139 if(FALSE == ps_seq->u1_is_valid) 1140 return ERROR_INV_SLICE_HDR_T; 1141 1142 /* Get the frame num */ 1143 u2_frame_num = ih264d_get_bits_h264(ps_bitstrm, 1144 ps_seq->u1_bits_in_frm_num); 1145 // H264_DEC_DEBUG_PRINT("FRAME %d First MB in slice: %d\n", u2_frame_num, u2_first_mb_in_slice); 1146 1147 COPYTHECONTEXT("SH: frame_num", u2_frame_num); 1148 // H264_DEC_DEBUG_PRINT("Second field: %d frame num: %d prv_frame_num: %d \n", ps_dec->u1_second_field, u2_frame_num, ps_dec->u2_prv_frame_num); 1149 if(!ps_dec->u1_first_slice_in_stream && ps_dec->u4_first_slice_in_pic) 1150 { 1151 pocstruct_t *ps_prev_poc = &ps_dec->s_prev_pic_poc; 1152 pocstruct_t *ps_cur_poc = &ps_dec->s_cur_pic_poc; 1153 1154 ps_dec->u2_mbx = 0xffff; 1155 ps_dec->u2_mby = 0; 1156 1157 if((0 == u1_is_idr_slice) && ps_cur_slice->u1_nal_ref_idc) 1158 ps_dec->u2_prev_ref_frame_num = ps_cur_slice->u2_frame_num; 1159 1160 if(u1_is_idr_slice || ps_cur_slice->u1_mmco_equalto5) 1161 ps_dec->u2_prev_ref_frame_num = 0; 1162 1163 if(ps_dec->ps_cur_sps->u1_gaps_in_frame_num_value_allowed_flag) 1164 { 1165 ih264d_decode_gaps_in_frame_num(ps_dec, u2_frame_num); 1166 } 1167 1168 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst; 1169 ps_prev_poc->u2_frame_num = ps_cur_poc->u2_frame_num; 1170 ps_prev_poc->u1_mmco_equalto5 = ps_cur_slice->u1_mmco_equalto5; 1171 if(ps_cur_slice->u1_nal_ref_idc) 1172 { 1173 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb; 1174 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb; 1175 ps_prev_poc->i4_delta_pic_order_cnt_bottom = 1176 ps_cur_poc->i4_delta_pic_order_cnt_bottom; 1177 ps_prev_poc->i4_delta_pic_order_cnt[0] = 1178 ps_cur_poc->i4_delta_pic_order_cnt[0]; 1179 ps_prev_poc->i4_delta_pic_order_cnt[1] = 1180 ps_cur_poc->i4_delta_pic_order_cnt[1]; 1181 ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field; 1182 } 1183 1184 ps_dec->u2_total_mbs_coded = 0; 1185 } 1186 /* Get the field related flags */ 1187 if(!ps_seq->u1_frame_mbs_only_flag) 1188 { 1189 1190 u1_field_pic_flag = ih264d_get_bit_h264(ps_bitstrm); 1191 COPYTHECONTEXT("SH: field_pic_flag", u1_field_pic_flag); 1192 u1_bottom_field_flag = 0; 1193 1194 if(u1_field_pic_flag) 1195 { 1196 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan_fld; 1197 u1_bottom_field_flag = ih264d_get_bit_h264(ps_bitstrm); 1198 COPYTHECONTEXT("SH: bottom_field_flag", u1_bottom_field_flag); 1199 1200 } 1201 else 1202 { 1203 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan; 1204 } 1205 } 1206 else 1207 { 1208 u1_field_pic_flag = 0; 1209 u1_bottom_field_flag = 0; 1210 1211 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan; 1212 } 1213 1214 u1_nal_unit_type = SLICE_NAL; 1215 if(u1_is_idr_slice) 1216 { 1217 u1_nal_unit_type = IDR_SLICE_NAL; 1218 u4_idr_pic_id = ih264d_uev(pu4_bitstrm_ofst, 1219 pu4_bitstrm_buf); 1220 if(u4_idr_pic_id > 65535) 1221 return ERROR_INV_SLICE_HDR_T; 1222 COPYTHECONTEXT("SH: ", u4_idr_pic_id); 1223 } 1224 1225 /* read delta pic order count information*/ 1226 i_delta_poc[0] = i_delta_poc[1] = 0; 1227 s_tmp_poc.i4_pic_order_cnt_lsb = 0; 1228 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0; 1229 u1_pic_order_cnt_type = ps_seq->u1_pic_order_cnt_type; 1230 if(u1_pic_order_cnt_type == 0) 1231 { 1232 i_temp = ih264d_get_bits_h264( 1233 ps_bitstrm, 1234 ps_seq->u1_log2_max_pic_order_cnt_lsb_minus); 1235 if(i_temp < 0 || i_temp >= ps_seq->i4_max_pic_order_cntLsb) 1236 return ERROR_INV_SLICE_HDR_T; 1237 s_tmp_poc.i4_pic_order_cnt_lsb = i_temp; 1238 COPYTHECONTEXT("SH: pic_order_cnt_lsb", s_tmp_poc.i4_pic_order_cnt_lsb); 1239 1240 if((ps_pps->u1_pic_order_present_flag == 1) && (!u1_field_pic_flag)) 1241 { 1242 s_tmp_poc.i4_delta_pic_order_cnt_bottom = ih264d_sev( 1243 pu4_bitstrm_ofst, pu4_bitstrm_buf); 1244 //if(s_tmp_poc.i4_delta_pic_order_cnt_bottom > ps_seq->i4_max_pic_order_cntLsb) 1245 COPYTHECONTEXT("SH: delta_pic_order_cnt_bottom", 1246 s_tmp_poc.i4_delta_pic_order_cnt_bottom); 1247 } 1248 } 1249 1250 s_tmp_poc.i4_delta_pic_order_cnt[0] = 0; 1251 s_tmp_poc.i4_delta_pic_order_cnt[1] = 0; 1252 if(u1_pic_order_cnt_type == 1 1253 && (!ps_seq->u1_delta_pic_order_always_zero_flag)) 1254 { 1255 s_tmp_poc.i4_delta_pic_order_cnt[0] = ih264d_sev(pu4_bitstrm_ofst, 1256 pu4_bitstrm_buf); 1257 COPYTHECONTEXT("SH: delta_pic_order_cnt[0]", 1258 s_tmp_poc.i4_delta_pic_order_cnt[0]); 1259 1260 if(ps_pps->u1_pic_order_present_flag && !u1_field_pic_flag) 1261 { 1262 s_tmp_poc.i4_delta_pic_order_cnt[1] = ih264d_sev( 1263 pu4_bitstrm_ofst, pu4_bitstrm_buf); 1264 COPYTHECONTEXT("SH: delta_pic_order_cnt[1]", 1265 s_tmp_poc.i4_delta_pic_order_cnt[1]); 1266 } 1267 } 1268 1269 if(ps_pps->u1_redundant_pic_cnt_present_flag) 1270 { 1271 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 1272 if(u4_temp > MAX_REDUNDANT_PIC_CNT) 1273 return ERROR_INV_SLICE_HDR_T; 1274 u1_redundant_pic_cnt = u4_temp; 1275 COPYTHECONTEXT("SH: redundant_pic_cnt", u1_redundant_pic_cnt); 1276 } 1277 1278 /*--------------------------------------------------------------------*/ 1279 /* Check if the slice is part of new picture */ 1280 /*--------------------------------------------------------------------*/ 1281 /* First slice of a picture is always considered as part of new picture */ 1282 i1_is_end_of_poc = 1; 1283 ps_dec->ps_dec_err_status->u1_err_flag &= MASK_REJECT_CUR_PIC; 1284 1285 if(ps_dec->u4_first_slice_in_pic == 0) 1286 { 1287 i1_is_end_of_poc = ih264d_is_end_of_pic(u2_frame_num, u1_nal_ref_idc, 1288 &s_tmp_poc, &ps_dec->s_cur_pic_poc, 1289 ps_cur_slice, u1_pic_order_cnt_type, 1290 u1_nal_unit_type, u4_idr_pic_id, 1291 u1_field_pic_flag, 1292 u1_bottom_field_flag); 1293 if(i1_is_end_of_poc) 1294 { 1295 ps_dec->u1_first_slice_in_stream = 0; 1296 return ERROR_INCOMPLETE_FRAME; 1297 } 1298 1299 } 1300 1301 /*--------------------------------------------------------------------*/ 1302 /* Check for error in slice and parse the missing/corrupted MB's */ 1303 /* as skip-MB's in an inserted P-slice */ 1304 /*--------------------------------------------------------------------*/ 1305 u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag); 1306 prev_slice_err = 0; 1307 1308 if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream) 1309 { 1310 if(u2_frame_num != ps_dec->u2_prv_frame_num 1311 && ps_dec->u1_top_bottom_decoded != 0 1312 && ps_dec->u1_top_bottom_decoded 1313 != (TOP_FIELD_ONLY | BOT_FIELD_ONLY)) 1314 { 1315 ps_dec->u1_dangling_field = 1; 1316 if(ps_dec->u4_first_slice_in_pic) 1317 { 1318 // first slice - dangling field 1319 prev_slice_err = 1; 1320 } 1321 else 1322 { 1323 // last slice - dangling field 1324 prev_slice_err = 2; 1325 } 1326 1327 if(ps_dec->u1_top_bottom_decoded ==TOP_FIELD_ONLY) 1328 ps_cur_slice->u1_bottom_field_flag = 1; 1329 else 1330 ps_cur_slice->u1_bottom_field_flag = 0; 1331 1332 num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) 1333 - ps_dec->u2_total_mbs_coded; 1334 ps_cur_poc = &ps_dec->s_cur_pic_poc; 1335 1336 u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL; 1337 } 1338 else if(ps_dec->u4_first_slice_in_pic) 1339 { 1340 if(u2_first_mb_in_slice > 0) 1341 { 1342 // first slice - missing/header corruption 1343 prev_slice_err = 1; 1344 num_mb_skipped = u2_first_mb_in_slice << u1_mbaff; 1345 ps_cur_poc = &s_tmp_poc; 1346 1347 // initializing slice parameters 1348 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id; 1349 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag; 1350 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag; 1351 ps_cur_slice->i4_pic_order_cnt_lsb = 1352 s_tmp_poc.i4_pic_order_cnt_lsb; 1353 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type; 1354 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt; 1355 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc; 1356 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type; 1357 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag 1358 && (!u1_field_pic_flag); 1359 } 1360 } 1361 else 1362 { 1363 /* since i1_is_end_of_poc is set ,means new frame num is encountered. so conceal the current frame 1364 * completely */ 1365 prev_slice_err = 2; 1366 num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs 1367 * ps_dec->u2_frm_wd_in_mbs) 1368 - ps_dec->u2_total_mbs_coded; 1369 ps_cur_poc = &s_tmp_poc; 1370 } 1371 } 1372 else 1373 { 1374 if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded) 1375 { 1376 // previous slice - missing/corruption 1377 prev_slice_err = 2; 1378 num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) 1379 - ps_dec->u2_total_mbs_coded; 1380 ps_cur_poc = &s_tmp_poc; 1381 } 1382 else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded) 1383 { 1384 return ERROR_CORRUPTED_SLICE; 1385 } 1386 } 1387 1388 if(prev_slice_err) 1389 { 1390 ret = ih264d_mark_err_slice_skip(ps_dec, num_mb_skipped, u1_is_idr_slice, u2_frame_num, ps_cur_poc, prev_slice_err); 1391 1392 if(ps_dec->u1_dangling_field == 1) 1393 { 1394 ps_dec->u1_second_field = 1 - ps_dec->u1_second_field; 1395 ps_dec->u1_first_slice_in_stream = 0; 1396 ps_dec->u1_top_bottom_decoded = TOP_FIELD_ONLY | BOT_FIELD_ONLY; 1397 return ERROR_DANGLING_FIELD_IN_PIC; 1398 } 1399 1400 if(prev_slice_err == 2) 1401 { 1402 ps_dec->u1_first_slice_in_stream = 0; 1403 return ERROR_INCOMPLETE_FRAME; 1404 } 1405 1406 if(ps_dec->u2_total_mbs_coded 1407 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) 1408 { 1409 /* return if all MBs in frame are parsed*/ 1410 ps_dec->u1_first_slice_in_stream = 0; 1411 return ERROR_IN_LAST_SLICE_OF_PIC; 1412 } 1413 1414 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC) 1415 { 1416 ih264d_err_pic_dispbuf_mgr(ps_dec); 1417 return ERROR_NEW_FRAME_EXPECTED; 1418 } 1419 1420 if(ret != OK) 1421 return ret; 1422 1423 i1_is_end_of_poc = 0; 1424 } 1425 1426 if (ps_dec->u4_first_slice_in_pic == 0) 1427 { 1428 ps_dec->ps_parse_cur_slice++; 1429 ps_dec->u2_cur_slice_num++; 1430 } 1431 1432 // in the case of single core increment ps_decode_cur_slice 1433 if((ps_dec->u1_separate_parse == 0) && (ps_dec->u4_first_slice_in_pic == 0)) 1434 { 1435 ps_dec->ps_decode_cur_slice++; 1436 } 1437 ps_dec->u1_slice_header_done = 0; 1438 1439 1440 if(u1_field_pic_flag) 1441 { 1442 ps_dec->u2_prv_frame_num = u2_frame_num; 1443 } 1444 1445 if(ps_cur_slice->u1_mmco_equalto5) 1446 { 1447 WORD32 i4_temp_poc; 1448 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc; 1449 1450 if(!ps_cur_slice->u1_field_pic_flag) // or a complementary field pair 1451 { 1452 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt; 1453 i4_bot_field_order_poc = 1454 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt; 1455 i4_temp_poc = MIN(i4_top_field_order_poc, 1456 i4_bot_field_order_poc); 1457 } 1458 else if(!ps_cur_slice->u1_bottom_field_flag) 1459 i4_temp_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt; 1460 else 1461 i4_temp_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt; 1462 1463 ps_dec->ps_cur_pic->i4_top_field_order_cnt = i4_temp_poc 1464 - ps_dec->ps_cur_pic->i4_top_field_order_cnt; 1465 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt = i4_temp_poc 1466 - ps_dec->ps_cur_pic->i4_bottom_field_order_cnt; 1467 ps_dec->ps_cur_pic->i4_poc = i4_temp_poc; 1468 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc; 1469 } 1470 if(ps_dec->u4_first_slice_in_pic) 1471 { 1472 ret = ih264d_decode_pic_order_cnt(u1_is_idr_slice, u2_frame_num, 1473 &ps_dec->s_prev_pic_poc, 1474 &s_tmp_poc, ps_cur_slice, ps_pps, 1475 u1_nal_ref_idc, 1476 u1_bottom_field_flag, 1477 u1_field_pic_flag, &i4_poc); 1478 if(ret != OK) 1479 return ret; 1480 /* Display seq no calculations */ 1481 if(i4_poc >= ps_dec->i4_max_poc) 1482 ps_dec->i4_max_poc = i4_poc; 1483 /* IDR Picture or POC wrap around */ 1484 if(i4_poc == 0) 1485 { 1486 UWORD64 u8_temp; 1487 u8_temp = (UWORD64)ps_dec->i4_prev_max_display_seq 1488 + ps_dec->i4_max_poc 1489 + ps_dec->u1_max_dec_frame_buffering + 1; 1490 /*If i4_prev_max_display_seq overflows integer range, reset it */ 1491 ps_dec->i4_prev_max_display_seq = (u8_temp > 0x7fffffff)? 1492 0 : u8_temp; 1493 ps_dec->i4_max_poc = 0; 1494 } 1495 } 1496 1497 /*--------------------------------------------------------------------*/ 1498 /* Copy the values read from the bitstream to the slice header and then*/ 1499 /* If the slice is first slice in picture, then do Start of Picture */ 1500 /* processing. */ 1501 /*--------------------------------------------------------------------*/ 1502 ps_cur_slice->i4_delta_pic_order_cnt[0] = i_delta_poc[0]; 1503 ps_cur_slice->i4_delta_pic_order_cnt[1] = i_delta_poc[1]; 1504 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id; 1505 ps_cur_slice->u2_first_mb_in_slice = u2_first_mb_in_slice; 1506 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag; 1507 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag; 1508 ps_cur_slice->u1_slice_type = u1_slice_type; 1509 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb; 1510 1511 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type; 1512 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt; 1513 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc; 1514 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type; 1515 1516 if(ps_seq->u1_frame_mbs_only_flag) 1517 ps_cur_slice->u1_direct_8x8_inference_flag = 1518 ps_seq->u1_direct_8x8_inference_flag; 1519 else 1520 ps_cur_slice->u1_direct_8x8_inference_flag = 1; 1521 1522 if(u1_slice_type == B_SLICE) 1523 { 1524 ps_cur_slice->u1_direct_spatial_mv_pred_flag = ih264d_get_bit_h264( 1525 ps_bitstrm); 1526 COPYTHECONTEXT("SH: direct_spatial_mv_pred_flag", 1527 ps_cur_slice->u1_direct_spatial_mv_pred_flag); 1528 1529 if(ps_cur_slice->u1_direct_spatial_mv_pred_flag) 1530 ps_cur_slice->pf_decodeDirect = ih264d_decode_spatial_direct; 1531 else 1532 ps_cur_slice->pf_decodeDirect = ih264d_decode_temporal_direct; 1533 if(!((ps_pps->ps_sps->u1_mb_aff_flag) && (!u1_field_pic_flag))) 1534 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaffB; 1535 } 1536 else 1537 { 1538 if(!((ps_pps->ps_sps->u1_mb_aff_flag) && (!u1_field_pic_flag))) 1539 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff; 1540 } 1541 1542 if(ps_dec->u4_first_slice_in_pic) 1543 { 1544 if(u2_first_mb_in_slice == 0) 1545 { 1546 ret = ih264d_start_of_pic(ps_dec, i4_poc, &s_tmp_poc, u2_frame_num, ps_pps); 1547 if(ret != OK) 1548 return ret; 1549 } 1550 1551 ps_dec->u4_output_present = 0; 1552 1553 { 1554 ih264d_get_next_display_field(ps_dec, 1555 ps_dec->ps_out_buffer, 1556 &(ps_dec->s_disp_op)); 1557 /* If error code is non-zero then there is no buffer available for display, 1558 hence avoid format conversion */ 1559 1560 if(0 != ps_dec->s_disp_op.u4_error_code) 1561 { 1562 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht; 1563 } 1564 else 1565 ps_dec->u4_output_present = 1; 1566 } 1567 if(ps_dec->u1_separate_parse == 1) 1568 { 1569 if(ps_dec->u4_dec_thread_created == 0) 1570 { 1571 ithread_create(ps_dec->pv_dec_thread_handle, NULL, 1572 (void *)ih264d_decode_picture_thread, 1573 (void *)ps_dec); 1574 1575 ps_dec->u4_dec_thread_created = 1; 1576 } 1577 1578 if((ps_dec->u4_num_cores == 3) && 1579 ((ps_dec->u4_app_disable_deblk_frm == 0) || ps_dec->i1_recon_in_thread3_flag) 1580 && (ps_dec->u4_bs_deblk_thread_created == 0)) 1581 { 1582 ps_dec->u4_start_recon_deblk = 0; 1583 ithread_create(ps_dec->pv_bs_deblk_thread_handle, NULL, 1584 (void *)ih264d_recon_deblk_thread, 1585 (void *)ps_dec); 1586 ps_dec->u4_bs_deblk_thread_created = 1; 1587 } 1588 } 1589 1590 } 1591 1592 /* INITIALIZATION of fn ptrs for MC and formMbPartInfo functions */ 1593 { 1594 UWORD8 uc_nofield_nombaff; 1595 1596 1597 1598 uc_nofield_nombaff = ((ps_dec->ps_cur_slice->u1_field_pic_flag == 0) 1599 && (ps_dec->ps_cur_slice->u1_mbaff_frame_flag == 0) 1600 && (u1_slice_type != B_SLICE) 1601 && (ps_dec->ps_cur_pps->u1_wted_pred_flag == 0)); 1602 1603 /* Initialise MC and formMbPartInfo fn ptrs one time based on profile_idc */ 1604 1605 if(uc_nofield_nombaff) 1606 { 1607 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp; 1608 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp; 1609 } 1610 else 1611 { 1612 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_mp; 1613 ps_dec->p_motion_compensate = ih264d_motion_compensate_mp; 1614 } 1615 1616 1617 } 1618 1619 /* 1620 * Decide whether to decode the current picture or not 1621 */ 1622 { 1623 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status; 1624 if(ps_err->u4_frm_sei_sync == u2_frame_num) 1625 { 1626 ps_err->u1_err_flag = ACCEPT_ALL_PICS; 1627 ps_err->u4_frm_sei_sync = SYNC_FRM_DEFAULT; 1628 } 1629 ps_err->u4_cur_frm = u2_frame_num; 1630 } 1631 1632 /* Decision for decoding if the picture is to be skipped */ 1633 { 1634 WORD32 i4_skip_b_pic, i4_skip_p_pic; 1635 1636 i4_skip_b_pic = (ps_dec->u4_skip_frm_mask & B_SLC_BIT) 1637 && (B_SLICE == u1_slice_type) && (0 == u1_nal_ref_idc); 1638 1639 i4_skip_p_pic = (ps_dec->u4_skip_frm_mask & P_SLC_BIT) 1640 && (P_SLICE == u1_slice_type) && (0 == u1_nal_ref_idc); 1641 1642 /**************************************************************/ 1643 /* Skip the B picture if skip mask is set for B picture and */ 1644 /* Current B picture is a non reference B picture or there is */ 1645 /* no user for reference B picture */ 1646 /**************************************************************/ 1647 if(i4_skip_b_pic) 1648 { 1649 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT; 1650 /* Don't decode the picture in SKIP-B mode if that picture is B */ 1651 /* and also it is not to be used as a reference picture */ 1652 ps_dec->u1_last_pic_not_decoded = 1; 1653 1654 return OK; 1655 } 1656 /**************************************************************/ 1657 /* Skip the P picture if skip mask is set for P picture and */ 1658 /* Current P picture is a non reference P picture or there is */ 1659 /* no user for reference P picture */ 1660 /**************************************************************/ 1661 if(i4_skip_p_pic) 1662 { 1663 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT; 1664 /* Don't decode the picture in SKIP-P mode if that picture is P */ 1665 /* and also it is not to be used as a reference picture */ 1666 ps_dec->u1_last_pic_not_decoded = 1; 1667 1668 return OK; 1669 } 1670 } 1671 1672 { 1673 UWORD16 u2_mb_x, u2_mb_y; 1674 1675 ps_dec->i4_submb_ofst = ((u2_first_mb_in_slice 1676 << ps_cur_slice->u1_mbaff_frame_flag) * SUB_BLK_SIZE) 1677 - SUB_BLK_SIZE; 1678 if(u2_first_mb_in_slice) 1679 { 1680 UWORD8 u1_mb_aff; 1681 UWORD8 u1_field_pic; 1682 UWORD16 u2_frm_wd_in_mbs; 1683 u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs; 1684 u1_mb_aff = ps_cur_slice->u1_mbaff_frame_flag; 1685 u1_field_pic = ps_cur_slice->u1_field_pic_flag; 1686 1687 { 1688 UWORD32 x_offset; 1689 UWORD32 y_offset; 1690 UWORD32 u4_frame_stride; 1691 tfr_ctxt_t *ps_trns_addr; // = &ps_dec->s_tran_addrecon_parse; 1692 1693 if(ps_dec->u1_separate_parse) 1694 { 1695 ps_trns_addr = &ps_dec->s_tran_addrecon_parse; 1696 } 1697 else 1698 { 1699 ps_trns_addr = &ps_dec->s_tran_addrecon; 1700 } 1701 u2_mb_x = MOD(u2_first_mb_in_slice, u2_frm_wd_in_mbs); 1702 u2_mb_y = DIV(u2_first_mb_in_slice, u2_frm_wd_in_mbs); 1703 1704 u2_mb_y <<= u1_mb_aff; 1705 1706 if((u2_mb_x > u2_frm_wd_in_mbs - 1) 1707 || (u2_mb_y > ps_dec->u2_frm_ht_in_mbs - 1)) 1708 { 1709 return ERROR_CORRUPTED_SLICE; 1710 } 1711 1712 u4_frame_stride = ps_dec->u2_frm_wd_y << u1_field_pic; 1713 x_offset = u2_mb_x << 4; 1714 y_offset = (u2_mb_y * u4_frame_stride) << 4; 1715 1716 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + x_offset 1717 + y_offset; 1718 1719 u4_frame_stride = ps_dec->u2_frm_wd_uv << u1_field_pic; 1720 x_offset >>= 1; 1721 y_offset = (u2_mb_y * u4_frame_stride) << 3; 1722 1723 x_offset *= YUV420SP_FACTOR; 1724 1725 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + x_offset 1726 + y_offset; 1727 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + x_offset 1728 + y_offset; 1729 1730 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y; 1731 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u; 1732 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v; 1733 1734 1735 // assign the deblock structure pointers to start of slice 1736 if(ps_dec->u1_separate_parse == 1) 1737 { 1738 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic 1739 + (u2_first_mb_in_slice << u1_mb_aff); 1740 } 1741 else 1742 { 1743 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic 1744 + (u2_first_mb_in_slice << u1_mb_aff); 1745 } 1746 1747 ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff); 1748 1749 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv 1750 + ((u2_first_mb_in_slice << u1_mb_aff) << 4); 1751 } 1752 } 1753 else 1754 { 1755 tfr_ctxt_t *ps_trns_addr; 1756 1757 if(ps_dec->u1_separate_parse) 1758 { 1759 ps_trns_addr = &ps_dec->s_tran_addrecon_parse; 1760 } 1761 else 1762 { 1763 ps_trns_addr = &ps_dec->s_tran_addrecon; 1764 } 1765 1766 u2_mb_x = 0xffff; 1767 u2_mb_y = 0; 1768 // assign the deblock structure pointers to start of slice 1769 ps_dec->u2_cur_mb_addr = 0; 1770 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic; 1771 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv; 1772 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1; 1773 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2; 1774 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3; 1775 1776 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y; 1777 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u; 1778 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v; 1779 1780 } 1781 1782 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1783 1784 ps_dec->u2_mbx = 1785 (MOD(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs)); 1786 ps_dec->u2_mby = 1787 (DIV(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs)); 1788 ps_dec->u2_mby <<= ps_cur_slice->u1_mbaff_frame_flag; 1789 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx; 1790 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby; 1791 } 1792 1793 /* RBSP stop bit is used for CABAC decoding*/ 1794 ps_bitstrm->u4_max_ofst += ps_dec->ps_cur_pps->u1_entropy_coding_mode; 1795 1796 ps_dec->u1_B = (u1_slice_type == B_SLICE); 1797 ps_dec->u4_next_mb_skip = 0; 1798 1799 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = 1800 ps_dec->ps_cur_slice->u2_first_mb_in_slice; 1801 ps_dec->ps_parse_cur_slice->slice_type = 1802 ps_dec->ps_cur_slice->u1_slice_type; 1803 1804 1805 ps_dec->u4_start_recon_deblk = 1; 1806 { 1807 WORD32 num_entries; 1808 WORD32 size; 1809 UWORD8 *pu1_buf; 1810 1811 num_entries = MAX_FRAMES; 1812 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) && 1813 (0 == ps_dec->i4_display_delay)) 1814 { 1815 num_entries = 1; 1816 } 1817 num_entries = ((2 * num_entries) + 1); 1818 num_entries *= 2; 1819 1820 1821 size = num_entries * sizeof(void *); 1822 size += PAD_MAP_IDX_POC * sizeof(void *); 1823 1824 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf; 1825 pu1_buf += size * ps_dec->u2_cur_slice_num; 1826 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = ( void *)pu1_buf; 1827 } 1828 1829 if(ps_dec->u1_separate_parse) 1830 { 1831 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data; 1832 } 1833 else 1834 { 1835 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data; 1836 } 1837 1838 ret = ih264d_fix_error_in_dpb(ps_dec); 1839 if(ret < 0) 1840 return ERROR_DBP_MANAGER_T; 1841 1842 if(u1_slice_type == I_SLICE) 1843 { 1844 ps_dec->ps_cur_pic->u4_pack_slc_typ |= I_SLC_BIT; 1845 1846 ret = ih264d_parse_islice(ps_dec, u2_first_mb_in_slice); 1847 ps_dec->u1_pr_sl_type = u1_slice_type; 1848 if(ps_dec->i4_pic_type != B_SLICE && ps_dec->i4_pic_type != P_SLICE) 1849 ps_dec->i4_pic_type = I_SLICE; 1850 1851 } 1852 else if(u1_slice_type == P_SLICE) 1853 { 1854 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT; 1855 ret = ih264d_parse_pslice(ps_dec, u2_first_mb_in_slice); 1856 ps_dec->u1_pr_sl_type = u1_slice_type; 1857 if(ps_dec->i4_pic_type != B_SLICE) 1858 ps_dec->i4_pic_type = P_SLICE; 1859 } 1860 else if(u1_slice_type == B_SLICE) 1861 { 1862 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT; 1863 ret = ih264d_parse_bslice(ps_dec, u2_first_mb_in_slice); 1864 ps_dec->u1_pr_sl_type = u1_slice_type; 1865 ps_dec->i4_pic_type = B_SLICE; 1866 } 1867 else 1868 return ERROR_INV_SLC_TYPE_T; 1869 1870 if(ps_dec->u1_slice_header_done) 1871 { 1872 /* set to zero to indicate a valid slice has been decoded */ 1873 ps_dec->u1_first_slice_in_stream = 0; 1874 } 1875 1876 if(ret != OK) 1877 return ret; 1878 1879 if(u1_nal_ref_idc != 0) 1880 { 1881 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read) 1882 { 1883 memcpy((void *)ps_dec->ps_dpb_cmds, (void *)(&(ps_dec->s_dpb_cmds_scratch)), 1884 sizeof(dpb_commands_t)); 1885 } 1886 } 1887 1888 /* storing last Mb X and MbY of the slice */ 1889 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx; 1890 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby; 1891 1892 /* End of Picture detection */ 1893 1894 if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1)) 1895 { 1896 ps_dec->u1_pic_decode_done = 1; 1897 1898 } 1899 1900 { 1901 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status; 1902 if((ps_err->u1_err_flag & REJECT_PB_PICS) 1903 && (ps_err->u1_cur_pic_type == PIC_TYPE_I)) 1904 { 1905 ps_err->u1_err_flag = ACCEPT_ALL_PICS; 1906 } 1907 } 1908 1909 PRINT_BIN_BIT_RATIO(ps_dec) 1910 1911 return ret; 1912 } 1913 1914
