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