1 /****************************************************************************** 2 * 3 * Copyright (C) 2015 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ***************************************************************************** 18 * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore 19 */ 20 /*! 21 *************************************************************************** 22 * \file ih264d_parse_cabac.c 23 * 24 * \brief 25 * This file contains cabac Residual decoding routines. 26 * 27 * \date 28 * 20/03/2003 29 * 30 * \author NS 31 *************************************************************************** 32 */ 33 34 #include "ih264_typedefs.h" 35 #include "ih264_macros.h" 36 #include "ih264_platform_macros.h" 37 #include "ih264d_defs.h" 38 #include "ih264d_structs.h" 39 40 #include "ih264d_cabac.h" 41 #include "ih264d_bitstrm.h" 42 #include "ih264d_parse_mb_header.h" 43 #include "ih264d_debug.h" 44 #include "ih264d_tables.h" 45 #include "ih264d_error_handler.h" 46 #include "ih264d_parse_cabac.h" 47 #include "ih264d_parse_slice.h" 48 #include "ih264d_tables.h" 49 #include "ih264d_mb_utils.h" 50 #include "ih264d_utils.h" 51 52 /*! 53 ******************************************************************************** 54 * \if Function name : ih264d_read_coeff4x4_cabac \endif 55 * 56 * \brief This function encodes residual_block_cabac as defined in 7.3.5.3.2. 57 * 58 * \return 59 * Returns the index of last significant coeff. 60 * 61 ******************************************************************************** 62 */ 63 64 UWORD8 ih264d_read_coeff4x4_cabac(dec_bit_stream_t *ps_bitstrm, 65 UWORD32 u4_ctxcat, 66 bin_ctxt_model_t *ps_ctxt_sig_coeff, 67 dec_struct_t *ps_dec, /*!< pointer to access global variables*/ 68 bin_ctxt_model_t *ps_ctxt_coded) 69 { 70 71 decoding_envirnoment_t *ps_cab_env = &ps_dec->s_cab_dec_env; 72 UWORD32 u4_coded_flag; 73 UWORD32 u4_offset, *pu4_buffer; 74 UWORD32 u4_code_int_range, u4_code_int_val_ofst; 75 tu_sblk4x4_coeff_data_t *ps_tu_4x4; 76 WORD16 *pi2_coeff_data; 77 WORD32 num_sig_coeffs = 0; 78 79 /*loading from strcuctures*/ 80 81 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; 82 ps_tu_4x4->u2_sig_coeff_map = 0; 83 pi2_coeff_data = &ps_tu_4x4->ai2_level[0]; 84 85 u4_offset = ps_bitstrm->u4_ofst; 86 pu4_buffer = ps_bitstrm->pu4_buffer; 87 88 u4_code_int_range = ps_cab_env->u4_code_int_range; 89 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst; 90 91 { 92 93 /*inilined DecodeDecision_onebin begins*/ 94 95 { 96 97 UWORD32 u4_qnt_int_range, u4_int_range_lps; 98 UWORD32 u4_symbol, u1_mps_state; 99 100 UWORD32 table_lookup; 101 const UWORD32 *pu4_table = (const UWORD32 *)ps_cab_env->cabac_table; 102 UWORD32 u4_clz; 103 104 u1_mps_state = (ps_ctxt_coded->u1_mps_state); 105 u4_clz = CLZ(u4_code_int_range); 106 u4_qnt_int_range = u4_code_int_range << u4_clz; 107 u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3; 108 table_lookup = 109 pu4_table[(u1_mps_state << 2) + u4_qnt_int_range]; 110 u4_int_range_lps = table_lookup & 0xff; 111 u4_int_range_lps = u4_int_range_lps << (23 - u4_clz); 112 u4_code_int_range = u4_code_int_range - u4_int_range_lps; 113 u4_symbol = ((u1_mps_state >> 6) & 0x1); 114 u1_mps_state = (table_lookup >> 8) & 0x7F; 115 116 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, u4_symbol, 117 u4_int_range_lps, u1_mps_state, table_lookup) 118 119 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_8) 120 { 121 122 RENORM_RANGE_OFFSET(u4_code_int_range, u4_code_int_val_ofst, 123 u4_offset, pu4_buffer) 124 } 125 126 ps_ctxt_coded->u1_mps_state = u1_mps_state; 127 u4_coded_flag = u4_symbol; 128 129 /*inilined DecodeDecision_onebin ends*/ 130 131 } 132 133 } 134 135 if(u4_coded_flag) 136 { 137 138 { 139 bin_ctxt_model_t *p_binCtxt_last, *p_binCtxt_last_org; 140 UWORD32 uc_last_coeff_idx; 141 UWORD32 uc_bin; 142 UWORD32 i; 143 WORD32 first_coeff_offset = 0; 144 145 if((u4_ctxcat == CHROMA_AC_CTXCAT) || (u4_ctxcat == LUMA_AC_CTXCAT)) 146 { 147 first_coeff_offset = 1; 148 } 149 150 i = 0; 151 if(u4_ctxcat == CHROMA_DC_CTXCAT) 152 { 153 uc_last_coeff_idx = 3; 154 } 155 else 156 { 157 UWORD32 u4_start; 158 u4_start = (u4_ctxcat & 1) + (u4_ctxcat >> 2); 159 uc_last_coeff_idx = 15 - u4_start; 160 } 161 p_binCtxt_last_org = ps_ctxt_sig_coeff 162 + LAST_COEFF_CTXT_MINUS_SIG_COEFF_CTXT; 163 164 do 165 { 166 167 /*inilined DecodeDecision_onebin begins*/ 168 { 169 170 UWORD32 u4_qnt_int_range, u4_int_range_lps; 171 UWORD32 u4_symbol, u1_mps_state; 172 UWORD32 table_lookup; 173 const UWORD32 *pu4_table = 174 (const UWORD32 *)ps_cab_env->cabac_table; 175 UWORD32 u4_clz; 176 177 u1_mps_state = (ps_ctxt_sig_coeff->u1_mps_state); 178 179 u4_clz = CLZ(u4_code_int_range); 180 181 u4_qnt_int_range = u4_code_int_range << u4_clz; 182 u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3; 183 184 table_lookup = pu4_table[(u1_mps_state << 2) 185 + u4_qnt_int_range]; 186 187 u4_int_range_lps = table_lookup & 0xff; 188 189 u4_int_range_lps = u4_int_range_lps << (23 - u4_clz); 190 u4_code_int_range = u4_code_int_range - u4_int_range_lps; 191 u4_symbol = ((u1_mps_state >> 6) & 0x1); 192 u1_mps_state = (table_lookup >> 8) & 0x7F; 193 194 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, 195 u4_symbol, u4_int_range_lps, u1_mps_state, 196 table_lookup) 197 198 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_14) 199 { 200 201 UWORD32 read_bits, u4_clz; 202 u4_clz = CLZ(u4_code_int_range); 203 NEXTBITS(read_bits, (u4_offset + 23), pu4_buffer, 204 u4_clz) 205 FLUSHBITS(u4_offset, (u4_clz)) 206 u4_code_int_range = u4_code_int_range << u4_clz; 207 u4_code_int_val_ofst = (u4_code_int_val_ofst << u4_clz) 208 | read_bits; 209 } 210 211 INC_BIN_COUNT( 212 ps_cab_env) 213 214 ps_ctxt_sig_coeff->u1_mps_state = u1_mps_state; 215 uc_bin = u4_symbol; 216 217 } 218 /*incrementing pointer to point to the context of the next bin*/ 219 ps_ctxt_sig_coeff++; 220 221 /*inilined DecodeDecision_onebin ends*/ 222 223 if(uc_bin) 224 { 225 num_sig_coeffs++; 226 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, (i + first_coeff_offset)); 227 228 p_binCtxt_last = p_binCtxt_last_org + i; 229 230 /*inilined DecodeDecision_onebin begins*/ 231 232 { 233 234 UWORD32 u4_qnt_int_range, u4_int_range_lps; 235 UWORD32 u4_symbol, u1_mps_state; 236 UWORD32 table_lookup; 237 const UWORD32 *pu4_table = 238 (const UWORD32 *)ps_cab_env->cabac_table; 239 UWORD32 u4_clz; 240 241 u1_mps_state = (p_binCtxt_last->u1_mps_state); 242 243 u4_clz = CLZ(u4_code_int_range); 244 u4_qnt_int_range = u4_code_int_range << u4_clz; 245 u4_qnt_int_range = (u4_qnt_int_range >> 29) 246 & 0x3; 247 248 table_lookup = pu4_table[(u1_mps_state << 2) 249 + u4_qnt_int_range]; 250 u4_int_range_lps = table_lookup & 0xff; 251 252 u4_int_range_lps = u4_int_range_lps 253 << (23 - u4_clz); 254 255 u4_code_int_range = u4_code_int_range 256 - u4_int_range_lps; 257 u4_symbol = ((u1_mps_state >> 6) & 0x1); 258 u1_mps_state = (table_lookup >> 8) & 0x7F; 259 260 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, 261 u4_symbol, u4_int_range_lps, 262 u1_mps_state, table_lookup) 263 264 INC_BIN_COUNT(ps_cab_env) 265 266 p_binCtxt_last->u1_mps_state = u1_mps_state; 267 uc_bin = u4_symbol; 268 269 } 270 271 /*inilined DecodeDecision_onebin ends*/ 272 if(uc_bin == 1) 273 goto label_read_levels; 274 275 } 276 277 i = i + 1; 278 279 } 280 while(i < uc_last_coeff_idx); 281 282 num_sig_coeffs++; 283 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, (i + first_coeff_offset)); 284 285 label_read_levels: ; 286 287 } 288 289 /// VALUE of No of Coeff in BLOCK = i + 1 for second case else i; 290 291 /* Decode coeff_abs_level_minus1 and coeff_sign_flag */ 292 { 293 294 WORD32 i2_abs_lvl; 295 UWORD32 u1_abs_level_equal1 = 1, u1_abs_level_gt1 = 0; 296 297 UWORD32 u4_ctx_inc; 298 UWORD32 ui_prefix; 299 bin_ctxt_model_t *p_ctxt_abs_level; 300 301 302 p_ctxt_abs_level = ps_dec->p_coeff_abs_level_minus1_t[u4_ctxcat]; 303 u4_ctx_inc = ((0x51)); 304 305 /*****************************************************/ 306 /* Main Loop runs for no. of Significant coefficient */ 307 /*****************************************************/ 308 309 310 do 311 { 312 313 { 314 INC_SYM_COUNT(&(ps_dec.s_cab_dec_env)); 315 316 /*****************************************************/ 317 /* inilining a modified ih264d_decode_bins_unary */ 318 /*****************************************************/ 319 320 { 321 UWORD32 u4_value; 322 UWORD32 u4_symbol; 323 bin_ctxt_model_t *ps_bin_ctxt; 324 UWORD32 u4_ctx_Inc; 325 326 u4_value = 0; 327 328 u4_ctx_Inc = u4_ctx_inc & 0xf; 329 ps_bin_ctxt = p_ctxt_abs_level + u4_ctx_Inc; 330 331 do 332 { 333 334 { 335 336 UWORD32 u4_qnt_int_range, 337 u4_int_range_lps; 338 UWORD32 u1_mps_state; 339 UWORD32 table_lookup; 340 const UWORD32 *pu4_table = 341 (const UWORD32 *)ps_cab_env->cabac_table; 342 UWORD32 u4_clz; 343 344 u1_mps_state = (ps_bin_ctxt->u1_mps_state); 345 u4_clz = CLZ(u4_code_int_range); 346 u4_qnt_int_range = u4_code_int_range 347 << u4_clz; 348 u4_qnt_int_range = (u4_qnt_int_range 349 >> 29) & 0x3; 350 table_lookup = pu4_table[(u1_mps_state << 2) 351 + u4_qnt_int_range]; 352 u4_int_range_lps = table_lookup & 0xff; 353 354 u4_int_range_lps = u4_int_range_lps 355 << (23 - u4_clz); 356 u4_code_int_range = u4_code_int_range 357 - u4_int_range_lps; 358 u4_symbol = ((u1_mps_state >> 6) & 0x1); 359 u1_mps_state = (table_lookup >> 8) & 0x7F; 360 361 CHECK_IF_LPS(u4_code_int_range, 362 u4_code_int_val_ofst, u4_symbol, 363 u4_int_range_lps, u1_mps_state, 364 table_lookup) 365 366 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9) 367 { 368 369 RENORM_RANGE_OFFSET(u4_code_int_range, 370 u4_code_int_val_ofst, 371 u4_offset, pu4_buffer) 372 } 373 374 INC_BIN_COUNT(ps_cab_env); 375 376 ps_bin_ctxt->u1_mps_state = u1_mps_state; 377 } 378 379 INC_BIN_COUNT(ps_cab_env);INC_DECISION_BINS(ps_cab_env); 380 381 u4_value++; 382 ps_bin_ctxt = p_ctxt_abs_level + (u4_ctx_inc >> 4); 383 384 } 385 while(u4_symbol && (u4_value < UCOFF_LEVEL)); 386 387 ui_prefix = u4_value - 1 + u4_symbol; 388 389 } 390 391 if(ui_prefix == UCOFF_LEVEL) 392 { 393 UWORD32 ui16_sufS = 0; 394 UWORD32 u1_max_bins; 395 UWORD32 u4_value; 396 397 i2_abs_lvl = UCOFF_LEVEL; 398 /*inlining ih264d_decode_bypass_bins_unary begins*/ 399 400 { 401 UWORD32 uc_bin; 402 UWORD32 bits_to_flush; 403 UWORD32 max_bits = 32; 404 405 bits_to_flush = 0; 406 /*renormalize to ensure there 23 bits more in the u4_code_int_val_ofst*/ 407 { 408 UWORD32 u4_clz, read_bits; 409 410 u4_clz = CLZ(u4_code_int_range); 411 FLUSHBITS(u4_offset, u4_clz) 412 NEXTBITS(read_bits, u4_offset, pu4_buffer, 23) 413 u4_code_int_range = u4_code_int_range << u4_clz; 414 u4_code_int_val_ofst = (u4_code_int_val_ofst 415 << u4_clz) | read_bits; 416 417 } 418 419 do 420 { 421 bits_to_flush++; 422 423 u4_code_int_range = u4_code_int_range >> 1; 424 425 if(u4_code_int_val_ofst >= u4_code_int_range) 426 { 427 /* S=1 */ 428 uc_bin = 1; 429 u4_code_int_val_ofst -= u4_code_int_range; 430 } 431 else 432 { 433 /* S=0 */ 434 uc_bin = 0; 435 } 436 437 INC_BIN_COUNT( 438 ps_cab_env);INC_BYPASS_BINS(ps_cab_env); 439 440 } 441 while(uc_bin && (bits_to_flush < max_bits)); 442 443 u4_value = (bits_to_flush - 1); 444 445 } 446 /*inlining ih264d_decode_bypass_bins_unary ends*/ 447 448 ui16_sufS = (1 << u4_value); 449 u1_max_bins = u4_value; 450 451 if(u4_value > 0) 452 { 453 454 /*inline bypassbins_flc begins*/ 455 456 if(u4_value > 10) 457 { 458 UWORD32 u4_clz, read_bits; 459 460 u4_clz = CLZ(u4_code_int_range); 461 FLUSHBITS(u4_offset, u4_clz) 462 NEXTBITS(read_bits, u4_offset, pu4_buffer, 23) 463 u4_code_int_range = u4_code_int_range << u4_clz; 464 u4_code_int_val_ofst = (u4_code_int_val_ofst 465 << u4_clz) | read_bits; 466 } 467 468 { 469 UWORD32 ui_bins; 470 UWORD32 uc_bin; 471 UWORD32 bits_to_flush; 472 473 ui_bins = 0; 474 bits_to_flush = 0; 475 476 do 477 { 478 bits_to_flush++; 479 480 u4_code_int_range = u4_code_int_range >> 1; 481 482 if(u4_code_int_val_ofst 483 >= u4_code_int_range) 484 { 485 /* S=1 */ 486 uc_bin = 1; 487 u4_code_int_val_ofst -= 488 u4_code_int_range; 489 } 490 else 491 { 492 /* S=0 */ 493 uc_bin = 0; 494 } 495 496 INC_BIN_COUNT( 497 ps_cab_env);INC_BYPASS_BINS(ps_cab_env); 498 499 ui_bins = ((ui_bins << 1) | uc_bin); 500 501 } 502 while(bits_to_flush < u1_max_bins); 503 504 u4_value = ui_bins; 505 } 506 507 /*inline bypassbins_flc ends*/ 508 509 } 510 511 //Value of K 512 ui16_sufS += u4_value; 513 i2_abs_lvl += ui16_sufS; 514 515 } 516 else 517 i2_abs_lvl = 1 + ui_prefix; 518 519 if(i2_abs_lvl > 1) 520 { 521 u1_abs_level_gt1++; 522 } 523 if(!u1_abs_level_gt1) 524 { 525 u1_abs_level_equal1++; 526 u4_ctx_inc = (5 << 4) + MIN(u1_abs_level_equal1, 4); 527 } 528 else 529 u4_ctx_inc = (5 + MIN(u1_abs_level_gt1, 4)) << 4; 530 531 /*u4_ctx_inc = g_table_temp[u1_abs_level_gt1][u1_abs_level_equal1];*/ 532 533 /* encode coeff_sign_flag[i] */ 534 535 { 536 u4_code_int_range = u4_code_int_range >> 1; 537 538 if(u4_code_int_val_ofst >= (u4_code_int_range)) 539 { 540 /* S=1 */ 541 u4_code_int_val_ofst -= u4_code_int_range; 542 i2_abs_lvl = (-i2_abs_lvl); 543 } 544 545 } 546 num_sig_coeffs--; 547 *pi2_coeff_data++ = i2_abs_lvl; 548 } 549 } 550 while(num_sig_coeffs > 0); 551 } 552 } 553 554 if(u4_coded_flag) 555 { 556 WORD32 offset; 557 offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4; 558 offset = ALIGN4(offset); 559 ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset); 560 } 561 562 563 /*updating structures*/ 564 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst; 565 ps_cab_env->u4_code_int_range = u4_code_int_range; 566 ps_bitstrm->u4_ofst = u4_offset; 567 return (u4_coded_flag); 568 } 569 /*! 570 ******************************************************************************** 571 * \if Function name : ih264d_read_coeff8x8_cabac \endif 572 * 573 * \brief This function encodes residual_block_cabac as defined in 7.3.5.3.2. 574 when transform_8x8_flag = 1 575 * 576 * \return 577 * Returns the index of last significant coeff. 578 * 579 ******************************************************************************** 580 */ 581 582 void ih264d_read_coeff8x8_cabac(dec_bit_stream_t *ps_bitstrm, 583 dec_struct_t *ps_dec, /*!< pointer to access global variables*/ 584 dec_mb_info_t *ps_cur_mb_info) 585 { 586 decoding_envirnoment_t *ps_cab_env = &ps_dec->s_cab_dec_env; 587 UWORD32 u4_offset, *pu4_buffer; 588 UWORD32 u4_code_int_range, u4_code_int_val_ofst; 589 590 /* High profile related declarations */ 591 UWORD8 u1_field_coding_flag = ps_cur_mb_info->ps_curmb->u1_mb_fld; 592 const UWORD8 *pu1_lastcoeff_context_inc = 593 (UWORD8 *)gau1_ih264d_lastcoeff_context_inc; 594 const UWORD8 *pu1_sigcoeff_context_inc; 595 bin_ctxt_model_t *ps_ctxt_sig_coeff; 596 WORD32 num_sig_coeffs = 0; 597 tu_blk8x8_coeff_data_t *ps_tu_8x8; 598 WORD16 *pi2_coeff_data; 599 600 /*loading from strcuctures*/ 601 602 ps_tu_8x8 = (tu_blk8x8_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; 603 ps_tu_8x8->au4_sig_coeff_map[0] = 0; 604 ps_tu_8x8->au4_sig_coeff_map[1] = 0; 605 pi2_coeff_data = &ps_tu_8x8->ai2_level[0]; 606 607 608 if(!u1_field_coding_flag) 609 { 610 pu1_sigcoeff_context_inc = 611 (UWORD8 *)gau1_ih264d_sigcoeff_context_inc_frame; 612 613 /*******************************************************************/ 614 /* last coefficient context is derived from significant coeff u4_flag */ 615 /* only significant coefficient matrix need to be initialized */ 616 /*******************************************************************/ 617 ps_ctxt_sig_coeff = ps_dec->s_high_profile.ps_sigcoeff_8x8_frame; 618 } 619 else 620 { 621 pu1_sigcoeff_context_inc = 622 (UWORD8 *)gau1_ih264d_sigcoeff_context_inc_field; 623 624 /*******************************************************************/ 625 /* last coefficient context is derived from significant coeff u4_flag */ 626 /* only significant coefficient matrix need to be initialized */ 627 /*******************************************************************/ 628 ps_ctxt_sig_coeff = ps_dec->s_high_profile.ps_sigcoeff_8x8_field; 629 } 630 631 /*loading from strcuctures*/ 632 633 u4_offset = ps_bitstrm->u4_ofst; 634 pu4_buffer = ps_bitstrm->pu4_buffer; 635 636 u4_code_int_range = ps_cab_env->u4_code_int_range; 637 u4_code_int_val_ofst = ps_cab_env->u4_code_int_val_ofst; 638 639 { 640 { 641 bin_ctxt_model_t *p_binCtxt_last, *p_binCtxt_last_org, 642 *p_ctxt_sig_coeff_org; 643 UWORD32 uc_last_coeff_idx; 644 UWORD32 uc_bin; 645 UWORD32 i; 646 647 i = 0; 648 649 uc_last_coeff_idx = 63; 650 651 p_binCtxt_last_org = ps_ctxt_sig_coeff 652 + LAST_COEFF_CTXT_MINUS_SIG_COEFF_CTXT_8X8; 653 654 p_ctxt_sig_coeff_org = ps_ctxt_sig_coeff; 655 656 do 657 { 658 /*inilined DecodeDecision_onebin begins*/ 659 { 660 UWORD32 u4_qnt_int_range, u4_int_range_lps; 661 UWORD32 u4_symbol, u1_mps_state; 662 UWORD32 table_lookup; 663 const UWORD32 *pu4_table = 664 (const UWORD32 *)ps_cab_env->cabac_table; 665 UWORD32 u4_clz; 666 667 u1_mps_state = (ps_ctxt_sig_coeff->u1_mps_state); 668 669 u4_clz = CLZ(u4_code_int_range); 670 671 u4_qnt_int_range = u4_code_int_range << u4_clz; 672 u4_qnt_int_range = (u4_qnt_int_range >> 29) & 0x3; 673 674 table_lookup = pu4_table[(u1_mps_state << 2) 675 + u4_qnt_int_range]; 676 677 u4_int_range_lps = table_lookup & 0xff; 678 679 u4_int_range_lps = u4_int_range_lps << (23 - u4_clz); 680 u4_code_int_range = u4_code_int_range - u4_int_range_lps; 681 u4_symbol = ((u1_mps_state >> 6) & 0x1); 682 u1_mps_state = (table_lookup >> 8) & 0x7F; 683 684 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, 685 u4_symbol, u4_int_range_lps, u1_mps_state, 686 table_lookup) 687 688 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_14) 689 { 690 UWORD32 read_bits, u4_clz; 691 u4_clz = CLZ(u4_code_int_range); 692 NEXTBITS(read_bits, (u4_offset + 23), pu4_buffer, 693 u4_clz) 694 FLUSHBITS(u4_offset, (u4_clz)) 695 u4_code_int_range = u4_code_int_range << u4_clz; 696 u4_code_int_val_ofst = (u4_code_int_val_ofst << u4_clz) 697 | read_bits; 698 } 699 700 ps_ctxt_sig_coeff->u1_mps_state = u1_mps_state; 701 uc_bin = u4_symbol; 702 } 703 /*incrementing pointer to point to the context of the next bin*/ 704 ps_ctxt_sig_coeff = p_ctxt_sig_coeff_org 705 + pu1_sigcoeff_context_inc[i + 1]; 706 707 /*inilined DecodeDecision_onebin ends*/ 708 if(uc_bin) 709 { 710 num_sig_coeffs++; 711 SET_BIT(ps_tu_8x8->au4_sig_coeff_map[i>31], (i > 31 ? i - 32:i)); 712 713 p_binCtxt_last = p_binCtxt_last_org 714 + pu1_lastcoeff_context_inc[i]; 715 716 /*inilined DecodeDecision_onebin begins*/ 717 718 { 719 UWORD32 u4_qnt_int_range, u4_int_range_lps; 720 UWORD32 u4_symbol, u1_mps_state; 721 UWORD32 table_lookup; 722 const UWORD32 *pu4_table = 723 (const UWORD32 *)ps_cab_env->cabac_table; 724 UWORD32 u4_clz; 725 726 u1_mps_state = (p_binCtxt_last->u1_mps_state); 727 728 u4_clz = CLZ(u4_code_int_range); 729 u4_qnt_int_range = u4_code_int_range << u4_clz; 730 u4_qnt_int_range = (u4_qnt_int_range >> 29) 731 & 0x3; 732 733 table_lookup = pu4_table[(u1_mps_state << 2) 734 + u4_qnt_int_range]; 735 u4_int_range_lps = table_lookup & 0xff; 736 737 u4_int_range_lps = u4_int_range_lps 738 << (23 - u4_clz); 739 740 u4_code_int_range = u4_code_int_range 741 - u4_int_range_lps; 742 u4_symbol = ((u1_mps_state >> 6) & 0x1); 743 u1_mps_state = (table_lookup >> 8) & 0x7F; 744 745 CHECK_IF_LPS(u4_code_int_range, u4_code_int_val_ofst, 746 u4_symbol, u4_int_range_lps, 747 u1_mps_state, table_lookup) 748 749 p_binCtxt_last->u1_mps_state = u1_mps_state; 750 uc_bin = u4_symbol; 751 } 752 753 /*inilined DecodeDecision_onebin ends*/ 754 if(uc_bin == 1) 755 goto label_read_levels; 756 757 } 758 759 i = i + 1; 760 761 } 762 while(i < uc_last_coeff_idx); 763 764 num_sig_coeffs++; 765 SET_BIT(ps_tu_8x8->au4_sig_coeff_map[i>31], (i > 31 ? i - 32:i)); 766 767 label_read_levels: ; 768 } 769 770 /// VALUE of No of Coeff in BLOCK = i + 1 for second case else i; 771 772 /* Decode coeff_abs_level_minus1 and coeff_sign_flag */ 773 { 774 WORD32 i2_abs_lvl; 775 UWORD32 u1_abs_level_equal1 = 1, u1_abs_level_gt1 = 0; 776 777 UWORD32 u4_ctx_inc; 778 UWORD32 ui_prefix; 779 bin_ctxt_model_t *p_ctxt_abs_level; 780 781 p_ctxt_abs_level = 782 ps_dec->p_coeff_abs_level_minus1_t[LUMA_8X8_CTXCAT]; 783 u4_ctx_inc = ((0x51)); 784 785 /*****************************************************/ 786 /* Main Loop runs for no. of Significant coefficient */ 787 /*****************************************************/ 788 do 789 { 790 { 791 792 /*****************************************************/ 793 /* inilining a modified ih264d_decode_bins_unary */ 794 /*****************************************************/ 795 796 { 797 UWORD32 u4_value; 798 UWORD32 u4_symbol; 799 bin_ctxt_model_t *ps_bin_ctxt; 800 UWORD32 u4_ctx_Inc; 801 u4_value = 0; 802 803 u4_ctx_Inc = u4_ctx_inc & 0xf; 804 ps_bin_ctxt = p_ctxt_abs_level + u4_ctx_Inc; 805 806 do 807 { 808 { 809 UWORD32 u4_qnt_int_range, 810 u4_int_range_lps; 811 UWORD32 u1_mps_state; 812 UWORD32 table_lookup; 813 const UWORD32 *pu4_table = 814 (const UWORD32 *)ps_cab_env->cabac_table; 815 UWORD32 u4_clz; 816 817 u1_mps_state = (ps_bin_ctxt->u1_mps_state); 818 u4_clz = CLZ(u4_code_int_range); 819 u4_qnt_int_range = u4_code_int_range 820 << u4_clz; 821 u4_qnt_int_range = (u4_qnt_int_range 822 >> 29) & 0x3; 823 table_lookup = pu4_table[(u1_mps_state << 2) 824 + u4_qnt_int_range]; 825 u4_int_range_lps = table_lookup & 0xff; 826 827 u4_int_range_lps = u4_int_range_lps 828 << (23 - u4_clz); 829 u4_code_int_range = u4_code_int_range 830 - u4_int_range_lps; 831 u4_symbol = ((u1_mps_state >> 6) & 0x1); 832 u1_mps_state = (table_lookup >> 8) & 0x7F; 833 834 CHECK_IF_LPS(u4_code_int_range, 835 u4_code_int_val_ofst, u4_symbol, 836 u4_int_range_lps, u1_mps_state, 837 table_lookup) 838 839 if(u4_code_int_range < ONE_RIGHT_SHIFTED_BY_9) 840 { 841 842 RENORM_RANGE_OFFSET(u4_code_int_range, 843 u4_code_int_val_ofst, 844 u4_offset, pu4_buffer) 845 } 846 847 ps_bin_ctxt->u1_mps_state = u1_mps_state; 848 } 849 850 u4_value++; 851 ps_bin_ctxt = p_ctxt_abs_level + (u4_ctx_inc >> 4); 852 853 } 854 while(u4_symbol && (u4_value < UCOFF_LEVEL)); 855 856 ui_prefix = u4_value - 1 + u4_symbol; 857 } 858 859 if(ui_prefix == UCOFF_LEVEL) 860 { 861 UWORD32 ui16_sufS = 0; 862 UWORD32 u1_max_bins; 863 UWORD32 u4_value; 864 865 i2_abs_lvl = UCOFF_LEVEL; 866 /*inlining ih264d_decode_bypass_bins_unary begins*/ 867 868 { 869 UWORD32 uc_bin; 870 UWORD32 bits_to_flush; 871 UWORD32 max_bits = 32; 872 873 bits_to_flush = 0; 874 /*renormalize to ensure there 23 bits more in the u4_code_int_val_ofst*/ 875 { 876 UWORD32 u4_clz, read_bits; 877 878 u4_clz = CLZ(u4_code_int_range); 879 FLUSHBITS(u4_offset, u4_clz) 880 NEXTBITS(read_bits, u4_offset, pu4_buffer, 23) 881 u4_code_int_range = u4_code_int_range << u4_clz; 882 u4_code_int_val_ofst = (u4_code_int_val_ofst 883 << u4_clz) | read_bits; 884 } 885 886 do 887 { 888 bits_to_flush++; 889 890 u4_code_int_range = u4_code_int_range >> 1; 891 892 if(u4_code_int_val_ofst >= u4_code_int_range) 893 { 894 /* S=1 */ 895 uc_bin = 1; 896 u4_code_int_val_ofst -= u4_code_int_range; 897 } 898 else 899 { 900 /* S=0 */ 901 uc_bin = 0; 902 } 903 904 } 905 while(uc_bin && (bits_to_flush < max_bits)); 906 907 u4_value = (bits_to_flush - 1); 908 } 909 /*inlining ih264d_decode_bypass_bins_unary ends*/ 910 911 ui16_sufS = (1 << u4_value); 912 u1_max_bins = u4_value; 913 914 if(u4_value > 0) 915 { 916 /*inline bypassbins_flc begins*/ 917 918 if(u4_value > 10) 919 { 920 UWORD32 u4_clz, read_bits; 921 922 u4_clz = CLZ(u4_code_int_range); 923 FLUSHBITS(u4_offset, u4_clz) 924 NEXTBITS(read_bits, u4_offset, pu4_buffer, 23) 925 u4_code_int_range = u4_code_int_range << u4_clz; 926 u4_code_int_val_ofst = (u4_code_int_val_ofst 927 << u4_clz) | read_bits; 928 } 929 930 { 931 UWORD32 ui_bins; 932 UWORD32 uc_bin; 933 UWORD32 bits_to_flush; 934 935 ui_bins = 0; 936 bits_to_flush = 0; 937 938 do 939 { 940 bits_to_flush++; 941 942 u4_code_int_range = u4_code_int_range >> 1; 943 944 if(u4_code_int_val_ofst 945 >= u4_code_int_range) 946 { 947 /* S=1 */ 948 uc_bin = 1; 949 u4_code_int_val_ofst -= 950 u4_code_int_range; 951 } 952 else 953 { 954 /* S=0 */ 955 uc_bin = 0; 956 } 957 958 ui_bins = ((ui_bins << 1) | uc_bin); 959 960 } 961 while(bits_to_flush < u1_max_bins); 962 963 u4_value = ui_bins; 964 } 965 /*inline bypassbins_flc ends*/ 966 } 967 968 //Value of K 969 ui16_sufS += u4_value; 970 i2_abs_lvl += ui16_sufS; 971 } 972 else 973 { 974 i2_abs_lvl = 1 + ui_prefix; 975 } 976 977 if(i2_abs_lvl > 1) 978 { 979 u1_abs_level_gt1++; 980 } 981 if(!u1_abs_level_gt1) 982 { 983 u1_abs_level_equal1++; 984 u4_ctx_inc = (5 << 4) + MIN(u1_abs_level_equal1, 4); 985 } 986 else 987 { 988 u4_ctx_inc = (5 + MIN(u1_abs_level_gt1, 4)) << 4; 989 } 990 991 /*u4_ctx_inc = g_table_temp[u1_abs_level_gt1][u1_abs_level_equal1];*/ 992 993 /* encode coeff_sign_flag[i] */ 994 995 { 996 u4_code_int_range = u4_code_int_range >> 1; 997 998 if(u4_code_int_val_ofst >= (u4_code_int_range)) 999 { 1000 /* S=1 */ 1001 u4_code_int_val_ofst -= u4_code_int_range; 1002 i2_abs_lvl = (-i2_abs_lvl); 1003 } 1004 } 1005 1006 *pi2_coeff_data++ = i2_abs_lvl; 1007 num_sig_coeffs--; 1008 } 1009 } 1010 while(num_sig_coeffs > 0); 1011 } 1012 } 1013 1014 { 1015 WORD32 offset; 1016 offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_8x8; 1017 offset = ALIGN4(offset); 1018 ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset); 1019 } 1020 1021 /*updating structures*/ 1022 ps_cab_env->u4_code_int_val_ofst = u4_code_int_val_ofst; 1023 ps_cab_env->u4_code_int_range = u4_code_int_range; 1024 ps_bitstrm->u4_ofst = u4_offset; 1025 } 1026 1027 /*****************************************************************************/ 1028 /* */ 1029 /* Function Name : ih264d_cabac_parse_8x8block */ 1030 /* */ 1031 /* Description : This function does the residual parsing of 4 subblocks */ 1032 /* in a 8x8 block. */ 1033 /* */ 1034 /* Inputs : pi2_coeff_block : pointer to residual block where */ 1035 /* decoded and inverse scan coefficients are updated */ 1036 /* */ 1037 /* u4_sub_block_strd : indicates the number of sublocks */ 1038 /* in a row. It is 4 for luma and 2 for chroma. */ 1039 /* */ 1040 /* u4_ctx_cat : inidicates context category for residual */ 1041 /* decoding. */ 1042 /* */ 1043 /* ps_dec : pointer to Decstruct (decoder context) */ 1044 /* */ 1045 /* pu1_top_nnz : top nnz pointer */ 1046 /* */ 1047 /* pu1_left_nnz : left nnz pointer */ 1048 /* */ 1049 /* Globals : No */ 1050 /* Processing : Parsing for four subblocks in unrolled, top and left nnz */ 1051 /* are updated on the fly. csbp is set in accordance to */ 1052 /* decoded numcoeff for the subblock index in raster order */ 1053 /* */ 1054 /* Outputs : The updated residue buffer, nnzs and csbp current block */ 1055 /* */ 1056 /* Returns : Returns the coded sub block pattern csbp for the block */ 1057 /* */ 1058 /* Issues : <List any issues or problems with this function> */ 1059 /* */ 1060 /* Revision History: */ 1061 /* */ 1062 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1063 /* 09 10 2008 Jay Draft */ 1064 /* */ 1065 /*****************************************************************************/ 1066 UWORD32 ih264d_cabac_parse_8x8block(WORD16 *pi2_coeff_block, 1067 UWORD32 u4_sub_block_strd, 1068 UWORD32 u4_ctx_cat, 1069 dec_struct_t * ps_dec, 1070 UWORD8 *pu1_top_nnz, 1071 UWORD8 *pu1_left_nnz) 1072 { 1073 UWORD32 u4_ctxinc, u4_subblock_coded; 1074 UWORD32 u4_top0, u4_top1; 1075 UWORD32 u4_csbp = 0; 1076 UWORD32 u4_idx = 0; 1077 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 1078 bin_ctxt_model_t * const ps_cbf = ps_dec->p_cbf_t[u4_ctx_cat]; 1079 bin_ctxt_model_t *ps_src_bin_ctxt; 1080 bin_ctxt_model_t * const ps_sig_coeff_flag = 1081 ps_dec->p_significant_coeff_flag_t[u4_ctx_cat]; 1082 1083 UWORD8 *pu1_inv_scan = ps_dec->pu1_inv_scan; 1084 1085 /*------------------------------------------------------*/ 1086 /* Residual 4x4 decoding: SubBlock 0 */ 1087 /*------------------------------------------------------*/ 1088 u4_ctxinc = ((!!pu1_top_nnz[0]) << 1) + (!!pu1_left_nnz[0]); 1089 1090 ps_src_bin_ctxt = ps_cbf + u4_ctxinc; 1091 1092 u4_top0 = ih264d_read_coeff4x4_cabac( ps_bitstrm, 1093 u4_ctx_cat, ps_sig_coeff_flag, ps_dec, 1094 ps_src_bin_ctxt); 1095 1096 INSERT_BIT(u4_csbp, u4_idx, u4_top0); 1097 1098 /*------------------------------------------------------*/ 1099 /* Residual 4x4 decoding: SubBlock 1 */ 1100 /*------------------------------------------------------*/ 1101 u4_idx++; 1102 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; 1103 u4_ctxinc = ((!!pu1_top_nnz[1]) << 1) + u4_top0; 1104 1105 ps_src_bin_ctxt = ps_cbf + u4_ctxinc; 1106 1107 u4_top1 = ih264d_read_coeff4x4_cabac(ps_bitstrm, 1108 u4_ctx_cat, ps_sig_coeff_flag, ps_dec, 1109 ps_src_bin_ctxt); 1110 1111 INSERT_BIT(u4_csbp, u4_idx, u4_top1); 1112 pu1_left_nnz[0] = u4_top1; 1113 1114 /*------------------------------------------------------*/ 1115 /* Residual 4x4 decoding: SubBlock 2 */ 1116 /*------------------------------------------------------*/ 1117 u4_idx += (u4_sub_block_strd - 1); 1118 pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK); 1119 u4_ctxinc = (u4_top0 << 1) + (!!pu1_left_nnz[1]); 1120 1121 ps_src_bin_ctxt = ps_cbf + u4_ctxinc; 1122 1123 u4_subblock_coded = ih264d_read_coeff4x4_cabac(ps_bitstrm, u4_ctx_cat, 1124 ps_sig_coeff_flag, ps_dec, 1125 ps_src_bin_ctxt); 1126 1127 INSERT_BIT(u4_csbp, u4_idx, u4_subblock_coded); 1128 pu1_top_nnz[0] = u4_subblock_coded; 1129 1130 /*------------------------------------------------------*/ 1131 /* Residual 4x4 decoding: SubBlock 3 */ 1132 /*------------------------------------------------------*/ 1133 u4_idx++; 1134 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; 1135 u4_ctxinc = (u4_top1 << 1) + u4_subblock_coded; 1136 1137 ps_src_bin_ctxt = ps_cbf + u4_ctxinc; 1138 1139 u4_subblock_coded = ih264d_read_coeff4x4_cabac(ps_bitstrm, u4_ctx_cat, 1140 ps_sig_coeff_flag, ps_dec, 1141 ps_src_bin_ctxt); 1142 1143 INSERT_BIT(u4_csbp, u4_idx, u4_subblock_coded); 1144 pu1_top_nnz[1] = pu1_left_nnz[1] = u4_subblock_coded; 1145 1146 return (u4_csbp); 1147 } 1148 1149 /*! 1150 ************************************************************************** 1151 * \if Function name : ih264d_parse_residual4x4_cabac \endif 1152 * 1153 * \brief 1154 * This function parses CABAC syntax of a Luma and Chroma AC Residuals. 1155 * 1156 * \return 1157 * 0 on Success and Error code otherwise 1158 ************************************************************************** 1159 */ 1160 1161 WORD32 ih264d_parse_residual4x4_cabac(dec_struct_t * ps_dec, 1162 dec_mb_info_t *ps_cur_mb_info, 1163 UWORD8 u1_offset) 1164 { 1165 UWORD8 u1_cbp = ps_cur_mb_info->u1_cbp; 1166 UWORD16 ui16_csbp = 0; 1167 WORD16 *pi2_residual_buf; 1168 UWORD8 uc_ctx_cat; 1169 UWORD8 *pu1_top_nnz = ps_cur_mb_info->ps_curmb->pu1_nnz_y; 1170 UWORD8 *pu1_left_nnz = ps_dec->pu1_left_nnz_y; 1171 UWORD8 *pu1_top_nnz_uv = ps_cur_mb_info->ps_curmb->pu1_nnz_uv; 1172 ctxt_inc_mb_info_t *p_curr_ctxt = ps_dec->ps_curr_ctxt_mb_info; 1173 ctxt_inc_mb_info_t *ps_top_ctxt = ps_dec->p_top_ctxt_mb_info; 1174 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 1175 UWORD32 u4_nbr_avail = ps_dec->u1_mb_ngbr_availablity; 1176 WORD16 *pi2_coeff_block = NULL; 1177 bin_ctxt_model_t *ps_src_bin_ctxt; 1178 1179 UWORD8 u1_top_dc_csbp = (ps_top_ctxt->u1_yuv_dc_csbp) >> 1; 1180 UWORD8 u1_left_dc_csbp = (ps_dec->pu1_left_yuv_dc_csbp[0]) >> 1; 1181 1182 1183 if(!(u4_nbr_avail & TOP_MB_AVAILABLE_MASK)) 1184 { 1185 if(p_curr_ctxt->u1_mb_type & CAB_INTRA_MASK) 1186 { 1187 *(UWORD32 *)pu1_top_nnz = 0; 1188 u1_top_dc_csbp = 0; 1189 *(UWORD32 *)pu1_top_nnz_uv = 0; 1190 } 1191 else 1192 { 1193 *(UWORD32 *)pu1_top_nnz = 0x01010101; 1194 u1_top_dc_csbp = 0x3; 1195 *(UWORD32 *)pu1_top_nnz_uv = 0x01010101; 1196 } 1197 } 1198 else 1199 { 1200 UWORD32 *pu4_buf; 1201 UWORD8 *pu1_buf; 1202 pu1_buf = ps_cur_mb_info->ps_top_mb->pu1_nnz_y; 1203 pu4_buf = (UWORD32 *)pu1_buf; 1204 *(UWORD32 *)(pu1_top_nnz) = *pu4_buf; 1205 1206 pu1_buf = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv; 1207 pu4_buf = (UWORD32 *)pu1_buf; 1208 *(UWORD32 *)(pu1_top_nnz_uv) = *pu4_buf; 1209 1210 } 1211 1212 if(!(u4_nbr_avail & LEFT_MB_AVAILABLE_MASK)) 1213 { 1214 if(p_curr_ctxt->u1_mb_type & CAB_INTRA_MASK) 1215 { 1216 UWORD32 *pu4_buf; 1217 UWORD8 *pu1_buf; 1218 *(UWORD32 *)pu1_left_nnz = 0; 1219 u1_left_dc_csbp = 0; 1220 pu1_buf = ps_dec->pu1_left_nnz_uv; 1221 pu4_buf = (UWORD32 *)pu1_buf; 1222 *pu4_buf = 0; 1223 } 1224 else 1225 { 1226 UWORD32 *pu4_buf; 1227 UWORD8 *pu1_buf; 1228 *(UWORD32 *)pu1_left_nnz = 0x01010101; 1229 u1_left_dc_csbp = 0x3; 1230 pu1_buf = ps_dec->pu1_left_nnz_uv; 1231 pu4_buf = (UWORD32 *)pu1_buf; 1232 *pu4_buf = 0x01010101; 1233 } 1234 } 1235 1236 uc_ctx_cat = u1_offset ? LUMA_AC_CTXCAT : LUMA_4X4_CTXCAT; 1237 1238 ps_cur_mb_info->u1_qp_div6 = ps_dec->u1_qp_y_div6; 1239 ps_cur_mb_info->u1_qpc_div6 = ps_dec->u1_qp_u_div6; 1240 ps_cur_mb_info->u1_qp_rem6 = ps_dec->u1_qp_y_rem6; 1241 ps_cur_mb_info->u1_qpc_rem6 = ps_dec->u1_qp_u_rem6; 1242 // CHECK_THIS 1243 ps_cur_mb_info->u1_qpcr_div6 = ps_dec->u1_qp_v_div6; 1244 ps_cur_mb_info->u1_qpcr_rem6 = ps_dec->u1_qp_v_rem6; 1245 1246 if(u1_cbp & 0x0f) 1247 { 1248 if(ps_cur_mb_info->u1_tran_form8x8 == 0) 1249 { 1250 /*******************************************************************/ 1251 /* Block 0 residual decoding, check cbp and proceed (subblock = 0) */ 1252 /*******************************************************************/ 1253 if(!(u1_cbp & 0x1)) 1254 { 1255 *(UWORD16 *)(pu1_top_nnz) = 0; 1256 *(UWORD16 *)(pu1_left_nnz) = 0; 1257 } 1258 else 1259 { 1260 ui16_csbp = ih264d_cabac_parse_8x8block(pi2_coeff_block, 4, 1261 uc_ctx_cat, ps_dec, 1262 pu1_top_nnz, 1263 pu1_left_nnz); 1264 } 1265 1266 /*******************************************************************/ 1267 /* Block 1 residual decoding, check cbp and proceed (subblock = 2) */ 1268 /*******************************************************************/ 1269 pi2_coeff_block += (2 * NUM_COEFFS_IN_4x4BLK); 1270 if(!(u1_cbp & 0x2)) 1271 { 1272 *(UWORD16 *)(pu1_top_nnz + 2) = 0; 1273 *(UWORD16 *)(pu1_left_nnz) = 0; 1274 } 1275 else 1276 { 1277 UWORD32 u4_temp = ih264d_cabac_parse_8x8block(pi2_coeff_block, 1278 4, uc_ctx_cat, 1279 ps_dec, 1280 (pu1_top_nnz + 2), 1281 pu1_left_nnz); 1282 ui16_csbp |= (u4_temp << 2); 1283 } 1284 1285 /*******************************************************************/ 1286 /* Block 2 residual decoding, check cbp and proceed (subblock = 8) */ 1287 /*******************************************************************/ 1288 pi2_coeff_block += (6 * NUM_COEFFS_IN_4x4BLK); 1289 if(!(u1_cbp & 0x4)) 1290 { 1291 *(UWORD16 *)(pu1_top_nnz) = 0; 1292 *(UWORD16 *)(pu1_left_nnz + 2) = 0; 1293 } 1294 else 1295 { 1296 UWORD32 u4_temp = ih264d_cabac_parse_8x8block( 1297 pi2_coeff_block, 4, uc_ctx_cat, ps_dec, 1298 pu1_top_nnz, (pu1_left_nnz + 2)); 1299 ui16_csbp |= (u4_temp << 8); 1300 } 1301 1302 /*******************************************************************/ 1303 /* Block 3 residual decoding, check cbp and proceed (subblock = 10)*/ 1304 /*******************************************************************/ 1305 pi2_coeff_block += (2 * NUM_COEFFS_IN_4x4BLK); 1306 if(!(u1_cbp & 0x8)) 1307 { 1308 *(UWORD16 *)(pu1_top_nnz + 2) = 0; 1309 *(UWORD16 *)(pu1_left_nnz + 2) = 0; 1310 } 1311 else 1312 { 1313 UWORD32 u4_temp = ih264d_cabac_parse_8x8block( 1314 pi2_coeff_block, 4, uc_ctx_cat, ps_dec, 1315 (pu1_top_nnz + 2), (pu1_left_nnz + 2)); 1316 ui16_csbp |= (u4_temp << 10); 1317 } 1318 1319 } 1320 else 1321 { 1322 ui16_csbp = 0; 1323 1324 /*******************************************************************/ 1325 /* Block 0 residual decoding, check cbp and proceed (subblock = 0) */ 1326 /*******************************************************************/ 1327 if(!(u1_cbp & 0x1)) 1328 { 1329 *(UWORD16 *)(pu1_top_nnz) = 0; 1330 *(UWORD16 *)(pu1_left_nnz) = 0; 1331 } 1332 else 1333 { 1334 1335 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 1336 1337 ih264d_read_coeff8x8_cabac( ps_bitstrm, 1338 ps_dec, ps_cur_mb_info); 1339 1340 pu1_left_nnz[0] = 1; 1341 pu1_left_nnz[1] = 1; 1342 1343 pu1_top_nnz[0] = 1; 1344 pu1_top_nnz[1] = 1; 1345 1346 /* added to be used by BS computation module */ 1347 ui16_csbp |= 0x0033; 1348 } 1349 1350 /*******************************************************************/ 1351 /* Block 1 residual decoding, check cbp and proceed (subblock = 2) */ 1352 /*******************************************************************/ 1353 pi2_coeff_block += 64; 1354 1355 if(!(u1_cbp & 0x2)) 1356 { 1357 *(UWORD16 *)(pu1_top_nnz + 2) = 0; 1358 *(UWORD16 *)(pu1_left_nnz) = 0; 1359 } 1360 else 1361 { 1362 1363 1364 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 1365 1366 ih264d_read_coeff8x8_cabac(ps_bitstrm, 1367 ps_dec, ps_cur_mb_info); 1368 1369 pu1_left_nnz[0] = 1; 1370 pu1_left_nnz[1] = 1; 1371 1372 pu1_top_nnz[2] = 1; 1373 pu1_top_nnz[3] = 1; 1374 1375 /* added to be used by BS computation module */ 1376 ui16_csbp |= 0x00CC; 1377 1378 } 1379 1380 /*******************************************************************/ 1381 /* Block 2 residual decoding, check cbp and proceed (subblock = 8) */ 1382 /*******************************************************************/ 1383 pi2_coeff_block += 64; 1384 if(!(u1_cbp & 0x4)) 1385 { 1386 *(UWORD16 *)(pu1_top_nnz) = 0; 1387 *(UWORD16 *)(pu1_left_nnz + 2) = 0; 1388 } 1389 else 1390 { 1391 1392 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 1393 1394 ih264d_read_coeff8x8_cabac(ps_bitstrm, 1395 ps_dec, ps_cur_mb_info); 1396 1397 pu1_left_nnz[2] = 1; 1398 pu1_left_nnz[3] = 1; 1399 1400 pu1_top_nnz[0] = 1; 1401 pu1_top_nnz[1] = 1; 1402 1403 /* added to be used by BS computation module */ 1404 ui16_csbp |= 0x3300; 1405 } 1406 1407 /*******************************************************************/ 1408 /* Block 3 residual decoding, check cbp and proceed (subblock = 10)*/ 1409 /*******************************************************************/ 1410 pi2_coeff_block += 64; 1411 1412 if(!(u1_cbp & 0x8)) 1413 { 1414 *(UWORD16 *)(pu1_top_nnz + 2) = 0; 1415 *(UWORD16 *)(pu1_left_nnz + 2) = 0; 1416 } 1417 else 1418 { 1419 1420 dec_bit_stream_t * const ps_bitstrm = ps_dec->ps_bitstrm; 1421 1422 ih264d_read_coeff8x8_cabac(ps_bitstrm, 1423 ps_dec, ps_cur_mb_info); 1424 1425 pu1_left_nnz[2] = 1; 1426 pu1_left_nnz[3] = 1; 1427 1428 pu1_top_nnz[2] = 1; 1429 pu1_top_nnz[3] = 1; 1430 1431 /* added to be used by BS computation module */ 1432 ui16_csbp |= 0xCC00; 1433 } 1434 } 1435 } 1436 else 1437 { 1438 *(UWORD32 *)(pu1_top_nnz) = 0; 1439 *(UWORD32 *)(pu1_left_nnz) = 0; 1440 } 1441 /*--------------------------------------------------------------------*/ 1442 /* Store the last row of N values to top row */ 1443 /*--------------------------------------------------------------------*/ 1444 ps_cur_mb_info->u2_luma_csbp = ui16_csbp; 1445 ps_cur_mb_info->ps_curmb->u2_luma_csbp = ui16_csbp; 1446 { 1447 WORD8 i; 1448 UWORD16 u2_chroma_csbp = 0; 1449 ps_cur_mb_info->u2_chroma_csbp = 0; 1450 1451 u1_cbp >>= 4; 1452 pu1_top_nnz = pu1_top_nnz_uv; 1453 pu1_left_nnz = ps_dec->pu1_left_nnz_uv; 1454 /*--------------------------------------------------------------------*/ 1455 /* if Chroma Component not present OR no ac values present */ 1456 /* Set the values of N to zero */ 1457 /*--------------------------------------------------------------------*/ 1458 if(u1_cbp == CBPC_ALLZERO) 1459 { 1460 ps_dec->pu1_left_yuv_dc_csbp[0] &= 0x1; 1461 *(UWORD32 *)(pu1_top_nnz) = 0; 1462 *(UWORD32 *)(pu1_left_nnz) = 0; 1463 p_curr_ctxt->u1_yuv_dc_csbp &= 0x1; 1464 return (0); 1465 } 1466 1467 /*--------------------------------------------------------------------*/ 1468 /* Decode Chroma DC values */ 1469 /*--------------------------------------------------------------------*/ 1470 for(i = 0; i < 2; i++) 1471 { 1472 UWORD8 uc_a = 1, uc_b = 1; 1473 UWORD32 u4_ctx_inc; 1474 UWORD8 uc_codedBlockFlag; 1475 UWORD8 pu1_inv_scan[4] = 1476 { 0, 1, 2, 3 }; 1477 WORD32 u4_scale; 1478 WORD32 i4_mb_inter_inc; 1479 tu_sblk4x4_coeff_data_t *ps_tu_4x4 = 1480 (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; 1481 WORD16 *pi2_coeff_data = 1482 (WORD16 *)ps_dec->pv_parse_tu_coeff_data; 1483 WORD16 ai2_dc_coef[4]; 1484 1485 INC_SYM_COUNT(&(ps_dec->s_cab_dec_env)); 1486 u4_scale = (i) ? 1487 (ps_dec->pu2_quant_scale_v[0] 1488 << ps_dec->u1_qp_v_div6) : 1489 (ps_dec->pu2_quant_scale_u[0] 1490 << ps_dec->u1_qp_u_div6); 1491 1492 /*--------------------------------------------------------------------*/ 1493 /* Decode Bitstream to get the DC coeff */ 1494 /*--------------------------------------------------------------------*/ 1495 uc_a = (u1_left_dc_csbp >> i) & 0x01; 1496 uc_b = (u1_top_dc_csbp >> i) & 0x01; 1497 u4_ctx_inc = (uc_a + (uc_b << 1)); 1498 1499 ps_src_bin_ctxt = (ps_dec->p_cbf_t[CHROMA_DC_CTXCAT]) + u4_ctx_inc; 1500 1501 uc_codedBlockFlag = 1502 ih264d_read_coeff4x4_cabac(ps_bitstrm, 1503 CHROMA_DC_CTXCAT, 1504 ps_dec->p_significant_coeff_flag_t[CHROMA_DC_CTXCAT], 1505 ps_dec, ps_src_bin_ctxt); 1506 1507 i4_mb_inter_inc = (!((ps_cur_mb_info->ps_curmb->u1_mb_type == I_4x4_MB) 1508 || (ps_cur_mb_info->ps_curmb->u1_mb_type == I_16x16_MB))) 1509 * 3; 1510 1511 if(ps_dec->s_high_profile.u1_scaling_present) 1512 { 1513 u4_scale *= 1514 ps_dec->s_high_profile.i2_scalinglist4x4[i4_mb_inter_inc 1515 + 1 + i][0]; 1516 1517 } 1518 else 1519 { 1520 u4_scale <<= 4; 1521 } 1522 1523 if(uc_codedBlockFlag) 1524 { 1525 WORD32 i_z0, i_z1, i_z2, i_z3; 1526 WORD32 *pi4_scale; 1527 1528 SET_BIT(u1_top_dc_csbp, i); 1529 SET_BIT(u1_left_dc_csbp, i); 1530 1531 ai2_dc_coef[0] = 0; 1532 ai2_dc_coef[1] = 0; 1533 ai2_dc_coef[2] = 0; 1534 ai2_dc_coef[3] = 0; 1535 1536 ih264d_unpack_coeff4x4_dc_4x4blk(ps_tu_4x4, 1537 ai2_dc_coef, 1538 pu1_inv_scan); 1539 i_z0 = (ai2_dc_coef[0] + ai2_dc_coef[2]); 1540 i_z1 = (ai2_dc_coef[0] - ai2_dc_coef[2]); 1541 i_z2 = (ai2_dc_coef[1] - ai2_dc_coef[3]); 1542 i_z3 = (ai2_dc_coef[1] + ai2_dc_coef[3]); 1543 1544 /*-----------------------------------------------------------*/ 1545 /* Scaling and storing the values back */ 1546 /*-----------------------------------------------------------*/ 1547 *pi2_coeff_data++ = ((i_z0 + i_z3) * u4_scale) >> 5; 1548 *pi2_coeff_data++ = ((i_z0 - i_z3) * u4_scale) >> 5; 1549 *pi2_coeff_data++ = ((i_z1 + i_z2) * u4_scale) >> 5; 1550 *pi2_coeff_data++ = ((i_z1 - i_z2) * u4_scale) >> 5; 1551 1552 ps_dec->pv_parse_tu_coeff_data = (void *)pi2_coeff_data; 1553 1554 SET_BIT(ps_cur_mb_info->u1_yuv_dc_block_flag,(i+1)); 1555 } 1556 else 1557 { 1558 CLEARBIT(u1_top_dc_csbp, i); 1559 CLEARBIT(u1_left_dc_csbp, i); 1560 } 1561 } 1562 1563 /*********************************************************************/ 1564 /* Update the DC csbp */ 1565 /*********************************************************************/ 1566 ps_dec->pu1_left_yuv_dc_csbp[0] &= 0x1; 1567 p_curr_ctxt->u1_yuv_dc_csbp &= 0x1; 1568 ps_dec->pu1_left_yuv_dc_csbp[0] |= (u1_left_dc_csbp << 1); 1569 p_curr_ctxt->u1_yuv_dc_csbp |= (u1_top_dc_csbp << 1); 1570 if(u1_cbp == CBPC_ACZERO) 1571 { 1572 *(UWORD32 *)(pu1_top_nnz) = 0; 1573 *(UWORD32 *)(pu1_left_nnz) = 0; 1574 return (0); 1575 } 1576 /*--------------------------------------------------------------------*/ 1577 /* Decode Chroma AC values */ 1578 /*--------------------------------------------------------------------*/ 1579 { 1580 UWORD32 u4_temp; 1581 /*****************************************************************/ 1582 /* U Block residual decoding, check cbp and proceed (subblock=0)*/ 1583 /*****************************************************************/ 1584 u2_chroma_csbp = ih264d_cabac_parse_8x8block(pi2_coeff_block, 2, 1585 CHROMA_AC_CTXCAT, 1586 ps_dec, pu1_top_nnz, 1587 pu1_left_nnz); 1588 1589 pi2_coeff_block += MB_CHROM_SIZE; 1590 /*****************************************************************/ 1591 /* V Block residual decoding, check cbp and proceed (subblock=1)*/ 1592 /*****************************************************************/ 1593 u4_temp = ih264d_cabac_parse_8x8block(pi2_coeff_block, 2, 1594 CHROMA_AC_CTXCAT, 1595 ps_dec, (pu1_top_nnz + 2), 1596 (pu1_left_nnz + 2)); 1597 u2_chroma_csbp |= (u4_temp << 4); 1598 } 1599 /*********************************************************************/ 1600 /* Update the AC csbp */ 1601 /*********************************************************************/ 1602 ps_cur_mb_info->u2_chroma_csbp = u2_chroma_csbp; 1603 } 1604 1605 return (0); 1606 } 1607 1608
