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 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 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 ih264d_form_default_scaling_matrix(ps_dec); 709 } 710 711 /* required while reading the transform_size_8x8 u4_flag */ 712 ps_dec->s_high_profile.u1_direct_8x8_inference_flag = 713 ps_seq->u1_direct_8x8_inference_flag; 714 ps_dec->s_high_profile.s_cavlc_ctxt = ps_dec->s_cavlc_ctxt; 715 716 ps_dec->i1_recon_in_thread3_flag = 1; 717 ps_dec->ps_frame_buf_ip_recon = &ps_dec->s_tran_addrecon; 718 if(ps_dec->u1_separate_parse) 719 { 720 memcpy(&ps_dec->s_tran_addrecon_parse, &ps_dec->s_tran_addrecon, 721 sizeof(tfr_ctxt_t)); 722 if(ps_dec->u4_num_cores >= 3 && ps_dec->i1_recon_in_thread3_flag) 723 { 724 memcpy(&ps_dec->s_tran_iprecon, &ps_dec->s_tran_addrecon, 725 sizeof(tfr_ctxt_t)); 726 ps_dec->ps_frame_buf_ip_recon = &ps_dec->s_tran_iprecon; 727 } 728 } 729 730 731 ih264d_init_deblk_tfr_ctxt(ps_dec,&(ps_dec->s_pad_mgr), &(ps_dec->s_tran_addrecon), 732 ps_dec->u2_frm_wd_in_mbs, 0); 733 734 ps_dec->ps_cur_deblk_mb = ps_dec->ps_deblk_pic; 735 ps_dec->u4_cur_deblk_mb_num = 0; 736 737 ps_dec->u4_deblk_mb_x = 0; 738 ps_dec->u4_deblk_mb_y = 0; 739 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat; 740 741 ps_dec->u4_first_slice_in_pic = 0; 742 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex); 743 return OK; 744 } 745 746 /*! 747 ************************************************************************** 748 * \if Function name : ih264d_deblock_display \endif 749 * 750 * \brief : The function callls the deblocking routine and manages 751 : the Recon buffers and displays . 752 * \return : Nothing 753 * 754 ************************************************************************** 755 */ 756 WORD32 ih264d_end_of_pic_dispbuf_mgr(dec_struct_t * ps_dec) 757 { 758 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice; 759 UWORD8 u1_num_of_users = 0; 760 WORD32 ret; 761 762 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex); 763 if(1) 764 { 765 766 { 767 ih264d_delete_nonref_nondisplay_pics(ps_dec->ps_dpb_mgr); 768 if(ps_cur_slice->u1_mmco_equalto5 769 || (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL)) 770 { 771 ps_dec->ps_cur_pic->i4_poc = 0; 772 if(ps_dec->u2_total_mbs_coded 773 == (ps_dec->ps_cur_sps->u2_max_mb_addr + 1)) 774 ih264d_reset_ref_bufs(ps_dec->ps_dpb_mgr); 775 ih264d_release_display_bufs(ps_dec); 776 } 777 if(IVD_DECODE_FRAME_OUT != ps_dec->e_frm_out_mode) 778 { 779 ret = ih264d_assign_display_seq(ps_dec); 780 if(ret != OK) 781 return ret; 782 } 783 } 784 785 if(ps_cur_slice->u1_nal_ref_idc) 786 { 787 /* Mark pic buf as needed for reference */ 788 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 789 ps_dec->u1_pic_buf_id, 790 BUF_MGR_REF); 791 /* Mark mv buf as needed for reference */ 792 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 793 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id], 794 BUF_MGR_REF); 795 ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] = 1; 796 } 797 798 /* 420 consumer */ 799 /* Increment the number of users by 1 for display based upon */ 800 /*the SEEK KEY FRAME control sent to decoder */ 801 if(((0 == ps_dec->u1_last_pic_not_decoded) 802 && (0 803 == (ps_dec->ps_cur_pic->u4_pack_slc_typ 804 & ps_dec->u4_skip_frm_mask))) 805 || (ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL)) 806 { 807 /* Mark pic buf as needed for display */ 808 ih264_buf_mgr_set_status((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 809 ps_dec->u1_pic_buf_id, 810 BUF_MGR_IO); 811 812 } 813 814 if(!ps_cur_slice->u1_field_pic_flag 815 || ((TOP_FIELD_ONLY | BOT_FIELD_ONLY) 816 != ps_dec->u1_top_bottom_decoded)) 817 { 818 pic_buffer_t *ps_cur_pic = ps_dec->ps_cur_pic; 819 ps_cur_pic->u2_disp_width = ps_dec->u2_disp_width; 820 ps_cur_pic->u2_disp_height = ps_dec->u2_disp_height >> 1; 821 822 ps_cur_pic->u2_crop_offset_y = ps_dec->u2_crop_offset_y; 823 ps_cur_pic->u2_crop_offset_uv = ps_dec->u2_crop_offset_uv; 824 ps_cur_pic->u1_pic_type = 0; 825 826 ret = ih264d_insert_pic_in_display_list( 827 ps_dec->ps_dpb_mgr, 828 ps_dec->u1_pic_buf_id, 829 ps_dec->i4_prev_max_display_seq 830 + ps_dec->ps_cur_pic->i4_poc, 831 ps_dec->ps_cur_pic->i4_frame_num); 832 if(ret != OK) 833 return ret; 834 835 { 836 ivd_video_decode_op_t * ps_dec_output = 837 (ivd_video_decode_op_t *)ps_dec->pv_dec_out; 838 839 ps_dec_output->u4_frame_decoded_flag = 1; 840 } 841 if(ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] == 0) 842 { 843 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 844 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id], 845 BUF_MGR_REF); 846 ps_dec->au1_pic_buf_ref_flag[ps_dec->u1_pic_buf_id] = 0; 847 848 } 849 } 850 else 851 { 852 H264_DEC_DEBUG_PRINT("pic not inserted display %d %d\n", 853 ps_cur_slice->u1_field_pic_flag, 854 ps_dec->u1_second_field); 855 } 856 857 if(!ps_cur_slice->u1_field_pic_flag 858 || ((TOP_FIELD_ONLY | BOT_FIELD_ONLY) 859 == ps_dec->u1_top_bottom_decoded)) 860 { 861 if(IVD_DECODE_FRAME_OUT == ps_dec->e_frm_out_mode) 862 { 863 ret = ih264d_assign_display_seq(ps_dec); 864 if(ret != OK) 865 return ret; 866 } 867 } 868 } 869 870 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex); 871 872 return OK; 873 } 874 875 void ih264d_err_pic_dispbuf_mgr(dec_struct_t *ps_dec) 876 { 877 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice; 878 ivd_video_decode_op_t * ps_dec_output = 879 (ivd_video_decode_op_t *)ps_dec->pv_dec_out; 880 881 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 882 ps_dec->u1_pic_buf_id, 883 BUF_MGR_REF); 884 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_mv_buf_mgr, 885 ps_dec->au1_pic_buf_id_mv_buf_id_map[ps_dec->u1_pic_buf_id], 886 BUF_MGR_REF); 887 ih264_buf_mgr_release((buf_mgr_t *)ps_dec->pv_pic_buf_mgr, 888 ps_dec->u1_pic_buf_id, 889 BUF_MGR_IO); 890 } 891 892 void ih264d_deblock_picture(void *ptr) 893 { 894 dec_struct_t *ps_dec = (dec_struct_t *)ptr; 895 896 { 897 /*Deblock picture only if all the mb's in the frame have been decoded*/ 898 if(ps_dec->u1_pic_decode_done == 1) 899 { 900 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag 901 || ps_dec->ps_cur_slice->u1_field_pic_flag) 902 { 903 ps_dec->p_DeblockPicture[ps_dec->ps_cur_slice->u1_mbaff_frame_flag]( 904 ps_dec); 905 } 906 else 907 908 { 909 910 ih264d_deblock_picture_progressive(ps_dec); 911 } 912 913 } 914 } 915 916 } 917 918 /*! 919 ************************************************************************** 920 * \if Function name : ih264d_deblock_display \endif 921 * 922 * \brief : The function callls the deblocking routine and manages 923 : the Recon buffers and displays . 924 * \return : Nothing 925 * 926 ************************************************************************** 927 */ 928 WORD32 ih264d_deblock_display(dec_struct_t *ps_dec) 929 { 930 WORD32 ret; 931 /* Call deblocking */ 932 ih264d_deblock_picture(ps_dec); 933 934 ret = ih264d_end_of_pic_dispbuf_mgr(ps_dec); 935 if(ret != OK) 936 return ret; 937 938 return OK; 939 } 940 941 /* 942 *! 943 ************************************************************************** 944 * \if Function name : EndofPoc \endif 945 * 946 * \brief 947 * EndofPoc Processing 948 * 949 * \return 950 * 0 on Success and Error code otherwise 951 ************************************************************************** 952 */ 953 954 WORD32 ih264d_end_of_pic(dec_struct_t *ps_dec) 955 { 956 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice; 957 WORD32 ret; 958 959 { 960 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status; 961 if(ps_err->u1_err_flag & REJECT_CUR_PIC) 962 { 963 ih264d_err_pic_dispbuf_mgr(ps_dec); 964 return ERROR_NEW_FRAME_EXPECTED; 965 } 966 } 967 968 H264_MUTEX_LOCK(&ps_dec->process_disp_mutex); 969 ret = ih264d_end_of_pic_processing(ps_dec); 970 if(ret != OK) 971 return ret; 972 /*--------------------------------------------------------------------*/ 973 /* ih264d_decode_pic_order_cnt - calculate the Pic Order Cnt */ 974 /* Needed to detect end of picture */ 975 /*--------------------------------------------------------------------*/ 976 977 H264_MUTEX_UNLOCK(&ps_dec->process_disp_mutex); 978 979 return OK; 980 } 981 982 /*! 983 ************************************************************************** 984 * \if Function name : DecodeSlice \endif 985 * 986 * \brief 987 * Parses a slice 988 * 989 * \return 990 * 0 on Success and Error code otherwise 991 ************************************************************************** 992 */ 993 994 WORD32 ih264d_parse_decode_slice(UWORD8 u1_is_idr_slice, 995 UWORD8 u1_nal_ref_idc, 996 dec_struct_t *ps_dec /* Decoder parameters */ 997 ) 998 { 999 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm; 1000 dec_pic_params_t *ps_pps; 1001 dec_seq_params_t *ps_seq; 1002 dec_slice_params_t *ps_cur_slice = ps_dec->ps_cur_slice; 1003 pocstruct_t s_tmp_poc; 1004 WORD32 i_delta_poc[2]; 1005 WORD32 i4_poc = 0; 1006 UWORD16 u2_first_mb_in_slice, u2_frame_num; 1007 UWORD8 u1_field_pic_flag, u1_redundant_pic_cnt = 0, u1_slice_type; 1008 UWORD32 u4_idr_pic_id = 0; 1009 UWORD8 u1_bottom_field_flag, u1_pic_order_cnt_type; 1010 1011 UWORD8 u1_nal_unit_type; 1012 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1013 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst; 1014 WORD8 i1_is_end_of_poc; 1015 1016 WORD32 ret, end_of_frame; 1017 WORD32 prev_slice_err, num_mb_skipped; 1018 UWORD8 u1_mbaff; 1019 pocstruct_t *ps_cur_poc; 1020 1021 UWORD32 u4_temp; 1022 WORD32 i_temp; 1023 UWORD32 u4_call_end_of_pic = 0; 1024 1025 /* read FirstMbInSlice and slice type*/ 1026 ps_dec->ps_dpb_cmds->u1_dpb_commands_read_slc = 0; 1027 u2_first_mb_in_slice = ih264d_uev(pu4_bitstrm_ofst, 1028 pu4_bitstrm_buf); 1029 if(u2_first_mb_in_slice 1030 > (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs)) 1031 { 1032 1033 return ERROR_CORRUPTED_SLICE; 1034 } 1035 1036 /*we currently don not support ASO*/ 1037 if(((u2_first_mb_in_slice << ps_cur_slice->u1_mbaff_frame_flag) 1038 <= ps_dec->u2_cur_mb_addr) && (ps_dec->u4_first_slice_in_pic == 0)) 1039 { 1040 return ERROR_CORRUPTED_SLICE; 1041 } 1042 1043 COPYTHECONTEXT("SH: first_mb_in_slice",u2_first_mb_in_slice); 1044 1045 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 1046 1047 if(u4_temp > 9) 1048 return ERROR_INV_SLC_TYPE_T; 1049 1050 u1_slice_type = u4_temp; 1051 COPYTHECONTEXT("SH: slice_type",(u1_slice_type)); 1052 /* Find Out the Slice Type is 5 to 9 or not then Set the Flag */ 1053 /* u1_sl_typ_5_9 = 1 .Which tells that all the slices in the Pic*/ 1054 /* will be of same type of current */ 1055 if(u1_slice_type > 4) 1056 { 1057 u1_slice_type -= 5; 1058 } 1059 1060 { 1061 UWORD32 skip; 1062 1063 if((ps_dec->i4_app_skip_mode == IVD_SKIP_PB) 1064 || (ps_dec->i4_dec_skip_mode == IVD_SKIP_PB)) 1065 { 1066 UWORD32 u4_bit_stream_offset = 0; 1067 1068 if(ps_dec->u1_nal_unit_type == IDR_SLICE_NAL) 1069 { 1070 skip = 0; 1071 1072 ps_dec->i4_dec_skip_mode = IVD_SKIP_NONE; 1073 } 1074 else if((I_SLICE == u1_slice_type) 1075 && (1 >= ps_dec->ps_cur_sps->u1_num_ref_frames)) 1076 { 1077 skip = 0; 1078 1079 ps_dec->i4_dec_skip_mode = IVD_SKIP_NONE; 1080 } 1081 else 1082 { 1083 skip = 1; 1084 } 1085 1086 /* If one frame worth of data is already skipped, do not skip the next one */ 1087 if((0 == u2_first_mb_in_slice) && (1 == ps_dec->u4_prev_nal_skipped)) 1088 { 1089 skip = 0; 1090 } 1091 1092 if(skip) 1093 { 1094 ps_dec->u4_prev_nal_skipped = 1; 1095 ps_dec->i4_dec_skip_mode = IVD_SKIP_PB; 1096 return 0; 1097 } 1098 else 1099 { 1100 /* If the previous NAL was skipped, then 1101 do not process that buffer in this call. 1102 Return to app and process it in the next call. 1103 This is necessary to handle cases where I/IDR is not complete in 1104 the current buffer and application intends to fill the remaining part of the bitstream 1105 later. This ensures we process only frame worth of data in every call */ 1106 if(1 == ps_dec->u4_prev_nal_skipped) 1107 { 1108 ps_dec->u4_return_to_app = 1; 1109 return 0; 1110 } 1111 } 1112 } 1113 1114 } 1115 1116 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 1117 if(u4_temp & MASK_ERR_PIC_SET_ID) 1118 return ERROR_INV_SLICE_HDR_T; 1119 /* discard slice if pic param is invalid */ 1120 COPYTHECONTEXT("SH: pic_parameter_set_id", u4_temp); 1121 ps_pps = &ps_dec->ps_pps[u4_temp]; 1122 if(FALSE == ps_pps->u1_is_valid) 1123 { 1124 return ERROR_INV_SLICE_HDR_T; 1125 } 1126 ps_seq = ps_pps->ps_sps; 1127 if(!ps_seq) 1128 return ERROR_INV_SLICE_HDR_T; 1129 if(FALSE == ps_seq->u1_is_valid) 1130 return ERROR_INV_SLICE_HDR_T; 1131 1132 /* Get the frame num */ 1133 u2_frame_num = ih264d_get_bits_h264(ps_bitstrm, 1134 ps_seq->u1_bits_in_frm_num); 1135 // H264_DEC_DEBUG_PRINT("FRAME %d First MB in slice: %d\n", u2_frame_num, u2_first_mb_in_slice); 1136 1137 COPYTHECONTEXT("SH: frame_num", u2_frame_num); 1138 // 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); 1139 if(!ps_dec->u1_first_slice_in_stream && ps_dec->u4_first_slice_in_pic) 1140 { 1141 pocstruct_t *ps_prev_poc = &ps_dec->s_prev_pic_poc; 1142 pocstruct_t *ps_cur_poc = &ps_dec->s_cur_pic_poc; 1143 1144 ps_dec->u2_mbx = 0xffff; 1145 ps_dec->u2_mby = 0; 1146 1147 if((0 == u1_is_idr_slice) && ps_cur_slice->u1_nal_ref_idc) 1148 ps_dec->u2_prev_ref_frame_num = ps_cur_slice->u2_frame_num; 1149 1150 if(u1_is_idr_slice || ps_cur_slice->u1_mmco_equalto5) 1151 ps_dec->u2_prev_ref_frame_num = 0; 1152 1153 if(ps_dec->ps_cur_sps->u1_gaps_in_frame_num_value_allowed_flag) 1154 { 1155 ih264d_decode_gaps_in_frame_num(ps_dec, u2_frame_num); 1156 } 1157 1158 ps_prev_poc->i4_prev_frame_num_ofst = ps_cur_poc->i4_prev_frame_num_ofst; 1159 ps_prev_poc->u2_frame_num = ps_cur_poc->u2_frame_num; 1160 ps_prev_poc->u1_mmco_equalto5 = ps_cur_slice->u1_mmco_equalto5; 1161 if(ps_cur_slice->u1_nal_ref_idc) 1162 { 1163 ps_prev_poc->i4_pic_order_cnt_lsb = ps_cur_poc->i4_pic_order_cnt_lsb; 1164 ps_prev_poc->i4_pic_order_cnt_msb = ps_cur_poc->i4_pic_order_cnt_msb; 1165 ps_prev_poc->i4_delta_pic_order_cnt_bottom = 1166 ps_cur_poc->i4_delta_pic_order_cnt_bottom; 1167 ps_prev_poc->i4_delta_pic_order_cnt[0] = 1168 ps_cur_poc->i4_delta_pic_order_cnt[0]; 1169 ps_prev_poc->i4_delta_pic_order_cnt[1] = 1170 ps_cur_poc->i4_delta_pic_order_cnt[1]; 1171 ps_prev_poc->u1_bot_field = ps_cur_poc->u1_bot_field; 1172 } 1173 1174 ps_dec->u2_total_mbs_coded = 0; 1175 } 1176 /* Get the field related flags */ 1177 if(!ps_seq->u1_frame_mbs_only_flag) 1178 { 1179 1180 u1_field_pic_flag = ih264d_get_bit_h264(ps_bitstrm); 1181 COPYTHECONTEXT("SH: field_pic_flag", u1_field_pic_flag); 1182 u1_bottom_field_flag = 0; 1183 1184 if(u1_field_pic_flag) 1185 { 1186 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan_fld; 1187 u1_bottom_field_flag = ih264d_get_bit_h264(ps_bitstrm); 1188 COPYTHECONTEXT("SH: bottom_field_flag", u1_bottom_field_flag); 1189 1190 } 1191 else 1192 { 1193 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan; 1194 } 1195 } 1196 else 1197 { 1198 u1_field_pic_flag = 0; 1199 u1_bottom_field_flag = 0; 1200 1201 ps_dec->pu1_inv_scan = (UWORD8 *)gau1_ih264d_inv_scan; 1202 } 1203 1204 u1_nal_unit_type = SLICE_NAL; 1205 if(u1_is_idr_slice) 1206 { 1207 u1_nal_unit_type = IDR_SLICE_NAL; 1208 u4_idr_pic_id = ih264d_uev(pu4_bitstrm_ofst, 1209 pu4_bitstrm_buf); 1210 if(u4_idr_pic_id > 65535) 1211 return ERROR_INV_SLICE_HDR_T; 1212 COPYTHECONTEXT("SH: ", u4_idr_pic_id); 1213 } 1214 1215 /* read delta pic order count information*/ 1216 i_delta_poc[0] = i_delta_poc[1] = 0; 1217 s_tmp_poc.i4_pic_order_cnt_lsb = 0; 1218 s_tmp_poc.i4_delta_pic_order_cnt_bottom = 0; 1219 u1_pic_order_cnt_type = ps_seq->u1_pic_order_cnt_type; 1220 if(u1_pic_order_cnt_type == 0) 1221 { 1222 i_temp = ih264d_get_bits_h264( 1223 ps_bitstrm, 1224 ps_seq->u1_log2_max_pic_order_cnt_lsb_minus); 1225 if(i_temp < 0 || i_temp >= ps_seq->i4_max_pic_order_cntLsb) 1226 return ERROR_INV_SLICE_HDR_T; 1227 s_tmp_poc.i4_pic_order_cnt_lsb = i_temp; 1228 COPYTHECONTEXT("SH: pic_order_cnt_lsb", s_tmp_poc.i4_pic_order_cnt_lsb); 1229 1230 if((ps_pps->u1_pic_order_present_flag == 1) && (!u1_field_pic_flag)) 1231 { 1232 s_tmp_poc.i4_delta_pic_order_cnt_bottom = ih264d_sev( 1233 pu4_bitstrm_ofst, pu4_bitstrm_buf); 1234 //if(s_tmp_poc.i4_delta_pic_order_cnt_bottom > ps_seq->i4_max_pic_order_cntLsb) 1235 COPYTHECONTEXT("SH: delta_pic_order_cnt_bottom", 1236 s_tmp_poc.i4_delta_pic_order_cnt_bottom); 1237 } 1238 } 1239 1240 s_tmp_poc.i4_delta_pic_order_cnt[0] = 0; 1241 s_tmp_poc.i4_delta_pic_order_cnt[1] = 0; 1242 if(u1_pic_order_cnt_type == 1 1243 && (!ps_seq->u1_delta_pic_order_always_zero_flag)) 1244 { 1245 s_tmp_poc.i4_delta_pic_order_cnt[0] = ih264d_sev(pu4_bitstrm_ofst, 1246 pu4_bitstrm_buf); 1247 COPYTHECONTEXT("SH: delta_pic_order_cnt[0]", 1248 s_tmp_poc.i4_delta_pic_order_cnt[0]); 1249 1250 if(ps_pps->u1_pic_order_present_flag && !u1_field_pic_flag) 1251 { 1252 s_tmp_poc.i4_delta_pic_order_cnt[1] = ih264d_sev( 1253 pu4_bitstrm_ofst, pu4_bitstrm_buf); 1254 COPYTHECONTEXT("SH: delta_pic_order_cnt[1]", 1255 s_tmp_poc.i4_delta_pic_order_cnt[1]); 1256 } 1257 } 1258 1259 if(ps_pps->u1_redundant_pic_cnt_present_flag) 1260 { 1261 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 1262 if(u4_temp > MAX_REDUNDANT_PIC_CNT) 1263 return ERROR_INV_SLICE_HDR_T; 1264 u1_redundant_pic_cnt = u4_temp; 1265 COPYTHECONTEXT("SH: redundant_pic_cnt", u1_redundant_pic_cnt); 1266 } 1267 1268 /*--------------------------------------------------------------------*/ 1269 /* Check if the slice is part of new picture */ 1270 /*--------------------------------------------------------------------*/ 1271 /* First slice of a picture is always considered as part of new picture */ 1272 i1_is_end_of_poc = 1; 1273 ps_dec->ps_dec_err_status->u1_err_flag &= MASK_REJECT_CUR_PIC; 1274 1275 if(ps_dec->u4_first_slice_in_pic == 0) 1276 { 1277 i1_is_end_of_poc = ih264d_is_end_of_pic(u2_frame_num, u1_nal_ref_idc, 1278 &s_tmp_poc, &ps_dec->s_cur_pic_poc, 1279 ps_cur_slice, u1_pic_order_cnt_type, 1280 u1_nal_unit_type, u4_idr_pic_id, 1281 u1_field_pic_flag, 1282 u1_bottom_field_flag); 1283 if(i1_is_end_of_poc) 1284 { 1285 ps_dec->u1_first_slice_in_stream = 0; 1286 return ERROR_INCOMPLETE_FRAME; 1287 } 1288 1289 } 1290 1291 /*--------------------------------------------------------------------*/ 1292 /* Check for error in slice and parse the missing/corrupted MB's */ 1293 /* as skip-MB's in an inserted P-slice */ 1294 /*--------------------------------------------------------------------*/ 1295 u1_mbaff = ps_seq->u1_mb_aff_flag && (!u1_field_pic_flag); 1296 prev_slice_err = 0; 1297 1298 if(i1_is_end_of_poc || ps_dec->u1_first_slice_in_stream) 1299 { 1300 if(u2_frame_num != ps_dec->u2_prv_frame_num 1301 && ps_dec->u1_top_bottom_decoded != 0 1302 && ps_dec->u1_top_bottom_decoded 1303 != (TOP_FIELD_ONLY | BOT_FIELD_ONLY)) 1304 { 1305 ps_dec->u1_dangling_field = 1; 1306 if(ps_dec->u4_first_slice_in_pic) 1307 { 1308 // first slice - dangling field 1309 prev_slice_err = 1; 1310 } 1311 else 1312 { 1313 // last slice - dangling field 1314 prev_slice_err = 2; 1315 } 1316 1317 if(ps_dec->u1_top_bottom_decoded ==TOP_FIELD_ONLY) 1318 ps_cur_slice->u1_bottom_field_flag = 1; 1319 else 1320 ps_cur_slice->u1_bottom_field_flag = 0; 1321 1322 num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) 1323 - ps_dec->u2_total_mbs_coded; 1324 ps_cur_poc = &ps_dec->s_cur_pic_poc; 1325 1326 u1_is_idr_slice = ps_cur_slice->u1_nal_unit_type == IDR_SLICE_NAL; 1327 } 1328 else if(ps_dec->u4_first_slice_in_pic) 1329 { 1330 if(u2_first_mb_in_slice > 0) 1331 { 1332 // first slice - missing/header corruption 1333 prev_slice_err = 1; 1334 num_mb_skipped = u2_first_mb_in_slice << u1_mbaff; 1335 ps_cur_poc = &s_tmp_poc; 1336 1337 // initializing slice parameters 1338 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id; 1339 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag; 1340 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag; 1341 ps_cur_slice->i4_pic_order_cnt_lsb = 1342 s_tmp_poc.i4_pic_order_cnt_lsb; 1343 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type; 1344 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt; 1345 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc; 1346 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type; 1347 ps_cur_slice->u1_mbaff_frame_flag = ps_seq->u1_mb_aff_flag 1348 && (!u1_field_pic_flag); 1349 } 1350 } 1351 else 1352 { 1353 /* since i1_is_end_of_poc is set ,means new frame num is encountered. so conceal the current frame 1354 * completely */ 1355 prev_slice_err = 2; 1356 num_mb_skipped = (ps_dec->u2_frm_ht_in_mbs 1357 * ps_dec->u2_frm_wd_in_mbs) 1358 - ps_dec->u2_total_mbs_coded; 1359 ps_cur_poc = &s_tmp_poc; 1360 } 1361 } 1362 else 1363 { 1364 if((u2_first_mb_in_slice << u1_mbaff) > ps_dec->u2_total_mbs_coded) 1365 { 1366 // previous slice - missing/corruption 1367 prev_slice_err = 2; 1368 num_mb_skipped = (u2_first_mb_in_slice << u1_mbaff) 1369 - ps_dec->u2_total_mbs_coded; 1370 ps_cur_poc = &s_tmp_poc; 1371 } 1372 else if((u2_first_mb_in_slice << u1_mbaff) < ps_dec->u2_total_mbs_coded) 1373 { 1374 return ERROR_CORRUPTED_SLICE; 1375 } 1376 } 1377 1378 if(prev_slice_err) 1379 { 1380 ret = ih264d_mark_err_slice_skip(ps_dec, num_mb_skipped, u1_is_idr_slice, u2_frame_num, ps_cur_poc, prev_slice_err); 1381 1382 if(ps_dec->u1_dangling_field == 1) 1383 { 1384 ps_dec->u1_second_field = 1 - ps_dec->u1_second_field; 1385 ps_dec->u1_first_slice_in_stream = 0; 1386 ps_dec->u1_top_bottom_decoded = TOP_FIELD_ONLY | BOT_FIELD_ONLY; 1387 return ERROR_DANGLING_FIELD_IN_PIC; 1388 } 1389 1390 if(prev_slice_err == 2) 1391 { 1392 ps_dec->u1_first_slice_in_stream = 0; 1393 return ERROR_INCOMPLETE_FRAME; 1394 } 1395 1396 if(ps_dec->u2_total_mbs_coded 1397 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) 1398 { 1399 /* return if all MBs in frame are parsed*/ 1400 ps_dec->u1_first_slice_in_stream = 0; 1401 return ERROR_IN_LAST_SLICE_OF_PIC; 1402 } 1403 1404 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC) 1405 { 1406 ih264d_err_pic_dispbuf_mgr(ps_dec); 1407 return ERROR_NEW_FRAME_EXPECTED; 1408 } 1409 1410 if(ret != OK) 1411 return ret; 1412 1413 i1_is_end_of_poc = 0; 1414 } 1415 1416 if (ps_dec->u4_first_slice_in_pic == 0) 1417 { 1418 ps_dec->ps_parse_cur_slice++; 1419 ps_dec->u2_cur_slice_num++; 1420 } 1421 1422 // in the case of single core increment ps_decode_cur_slice 1423 if((ps_dec->u1_separate_parse == 0) && (ps_dec->u4_first_slice_in_pic == 0)) 1424 { 1425 ps_dec->ps_decode_cur_slice++; 1426 } 1427 ps_dec->u1_slice_header_done = 0; 1428 1429 1430 if(u1_field_pic_flag) 1431 { 1432 ps_dec->u2_prv_frame_num = u2_frame_num; 1433 } 1434 1435 if(ps_cur_slice->u1_mmco_equalto5) 1436 { 1437 WORD32 i4_temp_poc; 1438 WORD32 i4_top_field_order_poc, i4_bot_field_order_poc; 1439 1440 if(!ps_cur_slice->u1_field_pic_flag) // or a complementary field pair 1441 { 1442 i4_top_field_order_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt; 1443 i4_bot_field_order_poc = 1444 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt; 1445 i4_temp_poc = MIN(i4_top_field_order_poc, 1446 i4_bot_field_order_poc); 1447 } 1448 else if(!ps_cur_slice->u1_bottom_field_flag) 1449 i4_temp_poc = ps_dec->ps_cur_pic->i4_top_field_order_cnt; 1450 else 1451 i4_temp_poc = ps_dec->ps_cur_pic->i4_bottom_field_order_cnt; 1452 1453 ps_dec->ps_cur_pic->i4_top_field_order_cnt = i4_temp_poc 1454 - ps_dec->ps_cur_pic->i4_top_field_order_cnt; 1455 ps_dec->ps_cur_pic->i4_bottom_field_order_cnt = i4_temp_poc 1456 - ps_dec->ps_cur_pic->i4_bottom_field_order_cnt; 1457 ps_dec->ps_cur_pic->i4_poc = i4_temp_poc; 1458 ps_dec->ps_cur_pic->i4_avg_poc = i4_temp_poc; 1459 } 1460 if(ps_dec->u4_first_slice_in_pic) 1461 { 1462 ret = ih264d_decode_pic_order_cnt(u1_is_idr_slice, u2_frame_num, 1463 &ps_dec->s_prev_pic_poc, 1464 &s_tmp_poc, ps_cur_slice, ps_pps, 1465 u1_nal_ref_idc, 1466 u1_bottom_field_flag, 1467 u1_field_pic_flag, &i4_poc); 1468 if(ret != OK) 1469 return ret; 1470 /* Display seq no calculations */ 1471 if(i4_poc >= ps_dec->i4_max_poc) 1472 ps_dec->i4_max_poc = i4_poc; 1473 /* IDR Picture or POC wrap around */ 1474 if(i4_poc == 0) 1475 { 1476 ps_dec->i4_prev_max_display_seq = ps_dec->i4_prev_max_display_seq 1477 + ps_dec->i4_max_poc 1478 + ps_dec->u1_max_dec_frame_buffering + 1; 1479 ps_dec->i4_max_poc = 0; 1480 } 1481 } 1482 1483 /*--------------------------------------------------------------------*/ 1484 /* Copy the values read from the bitstream to the slice header and then*/ 1485 /* If the slice is first slice in picture, then do Start of Picture */ 1486 /* processing. */ 1487 /*--------------------------------------------------------------------*/ 1488 ps_cur_slice->i4_delta_pic_order_cnt[0] = i_delta_poc[0]; 1489 ps_cur_slice->i4_delta_pic_order_cnt[1] = i_delta_poc[1]; 1490 ps_cur_slice->u4_idr_pic_id = u4_idr_pic_id; 1491 ps_cur_slice->u2_first_mb_in_slice = u2_first_mb_in_slice; 1492 ps_cur_slice->u1_field_pic_flag = u1_field_pic_flag; 1493 ps_cur_slice->u1_bottom_field_flag = u1_bottom_field_flag; 1494 ps_cur_slice->u1_slice_type = u1_slice_type; 1495 ps_cur_slice->i4_pic_order_cnt_lsb = s_tmp_poc.i4_pic_order_cnt_lsb; 1496 1497 ps_cur_slice->u1_nal_unit_type = u1_nal_unit_type; 1498 ps_cur_slice->u1_redundant_pic_cnt = u1_redundant_pic_cnt; 1499 ps_cur_slice->u1_nal_ref_idc = u1_nal_ref_idc; 1500 ps_cur_slice->u1_pic_order_cnt_type = u1_pic_order_cnt_type; 1501 1502 if(ps_seq->u1_frame_mbs_only_flag) 1503 ps_cur_slice->u1_direct_8x8_inference_flag = 1504 ps_seq->u1_direct_8x8_inference_flag; 1505 else 1506 ps_cur_slice->u1_direct_8x8_inference_flag = 1; 1507 1508 if(u1_slice_type == B_SLICE) 1509 { 1510 ps_cur_slice->u1_direct_spatial_mv_pred_flag = ih264d_get_bit_h264( 1511 ps_bitstrm); 1512 COPYTHECONTEXT("SH: direct_spatial_mv_pred_flag", 1513 ps_cur_slice->u1_direct_spatial_mv_pred_flag); 1514 1515 if(ps_cur_slice->u1_direct_spatial_mv_pred_flag) 1516 ps_cur_slice->pf_decodeDirect = ih264d_decode_spatial_direct; 1517 else 1518 ps_cur_slice->pf_decodeDirect = ih264d_decode_temporal_direct; 1519 if(!((ps_pps->ps_sps->u1_mb_aff_flag) && (!u1_field_pic_flag))) 1520 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaffB; 1521 } 1522 else 1523 { 1524 if(!((ps_pps->ps_sps->u1_mb_aff_flag) && (!u1_field_pic_flag))) 1525 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff; 1526 } 1527 1528 if(ps_dec->u4_first_slice_in_pic) 1529 { 1530 if(u2_first_mb_in_slice == 0) 1531 { 1532 ret = ih264d_start_of_pic(ps_dec, i4_poc, &s_tmp_poc, u2_frame_num, ps_pps); 1533 if(ret != OK) 1534 return ret; 1535 } 1536 1537 ps_dec->u4_output_present = 0; 1538 1539 { 1540 ih264d_get_next_display_field(ps_dec, 1541 ps_dec->ps_out_buffer, 1542 &(ps_dec->s_disp_op)); 1543 /* If error code is non-zero then there is no buffer available for display, 1544 hence avoid format conversion */ 1545 1546 if(0 != ps_dec->s_disp_op.u4_error_code) 1547 { 1548 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht; 1549 } 1550 else 1551 ps_dec->u4_output_present = 1; 1552 } 1553 if(ps_dec->u1_separate_parse == 1) 1554 { 1555 if(ps_dec->u4_dec_thread_created == 0) 1556 { 1557 ithread_create(ps_dec->pv_dec_thread_handle, NULL, 1558 (void *)ih264d_decode_picture_thread, 1559 (void *)ps_dec); 1560 1561 ps_dec->u4_dec_thread_created = 1; 1562 } 1563 1564 if((ps_dec->u4_num_cores == 3) && 1565 ((ps_dec->u4_app_disable_deblk_frm == 0) || ps_dec->i1_recon_in_thread3_flag) 1566 && (ps_dec->u4_bs_deblk_thread_created == 0)) 1567 { 1568 ps_dec->u4_start_recon_deblk = 0; 1569 ithread_create(ps_dec->pv_bs_deblk_thread_handle, NULL, 1570 (void *)ih264d_recon_deblk_thread, 1571 (void *)ps_dec); 1572 ps_dec->u4_bs_deblk_thread_created = 1; 1573 } 1574 } 1575 1576 } 1577 1578 /* INITIALIZATION of fn ptrs for MC and formMbPartInfo functions */ 1579 { 1580 UWORD8 uc_nofield_nombaff; 1581 1582 1583 1584 uc_nofield_nombaff = ((ps_dec->ps_cur_slice->u1_field_pic_flag == 0) 1585 && (ps_dec->ps_cur_slice->u1_mbaff_frame_flag == 0) 1586 && (u1_slice_type != B_SLICE) 1587 && (ps_dec->ps_cur_pps->u1_wted_pred_flag == 0)); 1588 1589 /* Initialise MC and formMbPartInfo fn ptrs one time based on profile_idc */ 1590 1591 if(uc_nofield_nombaff) 1592 { 1593 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp; 1594 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp; 1595 } 1596 else 1597 { 1598 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_mp; 1599 ps_dec->p_motion_compensate = ih264d_motion_compensate_mp; 1600 } 1601 1602 1603 } 1604 1605 /* 1606 * Decide whether to decode the current picture or not 1607 */ 1608 { 1609 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status; 1610 if(ps_err->u4_frm_sei_sync == u2_frame_num) 1611 { 1612 ps_err->u1_err_flag = ACCEPT_ALL_PICS; 1613 ps_err->u4_frm_sei_sync = SYNC_FRM_DEFAULT; 1614 } 1615 ps_err->u4_cur_frm = u2_frame_num; 1616 } 1617 1618 /* Decision for decoding if the picture is to be skipped */ 1619 { 1620 WORD32 i4_skip_b_pic, i4_skip_p_pic; 1621 1622 i4_skip_b_pic = (ps_dec->u4_skip_frm_mask & B_SLC_BIT) 1623 && (B_SLICE == u1_slice_type) && (0 == u1_nal_ref_idc); 1624 1625 i4_skip_p_pic = (ps_dec->u4_skip_frm_mask & P_SLC_BIT) 1626 && (P_SLICE == u1_slice_type) && (0 == u1_nal_ref_idc); 1627 1628 /**************************************************************/ 1629 /* Skip the B picture if skip mask is set for B picture and */ 1630 /* Current B picture is a non reference B picture or there is */ 1631 /* no user for reference B picture */ 1632 /**************************************************************/ 1633 if(i4_skip_b_pic) 1634 { 1635 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT; 1636 /* Don't decode the picture in SKIP-B mode if that picture is B */ 1637 /* and also it is not to be used as a reference picture */ 1638 ps_dec->u1_last_pic_not_decoded = 1; 1639 1640 return OK; 1641 } 1642 /**************************************************************/ 1643 /* Skip the P picture if skip mask is set for P picture and */ 1644 /* Current P picture is a non reference P picture or there is */ 1645 /* no user for reference P picture */ 1646 /**************************************************************/ 1647 if(i4_skip_p_pic) 1648 { 1649 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT; 1650 /* Don't decode the picture in SKIP-P mode if that picture is P */ 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 1658 { 1659 UWORD16 u2_mb_x, u2_mb_y; 1660 1661 ps_dec->i4_submb_ofst = ((u2_first_mb_in_slice 1662 << ps_cur_slice->u1_mbaff_frame_flag) * SUB_BLK_SIZE) 1663 - SUB_BLK_SIZE; 1664 if(u2_first_mb_in_slice) 1665 { 1666 UWORD8 u1_mb_aff; 1667 UWORD8 u1_field_pic; 1668 UWORD16 u2_frm_wd_in_mbs; 1669 u2_frm_wd_in_mbs = ps_seq->u2_frm_wd_in_mbs; 1670 u1_mb_aff = ps_cur_slice->u1_mbaff_frame_flag; 1671 u1_field_pic = ps_cur_slice->u1_field_pic_flag; 1672 1673 { 1674 UWORD32 x_offset; 1675 UWORD32 y_offset; 1676 UWORD32 u4_frame_stride; 1677 tfr_ctxt_t *ps_trns_addr; // = &ps_dec->s_tran_addrecon_parse; 1678 1679 if(ps_dec->u1_separate_parse) 1680 { 1681 ps_trns_addr = &ps_dec->s_tran_addrecon_parse; 1682 } 1683 else 1684 { 1685 ps_trns_addr = &ps_dec->s_tran_addrecon; 1686 } 1687 u2_mb_x = MOD(u2_first_mb_in_slice, u2_frm_wd_in_mbs); 1688 u2_mb_y = DIV(u2_first_mb_in_slice, u2_frm_wd_in_mbs); 1689 1690 u2_mb_y <<= u1_mb_aff; 1691 1692 if((u2_mb_x > u2_frm_wd_in_mbs - 1) 1693 || (u2_mb_y > ps_dec->u2_frm_ht_in_mbs - 1)) 1694 { 1695 return ERROR_CORRUPTED_SLICE; 1696 } 1697 1698 u4_frame_stride = ps_dec->u2_frm_wd_y << u1_field_pic; 1699 x_offset = u2_mb_x << 4; 1700 y_offset = (u2_mb_y * u4_frame_stride) << 4; 1701 1702 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1 + x_offset 1703 + y_offset; 1704 1705 u4_frame_stride = ps_dec->u2_frm_wd_uv << u1_field_pic; 1706 x_offset >>= 1; 1707 y_offset = (u2_mb_y * u4_frame_stride) << 3; 1708 1709 x_offset *= YUV420SP_FACTOR; 1710 1711 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2 + x_offset 1712 + y_offset; 1713 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3 + x_offset 1714 + y_offset; 1715 1716 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y; 1717 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u; 1718 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v; 1719 1720 1721 // assign the deblock structure pointers to start of slice 1722 if(ps_dec->u1_separate_parse == 1) 1723 { 1724 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic 1725 + (u2_first_mb_in_slice << u1_mb_aff); 1726 } 1727 else 1728 { 1729 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic 1730 + (u2_first_mb_in_slice << u1_mb_aff); 1731 } 1732 1733 ps_dec->u2_cur_mb_addr = (u2_first_mb_in_slice << u1_mb_aff); 1734 1735 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv 1736 + ((u2_first_mb_in_slice << u1_mb_aff) << 4); 1737 } 1738 } 1739 else 1740 { 1741 tfr_ctxt_t *ps_trns_addr; 1742 1743 if(ps_dec->u1_separate_parse) 1744 { 1745 ps_trns_addr = &ps_dec->s_tran_addrecon_parse; 1746 } 1747 else 1748 { 1749 ps_trns_addr = &ps_dec->s_tran_addrecon; 1750 } 1751 1752 u2_mb_x = 0xffff; 1753 u2_mb_y = 0; 1754 // assign the deblock structure pointers to start of slice 1755 ps_dec->u2_cur_mb_addr = 0; 1756 ps_dec->ps_deblk_mbn = ps_dec->ps_deblk_pic; 1757 ps_dec->ps_mv_cur = ps_dec->s_cur_pic.ps_mv; 1758 ps_trns_addr->pu1_dest_y = ps_dec->s_cur_pic.pu1_buf1; 1759 ps_trns_addr->pu1_dest_u = ps_dec->s_cur_pic.pu1_buf2; 1760 ps_trns_addr->pu1_dest_v = ps_dec->s_cur_pic.pu1_buf3; 1761 1762 ps_trns_addr->pu1_mb_y = ps_trns_addr->pu1_dest_y; 1763 ps_trns_addr->pu1_mb_u = ps_trns_addr->pu1_dest_u; 1764 ps_trns_addr->pu1_mb_v = ps_trns_addr->pu1_dest_v; 1765 1766 } 1767 1768 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1769 1770 ps_dec->u2_mbx = 1771 (MOD(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs)); 1772 ps_dec->u2_mby = 1773 (DIV(u2_first_mb_in_slice - 1, ps_seq->u2_frm_wd_in_mbs)); 1774 ps_dec->u2_mby <<= ps_cur_slice->u1_mbaff_frame_flag; 1775 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx; 1776 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby; 1777 } 1778 1779 /* RBSP stop bit is used for CABAC decoding*/ 1780 ps_bitstrm->u4_max_ofst += ps_dec->ps_cur_pps->u1_entropy_coding_mode; 1781 1782 ps_dec->u1_B = (u1_slice_type == B_SLICE); 1783 ps_dec->u4_next_mb_skip = 0; 1784 1785 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = 1786 ps_dec->ps_cur_slice->u2_first_mb_in_slice; 1787 ps_dec->ps_parse_cur_slice->slice_type = 1788 ps_dec->ps_cur_slice->u1_slice_type; 1789 1790 1791 ps_dec->u4_start_recon_deblk = 1; 1792 { 1793 WORD32 num_entries; 1794 WORD32 size; 1795 UWORD8 *pu1_buf; 1796 1797 num_entries = MAX_FRAMES; 1798 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) && 1799 (0 == ps_dec->i4_display_delay)) 1800 { 1801 num_entries = 1; 1802 } 1803 num_entries = ((2 * num_entries) + 1); 1804 num_entries *= 2; 1805 1806 1807 size = num_entries * sizeof(void *); 1808 size += PAD_MAP_IDX_POC * sizeof(void *); 1809 1810 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf; 1811 pu1_buf += size * ps_dec->u2_cur_slice_num; 1812 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = ( void *)pu1_buf; 1813 } 1814 1815 if(ps_dec->u1_separate_parse) 1816 { 1817 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data; 1818 } 1819 else 1820 { 1821 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data; 1822 } 1823 1824 if(u1_slice_type == I_SLICE) 1825 { 1826 ps_dec->ps_cur_pic->u4_pack_slc_typ |= I_SLC_BIT; 1827 1828 ret = ih264d_parse_islice(ps_dec, u2_first_mb_in_slice); 1829 1830 if(ps_dec->i4_pic_type != B_SLICE && ps_dec->i4_pic_type != P_SLICE) 1831 ps_dec->i4_pic_type = I_SLICE; 1832 1833 } 1834 else if(u1_slice_type == P_SLICE) 1835 { 1836 ps_dec->ps_cur_pic->u4_pack_slc_typ |= P_SLC_BIT; 1837 ret = ih264d_parse_pslice(ps_dec, u2_first_mb_in_slice); 1838 ps_dec->u1_pr_sl_type = u1_slice_type; 1839 if(ps_dec->i4_pic_type != B_SLICE) 1840 ps_dec->i4_pic_type = P_SLICE; 1841 } 1842 else if(u1_slice_type == B_SLICE) 1843 { 1844 ps_dec->ps_cur_pic->u4_pack_slc_typ |= B_SLC_BIT; 1845 ret = ih264d_parse_bslice(ps_dec, u2_first_mb_in_slice); 1846 ps_dec->u1_pr_sl_type = u1_slice_type; 1847 ps_dec->i4_pic_type = B_SLICE; 1848 } 1849 else 1850 return ERROR_INV_SLC_TYPE_T; 1851 1852 if(ps_dec->u1_slice_header_done) 1853 { 1854 /* set to zero to indicate a valid slice has been decoded */ 1855 ps_dec->u1_first_slice_in_stream = 0; 1856 } 1857 1858 if(ret != OK) 1859 return ret; 1860 1861 /* storing last Mb X and MbY of the slice */ 1862 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx; 1863 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby; 1864 1865 /* End of Picture detection */ 1866 1867 if(ps_dec->u2_total_mbs_coded >= (ps_seq->u2_max_mb_addr + 1)) 1868 { 1869 ps_dec->u1_pic_decode_done = 1; 1870 1871 } 1872 1873 { 1874 dec_err_status_t * ps_err = ps_dec->ps_dec_err_status; 1875 if((ps_err->u1_err_flag & REJECT_PB_PICS) 1876 && (ps_err->u1_cur_pic_type == PIC_TYPE_I)) 1877 { 1878 ps_err->u1_err_flag = ACCEPT_ALL_PICS; 1879 } 1880 } 1881 1882 PRINT_BIN_BIT_RATIO(ps_dec) 1883 1884 return ret; 1885 } 1886 1887
