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