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