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