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 ret = ERROR_MB_ADDRESS_T; 880 break; 881 } 882 883 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs; 884 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs; 885 886 ps_cur_mb_info->u1_Mux = 0; 887 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff); 888 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs; 889 890 ps_cur_mb_info->u1_end_of_slice = 0; 891 892 /* Storing Default partition info */ 893 ps_parse_mb_data->u1_num_part = 1; 894 ps_parse_mb_data->u1_isI_mb = 0; 895 896 /***************************************************************/ 897 /* Get the required information for decoding of MB */ 898 /* mb_x, mb_y , neighbour availablity, */ 899 /***************************************************************/ 900 u4_mb_skip = ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, 1); 901 902 /*********************************************************************/ 903 /* initialize u1_tran_form8x8 to zero to aviod uninitialized accesses */ 904 /*********************************************************************/ 905 ps_cur_mb_info->u1_tran_form8x8 = 0; 906 ps_cur_mb_info->ps_curmb->u1_tran_form8x8 = 0; 907 908 /***************************************************************/ 909 /* Set the deblocking parameters for this MB */ 910 /***************************************************************/ 911 if(ps_dec->u4_app_disable_deblk_frm == 0) 912 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice, 913 ps_dec->u1_mb_ngbr_availablity, 914 ps_dec->u1_cur_mb_fld_dec_flag); 915 916 if(u4_mb_skip) 917 { 918 919 /* Set appropriate flags in ps_cur_mb_info and ps_dec */ 920 memset(ps_dec->ps_curr_ctxt_mb_info, 0, sizeof(ctxt_inc_mb_info_t)); 921 ps_dec->ps_curr_ctxt_mb_info->u1_mb_type = u1_inter_mb_skip_type; 922 923 MEMSET_16BYTES(&ps_dec->pu1_left_mv_ctxt_inc[0][0], 0); 924 925 *((UWORD32 *)ps_dec->pi1_left_ref_idx_ctxt_inc) = 0; 926 *(ps_dec->pu1_left_yuv_dc_csbp) = 0; 927 928 ps_dec->i1_prev_mb_qp_delta = 0; 929 ps_cur_mb_info->u1_mb_type = MB_SKIP; 930 ps_cur_mb_info->u1_cbp = 0; 931 932 { 933 /* Storing Skip partition info */ 934 parse_part_params_t *ps_part_info = ps_dec->ps_part; 935 ps_part_info->u1_is_direct = PART_DIRECT_16x16; 936 ps_part_info->u1_sub_mb_num = 0; 937 ps_dec->ps_part++; 938 } 939 940 /* Update Nnzs */ 941 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CABAC); 942 943 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type; 944 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type; 945 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp; 946 947 } 948 else 949 { 950 951 /* Macroblock Layer Begins */ 952 /* Decode the u1_mb_type */ 953 u1_mb_type = ih264d_parse_mb_type_cabac(ps_dec); 954 ps_cur_mb_info->u1_mb_type = u1_mb_type; 955 if(u1_mb_type > (25 + u1_mb_threshold)) 956 return ERROR_MB_TYPE; 957 958 /* Parse Macroblock Data */ 959 if(u1_mb_type < u1_mb_threshold) 960 { 961 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type; 962 *(ps_dec->pu1_left_yuv_dc_csbp) &= 0x6; 963 964 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs, 965 u1_num_mbsNby2); 966 if(ret != OK) 967 return ret; 968 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp; 969 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type; 970 } 971 else 972 { 973 /* Storing Intra partition info */ 974 ps_parse_mb_data->u1_num_part = 0; 975 ps_parse_mb_data->u1_isI_mb = 1; 976 977 if((25 + u1_mb_threshold) == u1_mb_type) 978 { 979 /* I_PCM_MB */ 980 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB; 981 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs); 982 if(ret != OK) 983 return ret; 984 ps_cur_deblk_mb->u1_mb_qp = 0; 985 } 986 else 987 { 988 if(u1_mb_type == u1_mb_threshold) 989 ps_cur_mb_info->ps_curmb->u1_mb_type = I_4x4_MB; 990 else 991 ps_cur_mb_info->ps_curmb->u1_mb_type = I_16x16_MB; 992 993 ret = ih264d_parse_imb_cabac( 994 ps_dec, ps_cur_mb_info, 995 (UWORD8)(u1_mb_type - u1_mb_threshold)); 996 if(ret != OK) 997 return ret; 998 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp; 999 } 1000 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB; 1001 1002 } 1003 1004 } 1005 1006 if(u1_mbaff) 1007 { 1008 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info); 1009 } 1010 /* Next macroblock information */ 1011 i2_cur_mb_addr++; 1012 1013 if(ps_cur_mb_info->u1_topmb && u1_mbaff) 1014 uc_more_data_flag = 1; 1015 else 1016 { 1017 uc_more_data_flag = ih264d_decode_terminate(&ps_dec->s_cab_dec_env, 1018 ps_bitstrm); 1019 uc_more_data_flag = !uc_more_data_flag; 1020 COPYTHECONTEXT("Decode Sliceterm",!uc_more_data_flag); 1021 } 1022 1023 u1_num_mbs++; 1024 ps_dec->u2_total_mbs_coded++; 1025 u1_num_mbsNby2++; 1026 ps_parse_mb_data++; 1027 1028 /****************************************************************/ 1029 /* Check for End Of Row and other flags that determine when to */ 1030 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */ 1031 /* N-Mb */ 1032 /****************************************************************/ 1033 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1; 1034 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01))); 1035 u1_slice_end = !uc_more_data_flag; 1036 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row 1037 || u1_slice_end; 1038 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end; 1039 ps_cur_mb_info->u1_end_of_slice = u1_slice_end; 1040 /*u1_dma_nby2mb = u1_decode_nmb || 1041 (u1_num_mbsNby2 == ps_dec->u1_recon_mb_grp_pair);*/ 1042 1043 //if(u1_dma_nby2mb) 1044 if(u1_decode_nmb) 1045 { 1046 1047 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs); 1048 u1_num_mbsNby2 = 0; 1049 1050 { 1051 ps_parse_mb_data = ps_dec->ps_parse_mb_data; 1052 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1053 } 1054 } 1055 1056 /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d", 1057 ps_slice->i4_poc >> ps_slice->u1_field_pic_flag, 1058 ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb)); 1059 H264_DEC_DEBUG_PRINT("u1_decode_nmb: %d, u1_num_mbs: %d", u1_decode_nmb, u1_num_mbs);*/ 1060 if(u1_decode_nmb) 1061 { 1062 1063 if(ps_dec->u1_separate_parse) 1064 { 1065 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1066 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row); 1067 ps_dec->ps_nmb_info += u1_num_mbs; 1068 } 1069 else 1070 { 1071 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1072 u1_num_mbs_next, u1_tfr_n_mb, 1073 u1_end_of_row); 1074 } 1075 1076 if(u1_tfr_n_mb) 1077 u1_num_mbs = 0; 1078 u1_mb_idx = u1_num_mbs; 1079 ps_dec->u1_mb_idx = u1_num_mbs; 1080 1081 } 1082 } 1083 1084 1085 ps_dec->u4_num_mbs_cur_nmb = 0; 1086 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr 1087 1088 - (u2_first_mb_in_slice << u1_mbaff); 1089 1090 return ret; 1091 } 1092 1093 /*****************************************************************************/ 1094 /* */ 1095 /* Function Name : ih264d_parse_inter_slice_data_cavlc */ 1096 /* */ 1097 /* Description : This function parses cavlc syntax of a inter slice on */ 1098 /* N MB basis. */ 1099 /* */ 1100 /* Inputs : ps_dec */ 1101 /* sliceparams */ 1102 /* firstMbInSlice */ 1103 /* */ 1104 /* Processing : 1. After parsing syntax for N MBs those N MBs are */ 1105 /* decoded till the end of slice. */ 1106 /* 2. MV prediction and DMA happens on a N/2 MB basis. */ 1107 /* */ 1108 /* Returns : 0 */ 1109 /* */ 1110 /* Issues : <List any issues or problems with this function> */ 1111 /* */ 1112 /* Revision History: */ 1113 /* */ 1114 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1115 /* 13 07 2002 Jay Draft */ 1116 /* */ 1117 /*****************************************************************************/ 1118 1119 WORD32 ih264d_parse_inter_slice_data_cavlc(dec_struct_t * ps_dec, 1120 dec_slice_params_t * ps_slice, 1121 UWORD16 u2_first_mb_in_slice) 1122 { 1123 UWORD32 uc_more_data_flag; 1124 WORD32 i2_cur_mb_addr; 1125 UWORD32 u1_num_mbs, u1_num_mbsNby2, u1_mb_idx; 1126 UWORD32 i2_mb_skip_run; 1127 UWORD32 u1_read_mb_type; 1128 1129 UWORD32 u1_mbaff; 1130 UWORD32 u1_num_mbs_next, u1_end_of_row; 1131 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs; 1132 UWORD32 u1_slice_end = 0; 1133 UWORD32 u1_tfr_n_mb = 0; 1134 UWORD32 u1_decode_nmb = 0; 1135 1136 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 1137 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1138 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst; 1139 deblk_mb_t *ps_cur_deblk_mb; 1140 dec_mb_info_t *ps_cur_mb_info; 1141 parse_pmbarams_t *ps_parse_mb_data = ps_dec->ps_parse_mb_data; 1142 UWORD32 u1_inter_mb_type; 1143 UWORD32 u1_deblk_mb_type; 1144 UWORD32 u1_mb_threshold; 1145 WORD32 ret = OK; 1146 1147 /******************************************************/ 1148 /* Initialisations specific to B or P slice */ 1149 /******************************************************/ 1150 1151 if(ps_slice->u1_slice_type == P_SLICE) 1152 { 1153 u1_inter_mb_type = P_MB; 1154 u1_deblk_mb_type = D_INTER_MB; 1155 u1_mb_threshold = 5; 1156 } 1157 else // B_SLICE 1158 { 1159 u1_inter_mb_type = B_MB; 1160 u1_deblk_mb_type = D_B_SLICE; 1161 u1_mb_threshold = 23; 1162 } 1163 /******************************************************/ 1164 /* Slice Level Initialisations */ 1165 /******************************************************/ 1166 ps_dec->u1_qp = ps_slice->u1_slice_qp; 1167 ih264d_update_qp(ps_dec, 0); 1168 u1_mb_idx = ps_dec->u1_mb_idx; 1169 u1_num_mbs = u1_mb_idx; 1170 1171 u1_num_mbsNby2 = 0; 1172 u1_mbaff = ps_slice->u1_mbaff_frame_flag; 1173 i2_cur_mb_addr = u2_first_mb_in_slice << u1_mbaff; 1174 i2_mb_skip_run = 0; 1175 uc_more_data_flag = 1; 1176 u1_read_mb_type = 0; 1177 1178 while(!u1_slice_end) 1179 { 1180 UWORD8 u1_mb_type; 1181 1182 ps_dec->pv_prev_mb_parse_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data; 1183 1184 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr) 1185 { 1186 ret = ERROR_MB_ADDRESS_T; 1187 break; 1188 } 1189 1190 1191 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs; 1192 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs; 1193 1194 ps_cur_mb_info->u1_Mux = 0; 1195 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff); 1196 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs; 1197 1198 ps_cur_mb_info->u1_end_of_slice = 0; 1199 1200 /* Storing Default partition info */ 1201 ps_parse_mb_data->u1_num_part = 1; 1202 ps_parse_mb_data->u1_isI_mb = 0; 1203 1204 if((!i2_mb_skip_run) && (!u1_read_mb_type)) 1205 { 1206 1207 //Inlined ih264d_uev 1208 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; 1209 UWORD32 u4_word, u4_ldz; 1210 1211 /***************************************************************/ 1212 /* Find leading zeros in next 32 bits */ 1213 /***************************************************************/ 1214 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); 1215 1216 u4_ldz = CLZ(u4_word); 1217 1218 /* Flush the ps_bitstrm */ 1219 u4_bitstream_offset += (u4_ldz + 1); 1220 /* Read the suffix from the ps_bitstrm */ 1221 u4_word = 0; 1222 if(u4_ldz) 1223 { 1224 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, 1225 u4_ldz); 1226 } 1227 *pu4_bitstrm_ofst = u4_bitstream_offset; 1228 i2_mb_skip_run = ((1 << u4_ldz) + u4_word - 1); 1229 //Inlined ih264d_uev 1230 COPYTHECONTEXT("mb_skip_run", i2_mb_skip_run); 1231 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm); 1232 u1_read_mb_type = uc_more_data_flag; 1233 } 1234 1235 /***************************************************************/ 1236 /* Get the required information for decoding of MB */ 1237 /* mb_x, mb_y , neighbour availablity, */ 1238 /***************************************************************/ 1239 ps_dec->pf_get_mb_info(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run); 1240 1241 /***************************************************************/ 1242 /* Set the deblocking parameters for this MB */ 1243 /***************************************************************/ 1244 if(ps_dec->u4_app_disable_deblk_frm == 0) 1245 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice, 1246 ps_dec->u1_mb_ngbr_availablity, 1247 ps_dec->u1_cur_mb_fld_dec_flag); 1248 1249 if(i2_mb_skip_run) 1250 { 1251 /* Set appropriate flags in ps_cur_mb_info and ps_dec */ 1252 ps_dec->i1_prev_mb_qp_delta = 0; 1253 ps_dec->u1_sub_mb_num = 0; 1254 ps_cur_mb_info->u1_mb_type = MB_SKIP; 1255 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16; 1256 ps_cur_mb_info->u1_cbp = 0; 1257 1258 { 1259 /* Storing Skip partition info */ 1260 parse_part_params_t *ps_part_info = ps_dec->ps_part; 1261 ps_part_info->u1_is_direct = PART_DIRECT_16x16; 1262 ps_part_info->u1_sub_mb_num = 0; 1263 ps_dec->ps_part++; 1264 } 1265 1266 /* Update Nnzs */ 1267 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC); 1268 1269 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type; 1270 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type; 1271 1272 i2_mb_skip_run--; 1273 } 1274 else 1275 { 1276 u1_read_mb_type = 0; 1277 /**************************************************************/ 1278 /* Macroblock Layer Begins, Decode the u1_mb_type */ 1279 /**************************************************************/ 1280 { 1281 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; 1282 UWORD32 u4_word, u4_ldz, u4_temp; 1283 1284 1285 //Inlined ih264d_uev 1286 /***************************************************************/ 1287 /* Find leading zeros in next 32 bits */ 1288 /***************************************************************/ 1289 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); 1290 u4_ldz = CLZ(u4_word); 1291 /* Flush the ps_bitstrm */ 1292 u4_bitstream_offset += (u4_ldz + 1); 1293 /* Read the suffix from the ps_bitstrm */ 1294 u4_word = 0; 1295 if(u4_ldz) 1296 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, 1297 u4_ldz); 1298 *pu4_bitstrm_ofst = u4_bitstream_offset; 1299 u4_temp = ((1 << u4_ldz) + u4_word - 1); 1300 //Inlined ih264d_uev 1301 if(u4_temp > (UWORD32)(25 + u1_mb_threshold)) 1302 return ERROR_MB_TYPE; 1303 u1_mb_type = u4_temp; 1304 COPYTHECONTEXT("u1_mb_type", u1_mb_type); 1305 } 1306 ps_cur_mb_info->u1_mb_type = u1_mb_type; 1307 1308 /**************************************************************/ 1309 /* Parse Macroblock data */ 1310 /**************************************************************/ 1311 if(u1_mb_type < u1_mb_threshold) 1312 { 1313 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type; 1314 1315 ret = ps_dec->pf_parse_inter_mb(ps_dec, ps_cur_mb_info, u1_num_mbs, 1316 u1_num_mbsNby2); 1317 if(ret != OK) 1318 return ret; 1319 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type; 1320 } 1321 else 1322 { 1323 /* Storing Intra partition info */ 1324 ps_parse_mb_data->u1_num_part = 0; 1325 ps_parse_mb_data->u1_isI_mb = 1; 1326 1327 if((25 + u1_mb_threshold) == u1_mb_type) 1328 { 1329 /* I_PCM_MB */ 1330 ps_cur_mb_info->ps_curmb->u1_mb_type = I_PCM_MB; 1331 ret = ih264d_parse_ipcm_mb(ps_dec, ps_cur_mb_info, u1_num_mbs); 1332 if(ret != OK) 1333 return ret; 1334 ps_dec->u1_qp = 0; 1335 } 1336 else 1337 { 1338 ret = ih264d_parse_imb_cavlc( 1339 ps_dec, ps_cur_mb_info, u1_num_mbs, 1340 (UWORD8)(u1_mb_type - u1_mb_threshold)); 1341 if(ret != OK) 1342 return ret; 1343 } 1344 1345 ps_cur_deblk_mb->u1_mb_type |= D_INTRA_MB; 1346 } 1347 uc_more_data_flag = MORE_RBSP_DATA(ps_bitstrm); 1348 } 1349 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp; 1350 1351 if(u1_mbaff) 1352 { 1353 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info); 1354 } 1355 /**************************************************************/ 1356 /* Get next Macroblock address */ 1357 /**************************************************************/ 1358 i2_cur_mb_addr++; 1359 1360 u1_num_mbs++; 1361 ps_dec->u2_total_mbs_coded++; 1362 u1_num_mbsNby2++; 1363 ps_parse_mb_data++; 1364 1365 /****************************************************************/ 1366 /* Check for End Of Row and other flags that determine when to */ 1367 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */ 1368 /* N-Mb */ 1369 /****************************************************************/ 1370 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1; 1371 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01))); 1372 u1_slice_end = (!(uc_more_data_flag || i2_mb_skip_run)); 1373 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row 1374 || u1_slice_end; 1375 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end; 1376 ps_cur_mb_info->u1_end_of_slice = u1_slice_end; 1377 1378 /*u1_dma_nby2mb = u1_decode_nmb || 1379 (u1_num_mbsNby2 == ps_dec->u1_recon_mb_grp_pair);*/ 1380 1381 //if(u1_dma_nby2mb) 1382 if(u1_decode_nmb) 1383 { 1384 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs); 1385 u1_num_mbsNby2 = 0; 1386 1387 { 1388 ps_parse_mb_data = ps_dec->ps_parse_mb_data; 1389 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1390 } 1391 } 1392 1393 /*H264_DEC_DEBUG_PRINT("Pic: %d Mb_X=%d Mb_Y=%d", 1394 ps_slice->i4_poc >> ps_slice->u1_field_pic_flag, 1395 ps_dec->u2_mbx,ps_dec->u2_mby + (1 - ps_cur_mb_info->u1_topmb)); 1396 H264_DEC_DEBUG_PRINT("u1_decode_nmb: %d", u1_decode_nmb);*/ 1397 if(u1_decode_nmb) 1398 { 1399 1400 1401 1402 if(ps_dec->u1_separate_parse) 1403 { 1404 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1405 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row); 1406 ps_dec->ps_nmb_info += u1_num_mbs; 1407 } 1408 else 1409 { 1410 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1411 u1_num_mbs_next, u1_tfr_n_mb, 1412 u1_end_of_row); 1413 } 1414 1415 if(u1_tfr_n_mb) 1416 u1_num_mbs = 0; 1417 u1_mb_idx = u1_num_mbs; 1418 ps_dec->u1_mb_idx = u1_num_mbs; 1419 1420 } 1421 //ps_dec->ps_pred++; 1422 } 1423 1424 ps_dec->u4_num_mbs_cur_nmb = 0; 1425 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr 1426 - (u2_first_mb_in_slice << u1_mbaff); 1427 1428 1429 return ret; 1430 } 1431 1432 WORD32 ih264d_mark_err_slice_skip(dec_struct_t * ps_dec, 1433 WORD32 num_mb_skip, 1434 UWORD8 u1_is_idr_slice, 1435 UWORD16 u2_frame_num, 1436 pocstruct_t *ps_cur_poc, 1437 WORD32 prev_slice_err) 1438 { 1439 WORD32 i2_cur_mb_addr; 1440 UWORD32 u1_num_mbs, u1_num_mbsNby2; 1441 UWORD32 u1_mb_idx = ps_dec->u1_mb_idx; 1442 UWORD32 i2_mb_skip_run; 1443 1444 UWORD32 u1_num_mbs_next, u1_end_of_row; 1445 const UWORD32 i2_pic_wdin_mbs = ps_dec->u2_frm_wd_in_mbs; 1446 UWORD32 u1_slice_end; 1447 UWORD32 u1_tfr_n_mb; 1448 UWORD32 u1_decode_nmb; 1449 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 1450 dec_slice_params_t * ps_slice = ps_dec->ps_cur_slice; 1451 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1452 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst; 1453 deblk_mb_t *ps_cur_deblk_mb; 1454 dec_mb_info_t *ps_cur_mb_info; 1455 parse_pmbarams_t *ps_parse_mb_data; 1456 UWORD32 u1_inter_mb_type; 1457 UWORD32 u1_deblk_mb_type; 1458 UWORD16 u2_total_mbs_coded; 1459 UWORD32 u1_mbaff = ps_slice->u1_mbaff_frame_flag; 1460 parse_part_params_t *ps_part_info; 1461 WORD32 ret; 1462 1463 1464 if(ps_dec->ps_dec_err_status->u1_err_flag & REJECT_CUR_PIC) 1465 { 1466 ih264d_err_pic_dispbuf_mgr(ps_dec); 1467 return 0; 1468 } 1469 1470 if(prev_slice_err == 1) 1471 { 1472 /* first slice - missing/header corruption */ 1473 ps_dec->ps_cur_slice->u2_frame_num = u2_frame_num; 1474 1475 1476 if(!ps_dec->u1_first_slice_in_stream) 1477 { 1478 ih264d_end_of_pic(ps_dec, u1_is_idr_slice, 1479 ps_dec->ps_cur_slice->u2_frame_num); 1480 ps_dec->s_cur_pic_poc.u2_frame_num = 1481 ps_dec->ps_cur_slice->u2_frame_num; 1482 } 1483 1484 { 1485 WORD32 i, j, poc = 0; 1486 1487 ps_dec->ps_cur_slice->u2_first_mb_in_slice = 0; 1488 1489 ps_dec->pf_mvpred = ih264d_mvpred_nonmbaff; 1490 ps_dec->p_form_mb_part_info = ih264d_form_mb_part_info_bp; 1491 ps_dec->p_motion_compensate = ih264d_motion_compensate_bp; 1492 1493 if(ps_dec->ps_cur_pic != NULL) 1494 poc = ps_dec->ps_cur_pic->i4_poc + 2; 1495 1496 j = 0; 1497 for(i = 0; i < MAX_NUM_PIC_PARAMS; i++) 1498 if(ps_dec->ps_pps[i].u1_is_valid == TRUE) 1499 j = i; 1500 { 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 } 1554 else 1555 { 1556 // Middle / last slice 1557 1558 dec_slice_struct_t *ps_parse_cur_slice; 1559 ps_parse_cur_slice = ps_dec->ps_dec_slice_buf + ps_dec->u2_cur_slice_num; 1560 1561 if(ps_dec->u1_slice_header_done 1562 && ps_parse_cur_slice == ps_dec->ps_parse_cur_slice) 1563 { 1564 // Slice data corrupted 1565 u1_num_mbs = ps_dec->u4_num_mbs_cur_nmb; 1566 1567 if(u1_num_mbs) 1568 { 1569 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs - 1; 1570 } 1571 else 1572 { 1573 if(ps_dec->u1_separate_parse) 1574 { 1575 ps_cur_mb_info = ps_dec->ps_nmb_info - 1; 1576 } 1577 else 1578 { 1579 ps_cur_mb_info = ps_dec->ps_nmb_info 1580 + ps_dec->u4_num_mbs_prev_nmb - 1; 1581 } 1582 } 1583 1584 ps_dec->u2_mby = ps_cur_mb_info->u2_mby; 1585 ps_dec->u2_mbx = ps_cur_mb_info->u2_mbx; 1586 1587 ps_dec->u1_mb_ngbr_availablity = 1588 ps_cur_mb_info->u1_mb_ngbr_availablity; 1589 1590 // Going back 1 mb 1591 ps_dec->pv_parse_tu_coeff_data = ps_dec->pv_prev_mb_parse_tu_coeff_data; 1592 ps_dec->u2_cur_mb_addr--; 1593 ps_dec->i4_submb_ofst -= SUB_BLK_SIZE; 1594 1595 if(u1_num_mbs) 1596 { 1597 // Parse/decode N-MB left unparsed 1598 if (ps_dec->u1_pr_sl_type == P_SLICE 1599 || ps_dec->u1_pr_sl_type == B_SLICE) 1600 { 1601 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs); 1602 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1603 } 1604 1605 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1; 1606 u1_end_of_row = (!u1_num_mbs_next) 1607 && (!(u1_mbaff && (u1_num_mbs & 0x01))); 1608 u1_slice_end = 1; 1609 u1_tfr_n_mb = 1; 1610 ps_cur_mb_info->u1_end_of_slice = u1_slice_end; 1611 1612 if(ps_dec->u1_separate_parse) 1613 { 1614 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1615 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row); 1616 ps_dec->ps_nmb_info += u1_num_mbs; 1617 } 1618 else 1619 { 1620 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1621 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row); 1622 } 1623 1624 ps_dec->u1_mb_idx = 0; 1625 ps_dec->u4_num_mbs_cur_nmb = 0; 1626 } 1627 1628 if(ps_dec->u2_total_mbs_coded 1629 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) 1630 { 1631 ps_dec->u1_pic_decode_done = 1; 1632 return 0; 1633 } 1634 1635 // Inserting new slice 1636 ps_dec->u2_cur_slice_num++; 1637 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx; 1638 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby; 1639 ps_dec->ps_parse_cur_slice++; 1640 1641 } 1642 else 1643 { 1644 // Slice missing / header corrupted 1645 ps_dec->ps_parse_cur_slice = ps_dec->ps_dec_slice_buf 1646 + ps_dec->u2_cur_slice_num; 1647 } 1648 } 1649 1650 /******************************************************/ 1651 /* Initializations to new slice */ 1652 /******************************************************/ 1653 { 1654 WORD32 num_entries; 1655 WORD32 size; 1656 UWORD8 *pu1_buf; 1657 1658 num_entries = MIN(MAX_FRAMES, ps_dec->u4_num_ref_frames_at_init); 1659 num_entries = 2 * ((2 * num_entries) + 1); 1660 1661 size = num_entries * sizeof(void *); 1662 size += PAD_MAP_IDX_POC * sizeof(void *); 1663 1664 pu1_buf = (UWORD8 *)ps_dec->pv_map_ref_idx_to_poc_buf; 1665 pu1_buf += size * ps_dec->u2_cur_slice_num; 1666 ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc = (volatile void **)pu1_buf; 1667 } 1668 1669 ps_dec->ps_cur_slice->u2_first_mb_in_slice = ps_dec->u2_total_mbs_coded << u1_mbaff; 1670 if(ps_dec->ps_cur_slice->u1_field_pic_flag) 1671 ps_dec->u2_prv_frame_num = ps_dec->ps_cur_slice->u2_frame_num; 1672 1673 ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice = ps_dec->u2_total_mbs_coded << u1_mbaff; 1674 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = ps_dec->ps_cur_slice->u2_log2Y_crwd; 1675 1676 1677 if(ps_dec->u1_separate_parse) 1678 { 1679 ps_dec->ps_parse_cur_slice->pv_tu_coeff_data_start = ps_dec->pv_parse_tu_coeff_data; 1680 } 1681 else 1682 { 1683 ps_dec->pv_proc_tu_coeff_data = ps_dec->pv_parse_tu_coeff_data; 1684 } 1685 1686 /******************************************************/ 1687 /* Initializations specific to P slice */ 1688 /******************************************************/ 1689 u1_inter_mb_type = P_MB; 1690 u1_deblk_mb_type = D_INTER_MB; 1691 1692 ps_dec->ps_cur_slice->u1_slice_type = P_SLICE; 1693 ps_dec->ps_parse_cur_slice->slice_type = P_SLICE; 1694 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb; 1695 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1696 1697 /******************************************************/ 1698 /* Parsing / decoding the slice */ 1699 /******************************************************/ 1700 ps_dec->u1_slice_header_done = 2; 1701 ps_dec->u1_qp = ps_slice->u1_slice_qp; 1702 ih264d_update_qp(ps_dec, 0); 1703 u1_mb_idx = ps_dec->u1_mb_idx; 1704 ps_parse_mb_data = ps_dec->ps_parse_mb_data; 1705 u1_num_mbs = u1_mb_idx; 1706 1707 u1_slice_end = 0; 1708 u1_tfr_n_mb = 0; 1709 u1_decode_nmb = 0; 1710 u1_num_mbsNby2 = 0; 1711 i2_cur_mb_addr = ps_dec->u2_total_mbs_coded; 1712 i2_mb_skip_run = num_mb_skip; 1713 1714 while(!u1_slice_end) 1715 { 1716 UWORD8 u1_mb_type; 1717 1718 if(i2_cur_mb_addr > ps_dec->ps_cur_sps->u2_max_mb_addr) 1719 break; 1720 1721 ps_cur_mb_info = ps_dec->ps_nmb_info + u1_num_mbs; 1722 ps_dec->u4_num_mbs_cur_nmb = u1_num_mbs; 1723 1724 ps_cur_mb_info->u1_Mux = 0; 1725 ps_dec->u4_num_pmbair = (u1_num_mbs >> u1_mbaff); 1726 ps_cur_deblk_mb = ps_dec->ps_deblk_mbn + u1_num_mbs; 1727 1728 ps_cur_mb_info->u1_end_of_slice = 0; 1729 1730 /* Storing Default partition info */ 1731 ps_parse_mb_data->u1_num_part = 1; 1732 ps_parse_mb_data->u1_isI_mb = 0; 1733 1734 /**************************************************************/ 1735 /* Get the required information for decoding of MB */ 1736 /**************************************************************/ 1737 /* mb_x, mb_y, neighbor availablity, */ 1738 if (u1_mbaff) 1739 ih264d_get_mb_info_cavlc_mbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run); 1740 else 1741 ih264d_get_mb_info_cavlc_nonmbaff(ps_dec, i2_cur_mb_addr, ps_cur_mb_info, i2_mb_skip_run); 1742 1743 /* Set the deblocking parameters for this MB */ 1744 if(ps_dec->u4_app_disable_deblk_frm == 0) 1745 { 1746 ih264d_set_deblocking_parameters(ps_cur_deblk_mb, ps_slice, 1747 ps_dec->u1_mb_ngbr_availablity, 1748 ps_dec->u1_cur_mb_fld_dec_flag); 1749 } 1750 1751 /* Set appropriate flags in ps_cur_mb_info and ps_dec */ 1752 ps_dec->i1_prev_mb_qp_delta = 0; 1753 ps_dec->u1_sub_mb_num = 0; 1754 ps_cur_mb_info->u1_mb_type = MB_SKIP; 1755 ps_cur_mb_info->u1_mb_mc_mode = PRED_16x16; 1756 ps_cur_mb_info->u1_cbp = 0; 1757 1758 /* Storing Skip partition info */ 1759 ps_part_info = ps_dec->ps_part; 1760 ps_part_info->u1_is_direct = PART_DIRECT_16x16; 1761 ps_part_info->u1_sub_mb_num = 0; 1762 ps_dec->ps_part++; 1763 1764 /* Update Nnzs */ 1765 ih264d_update_nnz_for_skipmb(ps_dec, ps_cur_mb_info, CAVLC); 1766 1767 ps_cur_mb_info->ps_curmb->u1_mb_type = u1_inter_mb_type; 1768 ps_cur_deblk_mb->u1_mb_type |= u1_deblk_mb_type; 1769 1770 i2_mb_skip_run--; 1771 1772 ps_cur_deblk_mb->u1_mb_qp = ps_dec->u1_qp; 1773 1774 if (u1_mbaff) 1775 { 1776 ih264d_update_mbaff_left_nnz(ps_dec, ps_cur_mb_info); 1777 } 1778 1779 /**************************************************************/ 1780 /* Get next Macroblock address */ 1781 /**************************************************************/ 1782 i2_cur_mb_addr++; 1783 1784 u1_num_mbs++; 1785 ps_dec->u2_total_mbs_coded++; 1786 u1_num_mbsNby2++; 1787 ps_parse_mb_data++; 1788 1789 /****************************************************************/ 1790 /* Check for End Of Row and other flags that determine when to */ 1791 /* do DMA setup for N/2-Mb, Decode for N-Mb, and Transfer for */ 1792 /* N-Mb */ 1793 /****************************************************************/ 1794 u1_num_mbs_next = i2_pic_wdin_mbs - ps_dec->u2_mbx - 1; 1795 u1_end_of_row = (!u1_num_mbs_next) && (!(u1_mbaff && (u1_num_mbs & 0x01))); 1796 u1_slice_end = !i2_mb_skip_run; 1797 u1_tfr_n_mb = (u1_num_mbs == ps_dec->u1_recon_mb_grp) || u1_end_of_row 1798 || u1_slice_end; 1799 u1_decode_nmb = u1_tfr_n_mb || u1_slice_end; 1800 ps_cur_mb_info->u1_end_of_slice = u1_slice_end; 1801 1802 if(u1_decode_nmb) 1803 { 1804 ps_dec->pf_mvpred_ref_tfr_nby2mb(ps_dec, u1_mb_idx, u1_num_mbs); 1805 u1_num_mbsNby2 = 0; 1806 1807 ps_parse_mb_data = ps_dec->ps_parse_mb_data; 1808 ps_dec->ps_part = ps_dec->ps_parse_part_params; 1809 1810 if(ps_dec->u1_separate_parse) 1811 { 1812 ih264d_parse_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, 1813 u1_num_mbs_next, u1_tfr_n_mb, u1_end_of_row); 1814 ps_dec->ps_nmb_info += u1_num_mbs; 1815 } 1816 else 1817 { 1818 ih264d_decode_recon_tfr_nmb(ps_dec, u1_mb_idx, u1_num_mbs, u1_num_mbs_next, 1819 u1_tfr_n_mb, u1_end_of_row); 1820 } 1821 1822 if(u1_tfr_n_mb) 1823 u1_num_mbs = 0; 1824 u1_mb_idx = u1_num_mbs; 1825 ps_dec->u1_mb_idx = u1_num_mbs; 1826 } 1827 } 1828 1829 ps_dec->u4_num_mbs_cur_nmb = 0; 1830 ps_dec->ps_cur_slice->u4_mbs_in_slice = i2_cur_mb_addr 1831 - ps_dec->ps_parse_cur_slice->u4_first_mb_in_slice; 1832 1833 H264_DEC_DEBUG_PRINT("Mbs in slice: %d\n", ps_dec->ps_cur_slice->u4_mbs_in_slice); 1834 1835 ps_dec->u2_cur_slice_num++; 1836 1837 /* incremented here only if first slice is inserted */ 1838 if(ps_dec->u4_first_slice_in_pic != 0) 1839 ps_dec->ps_parse_cur_slice++; 1840 1841 ps_dec->i2_prev_slice_mbx = ps_dec->u2_mbx; 1842 ps_dec->i2_prev_slice_mby = ps_dec->u2_mby; 1843 1844 if(ps_dec->u2_total_mbs_coded 1845 >= ps_dec->u2_frm_ht_in_mbs * ps_dec->u2_frm_wd_in_mbs) 1846 { 1847 ps_dec->u1_pic_decode_done = 1; 1848 } 1849 1850 return 0; 1851 1852 } 1853 1854 /*! 1855 ************************************************************************** 1856 * \if Function name : ih264d_decode_pslice \endif 1857 * 1858 * \brief 1859 * Decodes a P Slice 1860 * 1861 * 1862 * \return 1863 * 0 on Success and Error code otherwise 1864 ************************************************************************** 1865 */ 1866 WORD32 ih264d_parse_pslice(dec_struct_t *ps_dec, UWORD16 u2_first_mb_in_slice) 1867 { 1868 dec_pic_params_t * ps_pps = ps_dec->ps_cur_pps; 1869 dec_slice_params_t * ps_cur_slice = ps_dec->ps_cur_slice; 1870 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm; 1871 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1872 UWORD32 *pu4_bitstrm_ofst = &ps_bitstrm->u4_ofst; 1873 UWORD8 u1_mbaff = ps_dec->ps_cur_slice->u1_mbaff_frame_flag; //ps_dec->ps_cur_sps->u1_mb_aff_flag; 1874 UWORD8 u1_field_pic_flag = ps_cur_slice->u1_field_pic_flag; 1875 1876 UWORD32 u4_temp; 1877 WORD32 i_temp; 1878 WORD32 ret; 1879 1880 /*--------------------------------------------------------------------*/ 1881 /* Read remaining contents of the slice header */ 1882 /*--------------------------------------------------------------------*/ 1883 { 1884 WORD8 *pi1_buf; 1885 WORD16 *pi2_mv = ps_dec->s_default_mv_pred.i2_mv; 1886 WORD32 *pi4_mv = (WORD32*)pi2_mv; 1887 WORD16 *pi16_refFrame; 1888 1889 pi1_buf = ps_dec->s_default_mv_pred.i1_ref_frame; 1890 pi16_refFrame = (WORD16*)pi1_buf; 1891 *pi4_mv = 0; 1892 *(pi4_mv + 1) = 0; 1893 *pi16_refFrame = OUT_OF_RANGE_REF; 1894 ps_dec->s_default_mv_pred.u1_col_ref_pic_idx = (UWORD8)-1; 1895 ps_dec->s_default_mv_pred.u1_pic_type = (UWORD8)-1; 1896 } 1897 1898 ps_cur_slice->u1_num_ref_idx_active_override_flag = ih264d_get_bit_h264( 1899 ps_bitstrm); 1900 1901 COPYTHECONTEXT("SH: num_ref_idx_override_flag", 1902 ps_cur_slice->u1_num_ref_idx_active_override_flag); 1903 1904 u4_temp = ps_dec->ps_cur_pps->u1_num_ref_idx_lx_active[0]; 1905 if(ps_cur_slice->u1_num_ref_idx_active_override_flag) 1906 { 1907 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf) + 1; 1908 } 1909 1910 { 1911 1912 1913 1914 UWORD8 u1_max_ref_idx = MAX_FRAMES << u1_field_pic_flag; 1915 if(u4_temp > u1_max_ref_idx) 1916 { 1917 return ERROR_NUM_REF; 1918 } 1919 ps_cur_slice->u1_num_ref_idx_lx_active[0] = u4_temp; 1920 COPYTHECONTEXT("SH: num_ref_idx_l0_active_minus1", 1921 ps_cur_slice->u1_num_ref_idx_lx_active[0] - 1); 1922 1923 } 1924 1925 { 1926 UWORD8 uc_refIdxReFlagL0 = ih264d_get_bit_h264(ps_bitstrm); 1927 COPYTHECONTEXT("SH: ref_pic_list_reordering_flag_l0",uc_refIdxReFlagL0); 1928 1929 /* Initialize the Reference list once in Picture if the slice type */ 1930 /* of first slice is between 5 to 9 defined in table 7.3 of standard */ 1931 /* If picture contains both P & B slices then Initialize the Reference*/ 1932 /* List only when it switches from P to B and B to P */ 1933 { 1934 UWORD8 init_idx_flg = (ps_dec->u1_pr_sl_type 1935 != ps_dec->ps_cur_slice->u1_slice_type); 1936 if(ps_dec->u1_first_pb_nal_in_pic 1937 || (init_idx_flg & !ps_dec->u1_sl_typ_5_9) 1938 || ps_dec->u1_num_ref_idx_lx_active_prev 1939 != ps_cur_slice->u1_num_ref_idx_lx_active[0]) 1940 { 1941 ih264d_init_ref_idx_lx_p(ps_dec); 1942 } 1943 if(ps_dec->u1_first_pb_nal_in_pic & ps_dec->u1_sl_typ_5_9) 1944 ps_dec->u1_first_pb_nal_in_pic = 0; 1945 } 1946 /* Store the value for future slices in the same picture */ 1947 ps_dec->u1_num_ref_idx_lx_active_prev = 1948 ps_cur_slice->u1_num_ref_idx_lx_active[0]; 1949 1950 /* Modified temporarily */ 1951 if(uc_refIdxReFlagL0) 1952 { 1953 WORD8 ret; 1954 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0]; 1955 ret = ih264d_ref_idx_reordering(ps_dec, 0); 1956 if(ret == -1) 1957 return ERROR_REFIDX_ORDER_T; 1958 ps_dec->ps_ref_pic_buf_lx[0] = ps_dec->ps_dpb_mgr->ps_mod_dpb[0]; 1959 } 1960 else 1961 ps_dec->ps_ref_pic_buf_lx[0] = 1962 ps_dec->ps_dpb_mgr->ps_init_dpb[0]; 1963 } 1964 /* Create refIdx to POC mapping */ 1965 { 1966 void **pui_map_ref_idx_to_poc_lx0, **pui_map_ref_idx_to_poc_lx1; 1967 WORD8 idx; 1968 struct pic_buffer_t *ps_pic; 1969 1970 pui_map_ref_idx_to_poc_lx0 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L0; 1971 pui_map_ref_idx_to_poc_lx0[0] = 0; //For ref_idx = -1 1972 pui_map_ref_idx_to_poc_lx0++; 1973 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++) 1974 { 1975 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx]; 1976 pui_map_ref_idx_to_poc_lx0[idx] = (ps_pic->pu1_buf1); 1977 } 1978 1979 /* Bug Fix Deblocking */ 1980 pui_map_ref_idx_to_poc_lx1 = ps_dec->ppv_map_ref_idx_to_poc + FRM_LIST_L1; 1981 pui_map_ref_idx_to_poc_lx1[0] = 0; 1982 1983 if(u1_mbaff) 1984 { 1985 void **ppv_map_ref_idx_to_poc_lx_t, **ppv_map_ref_idx_to_poc_lx_b; 1986 void **ppv_map_ref_idx_to_poc_lx_t1, **ppv_map_ref_idx_to_poc_lx_b1; 1987 ppv_map_ref_idx_to_poc_lx_t = ps_dec->ppv_map_ref_idx_to_poc 1988 + TOP_LIST_FLD_L0; 1989 ppv_map_ref_idx_to_poc_lx_b = ps_dec->ppv_map_ref_idx_to_poc 1990 + BOT_LIST_FLD_L0; 1991 1992 ppv_map_ref_idx_to_poc_lx_t[0] = 0; // For ref_idx = -1 1993 ppv_map_ref_idx_to_poc_lx_t++; 1994 ppv_map_ref_idx_to_poc_lx_b[0] = 0; // For ref_idx = -1 1995 ppv_map_ref_idx_to_poc_lx_b++; 1996 1997 idx = 0; 1998 for(idx = 0; idx < ps_cur_slice->u1_num_ref_idx_lx_active[0]; idx++) 1999 { 2000 ps_pic = ps_dec->ps_ref_pic_buf_lx[0][idx]; 2001 ppv_map_ref_idx_to_poc_lx_t[0] = (ps_pic->pu1_buf1); 2002 ppv_map_ref_idx_to_poc_lx_b[1] = (ps_pic->pu1_buf1); 2003 2004 ppv_map_ref_idx_to_poc_lx_b[0] = (ps_pic->pu1_buf1) + 1; 2005 ppv_map_ref_idx_to_poc_lx_t[1] = (ps_pic->pu1_buf1) + 1; 2006 2007 ppv_map_ref_idx_to_poc_lx_t += 2; 2008 ppv_map_ref_idx_to_poc_lx_b += 2; 2009 } 2010 ppv_map_ref_idx_to_poc_lx_t1 = ps_dec->ppv_map_ref_idx_to_poc 2011 + TOP_LIST_FLD_L1; 2012 ppv_map_ref_idx_to_poc_lx_t1[0] = 0; 2013 ppv_map_ref_idx_to_poc_lx_b1 = ps_dec->ppv_map_ref_idx_to_poc 2014 + BOT_LIST_FLD_L1; 2015 ppv_map_ref_idx_to_poc_lx_b1[0] = 0; 2016 2017 } 2018 2019 if(ps_dec->u4_num_cores >= 3) 2020 { 2021 WORD32 num_entries; 2022 WORD32 size; 2023 2024 num_entries = MIN(MAX_FRAMES, ps_dec->u4_num_ref_frames_at_init); 2025 num_entries = 2 * ((2 * num_entries) + 1); 2026 2027 size = num_entries * sizeof(void *); 2028 size += PAD_MAP_IDX_POC * sizeof(void *); 2029 2030 memcpy((void *)ps_dec->ps_parse_cur_slice->ppv_map_ref_idx_to_poc, 2031 ps_dec->ppv_map_ref_idx_to_poc, 2032 size); 2033 } 2034 2035 2036 } 2037 if(ps_pps->u1_wted_pred_flag) 2038 { 2039 ret = ih264d_parse_pred_weight_table(ps_cur_slice, ps_bitstrm); 2040 if(ret != OK) 2041 return ret; 2042 ih264d_form_pred_weight_matrix(ps_dec); 2043 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat; 2044 } 2045 else 2046 { 2047 ps_dec->ps_cur_slice->u2_log2Y_crwd = 0; 2048 ps_dec->pu4_wt_ofsts = ps_dec->pu4_wts_ofsts_mat; 2049 } 2050 2051 ps_dec->ps_parse_cur_slice->u2_log2Y_crwd = 2052 ps_dec->ps_cur_slice->u2_log2Y_crwd; 2053 2054 if(u1_mbaff && (u1_field_pic_flag == 0)) 2055 { 2056 ih264d_convert_frm_mbaff_list(ps_dec); 2057 } 2058 2059 /* G050 */ 2060 if(ps_cur_slice->u1_nal_ref_idc != 0) 2061 { 2062 if(!ps_dec->ps_dpb_cmds->u1_dpb_commands_read) 2063 ps_dec->u4_bitoffset = ih264d_read_mmco_commands(ps_dec); 2064 else 2065 ps_bitstrm->u4_ofst += ps_dec->u4_bitoffset; 2066 2067 } 2068 /* G050 */ 2069 2070 if(ps_pps->u1_entropy_coding_mode == CABAC) 2071 { 2072 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 2073 2074 if(u4_temp > MAX_CABAC_INIT_IDC) 2075 { 2076 return ERROR_INV_SLICE_HDR_T; 2077 } 2078 ps_cur_slice->u1_cabac_init_idc = u4_temp; 2079 COPYTHECONTEXT("SH: cabac_init_idc",ps_cur_slice->u1_cabac_init_idc); 2080 } 2081 2082 /* Read slice_qp_delta */ 2083 i_temp = ps_pps->u1_pic_init_qp 2084 + ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 2085 if((i_temp < 0) || (i_temp > 51)) 2086 { 2087 return ERROR_INV_RANGE_QP_T; 2088 } 2089 ps_cur_slice->u1_slice_qp = i_temp; 2090 COPYTHECONTEXT("SH: slice_qp_delta", 2091 (WORD8)(ps_cur_slice->u1_slice_qp - ps_pps->u1_pic_init_qp)); 2092 2093 if(ps_pps->u1_deblocking_filter_parameters_present_flag == 1) 2094 { 2095 u4_temp = ih264d_uev(pu4_bitstrm_ofst, pu4_bitstrm_buf); 2096 if(u4_temp > SLICE_BOUNDARY_DBLK_DISABLED) 2097 { 2098 return ERROR_INV_SLICE_HDR_T; 2099 } 2100 2101 COPYTHECONTEXT("SH: disable_deblocking_filter_idc", u4_temp); 2102 ps_cur_slice->u1_disable_dblk_filter_idc = u4_temp; 2103 if(u4_temp != 1) 2104 { 2105 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf) 2106 << 1; 2107 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF)) 2108 { 2109 return ERROR_INV_SLICE_HDR_T; 2110 } 2111 ps_cur_slice->i1_slice_alpha_c0_offset = i_temp; 2112 COPYTHECONTEXT("SH: slice_alpha_c0_offset_div2", 2113 ps_cur_slice->i1_slice_alpha_c0_offset >> 1); 2114 2115 i_temp = ih264d_sev(pu4_bitstrm_ofst, pu4_bitstrm_buf) 2116 << 1; 2117 if((MIN_DBLK_FIL_OFF > i_temp) || (i_temp > MAX_DBLK_FIL_OFF)) 2118 { 2119 return ERROR_INV_SLICE_HDR_T; 2120 } 2121 ps_cur_slice->i1_slice_beta_offset = i_temp; 2122 COPYTHECONTEXT("SH: slice_beta_offset_div2", 2123 ps_cur_slice->i1_slice_beta_offset >> 1); 2124 } 2125 else 2126 { 2127 ps_cur_slice->i1_slice_alpha_c0_offset = 0; 2128 ps_cur_slice->i1_slice_beta_offset = 0; 2129 } 2130 } 2131 else 2132 { 2133 ps_cur_slice->u1_disable_dblk_filter_idc = 0; 2134 ps_cur_slice->i1_slice_alpha_c0_offset = 0; 2135 ps_cur_slice->i1_slice_beta_offset = 0; 2136 } 2137 2138 ps_dec->u1_slice_header_done = 2; 2139 2140 if(ps_pps->u1_entropy_coding_mode) 2141 { 2142 SWITCHOFFTRACE; SWITCHONTRACECABAC; 2143 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cabac; 2144 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cabac; 2145 ih264d_init_cabac_contexts(P_SLICE, ps_dec); 2146 2147 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag) 2148 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_mbaff; 2149 else 2150 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cabac_nonmbaff; 2151 } 2152 else 2153 { 2154 SWITCHONTRACE; SWITCHOFFTRACECABAC; 2155 ps_dec->pf_parse_inter_slice = ih264d_parse_inter_slice_data_cavlc; 2156 ps_dec->pf_parse_inter_mb = ih264d_parse_pmb_cavlc; 2157 if(ps_dec->ps_cur_slice->u1_mbaff_frame_flag) 2158 { 2159 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_mbaff; 2160 } 2161 else 2162 ps_dec->pf_get_mb_info = ih264d_get_mb_info_cavlc_nonmbaff; 2163 } 2164 2165 ps_dec->u1_B = 0; 2166 ps_dec->pf_mvpred_ref_tfr_nby2mb = ih264d_mv_pred_ref_tfr_nby2_pmb; 2167 ret = ps_dec->pf_parse_inter_slice(ps_dec, ps_cur_slice, u2_first_mb_in_slice); 2168 if(ret != OK) 2169 return ret; 2170 // ps_dec->curr_slice_in_error = 0 ; 2171 return OK; 2172 } 2173
