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 ************************************************************************** 23 * \file ih264d_parse_pslice.c 24 * 25 * \brief 26 * Contains routines that decode a I slice type 27 * 28 * Detailed_description 29 * 30 * \date 31 * 07/07/2003 32 * 33 * \author NS 34 ************************************************************************** 35 */ 36 37 #include <string.h> 38 #include "ih264d_bitstrm.h" 39 #include "ih264d_defs.h" 40 #include "ih264d_debug.h" 41 #include "ih264d_tables.h" 42 #include "ih264d_structs.h" 43 #include "ih264d_defs.h" 44 #include "ih264d_parse_cavlc.h" 45 #include "ih264d_mb_utils.h" 46 #include "ih264d_parse_slice.h" 47 #include "ih264d_mvpred.h" 48 #include "ih264d_parse_islice.h" 49 #include "ih264d_process_intra_mb.h" 50 #include "ih264d_inter_pred.h" 51 #include "ih264d_process_pslice.h" 52 #include "ih264d_deblocking.h" 53 #include "ih264d_cabac.h" 54 #include "ih264d_parse_mb_header.h" 55 #include "ih264d_error_handler.h" 56 #include "ih264d_defs.h" 57 #include "ih264d_format_conv.h" 58 #include "ih264d_quant_scaling.h" 59 #include "ih264d_thread_parse_decode.h" 60 #include "ih264d_thread_compute_bs.h" 61 #include "ih264d_process_bslice.h" 62 #include "ithread.h" 63 #include "ih264d_utils.h" 64 #include "ih264d_format_conv.h" 65 66 void ih264d_init_cabac_contexts(UWORD8 u1_slice_type, dec_struct_t * ps_dec); 67 void ih264d_deblock_mb_level(dec_struct_t *ps_dec, 68 dec_mb_info_t *ps_cur_mb_info, 69 UWORD32 nmb_index); 70 71 /*! 72 ************************************************************************** 73 * \if Function name : ih264d_parse_pmb_cavlc \endif 74 * 75 * \brief 76 * This function parses CAVLC syntax of a P MB. 77 * 78 * \return 79 * 0 on Success and Error code otherwise 80 ************************************************************************** 81 */ 82 WORD32 ih264d_parse_pmb_cavlc(dec_struct_t * ps_dec, 83 dec_mb_info_t * ps_cur_mb_info, 84 UWORD8 u1_mb_num, 85 UWORD8 u1_num_mbsNby2) 86 { 87 UWORD32 u1_num_mb_part; 88 UWORD32 uc_sub_mb; 89 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 90 UWORD32 * const pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 91 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst; 92 93 parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data 94 + u1_num_mbsNby2; 95 WORD8 * pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0]; 96 const UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; 97 const UWORD8 * pu1_num_mb_part = (const UWORD8 *)gau1_ih264d_num_mb_part; 98 UWORD8 * pu1_col_info = ps_parse_mb_data->u1_col_info; 99 100 UWORD32 u1_mb_type = ps_cur_mb_info->u1_mb_type; 101 UWORD32 u4_sum_mb_mode_pack = 0; 102 WORD32 ret; 103 104 UWORD8 u1_no_submb_part_size_lt8x8_flag = 1; 105 ps_cur_mb_info->u1_tran_form8x8 = 0; 106 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0; 107 108 ps_cur_mb_info->u1_yuv_dc_block_flag = 0; 109 110 ps_cur_mb_info->u1_mb_mc_mode = u1_mb_type; 111 uc_sub_mb = ((u1_mb_type == PRED_8x8) | (u1_mb_type == PRED_8x8R0)); 112 113 /* Reading the subMB type */ 114 if(uc_sub_mb) 115 { 116 WORD32 i; 117 UWORD8 u1_colz = (PRED_8x8 << 6); 118 119 for(i = 0; i < 4; i++) 120 { 121 UWORD32 ui_sub_mb_mode; 122 123 //Inlined ih264d_uev 124 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; 125 UWORD32 u4_word, u4_ldz; 126 127 /***************************************************************/ 128 /* Find leading zeros in next 32 bits */ 129 /***************************************************************/ 130 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); 131 u4_ldz = CLZ(u4_word); 132 /* Flush the ps_bitstrm */ 133 u4_bitstream_offset += (u4_ldz + 1); 134 /* Read the suffix from the ps_bitstrm */ 135 u4_word = 0; 136 if(u4_ldz) 137 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, 138 u4_ldz); 139 *pu4_bitstrm_ofst = u4_bitstream_offset; 140 ui_sub_mb_mode = ((1 << u4_ldz) + u4_word - 1); 141 //Inlined ih264d_uev 142 143 if(ui_sub_mb_mode > 3) 144 { 145 return ERROR_SUB_MB_TYPE; 146 } 147 else 148 { 149 u4_sum_mb_mode_pack = (u4_sum_mb_mode_pack << 8) | ui_sub_mb_mode; 150 /* Storing collocated information */ 151 *pu1_col_info++ = u1_colz | (UWORD8)(ui_sub_mb_mode << 4); 152 153 COPYTHECONTEXT("sub_mb_type", ui_sub_mb_mode); 154 } 155 156 /* check if Motion compensation is done below 8x8 */ 157 if(ui_sub_mb_mode != P_L0_8x8) 158 { 159 u1_no_submb_part_size_lt8x8_flag = 0; 160 } 161 } 162 163 // 164 u1_num_mb_part = 4; 165 } 166 else 167 { 168 *pu1_col_info++ = (u1_mb_type << 6); 169 if(u1_mb_type) 170 *pu1_col_info++ = (u1_mb_type << 6); 171 u1_num_mb_part = pu1_num_mb_part[u1_mb_type]; 172 173 } 174 175 /* Decoding reference index 0: For simple profile the following */ 176 /* conditions are always true (mb_field_decoding_flag == 0); */ 177 /* (MbPartPredMode != PredL1) */ 178 179 { 180 181 UWORD8 uc_field = ps_cur_mb_info->u1_mb_field_decodingflag; 182 UWORD8 uc_num_ref_idx_l0_active_minus1 = 183 (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0] 184 << (u1_mbaff & uc_field)) - 1; 185 186 if((uc_num_ref_idx_l0_active_minus1 > 0) & (u1_mb_type != PRED_8x8R0)) 187 { 188 if(1 == uc_num_ref_idx_l0_active_minus1) 189 ih264d_parse_pmb_ref_index_cavlc_range1( 190 u1_num_mb_part, ps_bitstrm, pi1_ref_idx, 191 uc_num_ref_idx_l0_active_minus1); 192 else 193 { 194 ret = ih264d_parse_pmb_ref_index_cavlc( 195 u1_num_mb_part, ps_bitstrm, pi1_ref_idx, 196 uc_num_ref_idx_l0_active_minus1); 197 if(ret != OK) 198 return ret; 199 } 200 } 201 else 202 { 203 /* When there exists only a single frame to predict from */ 204 UWORD8 uc_i; 205 for(uc_i = 0; uc_i < u1_num_mb_part; uc_i++) 206 /* Storing Reference Idx Information */ 207 pi1_ref_idx[uc_i] = 0; 208 } 209 } 210 211 { 212 UWORD8 u1_p_idx, uc_i; 213 parse_part_params_t * ps_part = ps_dec->ps_part; 214 UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height; 215 UWORD8 u1_sub_mb_num; 216 const UWORD8 * pu1_top_left_sub_mb_indx; 217 mv_pred_t * ps_mv, *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4); 218 /* Loading the table pointers */ 219 const UWORD8 * pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw; 220 const UWORD8 * pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth; 221 const UWORD8 * pu1_sub_mb_indx_mod = 222 (const UWORD8 *)(gau1_ih264d_submb_indx_mod) 223 + (uc_sub_mb * 6); 224 const UWORD8 * pu1_sub_mb_partw = (const UWORD8 *)gau1_ih264d_submb_partw; 225 const UWORD8 * pu1_sub_mb_parth = (const UWORD8 *)gau1_ih264d_submb_parth; 226 const UWORD8 * pu1_num_sub_mb_part = 227 (const UWORD8 *)gau1_ih264d_num_submb_part; 228 229 UWORD16 u2_sub_mb_num = 0x028A; 230 231 /*********************************************************/ 232 /* default initialisations for condition (uc_sub_mb == 0) */ 233 /* i.e. all are subpartitions of 8x8 */ 234 /*********************************************************/ 235 u1_sub_mb_mode = 0; 236 u1_num_subpart = 1; 237 u1_mb_part_width = pu1_mb_partw[u1_mb_type]; 238 u1_mb_part_height = pu1_mb_parth[u1_mb_type]; 239 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1); 240 u1_sub_mb_num = 0; 241 242 /* Loop on number of partitions */ 243 for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++) 244 { 245 UWORD8 uc_j; 246 if(uc_sub_mb) 247 { 248 u1_sub_mb_mode = u4_sum_mb_mode_pack >> 24; 249 u1_num_subpart = pu1_num_sub_mb_part[u1_sub_mb_mode]; 250 u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode]; 251 u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode]; 252 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1); 253 u1_sub_mb_num = u2_sub_mb_num >> 12; 254 u4_sum_mb_mode_pack <<= 8; 255 u2_sub_mb_num <<= 4; 256 } 257 258 /* Loop on Number of sub-partitions */ 259 for(uc_j = 0; uc_j < u1_num_subpart; uc_j++, pu1_top_left_sub_mb_indx++) 260 { 261 WORD16 i2_mvx, i2_mvy; 262 u1_sub_mb_num += *pu1_top_left_sub_mb_indx; 263 ps_mv = ps_mv_start + u1_sub_mb_num; 264 265 /* Reading the differential Mv from the bitstream */ 266 //i2_mvx = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 267 //inlining ih264d_sev 268 { 269 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; 270 UWORD32 u4_word, u4_ldz, u4_abs_val; 271 272 /***************************************************************/ 273 /* Find leading zeros in next 32 bits */ 274 /***************************************************************/ 275 NEXTBITS_32(u4_word, u4_bitstream_offset, 276 pu4_bitstrm_buf); 277 u4_ldz = CLZ(u4_word); 278 279 /* Flush the ps_bitstrm */ 280 u4_bitstream_offset += (u4_ldz + 1); 281 282 /* Read the suffix from the ps_bitstrm */ 283 u4_word = 0; 284 if(u4_ldz) 285 GETBITS(u4_word, u4_bitstream_offset, 286 pu4_bitstrm_buf, u4_ldz); 287 288 *pu4_bitstrm_ofst = u4_bitstream_offset; 289 u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1; 290 291 if(u4_word & 0x1) 292 i2_mvx = (-(WORD32)u4_abs_val); 293 else 294 i2_mvx = (u4_abs_val); 295 } 296 //inlinined ih264d_sev 297 COPYTHECONTEXT("MVD", i2_mvx); 298 i2_mvy = ih264d_sev(pu4_bitstrm_ofst, 299 pu4_bitstrm_buf); 300 COPYTHECONTEXT("MVD", i2_mvy); 301 302 /* Storing Info for partitions */ 303 ps_part->u1_is_direct = PART_NOT_DIRECT; 304 ps_part->u1_sub_mb_num = u1_sub_mb_num; 305 ps_part->u1_partheight = u1_mb_part_height; 306 ps_part->u1_partwidth = u1_mb_part_width; 307 308 /* Storing Mv residuals */ 309 ps_mv->i2_mv[0] = i2_mvx; 310 ps_mv->i2_mv[1] = i2_mvy; 311 312 /* Increment partition Index */ 313 u1_p_idx++; 314 ps_part++; 315 } 316 } 317 ps_parse_mb_data->u1_num_part = u1_p_idx; 318 ps_dec->ps_part = ps_part; 319 } 320 321 { 322 UWORD32 u4_cbp; 323 324 /* Read the Coded block pattern */ 325 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; 326 UWORD32 u4_word, u4_ldz; 327 328 /***************************************************************/ 329 /* Find leading zeros in next 32 bits */ 330 /***************************************************************/ 331 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); 332 u4_ldz = CLZ(u4_word); 333 /* Flush the ps_bitstrm */ 334 u4_bitstream_offset += (u4_ldz + 1); 335 /* Read the suffix from the ps_bitstrm */ 336 u4_word = 0; 337 if(u4_ldz) 338 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz); 339 *pu4_bitstrm_ofst = u4_bitstream_offset; 340 u4_cbp = ((1 << u4_ldz) + u4_word - 1); 341 342 if(u4_cbp > 47) 343 return ERROR_CBP; 344 345 u4_cbp = *((UWORD8*)gau1_ih264d_cbp_inter + u4_cbp); 346 COPYTHECONTEXT("coded_block_pattern", u4_cbp); 347 ps_cur_mb_info->u1_cbp = u4_cbp; 348 349 /* Read the transform8x8 u4_flag if present */ 350 if((ps_dec->s_high_profile.u1_transform8x8_present) && (u4_cbp & 0xf) 351 && u1_no_submb_part_size_lt8x8_flag) 352 { 353 ps_cur_mb_info->u1_tran_form8x8 = ih264d_get_bit_h264(ps_bitstrm); 354 COPYTHECONTEXT("transform_size_8x8_flag", ps_cur_mb_info->u1_tran_form8x8); 355 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = ps_cur_mb_info->u1_tran_form8x8; 356 } 357 358 /* Read mb_qp_delta */ 359 if(u4_cbp) 360 { 361 WORD32 i_temp; 362 363 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; 364 UWORD32 u4_word, u4_ldz, u4_abs_val; 365 366 /***************************************************************/ 367 /* Find leading zeros in next 32 bits */ 368 /***************************************************************/ 369 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); 370 u4_ldz = CLZ(u4_word); 371 372 /* Flush the ps_bitstrm */ 373 u4_bitstream_offset += (u4_ldz + 1); 374 375 /* Read the suffix from the ps_bitstrm */ 376 u4_word = 0; 377 if(u4_ldz) 378 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, 379 u4_ldz); 380 381 *pu4_bitstrm_ofst = u4_bitstream_offset; 382 u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1; 383 384 if(u4_word & 0x1) 385 i_temp = (-(WORD32)u4_abs_val); 386 else 387 i_temp = (u4_abs_val); 388 389 if((i_temp < -26) || (i_temp > 25)) 390 return ERROR_INV_RANGE_QP_T; 391 //inlinined ih264d_sev 392 393 COPYTHECONTEXT("mb_qp_delta", i_temp); 394 if(i_temp) 395 { 396 ret = ih264d_update_qp(ps_dec, (WORD8)i_temp); 397 if(ret != OK) 398 return ret; 399 } 400 401 ret = ih264d_parse_residual4x4_cavlc(ps_dec, ps_cur_mb_info, 0); 402 if(ret != OK) 403 return ret; 404 if(EXCEED_OFFSET(ps_bitstrm)) 405 return ERROR_EOB_TERMINATE_T; 406 } 407 else 408 { 409 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC); 410 } 411 412 413 414 } 415 416 return OK; 417 } 418 419 /*! 420 ************************************************************************** 421 * \if Function name : ih264d_parse_pmb_cabac \endif 422 * 423 * \brief 424 * This function parses CABAC syntax of a P MB. 425 * 426 * \return 427 * 0 on Success and Error code otherwise 428 ************************************************************************** 429 */ 430 WORD32 ih264d_parse_pmb_cabac(dec_struct_t * ps_dec, 431 dec_mb_info_t * ps_cur_mb_info, 432 UWORD8 u1_mb_num, 433 UWORD8 u1_num_mbsNby2) 434 { 435 UWORD32 u1_num_mb_part; 436 UWORD32 uc_sub_mb; 437 parse_pmbarams_t * ps_parse_mb_data = ps_dec->ps_parse_mb_data 438 + u1_num_mbsNby2; 439 WORD8 * pi1_ref_idx = ps_parse_mb_data->i1_ref_idx[0]; 440 const UWORD8 * pu1_num_mb_part = (const UWORD8 *)gau1_ih264d_num_mb_part; 441 const UWORD32 u1_mb_type = ps_cur_mb_info->u1_mb_type; 442 UWORD8 * pu1_col_info = ps_parse_mb_data->u1_col_info; 443 UWORD32 u1_mb_mc_mode = u1_mb_type; 444 ctxt_inc_mb_info_t * p_curr_ctxt = ps_dec->ps_curr_ctxt_mb_info; 445 decoding_envirnoment_t * ps_cab_env = &ps_dec->s_cab_dec_env; 446 dec_bit_stream_t * ps_bitstrm = ps_dec->ps_bitstrm; 447 UWORD32 u4_sub_mb_pack = 0; 448 WORD32 ret; 449 450 UWORD8 u1_no_submb_part_size_lt8x8_flag = 1; 451 ps_cur_mb_info->u1_tran_form8x8 = 0; 452 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0; 453 454 ps_cur_mb_info->u1_yuv_dc_block_flag = 0; 455 456 p_curr_ctxt->u1_mb_type = CAB_P; 457 ps_cur_mb_info->u1_mb_mc_mode = u1_mb_type; 458 uc_sub_mb = ((u1_mb_type == PRED_8x8) | (u1_mb_type == PRED_8x8R0)); 459 460 /* Reading the subMB type */ 461 if(uc_sub_mb) 462 { 463 464 UWORD8 u1_colz = (PRED_8x8 << 6); 465 u1_mb_mc_mode = 0; 466 467 { 468 UWORD8 u1_sub_mb_mode; 469 u1_sub_mb_mode = ih264d_parse_submb_type_cabac( 470 0, ps_cab_env, ps_bitstrm, 471 ps_dec->p_sub_mb_type_t); 472 if(u1_sub_mb_mode > 3) 473 return ERROR_SUB_MB_TYPE; 474 475 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode; 476 /* Storing collocated information */ 477 *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4)); 478 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode); 479 /* check if Motion compensation is done below 8x8 */ 480 if(u1_sub_mb_mode != P_L0_8x8) 481 { 482 u1_no_submb_part_size_lt8x8_flag = 0; 483 } 484 } 485 { 486 UWORD8 u1_sub_mb_mode; 487 u1_sub_mb_mode = ih264d_parse_submb_type_cabac( 488 0, ps_cab_env, ps_bitstrm, 489 ps_dec->p_sub_mb_type_t); 490 if(u1_sub_mb_mode > 3) 491 return ERROR_SUB_MB_TYPE; 492 493 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode; 494 /* Storing collocated information */ 495 *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4)); 496 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode); 497 /* check if Motion compensation is done below 8x8 */ 498 if(u1_sub_mb_mode != P_L0_8x8) 499 { 500 u1_no_submb_part_size_lt8x8_flag = 0; 501 } 502 } 503 { 504 UWORD8 u1_sub_mb_mode; 505 u1_sub_mb_mode = ih264d_parse_submb_type_cabac( 506 0, ps_cab_env, ps_bitstrm, 507 ps_dec->p_sub_mb_type_t); 508 if(u1_sub_mb_mode > 3) 509 return ERROR_SUB_MB_TYPE; 510 511 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode; 512 /* Storing collocated information */ 513 *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4)); 514 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode); 515 /* check if Motion compensation is done below 8x8 */ 516 if(u1_sub_mb_mode != P_L0_8x8) 517 { 518 u1_no_submb_part_size_lt8x8_flag = 0; 519 } 520 } 521 { 522 UWORD8 u1_sub_mb_mode; 523 u1_sub_mb_mode = ih264d_parse_submb_type_cabac( 524 0, ps_cab_env, ps_bitstrm, 525 ps_dec->p_sub_mb_type_t); 526 if(u1_sub_mb_mode > 3) 527 return ERROR_SUB_MB_TYPE; 528 529 u4_sub_mb_pack = (u4_sub_mb_pack << 8) | u1_sub_mb_mode; 530 /* Storing collocated information */ 531 *pu1_col_info++ = u1_colz | ((UWORD8)(u1_sub_mb_mode << 4)); 532 COPYTHECONTEXT("sub_mb_type", u1_sub_mb_mode); 533 /* check if Motion compensation is done below 8x8 */ 534 if(u1_sub_mb_mode != P_L0_8x8) 535 { 536 u1_no_submb_part_size_lt8x8_flag = 0; 537 } 538 } 539 u1_num_mb_part = 4; 540 } 541 else 542 { 543 u1_num_mb_part = pu1_num_mb_part[u1_mb_type]; 544 /* Storing collocated Mb and SubMb mode information */ 545 *pu1_col_info++ = (u1_mb_type << 6); 546 if(u1_mb_type) 547 *pu1_col_info++ = (u1_mb_type << 6); 548 } 549 /* Decoding reference index 0: For simple profile the following */ 550 /* conditions are always true (mb_field_decoding_flag == 0); */ 551 /* (MbPartPredMode != PredL1) */ 552 { 553 WORD8 * pi1_top_ref_idx_ctx_inc_arr = p_curr_ctxt->i1_ref_idx; 554 WORD8 * pi1_left_ref_idx_ctxt_inc = ps_dec->pi1_left_ref_idx_ctxt_inc; 555 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; 556 UWORD8 uc_field = ps_cur_mb_info->u1_mb_field_decodingflag; 557 UWORD8 uc_num_ref_idx_l0_active_minus1 = 558 (ps_dec->ps_cur_slice->u1_num_ref_idx_lx_active[0] 559 << (u1_mbaff & uc_field)) - 1; 560 561 if((uc_num_ref_idx_l0_active_minus1 > 0) & (u1_mb_type != PRED_8x8R0)) 562 { 563 /* force the routine to decode ref idx for each partition */ 564 *((UWORD32 *)pi1_ref_idx) = 0x01010101; 565 ret = ih264d_parse_ref_idx_cabac(u1_num_mb_part, 0, 566 uc_num_ref_idx_l0_active_minus1, 567 u1_mb_mc_mode, pi1_ref_idx, 568 pi1_left_ref_idx_ctxt_inc, 569 pi1_top_ref_idx_ctx_inc_arr, ps_cab_env, 570 ps_bitstrm, ps_dec->p_ref_idx_t); 571 if(ret != OK) 572 return ret; 573 } 574 else 575 { 576 /* When there exists only a single frame to predict from */ 577 pi1_left_ref_idx_ctxt_inc[0] = 0; 578 pi1_left_ref_idx_ctxt_inc[1] = 0; 579 pi1_top_ref_idx_ctx_inc_arr[0] = 0; 580 pi1_top_ref_idx_ctx_inc_arr[1] = 0; 581 *((UWORD32 *)pi1_ref_idx) = 0; 582 } 583 } 584 585 { 586 UWORD8 u1_p_idx, uc_i; 587 parse_part_params_t * ps_part = ps_dec->ps_part; 588 UWORD8 u1_sub_mb_mode, u1_num_subpart, u1_mb_part_width, u1_mb_part_height; 589 UWORD8 u1_sub_mb_num; 590 const UWORD8 * pu1_top_left_sub_mb_indx; 591 mv_pred_t *ps_mv_start = ps_dec->ps_mv_cur + (u1_mb_num << 4); 592 UWORD16 u2_sub_mb_num_pack = 0x028A; 593 594 /* Loading the table pointers */ 595 const UWORD8 * pu1_mb_partw = (const UWORD8 *)gau1_ih264d_mb_partw; 596 const UWORD8 * pu1_mb_parth = (const UWORD8 *)gau1_ih264d_mb_parth; 597 const UWORD8 * pu1_sub_mb_indx_mod = 598 (const UWORD8 *)(gau1_ih264d_submb_indx_mod) 599 + (uc_sub_mb * 6); 600 const UWORD8 * pu1_sub_mb_partw = (const UWORD8 *)gau1_ih264d_submb_partw; 601 const UWORD8 * pu1_sub_mb_parth = (const UWORD8 *)gau1_ih264d_submb_parth; 602 const UWORD8 * pu1_num_sub_mb_part = 603 (const UWORD8 *)gau1_ih264d_num_submb_part; 604 605 /*********************************************************/ 606 /* default initialisations for condition (uc_sub_mb == 0) */ 607 /* i.e. all are subpartitions of 8x8 */ 608 /*********************************************************/ 609 u1_sub_mb_mode = 0; 610 u1_num_subpart = 1; 611 u1_mb_part_width = pu1_mb_partw[u1_mb_type]; 612 u1_mb_part_height = pu1_mb_parth[u1_mb_type]; 613 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_mb_type << 1); 614 u1_sub_mb_num = 0; 615 616 /* Loop on number of partitions */ 617 for(uc_i = 0, u1_p_idx = 0; uc_i < u1_num_mb_part; uc_i++) 618 { 619 UWORD8 uc_j; 620 if(uc_sub_mb) 621 { 622 u1_sub_mb_mode = u4_sub_mb_pack >> 24; 623 u1_num_subpart = pu1_num_sub_mb_part[u1_sub_mb_mode]; 624 u1_mb_part_width = pu1_sub_mb_partw[u1_sub_mb_mode]; 625 u1_mb_part_height = pu1_sub_mb_parth[u1_sub_mb_mode]; 626 pu1_top_left_sub_mb_indx = pu1_sub_mb_indx_mod + (u1_sub_mb_mode << 1); 627 u1_sub_mb_num = u2_sub_mb_num_pack >> 12; 628 u4_sub_mb_pack <<= 8; 629 u2_sub_mb_num_pack <<= 4; 630 } 631 /* Loop on Number of sub-partitions */ 632 for(uc_j = 0; uc_j < u1_num_subpart; uc_j++, pu1_top_left_sub_mb_indx++) 633 { 634 mv_pred_t * ps_mv; 635 636 u1_sub_mb_num += *pu1_top_left_sub_mb_indx; 637 ps_mv = ps_mv_start + u1_sub_mb_num; 638 639 /* Storing Info for partitions */ 640 ps_part->u1_is_direct = PART_NOT_DIRECT; 641 ps_part->u1_sub_mb_num = u1_sub_mb_num; 642 ps_part->u1_partheight = u1_mb_part_height; 643 ps_part->u1_partwidth = u1_mb_part_width; 644 645 /* Increment partition Index */ 646 u1_p_idx++; 647 ps_part++; 648 649 ih264d_get_mvd_cabac(u1_sub_mb_num, 0, u1_mb_part_width, 650 u1_mb_part_height, 1, ps_dec, ps_mv); 651 } 652 } 653 ps_parse_mb_data->u1_num_part = u1_p_idx; 654 ps_dec->ps_part = ps_part; 655 } 656 { 657 UWORD8 u1_cbp; 658 659 /* Read the Coded block pattern */ 660 u1_cbp = (WORD8)ih264d_parse_ctx_cbp_cabac(ps_dec); 661 COPYTHECONTEXT("coded_block_pattern", u1_cbp); 662 ps_cur_mb_info->u1_cbp = u1_cbp; 663 p_curr_ctxt->u1_cbp = u1_cbp; 664 p_curr_ctxt->u1_intra_chroma_pred_mode = 0; 665 p_curr_ctxt->u1_yuv_dc_csbp &= 0xFE; 666 ps_dec->pu1_left_yuv_dc_csbp[0] &= 0x6; 667 668 if(u1_cbp > 47) 669 return ERROR_CBP; 670 671 ps_cur_mb_info->u1_tran_form8x8 = 0; 672 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0; 673 674 /* Read the transform8x8 u4_flag if present */ 675 if((ps_dec->s_high_profile.u1_transform8x8_present) && (u1_cbp & 0xf) 676 && u1_no_submb_part_size_lt8x8_flag) 677 { 678 ps_cur_mb_info->u1_tran_form8x8 = ih264d_parse_transform8x8flag_cabac( 679 ps_dec, ps_cur_mb_info); 680 COPYTHECONTEXT("transform_size_8x8_flag", ps_cur_mb_info->u1_tran_form8x8); 681 p_curr_ctxt->u1_transform8x8_ctxt = ps_cur_mb_info->u1_tran_form8x8; 682 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = ps_cur_mb_info->u1_tran_form8x8; 683 684 } 685 else 686 { 687 p_curr_ctxt->u1_transform8x8_ctxt = 0; 688 } 689 690 /* Read mb_qp_delta */ 691 if(u1_cbp) 692 { 693 WORD8 c_temp; 694 ret = ih264d_parse_mb_qp_delta_cabac(ps_dec, &c_temp); 695 if(ret != OK) 696 return ret; 697 COPYTHECONTEXT("mb_qp_delta", c_temp); 698 if(c_temp != 0) 699 { 700 ret = ih264d_update_qp(ps_dec, c_temp); 701 if(ret != OK) 702 return ret; 703 } 704 } 705 else 706 ps_dec->i1_prev_mb_qp_delta = 0; 707 708 709 710 ih264d_parse_residual4x4_cabac(ps_dec, ps_cur_mb_info, 0); 711 if(EXCEED_OFFSET(ps_dec->ps_bitstrm)) 712 return ERROR_EOB_TERMINATE_T; 713 } 714 return OK; 715 } 716 717 /*! 718 ************************************************************************** 719 * \if Function name : parsePSliceData \endif 720 * 721 * \brief 722 * This function parses CAVLC syntax of N MB's of a P slice. 723 * 1. After parsing syntax of N MB's, for those N MB's (less than N, incase 724 * of end of slice or end of row), MB is decoded. This process is carried 725 * for one complete MB row or till end of slice. 726 * 2. Bottom one row of current MB is copied to IntraPredLine buffers. 727 * IntraPredLine buffers are used for Intra prediction of next row. 728 * 3. Current MB row along with previous 4 rows of Luma (and 2 of Chroma) are 729 * deblocked. 730 * 4. 4 rows (2 for Chroma) previous row and 12 rows (6 for Chroma) are 731 * DMA'ed to picture buffers. 732 * 733 * \return 734 * 0 on Success and Error code otherwise 735 ************************************************************************** 736 */ 737 738 /*! 739 ************************************************************************** 740 * \if Function name : ih264d_update_nnz_for_skipmb \endif 741 * 742 * \brief 743 * 744 * \return 745 * None 746 * 747 ************************************************************************** 748 */ 749 void ih264d_update_nnz_for_skipmb(dec_struct_t * ps_dec, 750 dec_mb_info_t * ps_cur_mb_info, 751 UWORD8 u1_entrpy) 752 { 753 UWORD32 *pu4_buf; 754 UWORD8 *pu1_buf; 755 UNUSED(u1_entrpy); 756 pu1_buf = ps_dec->pu1_left_nnz_y; 757 pu4_buf = (UWORD32 *)pu1_buf; 758 *pu4_buf = 0; 759 pu1_buf = ps_dec->pu1_left_nnz_uv; 760 pu4_buf = (UWORD32 *)pu1_buf; 761 *pu4_buf = 0; 762 pu1_buf = ps_cur_mb_info->ps_curmb->pu1_nnz_y; 763 pu4_buf = (UWORD32 *)pu1_buf; 764 *pu4_buf = 0; 765 pu1_buf = ps_cur_mb_info->ps_curmb->pu1_nnz_uv; 766 pu4_buf = (UWORD32 *)pu1_buf; 767 *pu4_buf = 0; 768 ps_cur_mb_info->ps_curmb->u2_luma_csbp = 0; 769 ps_cur_mb_info->u2_luma_csbp = 0; 770 ps_cur_mb_info->u2_chroma_csbp = 0; 771 } 772 773 774 775 /*****************************************************************************/ 776 /* */ 777 /* Function Name : ih264d_parse_inter_slice_data_cabac */ 778 /* */ 779 /* Description : This function parses cabac syntax of a inter slice on */ 780 /* N MB basis. */ 781 /* */ 782 /* Inputs : ps_dec */ 783 /* sliceparams */ 784 /* firstMbInSlice */ 785 /* */ 786 /* Processing : 1. After parsing syntax for N MBs those N MBs are */ 787 /* decoded till the end of slice. */ 788 /* 2. MV prediction and DMA happens on a N/2 MB basis. */ 789 /* */ 790 /* Returns : 0 */ 791 /* */ 792 /* Issues : <List any issues or problems with this function> */ 793 /* */ 794 /* Revision History: */ 795 /* */ 796 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 797 /* 13 07 2002 Jay Draft */ 798 /* */ 799 /*****************************************************************************/ 800 WORD32 ih264d_parse_inter_slice_data_cabac(dec_struct_t * ps_dec, 801 dec_slice_params_t * ps_slice, 802 UWORD16 u2_first_mb_in_slice) 803 { 804 UWORD32 uc_more_data_flag; 805 WORD32 i2_cur_mb_addr; 806 UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx; 807 UWORD32 u1_mbaff; 808 UWORD32 u1_num_mbs_next, u1_end_of_row; 809 const UWORD16 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs; 810 UWORD32 u1_slice_end = 0; 811 UWORD32 u1_tfr_n_mb = 0; 812 UWORD32 u1_decode_nmb = 0; 813 814 815 deblk_mb_t *ps_cur_deblk_mb; 816 dec_mb_info_t *ps_cur_mb_info; 817 818 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data; 819 UWORD32 u1_inter_mb_skip_type; 820 UWORD32 u1_inter_mb_type; 821 UWORD32 u1_deblk_mb_type; 822 UWORD32 u1_mb_threshold; 823 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 824 WORD32 ret = OK; 825 826 /******************************************************/ 827 /* Initialisations specific to B or P slice */ 828 /******************************************************/ 829 if(ps_slice->u1_slice_type == P_SLICE) 830 { 831 u1_inter_mb_skip_type = CAB_P_SKIP; 832 u1_inter_mb_type = P_MB; 833 u1_deblk_mb_type = D_INTER_MB; 834 u1_mb_threshold = 5; 835 } 836 else // B_SLICE 837 { 838 u1_inter_mb_skip_type = CAB_B_SKIP; 839 u1_inter_mb_type = B_MB; 840 u1_deblk_mb_type = D_B_SLICE; 841 u1_mb_threshold = 23; 842 } 843 844 /******************************************************/ 845 /* Slice Level Initialisations */ 846 /******************************************************/ 847 i2_cur_mb_addr = u2_first_mb_in_slice; 848 ps_dec->u1_qp = ps_slice->u1_slice_qp; 849 ih264d_update_qp(ps_dec, 0); 850 u1_mb_idx = ps_dec->u1_mb_idx; 851 u1_num_mbs = u1_mb_idx; 852 u1_num_mbsNby2 = 0; 853 u1_mbaff = ps_slice->u1_mbaff_frame_flag; 854 i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff; 855 uc_more_data_flag = 1; 856 857 /* Initialisations specific to cabac */ 858 if(ps_bitstrm->u4_ofst & 0x07) 859 { 860 ps_bitstrm->u4_ofst += 8; 861 ps_bitstrm->u4_ofst &= 0xFFFFFFF8; 862 } 863 864 ret = ih264d_init_cabac_dec_envirnoment(&(ps_dec->s_cab_dec_env), ps_bitstrm); 865 if(ret != OK) 866 return ret; 867 868 ps_dec->i1_prev_mb_qp_delta = 0; 869 870 while(!u1_slice_end) 871 { 872 UWORD8 u1_mb_type; 873 UWORD32 u4_mb_skip; 874 875 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data; 876 877 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr) 878 { 879 break; 880 } 881 882 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs; 883 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs; 884 885 ps_cur_mb_info->u1_Mux = 0; 886 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff); 887 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs; 888 889 ps_cur_mb_info->u1_end_of_slice = 0; 890 891 /* Storing Default partition info */ 892 ps_parse_mb_data->u1_num_part = 1; 893 ps_parse_mb_data->u1_isI_mb = 0; 894 895 /***************************************************************/ 896 /* Get the required information for decoding of MB */ 897 /* mb_x, mb_y , neighbour availablity, */ 898 /***************************************************************/ 899 u4_mb_skip = ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 1); 900 901 /*********************************************************************/ 902 /* initialize u1_tran_form8x8 to zero to aviod uninitialized accesses */ 903 /*********************************************************************/ 904 ps_cur_mb_info->u1_tran_form8x8 = 0; 905 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0; 906 907 /***************************************************************/ 908 /* Set the deblocking parameters for this MB */ 909 /***************************************************************/ 910 if(ps_dec->u4_app_disable_deblk_frm == 0) 911 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice, 912 ps_dec->u1_mb_ngbr_availablity, 913 ps_dec->u1_cur_mb_fld_dec_flag); 914 915 if(u4_mb_skip) 916 { 917 918 /* Set appropriate flags in ps_cur_mb_info and ps_dec */ 919 memset(ps_dec->ps_curr_ctxt_mb_info, 0, sizeof(ctxt_inc_mb_info_t)); 920 ps_dec->ps_curr_ctxt_mb_info->u1_mb_type = u1_inter_mb_skip_type; 921 922 MEMSET_16BYTES(&ps_dec->pu1_left_mv_ctxt_inc[0][0], 0); 923 924 *((UWORD32 *)ps_dec->pi1_left_ref_idx_ctxt_inc) = 0; 925 *(ps_dec->pu1_left_yuv_dc_csbp) = 0; 926 927 ps_dec->i1_prev_mb_qp_delta = 0; 928 ps_cur_mb_info->u1_mb_type = MB_SKIP; 929 ps_cur_mb_info->u1_cbp = 0; 930 931 { 932 /* Storing Skip partition info */ 933 parse_part_params_t *ps_part_info = ps_dec->ps_part; 934 ps_part_info->u1_is_direct = PART_DIRECT_16x16; 935 ps_part_info->u1_sub_mb_num = 0; 936 ps_dec->ps_part++; 937 } 938 939 /* Update Nnzs */ 940 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CABAC); 941 942 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type; 943 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type; 944 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp; 945 946 } 947 else 948 { 949 950 /* Macroblock Layer Begins */ 951 /* Decode the u1_mb_type */ 952 u1_mb_type = ih264d_parse_mb_type_cabac(ps_dec); 953 ps_cur_mb_info->u1_mb_type = u1_mb_type; 954 if(u1_mb_type > (25 + u1_mb_threshold)) 955 return ERROR_MB_TYPE; 956 957 /* Parse Macroblock Data */ 958 if(u1_mb_type < u1_mb_threshold) 959 { 960 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type; 961 *(ps_dec->pu1_left_yuv_dc_csbp) &= 0x6; 962 963 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs, 964 u1_num_mbsNby2); 965 if(ret != OK) 966 return ret; 967 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp; 968 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type; 969 } 970 else 971 { 972 /* Storing Intra partition info */ 973 ps_parse_mb_data->u1_num_part = 0; 974 ps_parse_mb_data->u1_isI_mb = 1; 975 976 if((25 + u1_mb_threshold) == u1_mb_type) 977 { 978 /* I_PCM_MB */ 979 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB; 980 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs); 981 if(ret != OK) 982 return ret; 983 ps_cur_deblk_mb->u1_mb_qp = 0; 984 } 985 else 986 { 987 if(u1_mb_type == u1_mb_threshold) 988 ps_cur_mb_info->ps_curmb->u1_mb_type = I_4x4_MB; 989 else 990 ps_cur_mb_info->ps_curmb->u1_mb_type = I_16x16_MB; 991 992 ret = ih264d_parse_imb_cabac( 993 ps_dec, ps_cur_mb_info, 994 (UWORD8)(u1_mb_type - u1_mb_threshold)); 995 if(ret != OK) 996 return ret; 997 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp; 998 } 999 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB; 1000 1001 } 1002 1003 } 1004 1005 if(u1_mbaff) 1006 { 1007 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info); 1008 } 1009 /* Next macroblock information */ 1010 i2_cur_mb_addr++; 1011 1012 if(ps_cur_mb_info->u1_topmb && u1_mbaff) 1013 uc_more_data_flag = 1; 1014 else 1015 { 1016 uc_more_data_flag = ih264d_decode_terminate(&ps_dec->s_cab_dec_env, 1017 ps_bitstrm); 1018 uc_more_data_flag = !uc_more_data_flag; 1019 COPYTHECONTEXT("Decode Sliceterm",!uc_more_data_flag); 1020 } 1021 1022 u1_num_mbs++; 1023 u1_num_mbsNby2++; 1024 ps_parse_mb_data++; 1025 1026 /****************************************************************/ 1027 /* Check for End Of Row and other flags that determine when to */ 1028 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */ 1029 /* N-Mb */ 1030 /****************************************************************/ 1031 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1; 1032 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01))); 1033 u1_slice_end = !uc_more_data_flag; 1034 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row 1035 || u1_slice_end; 1036 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end; 1037 ps_cur_mb_info->u1_end_of_slice = u1_slice_end; 1038 /*u1_dma_nby2mb = u1_decode_nmb || 1039 (u1_num_mbsNby2 == ps_dec->u1_recon_mb_grp_pair);*/ 1040 1041 //if(u1_dma_nby2mb) 1042 if(u1_decode_nmb) 1043 { 1044 1045 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs); 1046 u1_num_mbsNby2 = 0; 1047 1048 { 1049 ps_parse_mb_data = ps_dec->ps_parse_mb_data; 1050 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1051 } 1052 } 1053 1054 /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d", 1055 ps_slice->i4_poc >> ps_slice->u1_field_pic_flag, 1056 ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb)); 1057 H264_DEC_DEBUG_PRINT("u1_decode_nmb: %d, u1_num_mbs: %d", u1_decode_nmb, u1_num_mbs);*/ 1058 if(u1_decode_nmb) 1059 { 1060 1061 if(ps_dec->u1_separate_parse) 1062 { 1063 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1064 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row); 1065 ps_dec->ps_nmb_info += u1_num_mbs; 1066 } 1067 else 1068 { 1069 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1070 u1_num_mbs_next, u1_tfr_n_mb, 1071 u1_end_of_row); 1072 } 1073 ps_dec->u2_total_mbs_coded += u1_num_mbs; 1074 if(u1_tfr_n_mb) 1075 u1_num_mbs = 0; 1076 u1_mb_idx = u1_num_mbs; 1077 ps_dec->u1_mb_idx = u1_num_mbs; 1078 1079 } 1080 } 1081 1082 1083 ps_dec->u4_num_mbs_cur_nmb = 0; 1084 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr 1085 1086 - (u2_first_mb_in_slice << u1_mbaff); 1087 1088 return ret; 1089 } 1090 1091 /*****************************************************************************/ 1092 /* */ 1093 /* Function Name : ih264d_parse_inter_slice_data_cavlc */ 1094 /* */ 1095 /* Description : This function parses cavlc syntax of a inter slice on */ 1096 /* N MB basis. */ 1097 /* */ 1098 /* Inputs : ps_dec */ 1099 /* sliceparams */ 1100 /* firstMbInSlice */ 1101 /* */ 1102 /* Processing : 1. After parsing syntax for N MBs those N MBs are */ 1103 /* decoded till the end of slice. */ 1104 /* 2. MV prediction and DMA happens on a N/2 MB basis. */ 1105 /* */ 1106 /* Returns : 0 */ 1107 /* */ 1108 /* Issues : <List any issues or problems with this function> */ 1109 /* */ 1110 /* Revision History: */ 1111 /* */ 1112 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1113 /* 13 07 2002 Jay Draft */ 1114 /* */ 1115 /*****************************************************************************/ 1116 1117 WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec, 1118 dec_slice_params_t * ps_slice, 1119 UWORD16 u2_first_mb_in_slice) 1120 { 1121 UWORD32 uc_more_data_flag; 1122 WORD32 i2_cur_mb_addr; 1123 UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx; 1124 UWORD32 i2_mb_skip_run; 1125 UWORD32 u1_read_mb_type; 1126 1127 UWORD32 u1_mbaff; 1128 UWORD32 u1_num_mbs_next, u1_end_of_row; 1129 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs; 1130 UWORD32 u1_slice_end = 0; 1131 UWORD32 u1_tfr_n_mb = 0; 1132 UWORD32 u1_decode_nmb = 0; 1133 1134 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 1135 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1136 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst; 1137 deblk_mb_t *ps_cur_deblk_mb; 1138 dec_mb_info_t *ps_cur_mb_info; 1139 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data; 1140 UWORD32 u1_inter_mb_type; 1141 UWORD32 u1_deblk_mb_type; 1142 UWORD32 u1_mb_threshold; 1143 WORD32 ret = OK; 1144 1145 /******************************************************/ 1146 /* Initialisations specific to B or P slice */ 1147 /******************************************************/ 1148 1149 if(ps_slice->u1_slice_type == P_SLICE) 1150 { 1151 u1_inter_mb_type = P_MB; 1152 u1_deblk_mb_type = D_INTER_MB; 1153 u1_mb_threshold = 5; 1154 } 1155 else // B_SLICE 1156 { 1157 u1_inter_mb_type = B_MB; 1158 u1_deblk_mb_type = D_B_SLICE; 1159 u1_mb_threshold = 23; 1160 } 1161 /******************************************************/ 1162 /* Slice Level Initialisations */ 1163 /******************************************************/ 1164 ps_dec->u1_qp = ps_slice->u1_slice_qp; 1165 ih264d_update_qp(ps_dec, 0); 1166 u1_mb_idx = ps_dec->u1_mb_idx; 1167 u1_num_mbs = u1_mb_idx; 1168 1169 u1_num_mbsNby2 = 0; 1170 u1_mbaff = ps_slice->u1_mbaff_frame_flag; 1171 i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff; 1172 i2_mb_skip_run = 0; 1173 uc_more_data_flag = 1; 1174 u1_read_mb_type = 0; 1175 1176 while(!u1_slice_end) 1177 { 1178 UWORD8 u1_mb_type; 1179 1180 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data; 1181 1182 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr) 1183 { 1184 break; 1185 } 1186 1187 1188 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs; 1189 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs; 1190 1191 ps_cur_mb_info->u1_Mux = 0; 1192 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff); 1193 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs; 1194 1195 ps_cur_mb_info->u1_end_of_slice = 0; 1196 1197 /* Storing Default partition info */ 1198 ps_parse_mb_data->u1_num_part = 1; 1199 ps_parse_mb_data->u1_isI_mb = 0; 1200 1201 if((!i2_mb_skip_run) && (!u1_read_mb_type)) 1202 { 1203 1204 //Inlined ih264d_uev 1205 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; 1206 UWORD32 u4_word, u4_ldz; 1207 1208 /***************************************************************/ 1209 /* Find leading zeros in next 32 bits */ 1210 /***************************************************************/ 1211 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); 1212 1213 u4_ldz = CLZ(u4_word); 1214 1215 /* Flush the ps_bitstrm */ 1216 u4_bitstream_offset += (u4_ldz + 1); 1217 /* Read the suffix from the ps_bitstrm */ 1218 u4_word = 0; 1219 if(u4_ldz) 1220 { 1221 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, 1222 u4_ldz); 1223 } 1224 *pu4_bitstrm_ofst = u4_bitstream_offset; 1225 i2_mb_skip_run = ((1 << u4_ldz) + u4_word - 1); 1226 //Inlined ih264d_uev 1227 COPYTHECONTEXT("mb_skip_run", i2_mb_skip_run); 1228 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm); 1229 u1_read_mb_type = uc_more_data_flag; 1230 } 1231 1232 /***************************************************************/ 1233 /* Get the required information for decoding of MB */ 1234 /* mb_x, mb_y , neighbour availablity, */ 1235 /***************************************************************/ 1236 ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run); 1237 1238 /***************************************************************/ 1239 /* Set the deblocking parameters for this MB */ 1240 /***************************************************************/ 1241 if(ps_dec->u4_app_disable_deblk_frm == 0) 1242 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice, 1243 ps_dec->u1_mb_ngbr_availablity, 1244 ps_dec->u1_cur_mb_fld_dec_flag); 1245 1246 if(i2_mb_skip_run) 1247 { 1248 /* Set appropriate flags in ps_cur_mb_info and ps_dec */ 1249 ps_dec->i1_prev_mb_qp_delta = 0; 1250 ps_dec->u1_sub_mb_num = 0; 1251 ps_cur_mb_info->u1_mb_type = MB_SKIP; 1252 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16; 1253 ps_cur_mb_info->u1_cbp = 0; 1254 1255 { 1256 /* Storing Skip partition info */ 1257 parse_part_params_t *ps_part_info = ps_dec->ps_part; 1258 ps_part_info->u1_is_direct = PART_DIRECT_16x16; 1259 ps_part_info->u1_sub_mb_num = 0; 1260 ps_dec->ps_part++; 1261 } 1262 1263 /* Update Nnzs */ 1264 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC); 1265 1266 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type; 1267 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type; 1268 1269 i2_mb_skip_run--; 1270 } 1271 else 1272 { 1273 u1_read_mb_type = 0; 1274 /**************************************************************/ 1275 /* Macroblock Layer Begins, Decode the u1_mb_type */ 1276 /**************************************************************/ 1277 { 1278 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; 1279 UWORD32 u4_word, u4_ldz, u4_temp; 1280 1281 1282 //Inlined ih264d_uev 1283 /***************************************************************/ 1284 /* Find leading zeros in next 32 bits */ 1285 /***************************************************************/ 1286 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); 1287 u4_ldz = CLZ(u4_word); 1288 /* Flush the ps_bitstrm */ 1289 u4_bitstream_offset += (u4_ldz + 1); 1290 /* Read the suffix from the ps_bitstrm */ 1291 u4_word = 0; 1292 if(u4_ldz) 1293 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, 1294 u4_ldz); 1295 *pu4_bitstrm_ofst = u4_bitstream_offset; 1296 u4_temp = ((1 << u4_ldz) + u4_word - 1); 1297 //Inlined ih264d_uev 1298 if(u4_temp > (UWORD32)(25 + u1_mb_threshold)) 1299 return ERROR_MB_TYPE; 1300 u1_mb_type = u4_temp; 1301 COPYTHECONTEXT("u1_mb_type", u1_mb_type); 1302 } 1303 ps_cur_mb_info->u1_mb_type = u1_mb_type; 1304 1305 /**************************************************************/ 1306 /* Parse Macroblock data */ 1307 /**************************************************************/ 1308 if(u1_mb_type < u1_mb_threshold) 1309 { 1310 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type; 1311 1312 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs, 1313 u1_num_mbsNby2); 1314 if(ret != OK) 1315 return ret; 1316 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type; 1317 } 1318 else 1319 { 1320 /* Storing Intra partition info */ 1321 ps_parse_mb_data->u1_num_part = 0; 1322 ps_parse_mb_data->u1_isI_mb = 1; 1323 1324 if((25 + u1_mb_threshold) == u1_mb_type) 1325 { 1326 /* I_PCM_MB */ 1327 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB; 1328 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs); 1329 if(ret != OK) 1330 return ret; 1331 ps_dec->u1_qp = 0; 1332 } 1333 else 1334 { 1335 ret = ih264d_parse_imb_cavlc( 1336 ps_dec, ps_cur_mb_info, u1_num_mbs, 1337 (UWORD8)(u1_mb_type - u1_mb_threshold)); 1338 if(ret != OK) 1339 return ret; 1340 } 1341 1342 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB; 1343 } 1344 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm); 1345 } 1346 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp; 1347 1348 if(u1_mbaff) 1349 { 1350 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info); 1351 } 1352 /**************************************************************/ 1353 /* Get next Macroblock address */ 1354 /**************************************************************/ 1355 i2_cur_mb_addr++; 1356 1357 u1_num_mbs++; 1358 u1_num_mbsNby2++; 1359 ps_parse_mb_data++; 1360 1361 /****************************************************************/ 1362 /* Check for End Of Row and other flags that determine when to */ 1363 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */ 1364 /* N-Mb */ 1365 /****************************************************************/ 1366 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1; 1367 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01))); 1368 u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run)); 1369 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row 1370 || u1_slice_end; 1371 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end; 1372 ps_cur_mb_info->u1_end_of_slice = u1_slice_end; 1373 1374 /*u1_dma_nby2mb = u1_decode_nmb || 1375 (u1_num_mbsNby2 == ps_dec->u1_recon_mb_grp_pair);*/ 1376 1377 //if(u1_dma_nby2mb) 1378 if(u1_decode_nmb) 1379 { 1380 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs); 1381 u1_num_mbsNby2 = 0; 1382 1383 { 1384 ps_parse_mb_data = ps_dec->ps_parse_mb_data; 1385 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1386 } 1387 } 1388 1389 /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d", 1390 ps_slice->i4_poc >> ps_slice->u1_field_pic_flag, 1391 ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb)); 1392 H264_DEC_DEBUG_PRINT("u1_decode_nmb: %d", u1_decode_nmb);*/ 1393 if(u1_decode_nmb) 1394 { 1395 1396 1397 1398 if(ps_dec->u1_separate_parse) 1399 { 1400 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1401 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row); 1402 ps_dec->ps_nmb_info += u1_num_mbs; 1403 } 1404 else 1405 { 1406 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1407 u1_num_mbs_next, u1_tfr_n_mb, 1408 u1_end_of_row); 1409 } 1410 ps_dec->u2_total_mbs_coded += u1_num_mbs; 1411 if(u1_tfr_n_mb) 1412 u1_num_mbs = 0; 1413 u1_mb_idx = u1_num_mbs; 1414 ps_dec->u1_mb_idx = u1_num_mbs; 1415 1416 } 1417 //ps_dec->ps_pred++; 1418 } 1419 1420 ps_dec->u4_num_mbs_cur_nmb = 0; 1421 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr 1422 - (u2_first_mb_in_slice << u1_mbaff); 1423 1424 1425 return ret; 1426 } 1427 1428 WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec, 1429 WORD32 num_mb_skip, 1430 UWORD8 u1_is_idr_slice, 1431 UWORD16 u2_frame_num, 1432 pocstruct_t *ps_cur_poc, 1433 WORD32 prev_slice_err) 1434 { 1435 WORD32 i2_cur_mb_addr; 1436 UWORD32 u1_num_mbs, u1_num_mbsNby2; 1437 UWORD32 u1_mb_idx = ps_dec->u1_mb_idx; 1438 UWORD32 i2_mb_skip_run; 1439 1440 UWORD32 u1_num_mbs_next, u1_end_of_row; 1441 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs; 1442 UWORD32 u1_slice_end; 1443 UWORD32 u1_tfr_n_mb; 1444 UWORD32 u1_decode_nmb; 1445 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 1446 dec_slice_params_t * ps_slice = ps_dec->ps_cur_slice; 1447 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1448 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst; 1449 deblk_mb_t *ps_cur_deblk_mb; 1450 dec_mb_info_t *ps_cur_mb_info; 1451 parse_pmbarams_t *ps_parse_mb_data; 1452 UWORD32 u1_inter_mb_type; 1453 UWORD32 u1_deblk_mb_type; 1454 UWORD16 u2_total_mbs_coded; 1455 UWORD32 u1_mbaff = ps_slice->u1_mbaff_frame_flag; 1456 parse_part_params_t *ps_part_info; 1457 WORD32 ret; 1458 1459 1460 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC) 1461 { 1462 ih264d_err_pic_dispbuf_mgr(ps_dec); 1463 return 0; 1464 } 1465 ps_dec->ps_dpb_cmds->u1_long_term_reference_flag = 0; 1466 if(prev_slice_err == 1) 1467 { 1468 /* first slice - missing/header corruption */ 1469 ps_dec->ps_cur_slice->u2_frame_num = u2_frame_num; 1470 1471 1472 if(!ps_dec->u1_first_slice_in_stream) 1473 { 1474 ih264d_end_of_pic(ps_dec, u1_is_idr_slice, 1475 ps_dec->ps_cur_slice->u2_frame_num); 1476 ps_dec->s_cur_pic_poc.u2_frame_num = 1477 ps_dec->ps_cur_slice->u2_frame_num; 1478 } 1479 1480 { 1481 WORD32 i, j, poc = 0; 1482 1483 ps_dec->ps_cur_slice->u2_first_mb_in_slice = 0; 1484 1485 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff; 1486 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp; 1487 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp; 1488 1489 if(ps_dec->ps_cur_pic != NULL) 1490 poc = ps_dec->ps_cur_pic->i4_poc + 2; 1491 1492 j = 0; 1493 for(i = 0; i < MAX_NUM_PIC_PARAMS; i++) 1494 if(ps_dec->ps_pps[i].u1_is_valid == TRUE) 1495 j = i; 1496 { 1497 //initialize slice params required by ih264d_start_of_pic to valid values 1498 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE; 1499 ps_dec->ps_cur_slice->u1_nal_ref_idc = 1; 1500 ps_dec->ps_cur_slice->u1_nal_unit_type = 1; 1501 ret = ih264d_start_of_pic(ps_dec, poc, ps_cur_poc, 1502 ps_dec->ps_cur_slice->u2_frame_num, 1503 &ps_dec->ps_pps[j]); 1504 1505 if(ret != OK) 1506 { 1507 return ret; 1508 } 1509 } 1510 1511 ps_dec->ps_ref_pic_buf_lx[0][0]->u1_pic_buf_id = 0; 1512 1513 ps_dec->u4_output_present = 0; 1514 1515 { 1516 ih264d_get_next_display_field(ps_dec, 1517 ps_dec->ps_out_buffer, 1518 &(ps_dec->s_disp_op)); 1519 /* If error code is non-zero then there is no buffer available for display, 1520 hence avoid format conversion */ 1521 1522 if(0 != ps_dec->s_disp_op.u4_error_code) 1523 { 1524 ps_dec->u4_fmt_conv_cur_row = ps_dec->s_disp_frame_info.u4_y_ht; 1525 } 1526 else 1527 ps_dec->u4_output_present = 1; 1528 } 1529 1530 if(ps_dec->u1_separate_parse == 1) 1531 { 1532 if(ps_dec->u4_dec_thread_created == 0) 1533 { 1534 ithread_create(ps_dec->pv_dec_thread_handle, NULL, 1535 (void *)ih264d_decode_picture_thread, 1536 (void *)ps_dec); 1537 1538 ps_dec->u4_dec_thread_created = 1; 1539 } 1540 1541 if((ps_dec->u4_num_cores == 3) && 1542 ((ps_dec->u4_app_disable_deblk_frm == 0) || ps_dec->i1_recon_in_thread3_flag) 1543 && (ps_dec->u4_bs_deblk_thread_created == 0)) 1544 { 1545 ps_dec->u4_start_recon_deblk = 0; 1546 ithread_create(ps_dec->pv_bs_deblk_thread_handle, NULL, 1547 (void *)ih264d_recon_deblk_thread, 1548 (void *)ps_dec); 1549 ps_dec->u4_bs_deblk_thread_created = 1; 1550 } 1551 } 1552 } 1553 ps_dec->u4_first_slice_in_pic = 0; 1554 } 1555 else 1556 { 1557 // Middle / last slice 1558 1559 dec_slice_struct_t *ps_parse_cur_slice; 1560 ps_parse_cur_slice = ps_dec->ps_dec_slice_buf + ps_dec->u2_cur_slice_num; 1561 1562 if(ps_dec->u1_slice_header_done 1563 && ps_parse_cur_slice == ps_dec->ps_parse_cur_slice) 1564 { 1565 // Slice data corrupted 1566 u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb; 1567 1568 if(u1_num_mbs) 1569 { 1570 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs - 1; 1571 } 1572 else 1573 { 1574 if(ps_dec->u1_separate_parse) 1575 { 1576 ps_cur_mb_info = ps_dec->ps_nmb_info - 1; 1577 } 1578 else 1579 { 1580 ps_cur_mb_info = ps_dec->ps_nmb_info 1581 + ps_dec->u4_num_mbs_prev_nmb - 1; 1582 } 1583 } 1584 1585 ps_dec->u2_mby = ps_cur_mb_info->u2_mby; 1586 ps_dec->u2_mbx = ps_cur_mb_info->u2_mbx; 1587 1588 ps_dec->u1_mb_ngbr_availablity = 1589 ps_cur_mb_info->u1_mb_ngbr_availablity; 1590 1591 // Going back 1 mb 1592 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data; 1593 ps_dec->u2_cur_mb_addr--; 1594 ps_dec->i4_submb_ofst -= SUB_BLK_SIZE; 1595 1596 if(u1_num_mbs) 1597 { 1598 // Parse/decode N-MB left unparsed 1599 if (ps_dec->u1_pr_sl_type == P_SLICE 1600 || ps_dec->u1_pr_sl_type == B_SLICE) 1601 { 1602 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs); 1603 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1604 } 1605 1606 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1; 1607 u1_end_of_row = (!u1_num_mbs_next) 1608 && (!(u1_mbaff && (u1_num_mbs & 0x01))); 1609 u1_slice_end = 1; 1610 u1_tfr_n_mb = 1; 1611 ps_cur_mb_info->u1_end_of_slice = u1_slice_end; 1612 1613 if(ps_dec->u1_separate_parse) 1614 { 1615 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1616 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row); 1617 ps_dec->ps_nmb_info += u1_num_mbs; 1618 } 1619 else 1620 { 1621 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1622 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row); 1623 } 1624 ps_dec->u2_total_mbs_coded += u1_num_mbs; 1625 ps_dec->u1_mb_idx = 0; 1626 ps_dec->u4_num_mbs_cur_nmb = 0; 1627 } 1628 1629 if(ps_dec->u2_total_mbs_coded 1630 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) 1631 { 1632 ps_dec->u1_pic_decode_done = 1; 1633 return 0; 1634 } 1635 1636 // Inserting new slice 1637 ps_dec->u2_cur_slice_num++; 1638 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx; 1639 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby; 1640 ps_dec->ps_parse_cur_slice++; 1641 1642 } 1643 else 1644 { 1645 // Slice missing / header corrupted 1646 ps_dec->ps_parse_cur_slice = ps_dec->ps_dec_slice_buf 1647 + ps_dec->u2_cur_slice_num; 1648 } 1649 } 1650 1651 /******************************************************/ 1652 /* Initializations to new slice */ 1653 /******************************************************/ 1654 { 1655 WORD32 num_entries; 1656 WORD32 size; 1657 UWORD8 *pu1_buf; 1658 1659 num_entries = MAX_FRAMES; 1660 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) && 1661 (0 == ps_dec->i4_display_delay)) 1662 { 1663 num_entries = 1; 1664 } 1665 num_entries = ((2 * num_entries) + 1); 1666 if(BASE_PROFILE_IDC != ps_dec->ps_cur_sps->u1_profile_idc) 1667 { 1668 num_entries *= 2; 1669 } 1670 size = num_entries * sizeof(void *); 1671 size += PAD_MAP_IDX_POC * sizeof(void *); 1672 1673 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf; 1674 pu1_buf += size * ps_dec->u2_cur_slice_num; 1675 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **)pu1_buf; 1676 } 1677 1678 ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded << u1_mbaff; 1679 ps_dec->ps_cur_slice->i1_slice_alpha_c0_offset = 0; 1680 ps_dec->ps_cur_slice->i1_slice_beta_offset = 0; 1681 1682 if(ps_dec->ps_cur_slice->u1_field_pic_flag) 1683 ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num; 1684 1685 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded << u1_mbaff; 1686 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd; 1687 1688 1689 if(ps_dec->u1_separate_parse) 1690 { 1691 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data; 1692 } 1693 else 1694 { 1695 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data; 1696 } 1697 1698 /******************************************************/ 1699 /* Initializations specific to P slice */ 1700 /******************************************************/ 1701 u1_inter_mb_type = P_MB; 1702 u1_deblk_mb_type = D_INTER_MB; 1703 1704 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE; 1705 ps_dec->ps_parse_cur_slice->slice_type = P_SLICE; 1706 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb; 1707 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1708 1709 /******************************************************/ 1710 /* Parsing / decoding the slice */ 1711 /******************************************************/ 1712 ps_dec->u1_slice_header_done = 2; 1713 ps_dec->u1_qp = ps_slice->u1_slice_qp; 1714 ih264d_update_qp(ps_dec, 0); 1715 u1_mb_idx = ps_dec->u1_mb_idx; 1716 ps_parse_mb_data = ps_dec->ps_parse_mb_data; 1717 u1_num_mbs = u1_mb_idx; 1718 1719 u1_slice_end = 0; 1720 u1_tfr_n_mb = 0; 1721 u1_decode_nmb = 0; 1722 u1_num_mbsNby2 = 0; 1723 i2_cur_mb_addr = ps_dec->u2_total_mbs_coded; 1724 i2_mb_skip_run = num_mb_skip; 1725 1726 while(!u1_slice_end) 1727 { 1728 UWORD8 u1_mb_type; 1729 1730 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr) 1731 break; 1732 1733 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs; 1734 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs; 1735 1736 ps_cur_mb_info->u1_Mux = 0; 1737 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff); 1738 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs; 1739 1740 ps_cur_mb_info->u1_end_of_slice = 0; 1741 1742 /* Storing Default partition info */ 1743 ps_parse_mb_data->u1_num_part = 1; 1744 ps_parse_mb_data->u1_isI_mb = 0; 1745 1746 /**************************************************************/ 1747 /* Get the required information for decoding of MB */ 1748 /**************************************************************/ 1749 /* mb_x, mb_y, neighbor availablity, */ 1750 if (u1_mbaff) 1751 ih264d_get_mb_info_cavlc_mbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run); 1752 else 1753 ih264d_get_mb_info_cavlc_nonmbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run); 1754 1755 /* Set the deblocking parameters for this MB */ 1756 if(ps_dec->u4_app_disable_deblk_frm == 0) 1757 { 1758 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice, 1759 ps_dec->u1_mb_ngbr_availablity, 1760 ps_dec->u1_cur_mb_fld_dec_flag); 1761 } 1762 1763 /* Set appropriate flags in ps_cur_mb_info and ps_dec */ 1764 ps_dec->i1_prev_mb_qp_delta = 0; 1765 ps_dec->u1_sub_mb_num = 0; 1766 ps_cur_mb_info->u1_mb_type = MB_SKIP; 1767 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16; 1768 ps_cur_mb_info->u1_cbp = 0; 1769 1770 /* Storing Skip partition info */ 1771 ps_part_info = ps_dec->ps_part; 1772 ps_part_info->u1_is_direct = PART_DIRECT_16x16; 1773 ps_part_info->u1_sub_mb_num = 0; 1774 ps_dec->ps_part++; 1775 1776 /* Update Nnzs */ 1777 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC); 1778 1779 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type; 1780 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type; 1781 1782 i2_mb_skip_run--; 1783 1784 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp; 1785 1786 if (u1_mbaff) 1787 { 1788 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info); 1789 } 1790 1791 /**************************************************************/ 1792 /* Get next Macroblock address */ 1793 /**************************************************************/ 1794 i2_cur_mb_addr++; 1795 1796 u1_num_mbs++; 1797 u1_num_mbsNby2++; 1798 ps_parse_mb_data++; 1799 1800 /****************************************************************/ 1801 /* Check for End Of Row and other flags that determine when to */ 1802 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */ 1803 /* N-Mb */ 1804 /****************************************************************/ 1805 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1; 1806 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01))); 1807 u1_slice_end = !i2_mb_skip_run; 1808 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row 1809 || u1_slice_end; 1810 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end; 1811 ps_cur_mb_info->u1_end_of_slice = u1_slice_end; 1812 1813 if(u1_decode_nmb) 1814 { 1815 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs); 1816 u1_num_mbsNby2 = 0; 1817 1818 ps_parse_mb_data = ps_dec->ps_parse_mb_data; 1819 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1820 1821 if(ps_dec->u1_separate_parse) 1822 { 1823 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1824 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row); 1825 ps_dec->ps_nmb_info += u1_num_mbs; 1826 } 1827 else 1828 { 1829 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next, 1830 u1_tfr_n_mb, u1_end_of_row); 1831 } 1832 ps_dec->u2_total_mbs_coded += u1_num_mbs; 1833 if(u1_tfr_n_mb) 1834 u1_num_mbs = 0; 1835 u1_mb_idx = u1_num_mbs; 1836 ps_dec->u1_mb_idx = u1_num_mbs; 1837 } 1838 } 1839 1840 ps_dec->u4_num_mbs_cur_nmb = 0; 1841 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr 1842 - ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice; 1843 1844 H264_DEC_DEBUG_PRINT("Mbs in slice: %d\n", ps_dec->ps_cur_slice->u4_mbs_in_slice); 1845 1846 1847 /* incremented here only if first slice is inserted */ 1848 if(ps_dec->u4_first_slice_in_pic != 0) 1849 { 1850 ps_dec->ps_parse_cur_slice++; 1851 ps_dec->u2_cur_slice_num++; 1852 } 1853 1854 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx; 1855 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby; 1856 1857 if(ps_dec->u2_total_mbs_coded 1858 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) 1859 { 1860 ps_dec->u1_pic_decode_done = 1; 1861 } 1862 1863 return 0; 1864 1865 } 1866 1867 /*! 1868 ************************************************************************** 1869 * \if Function name : ih264d_decode_pslice \endif 1870 * 1871 * \brief 1872 * Decodes a P Slice 1873 * 1874 * 1875 * \return 1876 * 0 on Success and Error code otherwise 1877 ************************************************************************** 1878 */ 1879 WORD32 ih264d_parse_pslice(dec_struct_t *ps_dec, UWORD16 u2_first_mb_in_slice) 1880 { 1881 dec_pic_params_t * ps_pps = ps_dec->ps_cur_pps; 1882 dec_slice_params_t * ps_cur_slice = ps_dec->ps_cur_slice; 1883 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm; 1884 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1885 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst; 1886 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; //ps_dec->ps_cur_sps->u1_mb_aff_flag; 1887 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag; 1888 1889 UWORD32 u4_temp; 1890 WORD32 i_temp; 1891 WORD32 ret; 1892 1893 /*--------------------------------------------------------------------*/ 1894 /* Read remaining contents of the slice header */ 1895 /*--------------------------------------------------------------------*/ 1896 { 1897 WORD8 *pi1_buf; 1898 WORD16 *pi2_mv = ps_dec->s_default_mv_pred.i2_mv; 1899 WORD32 *pi4_mv = (WORD32*)pi2_mv; 1900 WORD16 *pi16_refFrame; 1901 1902 pi1_buf = ps_dec->s_default_mv_pred.i1_ref_frame; 1903 pi16_refFrame = (WORD16*)pi1_buf; 1904 *pi4_mv = 0; 1905 *(pi4_mv + 1) = 0; 1906 *pi16_refFrame = OUT_OF_RANGE_REF; 1907 ps_dec->s_default_mv_pred.u1_col_ref_pic_idx = (UWORD8)-1; 1908 ps_dec->s_default_mv_pred.u1_pic_type = (UWORD8)-1; 1909 } 1910 1911 ps_cur_slice->u1_num_ref_idx_active_override_flag = ih264d_get_bit_h264( 1912 ps_bitstrm); 1913 1914 COPYTHECONTEXT("SH: num_ref_idx_override_flag", 1915 ps_cur_slice->u1_num_ref_idx_active_override_flag); 1916 1917 u4_temp = ps_dec->ps_cur_pps->u1_num_ref_idx_lx_active[0]; 1918 if(ps_cur_slice->u1_num_ref_idx_active_override_flag) 1919 { 1920 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf) + 1; 1921 } 1922 1923 { 1924 1925 1926 1927 UWORD8 u1_max_ref_idx = MAX_FRAMES << u1_field_pic_flag; 1928 if(u4_temp > u1_max_ref_idx) 1929 { 1930 return ERROR_NUM_REF; 1931 } 1932 ps_cur_slice->u1_num_ref_idx_lx_active[0] = u4_temp; 1933 COPYTHECONTEXT("SH: num_ref_idx_l0_active_minus1", 1934 ps_cur_slice->u1_num_ref_idx_lx_active[0] - 1); 1935 1936 } 1937 1938 { 1939 UWORD8 uc_refIdxReFlagL0 = ih264d_get_bit_h264(ps_bitstrm); 1940 COPYTHECONTEXT("SH: ref_pic_list_reordering_flag_l0",uc_refIdxReFlagL0); 1941 1942 /* Initialize the Reference list once in Picture if the slice type */ 1943 /* of first slice is between 5 to 9 defined in table 7.3 of standard */ 1944 /* If picture contains both P & B slices then Initialize the Reference*/ 1945 /* List only when it switches from P to B and B to P */ 1946 { 1947 UWORD8 init_idx_flg = (ps_dec->u1_pr_sl_type 1948 != ps_dec->ps_cur_slice->u1_slice_type); 1949 if(ps_dec->u1_first_pb_nal_in_pic 1950 || (init_idx_flg & !ps_dec->u1_sl_typ_5_9) 1951 || ps_dec->u1_num_ref_idx_lx_active_prev 1952 != ps_cur_slice->u1_num_ref_idx_lx_active[0]) 1953 { 1954 ih264d_init_ref_idx_lx_p(ps_dec); 1955 } 1956 if(ps_dec->u1_first_pb_nal_in_pic & ps_dec->u1_sl_typ_5_9) 1957 ps_dec->u1_first_pb_nal_in_pic = 0; 1958 } 1959 /* Store the value for future slices in the same picture */ 1960 ps_dec->u1_num_ref_idx_lx_active_prev = 1961 ps_cur_slice->u1_num_ref_idx_lx_active[0]; 1962 1963 /* Modified temporarily */ 1964 if(uc_refIdxReFlagL0) 1965 { 1966 WORD8 ret; 1967 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0]; 1968 ret = ih264d_ref_idx_reordering(ps_dec, 0); 1969 if(ret == -1) 1970 return ERROR_REFIDX_ORDER_T; 1971 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0]; 1972 } 1973 else 1974 ps_dec->ps_ref_pic_buf_lx[0] = 1975 ps_dec->ps_dpb_mgr->ps_init_dpb[0]; 1976 } 1977 /* Create refIdx to POC mapping */ 1978 { 1979 void **pui_map_ref_idx_to_poc_lx0, **pui_map_ref_idx_to_poc_lx1; 1980 WORD8 idx; 1981 struct pic_buffer_t *ps_pic; 1982 1983 pui_map_ref_idx_to_poc_lx0 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L0; 1984 pui_map_ref_idx_to_poc_lx0[0] = 0; //For ref_idx = -1 1985 pui_map_ref_idx_to_poc_lx0++; 1986 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++) 1987 { 1988 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx]; 1989 pui_map_ref_idx_to_poc_lx0[idx] = (ps_pic->pu1_buf1); 1990 } 1991 1992 /* Bug Fix Deblocking */ 1993 pui_map_ref_idx_to_poc_lx1 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L1; 1994 pui_map_ref_idx_to_poc_lx1[0] = 0; 1995 1996 if(u1_mbaff) 1997 { 1998 void **ppv_map_ref_idx_to_poc_lx_t, **ppv_map_ref_idx_to_poc_lx_b; 1999 void **ppv_map_ref_idx_to_poc_lx_t1, **ppv_map_ref_idx_to_poc_lx_b1; 2000 ppv_map_ref_idx_to_poc_lx_t = ps_dec->ppv_map_ref_idx_to_poc 2001 + TOP_LIST_FLD_L0; 2002 ppv_map_ref_idx_to_poc_lx_b = ps_dec->ppv_map_ref_idx_to_poc 2003 + BOT_LIST_FLD_L0; 2004 2005 ppv_map_ref_idx_to_poc_lx_t[0] = 0; // For ref_idx = -1 2006 ppv_map_ref_idx_to_poc_lx_t++; 2007 ppv_map_ref_idx_to_poc_lx_b[0] = 0; // For ref_idx = -1 2008 ppv_map_ref_idx_to_poc_lx_b++; 2009 2010 idx = 0; 2011 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++) 2012 { 2013 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx]; 2014 ppv_map_ref_idx_to_poc_lx_t[0] = (ps_pic->pu1_buf1); 2015 ppv_map_ref_idx_to_poc_lx_b[1] = (ps_pic->pu1_buf1); 2016 2017 ppv_map_ref_idx_to_poc_lx_b[0] = (ps_pic->pu1_buf1) + 1; 2018 ppv_map_ref_idx_to_poc_lx_t[1] = (ps_pic->pu1_buf1) + 1; 2019 2020 ppv_map_ref_idx_to_poc_lx_t += 2; 2021 ppv_map_ref_idx_to_poc_lx_b += 2; 2022 } 2023 ppv_map_ref_idx_to_poc_lx_t1 = ps_dec->ppv_map_ref_idx_to_poc 2024 + TOP_LIST_FLD_L1; 2025 ppv_map_ref_idx_to_poc_lx_t1[0] = 0; 2026 ppv_map_ref_idx_to_poc_lx_b1 = ps_dec->ppv_map_ref_idx_to_poc 2027 + BOT_LIST_FLD_L1; 2028 ppv_map_ref_idx_to_poc_lx_b1[0] = 0; 2029 2030 } 2031 2032 if(ps_dec->u4_num_cores >= 3) 2033 { 2034 WORD32 num_entries; 2035 WORD32 size; 2036 2037 num_entries = MAX_FRAMES; 2038 if((1 >= ps_dec->ps_cur_sps->u1_num_ref_frames) && 2039 (0 == ps_dec->i4_display_delay)) 2040 { 2041 num_entries = 1; 2042 } 2043 num_entries = ((2 * num_entries) + 1); 2044 if(BASE_PROFILE_IDC != ps_dec->ps_cur_sps->u1_profile_idc) 2045 { 2046 num_entries *= 2; 2047 } 2048 2049 size = num_entries * sizeof(void *); 2050 size += PAD_MAP_IDX_POC * sizeof(void *); 2051 2052 memcpy((void *)ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc, 2053 ps_dec->ppv_map_ref_idx_to_poc, 2054 size); 2055 } 2056 2057 2058 } 2059 if(ps_pps->u1_wted_pred_flag) 2060 { 2061 ret = ih264d_parse_pred_weight_table(ps_cur_slice, ps_bitstrm); 2062 if(ret != OK) 2063 return ret; 2064 ih264d_form_pred_weight_matrix(ps_dec); 2065 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat; 2066 } 2067 else 2068 { 2069 ps_dec->ps_cur_slice->u2_log2Y_crwd = 0; 2070 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat; 2071 } 2072 2073 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = 2074 ps_dec->ps_cur_slice->u2_log2Y_crwd; 2075 2076 if(u1_mbaff && (u1_field_pic_flag == 0)) 2077 { 2078 ih264d_convert_frm_mbaff_list(ps_dec); 2079 } 2080 2081 /* G050 */ 2082 if(ps_cur_slice->u1_nal_ref_idc != 0) 2083 { 2084 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read) 2085 { 2086 i_temp = ih264d_read_mmco_commands(ps_dec); 2087 if (i_temp < 0) 2088 { 2089 return ERROR_DBP_MANAGER_T; 2090 } 2091 ps_dec->u4_bitoffset = i_temp; 2092 } 2093 else 2094 ps_bitstrm->u4_ofst += ps_dec->u4_bitoffset; 2095 2096 } 2097 /* G050 */ 2098 2099 if(ps_pps->u1_entropy_coding_mode == CABAC) 2100 { 2101 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 2102 2103 if(u4_temp > MAX_CABAC_INIT_IDC) 2104 { 2105 return ERROR_INV_SLICE_HDR_T; 2106 } 2107 ps_cur_slice->u1_cabac_init_idc = u4_temp; 2108 COPYTHECONTEXT("SH: cabac_init_idc",ps_cur_slice->u1_cabac_init_idc); 2109 } 2110 2111 /* Read slice_qp_delta */ 2112 i_temp = ps_pps->u1_pic_init_qp 2113 + ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 2114 if((i_temp < 0) || (i_temp > 51)) 2115 { 2116 return ERROR_INV_RANGE_QP_T; 2117 } 2118 ps_cur_slice->u1_slice_qp = i_temp; 2119 COPYTHECONTEXT("SH: slice_qp_delta", 2120 (WORD8)(ps_cur_slice->u1_slice_qp - ps_pps->u1_pic_init_qp)); 2121 2122 if(ps_pps->u1_deblocking_filter_parameters_present_flag == 1) 2123 { 2124 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 2125 if(u4_temp > SLICE_BOUNDARY_DBLK_DISABLED) 2126 { 2127 return ERROR_INV_SLICE_HDR_T; 2128 } 2129 2130 COPYTHECONTEXT("SH: disable_deblocking_filter_idc", u4_temp); 2131 ps_cur_slice->u1_disable_dblk_filter_idc = u4_temp; 2132 if(u4_temp != 1) 2133 { 2134 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf) 2135 << 1; 2136 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF)) 2137 { 2138 return ERROR_INV_SLICE_HDR_T; 2139 } 2140 ps_cur_slice->i1_slice_alpha_c0_offset = i_temp; 2141 COPYTHECONTEXT("SH: slice_alpha_c0_offset_div2", 2142 ps_cur_slice->i1_slice_alpha_c0_offset >> 1); 2143 2144 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf) 2145 << 1; 2146 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF)) 2147 { 2148 return ERROR_INV_SLICE_HDR_T; 2149 } 2150 ps_cur_slice->i1_slice_beta_offset = i_temp; 2151 COPYTHECONTEXT("SH: slice_beta_offset_div2", 2152 ps_cur_slice->i1_slice_beta_offset >> 1); 2153 } 2154 else 2155 { 2156 ps_cur_slice->i1_slice_alpha_c0_offset = 0; 2157 ps_cur_slice->i1_slice_beta_offset = 0; 2158 } 2159 } 2160 else 2161 { 2162 ps_cur_slice->u1_disable_dblk_filter_idc = 0; 2163 ps_cur_slice->i1_slice_alpha_c0_offset = 0; 2164 ps_cur_slice->i1_slice_beta_offset = 0; 2165 } 2166 2167 ps_dec->u1_slice_header_done = 2; 2168 2169 if(ps_pps->u1_entropy_coding_mode) 2170 { 2171 SWITCHOFFTRACE; SWITCHONTRACECABAC; 2172 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cabac; 2173 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cabac; 2174 ih264d_init_cabac_contexts(P_SLICE, ps_dec); 2175 2176 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag) 2177 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_mbaff; 2178 else 2179 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_nonmbaff; 2180 } 2181 else 2182 { 2183 SWITCHONTRACE; SWITCHOFFTRACECABAC; 2184 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cavlc; 2185 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cavlc; 2186 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag) 2187 { 2188 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_mbaff; 2189 } 2190 else 2191 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_nonmbaff; 2192 } 2193 2194 ps_dec->u1_B = 0; 2195 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb; 2196 ret = ps_dec->pf_parse_inter_slice(ps_dec, ps_cur_slice, u2_first_mb_in_slice); 2197 if(ret != OK) 2198 return ret; 2199 // ps_dec->curr_slice_in_error = 0 ; 2200 return OK; 2201 } 2202
