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_cavlc.c 23 * 24 * \brief 25 * This file contains UVLC related functions. 26 * 27 * \date 28 * 20/11/2002 29 * 30 * \author NS 31 *************************************************************************** 32 */ 33 34 #include <string.h> 35 #include <stdio.h> 36 37 #include "ih264d_bitstrm.h" 38 #include "ih264d_parse_cavlc.h" 39 #include "ih264d_error_handler.h" 40 #include "ih264d_defs.h" 41 #include "ih264d_debug.h" 42 #include "ih264d_cabac.h" 43 #include "ih264d_structs.h" 44 #include "ih264d_tables.h" 45 #include "ih264d_tables.h" 46 #include "ih264d_mb_utils.h" 47 48 void ih264d_unpack_coeff4x4_dc_4x4blk(tu_sblk4x4_coeff_data_t *ps_tu_4x4, 49 WORD16 *pi2_out_coeff_data, 50 UWORD8 *pu1_inv_scan); 51 52 /*****************************************************************************/ 53 /* */ 54 /* Function Name : ih264d_uev */ 55 /* */ 56 /* Description : Reads the unsigned Exp Golomb codec syntax from the */ 57 /* ps_bitstrm as specified in section 9.1 of H264 standard */ 58 /* It also increases bitstream u4_ofst by the number of bits */ 59 /* parsed for UEV decode operation */ 60 /* */ 61 /* Inputs : bitstream base pointer and bitsream u4_ofst in bits */ 62 /* Globals : None */ 63 /* Processing : */ 64 /* Outputs : UEV decoded syntax element and incremented ps_bitstrm u4_ofst */ 65 /* Returns : UEV decoded syntax element */ 66 /* */ 67 /* Issues : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size */ 68 /* for performamce. Caller might have to do error resilence */ 69 /* check for bitstream overflow */ 70 /* */ 71 /* Revision History: */ 72 /* */ 73 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 74 /* 19 09 2008 Jay Draft */ 75 /* */ 76 /*****************************************************************************/ 77 UWORD32 ih264d_uev(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf) 78 { 79 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; 80 UWORD32 u4_word, u4_ldz; 81 82 /***************************************************************/ 83 /* Find leading zeros in next 32 bits */ 84 /***************************************************************/ 85 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); 86 u4_ldz = CLZ(u4_word); 87 /* Flush the ps_bitstrm */ 88 u4_bitstream_offset += (u4_ldz + 1); 89 /* Read the suffix from the ps_bitstrm */ 90 u4_word = 0; 91 if(u4_ldz) 92 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz); 93 *pu4_bitstrm_ofst = u4_bitstream_offset; 94 return ((1 << u4_ldz) + u4_word - 1); 95 } 96 97 /*****************************************************************************/ 98 /* */ 99 /* Function Name : ih264d_sev */ 100 /* */ 101 /* Description : Reads the signed Exp Golomb codec syntax from the ps_bitstrm */ 102 /* as specified in section 9.1 of H264 standard. */ 103 /* It also increases bitstream u4_ofst by the number of bits */ 104 /* parsed for SEV decode operation */ 105 /* */ 106 /* Inputs : bitstream base pointer and bitsream u4_ofst in bits */ 107 /* Globals : None */ 108 /* Processing : */ 109 /* Outputs : SEV decoded syntax element and incremented ps_bitstrm u4_ofst */ 110 /* Returns : SEV decoded syntax element */ 111 /* */ 112 /* Issues : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size */ 113 /* for performamce. Caller might have to do error resilence */ 114 /* check for bitstream overflow */ 115 /* */ 116 /* Revision History: */ 117 /* */ 118 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 119 /* 19 09 2008 Jay Draft */ 120 /* */ 121 /*****************************************************************************/ 122 WORD32 ih264d_sev(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf) 123 { 124 UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; 125 UWORD32 u4_word, u4_ldz, u4_abs_val; 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 133 /* Flush the ps_bitstrm */ 134 u4_bitstream_offset += (u4_ldz + 1); 135 136 /* Read the suffix from the ps_bitstrm */ 137 u4_word = 0; 138 if(u4_ldz) 139 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz); 140 141 *pu4_bitstrm_ofst = u4_bitstream_offset; 142 u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1; 143 144 if(u4_word & 0x1) 145 return (-(WORD32)u4_abs_val); 146 else 147 return (u4_abs_val); 148 } 149 150 /*****************************************************************************/ 151 /* */ 152 /* Function Name : get_tev_range_1 */ 153 /* */ 154 /* Description : Reads the TEV Exp Golomb codec syntax from the ps_bitstrm */ 155 /* as specified in section 9.1 of H264 standard. This will */ 156 /* called only when the input range is 1 for TEV decode. */ 157 /* If range is more than 1, then UEV decode is done */ 158 /* */ 159 /* Inputs : bitstream base pointer and bitsream u4_ofst in bits */ 160 /* Globals : None */ 161 /* Processing : */ 162 /* Outputs : TEV decoded syntax element and incremented ps_bitstrm u4_ofst */ 163 /* Returns : TEV decoded syntax element */ 164 /* */ 165 /* Issues : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size */ 166 /* for performamce. Caller might have to do error resilence */ 167 /* check for bitstream overflow */ 168 /* */ 169 /* Revision History: */ 170 /* */ 171 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 172 /* 19 09 2008 Jay Draft */ 173 /* */ 174 /*****************************************************************************/ 175 UWORD32 ih264d_tev_range1(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf) 176 { 177 UWORD32 u4_code; 178 GETBIT(u4_code, *pu4_bitstrm_ofst, pu4_bitstrm_buf); 179 return (!u4_code); 180 } 181 182 /*! 183 ************************************************************************** 184 * \if Function name : ih264d_uvlc \endif 185 * 186 * \brief 187 * 188 * Reads the unsigned/signed/truncated integer Exp-Golomb-coded syntax element 189 * with the left bit first. The parsing process for this descriptor is specified 190 * in subclause 9.1. 191 * 192 * \param ps_bitstrm : Pointer to Bitstream Structure . 193 * \param u4_range : Range value in case of Truncated Exp-Golomb-code 194 * \param pi_bitstrm_ofst : Pointer to the local copy of Bitstream u4_ofst 195 * \param u1_flag : Flag indicating the case of UEV,SEV or TEV 196 * \param u4_bitstrm_ofst : Local copy of Bitstream u4_ofst 197 * \param pu4_bitstrm_buf : Pointer to the Bitstream buffer 198 * 199 * \return 200 * Returns Code Value. 201 * 202 ************************************************************************** 203 */ 204 205 WORD32 ih264d_uvlc(dec_bit_stream_t *ps_bitstrm, 206 UWORD32 u4_range, 207 UWORD32 *pi_bitstrm_ofst, 208 UWORD8 u1_flag, 209 UWORD32 u4_bitstrm_ofst, 210 UWORD32 *pu4_bitstrm_buf) 211 { 212 UWORD32 word, word2, cur_bit, cur_word, code_val, code_num, clz; 213 214 SWITCHOFFTRACE; 215 cur_bit = u4_bitstrm_ofst & 0x1F; 216 cur_word = u4_bitstrm_ofst >> 5; 217 word = pu4_bitstrm_buf[cur_word]; 218 word2 = pu4_bitstrm_buf[cur_word + 1]; 219 220 if(cur_bit != 0) 221 { 222 word <<= cur_bit; 223 word2 >>= (32 - cur_bit); 224 word |= word2; 225 } 226 227 if(u1_flag == TEV && u4_range == 1) 228 { 229 word >>= 31; 230 word = 1 - word; 231 (*pi_bitstrm_ofst)++; 232 ps_bitstrm->u4_ofst = *pi_bitstrm_ofst; 233 return (WORD32)word; 234 } 235 236 //finding clz 237 { 238 UWORD32 ui32_code, ui32_mask; 239 240 ui32_code = word; 241 ui32_mask = 0x80000000; 242 clz = 0; 243 244 /* DSP implements this with LMBD instruction */ 245 /* so there we don't need to break the loop */ 246 while(!(ui32_code & ui32_mask)) 247 { 248 clz++; 249 ui32_mask >>= 1; 250 if(0 == ui32_mask) 251 break; 252 } 253 } 254 255 if(clz == 0) 256 { 257 *pi_bitstrm_ofst = *pi_bitstrm_ofst + (2 * clz) + 1; 258 ps_bitstrm->u4_ofst = *pi_bitstrm_ofst; 259 return 0; 260 } 261 262 word <<= (clz + 1); 263 word >>= (32 - clz); 264 code_num = (1 << clz) + word - 1; 265 *pi_bitstrm_ofst = *pi_bitstrm_ofst + (2 * clz) + 1; 266 ps_bitstrm->u4_ofst = *pi_bitstrm_ofst; 267 268 if(u1_flag == TEV || u1_flag == UEV) 269 return (WORD32)code_num; 270 271 code_val = (code_num + 1) >> 1; 272 if(!(code_num & 0x01)) 273 return -((WORD32)code_val); 274 return (WORD32)code_val; 275 276 } 277 278 /*****************************************************************************/ 279 /* */ 280 /* Function Name : ih264d_cavlc_4x4res_block_totalcoeff_1 */ 281 /* */ 282 /* Description : This function does cavlc decoding of 4x4 block residual */ 283 /* coefficient when total coeff is equal to 1. The parsing */ 284 /* is done as defined in section 9.2.2 and 9.2.3 of the */ 285 /* H264 standard. */ 286 /* */ 287 /* Inputs : <What inputs does the function take?> */ 288 /* Globals : <Does it use any global variables?> */ 289 /* Processing : <Describe how the function operates - include algorithm */ 290 /* description> */ 291 /* Outputs : <What does the function produce?> */ 292 /* Returns : <What does the function return?> */ 293 /* */ 294 /* Issues : <List any issues or problems with this function> */ 295 /* */ 296 /* Revision History: */ 297 /* */ 298 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 299 /* 25 09 2008 Jay Draft */ 300 /* */ 301 /*****************************************************************************/ 302 WORD32 ih264d_cavlc_4x4res_block_totalcoeff_1(UWORD32 u4_isdc, 303 UWORD32 u4_total_coeff_trail_one, 304 dec_bit_stream_t *ps_bitstrm) 305 { 306 307 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 308 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; 309 UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF; 310 WORD32 i2_level; 311 UWORD32 u4_tot_zero, u4_ldz, u4_scan_pos; 312 313 tu_sblk4x4_coeff_data_t *ps_tu_4x4; 314 WORD16 *pi2_coeff_data; 315 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; 316 317 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; 318 ps_tu_4x4->u2_sig_coeff_map = 0; 319 pi2_coeff_data = &ps_tu_4x4->ai2_level[0]; 320 321 322 if(u4_trailing_ones) 323 { 324 UWORD32 u4_sign; 325 /****************************************************************/ 326 /* Decode Trailing One as in section 9.2.2 */ 327 /****************************************************************/ 328 GETBIT(u4_sign, u4_bitstream_offset, pu4_bitstrm_buf); 329 i2_level = u4_sign ? -1 : 1; 330 } 331 else 332 { 333 /****************************************************************/ 334 /* Decoding Level based on prefix and suffix as in 9.2.2 */ 335 /****************************************************************/ 336 UWORD32 u4_lev_suffix, u4_lev_suffix_size; 337 WORD32 u2_lev_code, u2_abs_value; 338 UWORD32 u4_lev_prefix; 339 /***************************************************************/ 340 /* Find leading zeros in next 32 bits */ 341 /***************************************************************/ 342 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, 343 pu4_bitstrm_buf); 344 u2_lev_code = (2 + MIN(u4_lev_prefix, 15)); 345 346 if(14 == u4_lev_prefix) 347 u4_lev_suffix_size = 4; 348 else if(15 <= u4_lev_prefix) 349 { 350 u2_lev_code += 15; 351 u4_lev_suffix_size = u4_lev_prefix - 3; 352 } 353 else 354 u4_lev_suffix_size = 0; 355 356 //HP_LEVEL_PREFIX 357 if(16 <= u4_lev_prefix) 358 { 359 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); 360 } 361 if(u4_lev_suffix_size) 362 { 363 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, 364 u4_lev_suffix_size); 365 u2_lev_code += u4_lev_suffix; 366 } 367 368 u2_abs_value = (u2_lev_code + 2) >> 1; 369 /*********************************************************/ 370 /* If Level code is odd, level is negative else positive */ 371 /*********************************************************/ 372 i2_level = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; 373 374 } 375 376 /****************************************************************/ 377 /* Decoding total zeros as in section 9.2.3, table 9.7 */ 378 /****************************************************************/ 379 FIND_ONE_IN_STREAM_LEN(u4_ldz, u4_bitstream_offset, pu4_bitstrm_buf, 8); 380 381 if(u4_ldz) 382 { 383 GETBIT(u4_tot_zero, u4_bitstream_offset, pu4_bitstrm_buf); 384 u4_tot_zero = (u4_ldz << 1) - u4_tot_zero; 385 } 386 else 387 u4_tot_zero = 0; 388 389 /***********************************************************************/ 390 /* Inverse scan and store residual coeff. Update the bitstream u4_ofst */ 391 /***********************************************************************/ 392 u4_scan_pos = u4_tot_zero + u4_isdc; 393 if(u4_scan_pos > 15) 394 return -1; 395 396 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); 397 *pi2_coeff_data++ = i2_level; 398 399 400 { 401 WORD32 offset; 402 offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4; 403 offset = ALIGN4(offset); 404 ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset); 405 } 406 407 ps_bitstrm->u4_ofst = u4_bitstream_offset; 408 return 0; 409 } 410 411 /*****************************************************************************/ 412 /* */ 413 /* Function Name : ih264d_cavlc_4x4res_block_totalcoeff_2to10 */ 414 /* */ 415 /* Description : This function does cavlc decoding of 4x4 block residual */ 416 /* coefficient when total coeffs are between two and ten */ 417 /* inclusive. Parsing is done as defined in section 9.2.2 */ 418 /* and 9.2.3 the H264 standard. */ 419 /* */ 420 /* Inputs : <What inputs does the function take?> */ 421 /* Globals : <Does it use any global variables?> */ 422 /* Processing : <Describe how the function operates - include algorithm */ 423 /* description> */ 424 /* Outputs : <What does the function produce?> */ 425 /* Returns : <What does the function return?> */ 426 /* */ 427 /* Issues : <List any issues or problems with this function> */ 428 /* */ 429 /* Revision History: */ 430 /* */ 431 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 432 /* 25 09 2008 Jay Draft */ 433 /* */ 434 /*****************************************************************************/ 435 436 WORD32 ih264d_cavlc_4x4res_block_totalcoeff_2to10(UWORD32 u4_isdc, 437 UWORD32 u4_total_coeff_trail_one, /*!<TotalCoefficients<<16+trailingones*/ 438 dec_bit_stream_t *ps_bitstrm) 439 { 440 UWORD32 u4_total_zeroes; 441 WORD32 i; 442 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 443 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; 444 UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF; 445 UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16; 446 // To avoid error check at 4x4 level, allocating for 3 extra levels(16+3) 447 // since u4_trailing_ones can at the max be 3. This will be required when 448 // u4_total_coeff is less than u4_trailing_ones 449 WORD16 ai2_level_arr[19]; 450 WORD16 *i2_level_arr = &ai2_level_arr[3]; 451 452 tu_sblk4x4_coeff_data_t *ps_tu_4x4; 453 WORD16 *pi2_coeff_data; 454 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; 455 456 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; 457 ps_tu_4x4->u2_sig_coeff_map = 0; 458 pi2_coeff_data = &ps_tu_4x4->ai2_level[0]; 459 460 i = u4_total_coeff - 1; 461 462 if(u4_trailing_ones) 463 { 464 /*********************************************************************/ 465 /* Decode Trailing Ones */ 466 /* read the sign of T1's and put them in level array */ 467 /*********************************************************************/ 468 UWORD32 u4_signs, u4_cnt = u4_trailing_ones; 469 WORD16 (*ppi2_trlone_lkup)[3] = 470 (WORD16 (*)[3])gai2_ih264d_trailing_one_level; 471 WORD16 *pi2_trlone_lkup; 472 473 GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt); 474 475 pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs]; 476 477 while(u4_cnt--) 478 i2_level_arr[i--] = *pi2_trlone_lkup++; 479 } 480 481 /****************************************************************/ 482 /* Decoding Levels Begins */ 483 /****************************************************************/ 484 if(i >= 0) 485 { 486 /****************************************************************/ 487 /* First level is decoded outside the loop as it has lot of */ 488 /* special cases. */ 489 /****************************************************************/ 490 UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size; 491 WORD32 u2_lev_code, u2_abs_value; 492 UWORD32 u4_lev_prefix; 493 494 /***************************************************************/ 495 /* u4_suffix_len = 0, Find leading zeros in next 32 bits */ 496 /***************************************************************/ 497 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, 498 pu4_bitstrm_buf); 499 500 /*********************************************************/ 501 /* Special decoding case when trailing ones are 3 */ 502 /*********************************************************/ 503 u2_lev_code = MIN(15, u4_lev_prefix); 504 505 u2_lev_code += (3 == u4_trailing_ones) ? 0 : 2; 506 507 if(14 == u4_lev_prefix) 508 u4_lev_suffix_size = 4; 509 else if(15 <= u4_lev_prefix) 510 { 511 u2_lev_code += 15; 512 u4_lev_suffix_size = u4_lev_prefix - 3; 513 } 514 else 515 u4_lev_suffix_size = 0; 516 517 //HP_LEVEL_PREFIX 518 if(16 <= u4_lev_prefix) 519 { 520 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); 521 } 522 if(u4_lev_suffix_size) 523 { 524 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, 525 u4_lev_suffix_size); 526 u2_lev_code += u4_lev_suffix; 527 } 528 529 u2_abs_value = (u2_lev_code + 2) >> 1; 530 /*********************************************************/ 531 /* If Level code is odd, level is negative else positive */ 532 /*********************************************************/ 533 i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; 534 535 u4_suffix_len = (u2_abs_value > 3) ? 2 : 1; 536 537 /*********************************************************/ 538 /* Now loop over the remaining levels */ 539 /*********************************************************/ 540 while(i >= 0) 541 { 542 543 /***************************************************************/ 544 /* Find leading zeros in next 32 bits */ 545 /***************************************************************/ 546 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, 547 pu4_bitstrm_buf); 548 549 u4_lev_suffix_size = 550 (15 <= u4_lev_prefix) ? 551 (u4_lev_prefix - 3) : u4_suffix_len; 552 553 /*********************************************************/ 554 /* Compute level code using prefix and suffix */ 555 /*********************************************************/ 556 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, 557 u4_lev_suffix_size); 558 u2_lev_code = (MIN(15,u4_lev_prefix) << u4_suffix_len) 559 + u4_lev_suffix; 560 561 //HP_LEVEL_PREFIX 562 if(16 <= u4_lev_prefix) 563 { 564 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); 565 } 566 u2_abs_value = (u2_lev_code + 2) >> 1; 567 568 /*********************************************************/ 569 /* If Level code is odd, level is negative else positive */ 570 /*********************************************************/ 571 i2_level_arr[i--] = 572 (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; 573 574 /*********************************************************/ 575 /* Increment suffix length if required */ 576 /*********************************************************/ 577 u4_suffix_len += 578 (u4_suffix_len < 6) ? 579 (u2_abs_value 580 > (3 581 << (u4_suffix_len 582 - 1))) : 583 0; 584 } 585 586 /****************************************************************/ 587 /* Decoding Levels Ends */ 588 /****************************************************************/ 589 } 590 591 /****************************************************************/ 592 /* Decoding total zeros as in section 9.2.3, table 9.7 */ 593 /****************************************************************/ 594 { 595 UWORD32 u4_index; 596 const UWORD8 (*ppu1_total_zero_lkup)[64] = 597 (const UWORD8 (*)[64])gau1_ih264d_table_total_zero_2to10; 598 599 NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 6); 600 u4_total_zeroes = ppu1_total_zero_lkup[u4_total_coeff - 2][u4_index]; 601 602 FLUSHBITS(u4_bitstream_offset, (u4_total_zeroes >> 4)); 603 u4_total_zeroes &= 0xf; 604 } 605 606 /**************************************************************/ 607 /* Decode the runs and form the coefficient buffer */ 608 /**************************************************************/ 609 { 610 const UWORD8 *pu1_table_runbefore; 611 UWORD32 u4_run; 612 WORD32 k; 613 UWORD32 u4_scan_pos = u4_total_coeff + u4_total_zeroes - 1 + u4_isdc; 614 WORD32 u4_zeroes_left = u4_total_zeroes; 615 k = u4_total_coeff - 1; 616 617 /**************************************************************/ 618 /* Decoding Runs Begin for zeros left > 6 */ 619 /**************************************************************/ 620 while((u4_zeroes_left > 6) && k) 621 { 622 UWORD32 u4_code; 623 624 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3); 625 626 if(u4_code != 0) 627 { 628 FLUSHBITS(u4_bitstream_offset, 3); 629 u4_run = (7 - u4_code); 630 } 631 else 632 { 633 634 FIND_ONE_IN_STREAM_LEN(u4_code, u4_bitstream_offset, 635 pu4_bitstrm_buf, 11); 636 u4_run = (4 + u4_code); 637 } 638 639 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); 640 *pi2_coeff_data++ = i2_level_arr[k--]; 641 u4_zeroes_left -= u4_run; 642 u4_scan_pos -= (u4_run + 1); 643 } 644 645 /**************************************************************/ 646 /* Decoding Runs for 0 < zeros left <=6 */ 647 /**************************************************************/ 648 pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before; 649 while((u4_zeroes_left > 0) && k) 650 { 651 UWORD32 u4_code; 652 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3); 653 654 u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)]; 655 u4_run = u4_code >> 2; 656 657 FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03)); 658 659 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); 660 *pi2_coeff_data++ = i2_level_arr[k--]; 661 u4_zeroes_left -= u4_run; 662 u4_scan_pos -= (u4_run + 1); 663 } 664 /**************************************************************/ 665 /* Decoding Runs End */ 666 /**************************************************************/ 667 668 /**************************************************************/ 669 /* Copy the remaining coefficients */ 670 /**************************************************************/ 671 if(u4_zeroes_left < 0) 672 return -1; 673 while(k >= 0) 674 { 675 676 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); 677 *pi2_coeff_data++ = i2_level_arr[k--]; 678 u4_scan_pos--; 679 } 680 } 681 682 { 683 WORD32 offset; 684 offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4; 685 offset = ALIGN4(offset); 686 ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset); 687 } 688 689 ps_bitstrm->u4_ofst = u4_bitstream_offset; 690 return 0; 691 } 692 693 /*****************************************************************************/ 694 /* */ 695 /* Function Name : ih264d_cavlc_4x4res_block_totalcoeff_11to16 */ 696 /* */ 697 /* Description : This function does cavlc decoding of 4x4 block residual */ 698 /* coefficient when total coeffs are greater than ten. */ 699 /* Parsing is done as defined in section 9.2.2 and 9.2.3 of */ 700 /* the H264 standard. */ 701 /* */ 702 /* Inputs : <What inputs does the function take?> */ 703 /* Globals : <Does it use any global variables?> */ 704 /* Processing : <Describe how the function operates - include algorithm */ 705 /* description> */ 706 /* Outputs : <What does the function produce?> */ 707 /* Returns : <What does the function return?> */ 708 /* */ 709 /* Issues : <List any issues or problems with this function> */ 710 /* */ 711 /* Revision History: */ 712 /* */ 713 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 714 /* 25 09 2008 Jay Draft */ 715 /* */ 716 /*****************************************************************************/ 717 718 WORD32 ih264d_cavlc_4x4res_block_totalcoeff_11to16(UWORD32 u4_isdc, 719 UWORD32 u4_total_coeff_trail_one, /*!<TotalCoefficients<<16+trailingones*/ 720 dec_bit_stream_t *ps_bitstrm ) 721 { 722 UWORD32 u4_total_zeroes; 723 WORD32 i; 724 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 725 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; 726 UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF; 727 UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16; 728 // To avoid error check at 4x4 level, allocating for 3 extra levels(16+3) 729 // since u4_trailing_ones can at the max be 3. This will be required when 730 // u4_total_coeff is less than u4_trailing_ones 731 WORD16 ai2_level_arr[19];// 732 WORD16 *i2_level_arr = &ai2_level_arr[3]; 733 734 tu_sblk4x4_coeff_data_t *ps_tu_4x4; 735 WORD16 *pi2_coeff_data; 736 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; 737 738 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; 739 ps_tu_4x4->u2_sig_coeff_map = 0; 740 pi2_coeff_data = &ps_tu_4x4->ai2_level[0]; 741 742 i = u4_total_coeff - 1; 743 if(u4_trailing_ones) 744 { 745 /*********************************************************************/ 746 /* Decode Trailing Ones */ 747 /* read the sign of T1's and put them in level array */ 748 /*********************************************************************/ 749 UWORD32 u4_signs, u4_cnt = u4_trailing_ones; 750 WORD16 (*ppi2_trlone_lkup)[3] = 751 (WORD16 (*)[3])gai2_ih264d_trailing_one_level; 752 WORD16 *pi2_trlone_lkup; 753 754 GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt); 755 756 pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs]; 757 758 while(u4_cnt--) 759 i2_level_arr[i--] = *pi2_trlone_lkup++; 760 } 761 762 /****************************************************************/ 763 /* Decoding Levels Begins */ 764 /****************************************************************/ 765 if(i >= 0) 766 { 767 /****************************************************************/ 768 /* First level is decoded outside the loop as it has lot of */ 769 /* special cases. */ 770 /****************************************************************/ 771 UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size; 772 UWORD16 u2_lev_code, u2_abs_value; 773 UWORD32 u4_lev_prefix; 774 775 if(u4_trailing_ones < 3) 776 { 777 /*********************************************************/ 778 /* u4_suffix_len = 1 */ 779 /*********************************************************/ 780 /***************************************************************/ 781 /* Find leading zeros in next 32 bits */ 782 /***************************************************************/ 783 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, 784 pu4_bitstrm_buf); 785 786 u4_lev_suffix_size = 787 (15 <= u4_lev_prefix) ? (u4_lev_prefix - 3) : 1; 788 789 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, 790 u4_lev_suffix_size); 791 u2_lev_code = 2 + (MIN(u4_lev_prefix,15) << 1) + u4_lev_suffix; 792 793 //HP_LEVEL_PREFIX 794 if(16 <= u4_lev_prefix) 795 { 796 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); 797 } 798 } 799 else 800 { 801 /*********************************************************/ 802 /*u4_suffix_len = 0 */ 803 /*********************************************************/ 804 /***************************************************************/ 805 /* Find leading zeros in next 32 bits */ 806 /***************************************************************/ 807 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, 808 pu4_bitstrm_buf); 809 810 /*********************************************************/ 811 /* Special decoding case when trailing ones are 3 */ 812 /*********************************************************/ 813 u2_lev_code = MIN(15, u4_lev_prefix); 814 815 u2_lev_code += (3 == u4_trailing_ones) ? 0 : (2); 816 817 if(14 == u4_lev_prefix) 818 u4_lev_suffix_size = 4; 819 else if(15 <= u4_lev_prefix) 820 { 821 u2_lev_code += 15; 822 u4_lev_suffix_size = (u4_lev_prefix - 3); 823 } 824 else 825 u4_lev_suffix_size = 0; 826 827 //HP_LEVEL_PREFIX 828 if(16 <= u4_lev_prefix) 829 { 830 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); 831 } 832 if(u4_lev_suffix_size) 833 { 834 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, 835 u4_lev_suffix_size); 836 u2_lev_code += u4_lev_suffix; 837 } 838 } 839 840 u2_abs_value = (u2_lev_code + 2) >> 1; 841 /*********************************************************/ 842 /* If Level code is odd, level is negative else positive */ 843 /*********************************************************/ 844 i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; 845 846 u4_suffix_len = (u2_abs_value > 3) ? 2 : 1; 847 848 /*********************************************************/ 849 /* Now loop over the remaining levels */ 850 /*********************************************************/ 851 while(i >= 0) 852 { 853 854 /***************************************************************/ 855 /* Find leading zeros in next 32 bits */ 856 /***************************************************************/ 857 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, 858 pu4_bitstrm_buf); 859 860 u4_lev_suffix_size = 861 (15 <= u4_lev_prefix) ? 862 (u4_lev_prefix - 3) : u4_suffix_len; 863 864 /*********************************************************/ 865 /* Compute level code using prefix and suffix */ 866 /*********************************************************/ 867 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, 868 u4_lev_suffix_size); 869 u2_lev_code = (MIN(15,u4_lev_prefix) << u4_suffix_len) 870 + u4_lev_suffix; 871 872 //HP_LEVEL_PREFIX 873 if(16 <= u4_lev_prefix) 874 { 875 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); 876 } 877 u2_abs_value = (u2_lev_code + 2) >> 1; 878 879 /*********************************************************/ 880 /* If Level code is odd, level is negative else positive */ 881 /*********************************************************/ 882 i2_level_arr[i--] = 883 (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; 884 885 /*********************************************************/ 886 /* Increment suffix length if required */ 887 /*********************************************************/ 888 u4_suffix_len += 889 (u4_suffix_len < 6) ? 890 (u2_abs_value 891 > (3 892 << (u4_suffix_len 893 - 1))) : 894 0; 895 } 896 897 /****************************************************************/ 898 /* Decoding Levels Ends */ 899 /****************************************************************/ 900 } 901 902 if(u4_total_coeff < (16 - u4_isdc)) 903 { 904 UWORD32 u4_index; 905 const UWORD8 (*ppu1_total_zero_lkup)[16] = 906 (const UWORD8 (*)[16])gau1_ih264d_table_total_zero_11to15; 907 908 NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 4); 909 u4_total_zeroes = ppu1_total_zero_lkup[u4_total_coeff - 11][u4_index]; 910 911 FLUSHBITS(u4_bitstream_offset, (u4_total_zeroes >> 4)); 912 u4_total_zeroes &= 0xf; 913 } 914 else 915 u4_total_zeroes = 0; 916 917 /**************************************************************/ 918 /* Decode the runs and form the coefficient buffer */ 919 /**************************************************************/ 920 { 921 const UWORD8 *pu1_table_runbefore; 922 UWORD32 u4_run; 923 WORD32 k; 924 UWORD32 u4_scan_pos = u4_total_coeff + u4_total_zeroes - 1 + u4_isdc; 925 WORD32 u4_zeroes_left = u4_total_zeroes; 926 k = u4_total_coeff - 1; 927 928 /**************************************************************/ 929 /* Decoding Runs for 0 < zeros left <=6 */ 930 /**************************************************************/ 931 pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before; 932 while((u4_zeroes_left > 0) && k) 933 { 934 UWORD32 u4_code; 935 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3); 936 937 u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)]; 938 u4_run = u4_code >> 2; 939 940 FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03)); 941 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); 942 *pi2_coeff_data++ = i2_level_arr[k--]; 943 u4_zeroes_left -= u4_run; 944 u4_scan_pos -= (u4_run + 1); 945 } 946 /**************************************************************/ 947 /* Decoding Runs End */ 948 /**************************************************************/ 949 950 /**************************************************************/ 951 /* Copy the remaining coefficients */ 952 /**************************************************************/ 953 if(u4_zeroes_left < 0) 954 return -1; 955 while(k >= 0) 956 { 957 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); 958 *pi2_coeff_data++ = i2_level_arr[k--]; 959 u4_scan_pos--; 960 } 961 } 962 963 { 964 WORD32 offset; 965 offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4; 966 offset = ALIGN4(offset); 967 ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset); 968 } 969 970 ps_bitstrm->u4_ofst = u4_bitstream_offset; 971 return 0; 972 } 973 974 /*****************************************************************************/ 975 /* */ 976 /* Function Name : ih264d_rest_of_residual_cav_chroma_dc_block */ 977 /* */ 978 /* Description : This function does the Cavlc parsing of the bitstream */ 979 /* for chroma dc coefficients */ 980 /* Inputs : <What inputs does the function take?> */ 981 /* Globals : <Does it use any global variables?> */ 982 /* Processing : <Describe how the function operates - include algorithm */ 983 /* description> */ 984 /* Outputs : <What does the function produce?> */ 985 /* Returns : <What does the function return?> */ 986 /* */ 987 /* Issues : <List any issues or problems with this function> */ 988 /* */ 989 /* Revision History: */ 990 /* */ 991 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 992 /* 15 09 2008 Jay Draft */ 993 /* */ 994 /*****************************************************************************/ 995 void ih264d_rest_of_residual_cav_chroma_dc_block(UWORD32 u4_total_coeff_trail_one, 996 dec_bit_stream_t *ps_bitstrm) 997 { 998 UWORD32 u4_total_zeroes; 999 WORD16 i; 1000 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1001 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; 1002 UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF; 1003 UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16; 1004 // To avoid error check at 4x4 level, allocating for 3 extra levels(4+3) 1005 // since u4_trailing_ones can at the max be 3. This will be required when 1006 // u4_total_coeff is less than u4_trailing_ones 1007 WORD16 ai2_level_arr[7];// 1008 WORD16 *i2_level_arr = &ai2_level_arr[3]; 1009 1010 tu_sblk4x4_coeff_data_t *ps_tu_4x4; 1011 WORD16 *pi2_coeff_data; 1012 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; 1013 1014 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; 1015 ps_tu_4x4->u2_sig_coeff_map = 0; 1016 pi2_coeff_data = &ps_tu_4x4->ai2_level[0]; 1017 1018 i = u4_total_coeff - 1; 1019 if(u4_trailing_ones) 1020 { 1021 /*********************************************************************/ 1022 /* Decode Trailing Ones */ 1023 /* read the sign of T1's and put them in level array */ 1024 /*********************************************************************/ 1025 UWORD32 u4_signs, u4_cnt = u4_trailing_ones; 1026 WORD16 (*ppi2_trlone_lkup)[3] = 1027 (WORD16 (*)[3])gai2_ih264d_trailing_one_level; 1028 WORD16 *pi2_trlone_lkup; 1029 1030 GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt); 1031 1032 pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs]; 1033 1034 while(u4_cnt--) 1035 i2_level_arr[i--] = *pi2_trlone_lkup++; 1036 } 1037 1038 /****************************************************************/ 1039 /* Decoding Levels Begins */ 1040 /****************************************************************/ 1041 if(i >= 0) 1042 { 1043 /****************************************************************/ 1044 /* First level is decoded outside the loop as it has lot of */ 1045 /* special cases. */ 1046 /****************************************************************/ 1047 UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size; 1048 UWORD16 u2_lev_code, u2_abs_value; 1049 UWORD32 u4_lev_prefix; 1050 1051 /***************************************************************/ 1052 /* u4_suffix_len = 0, Find leading zeros in next 32 bits */ 1053 /***************************************************************/ 1054 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, 1055 pu4_bitstrm_buf); 1056 1057 /*********************************************************/ 1058 /* Special decoding case when trailing ones are 3 */ 1059 /*********************************************************/ 1060 u2_lev_code = MIN(15, u4_lev_prefix); 1061 1062 u2_lev_code += (3 == u4_trailing_ones) ? 0 : (2); 1063 1064 if(14 == u4_lev_prefix) 1065 u4_lev_suffix_size = 4; 1066 else if(15 <= u4_lev_prefix) 1067 { 1068 u2_lev_code += 15; 1069 u4_lev_suffix_size = u4_lev_prefix - 3; 1070 } 1071 else 1072 u4_lev_suffix_size = 0; 1073 1074 //HP_LEVEL_PREFIX 1075 if(16 <= u4_lev_prefix) 1076 { 1077 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); 1078 } 1079 if(u4_lev_suffix_size) 1080 { 1081 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, 1082 u4_lev_suffix_size); 1083 u2_lev_code += u4_lev_suffix; 1084 } 1085 1086 u2_abs_value = (u2_lev_code + 2) >> 1; 1087 /*********************************************************/ 1088 /* If Level code is odd, level is negative else positive */ 1089 /*********************************************************/ 1090 i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; 1091 1092 u4_suffix_len = (u2_abs_value > 3) ? 2 : 1; 1093 1094 /*********************************************************/ 1095 /* Now loop over the remaining levels */ 1096 /*********************************************************/ 1097 while(i >= 0) 1098 { 1099 1100 /***************************************************************/ 1101 /* Find leading zeros in next 32 bits */ 1102 /***************************************************************/ 1103 FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, 1104 pu4_bitstrm_buf); 1105 1106 u4_lev_suffix_size = 1107 (15 <= u4_lev_prefix) ? 1108 (u4_lev_prefix - 3) : u4_suffix_len; 1109 1110 /*********************************************************/ 1111 /* Compute level code using prefix and suffix */ 1112 /*********************************************************/ 1113 GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, 1114 u4_lev_suffix_size); 1115 u2_lev_code = (MIN(u4_lev_prefix,15) << u4_suffix_len) 1116 + u4_lev_suffix; 1117 1118 //HP_LEVEL_PREFIX 1119 if(16 <= u4_lev_prefix) 1120 { 1121 u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); 1122 } 1123 u2_abs_value = (u2_lev_code + 2) >> 1; 1124 1125 /*********************************************************/ 1126 /* If Level code is odd, level is negative else positive */ 1127 /*********************************************************/ 1128 i2_level_arr[i--] = 1129 (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; 1130 1131 /*********************************************************/ 1132 /* Increment suffix length if required */ 1133 /*********************************************************/ 1134 u4_suffix_len += (u2_abs_value > (3 << (u4_suffix_len - 1))); 1135 } 1136 1137 /****************************************************************/ 1138 /* Decoding Levels Ends */ 1139 /****************************************************************/ 1140 } 1141 1142 if(u4_total_coeff < 4) 1143 { 1144 UWORD32 u4_max_ldz = (4 - u4_total_coeff); 1145 FIND_ONE_IN_STREAM_LEN(u4_total_zeroes, u4_bitstream_offset, 1146 pu4_bitstrm_buf, u4_max_ldz); 1147 } 1148 else 1149 u4_total_zeroes = 0; 1150 1151 /**************************************************************/ 1152 /* Decode the runs and form the coefficient buffer */ 1153 /**************************************************************/ 1154 { 1155 const UWORD8 *pu1_table_runbefore; 1156 UWORD32 u4_run; 1157 UWORD32 u4_scan_pos = (u4_total_coeff + u4_total_zeroes - 1); 1158 UWORD32 u4_zeroes_left = u4_total_zeroes; 1159 i = u4_total_coeff - 1; 1160 1161 /**************************************************************/ 1162 /* Decoding Runs for 0 < zeros left <=6 */ 1163 /**************************************************************/ 1164 pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before; 1165 while(u4_zeroes_left && i) 1166 { 1167 UWORD32 u4_code; 1168 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3); 1169 1170 u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)]; 1171 u4_run = u4_code >> 2; 1172 1173 FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03)); 1174 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); 1175 *pi2_coeff_data++ = i2_level_arr[i--]; 1176 u4_zeroes_left -= u4_run; 1177 u4_scan_pos -= (u4_run + 1); 1178 } 1179 /**************************************************************/ 1180 /* Decoding Runs End */ 1181 /**************************************************************/ 1182 1183 /**************************************************************/ 1184 /* Copy the remaining coefficients */ 1185 /**************************************************************/ 1186 while(i >= 0) 1187 { 1188 SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); 1189 *pi2_coeff_data++ = i2_level_arr[i--]; 1190 u4_scan_pos--; 1191 } 1192 } 1193 1194 { 1195 WORD32 offset; 1196 offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4; 1197 offset = ALIGN4(offset); 1198 ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset); 1199 } 1200 1201 ps_bitstrm->u4_ofst = u4_bitstream_offset; 1202 } 1203 1204 /*! 1205 ************************************************************************** 1206 * \if Function name : CavlcParsingInvScanInvQuant \endif 1207 * 1208 * \brief 1209 * This function do cavlc parsing of coefficient tokens for any block 1210 * type except chromDc and depending 1211 * on whenther any coefficients to be parsed calls module 1212 * RestOfResidualBlockCavlc. 1213 * 1214 * \return 1215 * Returns total number of non-zero coefficients. 1216 * 1217 ************************************************************************** 1218 */ 1219 1220 WORD32 ih264d_cavlc_parse4x4coeff_n0to7(WORD16 *pi2_coeff_block, 1221 UWORD32 u4_isdc, /* is it a DC block */ 1222 WORD32 u4_n, 1223 dec_struct_t *ps_dec, 1224 UWORD32 *pu4_total_coeff) 1225 { 1226 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm; 1227 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1228 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; 1229 UWORD32 u4_code, u4_index, u4_ldz; 1230 const UWORD16 *pu2_code = (const UWORD16*)gau2_ih264d_code_gx; 1231 const UWORD16 *pu2_offset_num_vlc = 1232 (const UWORD16 *)gau2_ih264d_offset_num_vlc_tab; 1233 UWORD32 u4_offset_num_vlc = pu2_offset_num_vlc[u4_n]; 1234 1235 1236 UNUSED(pi2_coeff_block); 1237 *pu4_total_coeff = 0; 1238 FIND_ONE_IN_STREAM_32(u4_ldz, u4_bitstream_offset, pu4_bitstrm_buf); 1239 NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 3); 1240 u4_index += (u4_ldz << 3); 1241 u4_index += u4_offset_num_vlc; 1242 1243 u4_index = MIN(u4_index, 303); 1244 u4_code = pu2_code[u4_index]; 1245 1246 FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03)); 1247 ps_bitstrm->u4_ofst = u4_bitstream_offset; 1248 *pu4_total_coeff = (u4_code >> 4); 1249 1250 if(*pu4_total_coeff) 1251 { 1252 UWORD32 u4_trailing_ones, u4_offset, u4_total_coeff_tone; 1253 const UWORD8 *pu1_offset = 1254 (UWORD8 *)gau1_ih264d_total_coeff_fn_ptr_offset; 1255 WORD32 ret; 1256 u4_trailing_ones = ((u4_code >> 2) & 0x03); 1257 u4_offset = pu1_offset[*pu4_total_coeff - 1]; 1258 u4_total_coeff_tone = (*pu4_total_coeff << 16) | u4_trailing_ones; 1259 1260 ret = ps_dec->pf_cavlc_4x4res_block[u4_offset](u4_isdc, 1261 u4_total_coeff_tone, 1262 ps_bitstrm); 1263 if(ret != 0) 1264 return ERROR_CAVLC_NUM_COEFF_T; 1265 } 1266 1267 return OK; 1268 } 1269 1270 WORD32 ih264d_cavlc_parse4x4coeff_n8(WORD16 *pi2_coeff_block, 1271 UWORD32 u4_isdc, /* is it a DC block */ 1272 WORD32 u4_n, 1273 dec_struct_t *ps_dec, 1274 UWORD32 *pu4_total_coeff) 1275 { 1276 1277 dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm; 1278 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1279 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; 1280 UWORD32 u4_code; 1281 UNUSED(u4_n); 1282 UNUSED(pi2_coeff_block); 1283 GETBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 6); 1284 ps_bitstrm->u4_ofst = u4_bitstream_offset; 1285 *pu4_total_coeff = 0; 1286 1287 if(u4_code != 3) 1288 { 1289 UWORD8 *pu1_offset = (UWORD8 *)gau1_ih264d_total_coeff_fn_ptr_offset; 1290 UWORD32 u4_trailing_ones, u4_offset, u4_total_coeff_tone; 1291 1292 *pu4_total_coeff = (u4_code >> 2) + 1; 1293 u4_trailing_ones = u4_code & 0x03; 1294 u4_offset = pu1_offset[*pu4_total_coeff - 1]; 1295 u4_total_coeff_tone = (*pu4_total_coeff << 16) | u4_trailing_ones; 1296 1297 ps_dec->pf_cavlc_4x4res_block[u4_offset](u4_isdc, 1298 u4_total_coeff_tone, 1299 ps_bitstrm); 1300 } 1301 1302 return OK; 1303 } 1304 1305 /*! 1306 ************************************************************************** 1307 * \if Function name : ih264d_cavlc_parse_chroma_dc \endif 1308 * 1309 * \brief 1310 * This function do cavlc parsing of coefficient tokens chromDc block 1311 * and depending on whenther any coefficients to be parsed calls module 1312 * ih264d_rest_of_residual_cav_chroma_dc_block. 1313 * 1314 * \return 1315 * Returns total number of non-zero coefficients. 1316 * 1317 ************************************************************************** 1318 */ 1319 1320 void ih264d_cavlc_parse_chroma_dc(dec_mb_info_t *ps_cur_mb_info, 1321 WORD16 *pi2_coeff_block, 1322 dec_bit_stream_t *ps_bitstrm, 1323 UWORD32 u4_scale_u, 1324 UWORD32 u4_scale_v, 1325 WORD32 i4_mb_inter_inc) 1326 { 1327 UWORD32 u4_total_coeff, u4_trailing_ones, u4_total_coeff_tone, u4_code; 1328 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1329 UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; 1330 const UWORD8 *pu1_cav_chromdc = (const UWORD8*)gau1_ih264d_cav_chromdc_vld; 1331 UNUSED(i4_mb_inter_inc); 1332 /******************************************************************/ 1333 /* Chroma DC Block for U component */ 1334 /******************************************************************/ 1335 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 8); 1336 1337 u4_code = pu1_cav_chromdc[u4_code]; 1338 1339 FLUSHBITS(u4_bitstream_offset, ((u4_code & 0x7) + 1)); 1340 ps_bitstrm->u4_ofst = u4_bitstream_offset; 1341 1342 u4_total_coeff = (u4_code >> 5); 1343 1344 if(u4_total_coeff) 1345 { 1346 WORD32 i_z0, i_z1, i_z2, i_z3; 1347 tu_sblk4x4_coeff_data_t *ps_tu_4x4; 1348 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; 1349 WORD16 ai2_dc_coef[4]; 1350 UWORD8 pu1_inv_scan[4] = 1351 { 0, 1, 2, 3 }; 1352 WORD16 *pi2_coeff_data = 1353 (WORD16 *)ps_dec->pv_parse_tu_coeff_data; 1354 1355 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; 1356 1357 u4_trailing_ones = ((u4_code >> 3) & 0x3); 1358 u4_total_coeff_tone = (u4_total_coeff << 16) | u4_trailing_ones; 1359 ih264d_rest_of_residual_cav_chroma_dc_block(u4_total_coeff_tone, 1360 ps_bitstrm); 1361 1362 ai2_dc_coef[0] = 0; 1363 ai2_dc_coef[1] = 0; 1364 ai2_dc_coef[2] = 0; 1365 ai2_dc_coef[3] = 0; 1366 1367 ih264d_unpack_coeff4x4_dc_4x4blk(ps_tu_4x4, 1368 ai2_dc_coef, 1369 pu1_inv_scan); 1370 /*-------------------------------------------------------------------*/ 1371 /* Inverse 2x2 transform and scaling of chroma DC */ 1372 /*-------------------------------------------------------------------*/ 1373 i_z0 = (ai2_dc_coef[0] + ai2_dc_coef[2]); 1374 i_z1 = (ai2_dc_coef[0] - ai2_dc_coef[2]); 1375 i_z2 = (ai2_dc_coef[1] - ai2_dc_coef[3]); 1376 i_z3 = (ai2_dc_coef[1] + ai2_dc_coef[3]); 1377 1378 /*-----------------------------------------------------------*/ 1379 /* Scaling and storing the values back */ 1380 /*-----------------------------------------------------------*/ 1381 *pi2_coeff_data++ = ((i_z0 + i_z3) * u4_scale_u) >> 5; 1382 *pi2_coeff_data++ = ((i_z0 - i_z3) * u4_scale_u) >> 5; 1383 *pi2_coeff_data++ = ((i_z1 + i_z2) * u4_scale_u) >> 5; 1384 *pi2_coeff_data++ = ((i_z1 - i_z2) * u4_scale_u) >> 5; 1385 1386 ps_dec->pv_parse_tu_coeff_data = (void *)pi2_coeff_data; 1387 1388 SET_BIT(ps_cur_mb_info->u1_yuv_dc_block_flag,1); 1389 } 1390 1391 /******************************************************************/ 1392 /* Chroma DC Block for V component */ 1393 /******************************************************************/ 1394 pi2_coeff_block += 64; 1395 u4_bitstream_offset = ps_bitstrm->u4_ofst; 1396 1397 NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 8); 1398 1399 u4_code = pu1_cav_chromdc[u4_code]; 1400 1401 FLUSHBITS(u4_bitstream_offset, ((u4_code & 0x7) + 1)); 1402 ps_bitstrm->u4_ofst = u4_bitstream_offset; 1403 1404 u4_total_coeff = (u4_code >> 5); 1405 1406 if(u4_total_coeff) 1407 { 1408 WORD32 i_z0, i_z1, i_z2, i_z3; 1409 tu_sblk4x4_coeff_data_t *ps_tu_4x4; 1410 dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; 1411 WORD16 ai2_dc_coef[4]; 1412 UWORD8 pu1_inv_scan[4] = 1413 { 0, 1, 2, 3 }; 1414 WORD16 *pi2_coeff_data = 1415 (WORD16 *)ps_dec->pv_parse_tu_coeff_data; 1416 1417 ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; 1418 1419 u4_trailing_ones = ((u4_code >> 3) & 0x3); 1420 u4_total_coeff_tone = (u4_total_coeff << 16) | u4_trailing_ones; 1421 ih264d_rest_of_residual_cav_chroma_dc_block(u4_total_coeff_tone, 1422 ps_bitstrm); 1423 1424 ai2_dc_coef[0] = 0; 1425 ai2_dc_coef[1] = 0; 1426 ai2_dc_coef[2] = 0; 1427 ai2_dc_coef[3] = 0; 1428 1429 ih264d_unpack_coeff4x4_dc_4x4blk(ps_tu_4x4, 1430 ai2_dc_coef, 1431 pu1_inv_scan); 1432 1433 /*-------------------------------------------------------------------*/ 1434 /* Inverse 2x2 transform and scaling of chroma DC */ 1435 /*-------------------------------------------------------------------*/ 1436 i_z0 = (ai2_dc_coef[0] + ai2_dc_coef[2]); 1437 i_z1 = (ai2_dc_coef[0] - ai2_dc_coef[2]); 1438 i_z2 = (ai2_dc_coef[1] - ai2_dc_coef[3]); 1439 i_z3 = (ai2_dc_coef[1] + ai2_dc_coef[3]); 1440 1441 /*-----------------------------------------------------------*/ 1442 /* Scaling and storing the values back */ 1443 /*-----------------------------------------------------------*/ 1444 *pi2_coeff_data++ = ((i_z0 + i_z3) * u4_scale_v) >> 5; 1445 *pi2_coeff_data++ = ((i_z0 - i_z3) * u4_scale_v) >> 5; 1446 *pi2_coeff_data++ = ((i_z1 + i_z2) * u4_scale_v) >> 5; 1447 *pi2_coeff_data++ = ((i_z1 - i_z2) * u4_scale_v) >> 5; 1448 1449 ps_dec->pv_parse_tu_coeff_data = (void *)pi2_coeff_data; 1450 1451 SET_BIT(ps_cur_mb_info->u1_yuv_dc_block_flag,2); 1452 } 1453 } 1454 1455 /*****************************************************************************/ 1456 /* */ 1457 /* Function Name : ih264d_parse_pmb_ref_index_cavlc_range1 */ 1458 /* */ 1459 /* Description : This function does the Cavlc TEV range =1 parsing of */ 1460 /* reference index for a P MB. Range is 1 when */ 1461 /* num_ref_idx_active_minus1 is 0 */ 1462 /* */ 1463 /* Inputs : <What inputs does the function take?> */ 1464 /* Globals : <Does it use any global variables?> */ 1465 /* Processing : <Describe how the function operates - include algorithm */ 1466 /* description> */ 1467 /* Outputs : <What does the function produce?> */ 1468 /* Returns : <What does the function return?> */ 1469 /* */ 1470 /* Issues : <List any issues or problems with this function> */ 1471 /* */ 1472 /* Revision History: */ 1473 /* */ 1474 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1475 /* 19 09 2008 Jay Draft */ 1476 /* */ 1477 /*****************************************************************************/ 1478 void ih264d_parse_pmb_ref_index_cavlc_range1(UWORD32 u4_num_part, /* Number of partitions in MB */ 1479 dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */ 1480 WORD8 *pi1_ref_idx, /* pointer to reference index array */ 1481 UWORD32 u4_num_ref_idx_active_minus1 /* Not used for range 1 */ 1482 ) 1483 { 1484 UWORD32 u4_i; 1485 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1486 UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst; 1487 UNUSED(u4_num_ref_idx_active_minus1); 1488 for(u4_i = 0; u4_i < u4_num_part; u4_i++) 1489 { 1490 UWORD32 u4_ref_idx; 1491 u4_ref_idx = ih264d_tev_range1(pu4_bitstream_off, pu4_bitstrm_buf); 1492 1493 /* Storing Reference Idx Information */ 1494 pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx; 1495 } 1496 } 1497 1498 /*****************************************************************************/ 1499 /* */ 1500 /* Function Name : ih264d_parse_pmb_ref_index_cavlc */ 1501 /* */ 1502 /* Description : This function does the Cavlc TEV range > 1 parsing of */ 1503 /* reference index for a P MB. */ 1504 /* Range > 1 when num_ref_idx_active_minus1 > 0 */ 1505 /* */ 1506 /* Inputs : <What inputs does the function take?> */ 1507 /* Globals : <Does it use any global variables?> */ 1508 /* Processing : <Describe how the function operates - include algorithm */ 1509 /* description> */ 1510 /* Outputs : <What does the function produce?> */ 1511 /* Returns : <What does the function return?> */ 1512 /* */ 1513 /* Issues : <List any issues or problems with this function> */ 1514 /* */ 1515 /* Revision History: */ 1516 /* */ 1517 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1518 /* 19 09 2008 Jay Draft */ 1519 /* */ 1520 /*****************************************************************************/ 1521 1522 WORD32 ih264d_parse_pmb_ref_index_cavlc(UWORD32 u4_num_part, /* Number of partitions in MB */ 1523 dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */ 1524 WORD8 *pi1_ref_idx, /* pointer to reference index array */ 1525 UWORD32 u4_num_ref_idx_active_minus1 /* Number of active references - 1 */ 1526 ) 1527 { 1528 UWORD32 u4_i; 1529 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1530 UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst; 1531 1532 for(u4_i = 0; u4_i < u4_num_part; u4_i++) 1533 { 1534 UWORD32 u4_ref_idx; 1535 //Inlined ih264d_uev 1536 UWORD32 u4_bitstream_offset = *pu4_bitstream_off; 1537 UWORD32 u4_word, u4_ldz; 1538 1539 /***************************************************************/ 1540 /* Find leading zeros in next 32 bits */ 1541 /***************************************************************/ 1542 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); 1543 u4_ldz = CLZ(u4_word); 1544 /* Flush the ps_bitstrm */ 1545 u4_bitstream_offset += (u4_ldz + 1); 1546 /* Read the suffix from the ps_bitstrm */ 1547 u4_word = 0; 1548 if(u4_ldz) 1549 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz); 1550 *pu4_bitstream_off = u4_bitstream_offset; 1551 u4_ref_idx = ((1 << u4_ldz) + u4_word - 1); 1552 //Inlined ih264d_uev 1553 1554 if(u4_ref_idx > u4_num_ref_idx_active_minus1) 1555 return ERROR_REF_IDX; 1556 1557 /* Storing Reference Idx Information */ 1558 pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx; 1559 } 1560 return OK; 1561 } 1562 1563 /*****************************************************************************/ 1564 /* */ 1565 /* Function Name : ih264d_parse_bmb_ref_index_cavlc_range1 */ 1566 /* */ 1567 /* Description : This function does the Cavlc TEV range =1 parsing of */ 1568 /* reference index for a B MB. Range is 1 when */ 1569 /* num_ref_idx_active_minus1 is 0 */ 1570 /* */ 1571 /* Inputs : <What inputs does the function take?> */ 1572 /* Globals : <Does it use any global variables?> */ 1573 /* Processing : <Describe how the function operates - include algorithm */ 1574 /* description> */ 1575 /* Outputs : <What does the function produce?> */ 1576 /* Returns : <What does the function return?> */ 1577 /* */ 1578 /* Issues : <List any issues or problems with this function> */ 1579 /* */ 1580 /* Revision History: */ 1581 /* */ 1582 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1583 /* 19 09 2008 Jay Draft */ 1584 /* */ 1585 /*****************************************************************************/ 1586 void ih264d_parse_bmb_ref_index_cavlc_range1(UWORD32 u4_num_part, /* Number of partitions in MB */ 1587 dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */ 1588 WORD8 *pi1_ref_idx, /* pointer to reference index array */ 1589 UWORD32 u4_num_ref_idx_active_minus1 /* Not used for range 1 */ 1590 ) 1591 { 1592 UWORD32 u4_i; 1593 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1594 UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst; 1595 UNUSED(u4_num_ref_idx_active_minus1); 1596 for(u4_i = 0; u4_i < u4_num_part; u4_i++) 1597 { 1598 if(pi1_ref_idx[u4_i] > -1) 1599 { 1600 UWORD32 u4_ref_idx; 1601 1602 u4_ref_idx = ih264d_tev_range1(pu4_bitstream_off, pu4_bitstrm_buf); 1603 1604 /* Storing Reference Idx Information */ 1605 pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx; 1606 } 1607 } 1608 } 1609 1610 /*****************************************************************************/ 1611 /* */ 1612 /* Function Name : ih264d_parse_bmb_ref_index_cavlc */ 1613 /* */ 1614 /* Description : This function does the Cavlc TEV range > 1 parsing of */ 1615 /* reference index for a B MB. */ 1616 /* Range > 1 when num_ref_idx_active_minus1 > 0 */ 1617 /* */ 1618 /* Inputs : <What inputs does the function take?> */ 1619 /* Globals : <Does it use any global variables?> */ 1620 /* Processing : <Describe how the function operates - include algorithm */ 1621 /* description> */ 1622 /* Outputs : <What does the function produce?> */ 1623 /* Returns : <What does the function return?> */ 1624 /* */ 1625 /* Issues : <List any issues or problems with this function> */ 1626 /* */ 1627 /* Revision History: */ 1628 /* */ 1629 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1630 /* 19 09 2008 Jay Draft */ 1631 /* */ 1632 /*****************************************************************************/ 1633 WORD32 ih264d_parse_bmb_ref_index_cavlc(UWORD32 u4_num_part, /* Number of partitions in MB */ 1634 dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */ 1635 WORD8 *pi1_ref_idx, /* pointer to reference index array */ 1636 UWORD32 u4_num_ref_idx_active_minus1 /* Number of active references - 1 */ 1637 ) 1638 { 1639 UWORD32 u4_i; 1640 UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; 1641 UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst; 1642 1643 for(u4_i = 0; u4_i < u4_num_part; u4_i++) 1644 { 1645 if(pi1_ref_idx[u4_i] > -1) 1646 { 1647 UWORD32 u4_ref_idx; 1648 //inlining ih264d_uev 1649 UWORD32 u4_bitstream_offset = *pu4_bitstream_off; 1650 UWORD32 u4_word, u4_ldz; 1651 1652 /***************************************************************/ 1653 /* Find leading zeros in next 32 bits */ 1654 /***************************************************************/ 1655 NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); 1656 u4_ldz = CLZ(u4_word); 1657 /* Flush the ps_bitstrm */ 1658 u4_bitstream_offset += (u4_ldz + 1); 1659 /* Read the suffix from the ps_bitstrm */ 1660 u4_word = 0; 1661 if(u4_ldz) 1662 GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz); 1663 *pu4_bitstream_off = u4_bitstream_offset; 1664 u4_ref_idx = ((1 << u4_ldz) + u4_word - 1); 1665 //inlining ih264d_uev 1666 if(u4_ref_idx > u4_num_ref_idx_active_minus1) 1667 return ERROR_REF_IDX; 1668 1669 /* Storing Reference Idx Information */ 1670 pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx; 1671 } 1672 } 1673 return OK; 1674 } 1675 /*****************************************************************************/ 1676 /* */ 1677 /* Function Name : ih264d_cavlc_parse_8x8block_both_available */ 1678 /* */ 1679 /* Description : This function does the residual parsing of 4 subblocks */ 1680 /* in a 8x8 block when both top and left are available */ 1681 /* */ 1682 /* Inputs : pi2_coeff_block : pointer to residual block where */ 1683 /* decoded and inverse scan coefficients are updated */ 1684 /* */ 1685 /* u4_sub_block_strd : indicates the number of sublocks */ 1686 /* in a row. It is 4 for luma and 2 for chroma. */ 1687 /* */ 1688 /* u4_isdc : required to indicate 4x4 parse modules if the */ 1689 /* current Mb is I_16x16/chroma DC coded. */ 1690 /* */ 1691 /* ps_dec : pointer to Decstruct (decoder context) */ 1692 /* */ 1693 /* pu1_top_nnz : top nnz pointer */ 1694 /* */ 1695 /* pu1_left_nnz : left nnz pointer */ 1696 /* */ 1697 /* Globals : No */ 1698 /* Processing : Parsing for four subblocks in unrolled, top and left nnz */ 1699 /* are updated on the fly. csbp is set in accordance to */ 1700 /* decoded numcoeff for the subblock index in raster order */ 1701 /* */ 1702 /* Outputs : The updated residue buffer, nnzs and csbp current block */ 1703 /* */ 1704 /* Returns : Returns the coded sub block pattern csbp for the block */ 1705 /* */ 1706 /* Issues : <List any issues or problems with this function> */ 1707 /* */ 1708 /* Revision History: */ 1709 /* */ 1710 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1711 /* 09 10 2008 Jay Draft */ 1712 /* */ 1713 /*****************************************************************************/ 1714 WORD32 ih264d_cavlc_parse_8x8block_both_available(WORD16 *pi2_coeff_block, 1715 UWORD32 u4_sub_block_strd, 1716 UWORD32 u4_isdc, 1717 dec_struct_t * ps_dec, 1718 UWORD8 *pu1_top_nnz, 1719 UWORD8 *pu1_left_nnz, 1720 UWORD8 u1_tran_form8x8, 1721 UWORD8 u1_mb_field_decodingflag, 1722 UWORD32 *pu4_csbp) 1723 { 1724 UWORD32 u4_num_coeff, u4_n, u4_subblock_coded; 1725 UWORD32 u4_top0, u4_top1; 1726 UWORD32 *pu4_dummy; 1727 WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block, 1728 UWORD32 u4_isdc, 1729 WORD32 u4_n, 1730 struct _DecStruct *ps_dec, 1731 UWORD32 *pu4_dummy) = 1732 ps_dec->pf_cavlc_parse4x4coeff; 1733 UWORD32 u4_idx = 0; 1734 UWORD8 *puc_temp; 1735 WORD32 ret; 1736 1737 *pu4_csbp = 0; 1738 /* need to change the inverse scan matrices here */ 1739 puc_temp = ps_dec->pu1_inv_scan; 1740 1741 /*------------------------------------------------------*/ 1742 /* Residual 4x4 decoding: SubBlock 0 */ 1743 /*------------------------------------------------------*/ 1744 if(u1_tran_form8x8) 1745 { 1746 if(!u1_mb_field_decodingflag) 1747 { 1748 ps_dec->pu1_inv_scan = 1749 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0]; 1750 } 1751 else 1752 { 1753 ps_dec->pu1_inv_scan = 1754 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0]; 1755 } 1756 } 1757 u4_n = (pu1_top_nnz[0] + pu1_left_nnz[0] + 1) >> 1; 1758 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 1759 u4_n, ps_dec, &u4_num_coeff); 1760 if(ret != OK) 1761 return ret; 1762 1763 u4_top0 = u4_num_coeff; 1764 u4_subblock_coded = (u4_num_coeff != 0); 1765 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 1766 1767 /*------------------------------------------------------*/ 1768 /* Residual 4x4 decoding: SubBlock 1 */ 1769 /*------------------------------------------------------*/ 1770 u4_idx++; 1771 if(u1_tran_form8x8) 1772 { 1773 if(!u1_mb_field_decodingflag) 1774 { 1775 ps_dec->pu1_inv_scan = 1776 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1]; 1777 } 1778 else 1779 { 1780 ps_dec->pu1_inv_scan = 1781 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1]; 1782 } 1783 } 1784 else 1785 { 1786 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; 1787 } 1788 u4_n = (pu1_top_nnz[1] + u4_num_coeff + 1) >> 1; 1789 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 1790 u4_n, ps_dec, &u4_num_coeff); 1791 if(ret != OK) 1792 return ret; 1793 1794 u4_top1 = pu1_left_nnz[0] = u4_num_coeff; 1795 u4_subblock_coded = (u4_num_coeff != 0); 1796 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 1797 1798 /*------------------------------------------------------*/ 1799 /* Residual 4x4 decoding: SubBlock 2 */ 1800 /*------------------------------------------------------*/ 1801 u4_idx += (u4_sub_block_strd - 1); 1802 if(u1_tran_form8x8) 1803 { 1804 if(!u1_mb_field_decodingflag) 1805 { 1806 ps_dec->pu1_inv_scan = 1807 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2]; 1808 } 1809 else 1810 { 1811 ps_dec->pu1_inv_scan = 1812 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2]; 1813 } 1814 } 1815 else 1816 { 1817 pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK); 1818 } 1819 u4_n = (u4_top0 + pu1_left_nnz[1] + 1) >> 1; 1820 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 1821 u4_n, ps_dec, &u4_num_coeff); 1822 if(ret != OK) 1823 return ret; 1824 1825 pu1_top_nnz[0] = u4_num_coeff; 1826 u4_subblock_coded = (u4_num_coeff != 0); 1827 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 1828 1829 /*------------------------------------------------------*/ 1830 /* Residual 4x4 decoding: SubBlock 3 */ 1831 /*------------------------------------------------------*/ 1832 u4_idx++; 1833 if(u1_tran_form8x8) 1834 { 1835 if(!u1_mb_field_decodingflag) 1836 { 1837 ps_dec->pu1_inv_scan = 1838 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3]; 1839 } 1840 else 1841 { 1842 ps_dec->pu1_inv_scan = 1843 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3]; 1844 } 1845 } 1846 else 1847 { 1848 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; 1849 } 1850 u4_n = (u4_top1 + u4_num_coeff + 1) >> 1; 1851 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 1852 u4_n, ps_dec, &u4_num_coeff); 1853 if(ret != OK) 1854 return ret; 1855 1856 pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff; 1857 u4_subblock_coded = (u4_num_coeff != 0); 1858 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 1859 1860 ps_dec->pu1_inv_scan = puc_temp; 1861 1862 return OK; 1863 } 1864 1865 /*****************************************************************************/ 1866 /* */ 1867 /* Function Name : ih264d_cavlc_parse_8x8block_left_available */ 1868 /* */ 1869 /* Description : This function does the residual parsing of 4 subblocks */ 1870 /* in a 8x8 block when only left is available for block */ 1871 /* */ 1872 /* Inputs : pi2_coeff_block : pointer to residual block where */ 1873 /* decoded and inverse scan coefficients are updated */ 1874 /* */ 1875 /* u4_sub_block_strd : indicates the number of sublocks */ 1876 /* in a row. It is 4 for luma and 2 for chroma. */ 1877 /* */ 1878 /* u4_isdc : required to indicate 4x4 parse modules if the */ 1879 /* current Mb is I_16x16/chroma DC coded. */ 1880 /* */ 1881 /* ps_dec : pointer to Decstruct (decoder context) */ 1882 /* */ 1883 /* pu1_top_nnz : top nnz pointer */ 1884 /* */ 1885 /* pu1_left_nnz : left nnz pointer */ 1886 /* */ 1887 /* Globals : No */ 1888 /* Processing : Parsing for four subblocks in unrolled, top and left nnz */ 1889 /* are updated on the fly. csbp is set in accordance to */ 1890 /* decoded numcoeff for the subblock index in raster order */ 1891 /* */ 1892 /* Outputs : The updated residue buffer, nnzs and csbp current block */ 1893 /* */ 1894 /* Returns : Returns the coded sub block pattern csbp for the block */ 1895 /* */ 1896 /* Issues : <List any issues or problems with this function> */ 1897 /* */ 1898 /* Revision History: */ 1899 /* */ 1900 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 1901 /* 09 10 2008 Jay Draft */ 1902 /* */ 1903 /*****************************************************************************/ 1904 WORD32 ih264d_cavlc_parse_8x8block_left_available(WORD16 *pi2_coeff_block, 1905 UWORD32 u4_sub_block_strd, 1906 UWORD32 u4_isdc, 1907 dec_struct_t * ps_dec, 1908 UWORD8 *pu1_top_nnz, 1909 UWORD8 *pu1_left_nnz, 1910 UWORD8 u1_tran_form8x8, 1911 UWORD8 u1_mb_field_decodingflag, 1912 UWORD32 *pu4_csbp) 1913 { 1914 UWORD32 u4_num_coeff, u4_n, u4_subblock_coded; 1915 UWORD32 u4_top0, u4_top1; 1916 UWORD32 *pu4_dummy; 1917 WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block, 1918 UWORD32 u4_isdc, 1919 WORD32 u4_n, 1920 struct _DecStruct *ps_dec, 1921 UWORD32 *pu4_dummy) = 1922 ps_dec->pf_cavlc_parse4x4coeff; 1923 UWORD32 u4_idx = 0; 1924 UWORD8 *puc_temp; 1925 WORD32 ret; 1926 1927 *pu4_csbp = 0; 1928 puc_temp = ps_dec->pu1_inv_scan; 1929 1930 /*------------------------------------------------------*/ 1931 /* Residual 4x4 decoding: SubBlock 0 */ 1932 /*------------------------------------------------------*/ 1933 if(u1_tran_form8x8) 1934 { 1935 if(!u1_mb_field_decodingflag) 1936 { 1937 ps_dec->pu1_inv_scan = 1938 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0]; 1939 } 1940 else 1941 { 1942 ps_dec->pu1_inv_scan = 1943 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0]; 1944 } 1945 } 1946 u4_n = pu1_left_nnz[0]; 1947 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 1948 u4_n, ps_dec, &u4_num_coeff); 1949 if(ret != OK) 1950 return ret; 1951 1952 u4_top0 = u4_num_coeff; 1953 u4_subblock_coded = (u4_num_coeff != 0); 1954 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 1955 1956 /*------------------------------------------------------*/ 1957 /* Residual 4x4 decoding: SubBlock 1 */ 1958 /*------------------------------------------------------*/ 1959 u4_idx++; 1960 if(u1_tran_form8x8) 1961 { 1962 if(!u1_mb_field_decodingflag) 1963 { 1964 ps_dec->pu1_inv_scan = 1965 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1]; 1966 } 1967 else 1968 { 1969 ps_dec->pu1_inv_scan = 1970 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1]; 1971 } 1972 } 1973 else 1974 { 1975 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; 1976 } 1977 u4_n = u4_num_coeff; 1978 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 1979 u4_n, ps_dec, &u4_num_coeff); 1980 if(ret != OK) 1981 return ret; 1982 1983 u4_top1 = pu1_left_nnz[0] = u4_num_coeff; 1984 u4_subblock_coded = (u4_num_coeff != 0); 1985 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 1986 1987 /*------------------------------------------------------*/ 1988 /* Residual 4x4 decoding: SubBlock 2 */ 1989 /*------------------------------------------------------*/ 1990 u4_idx += (u4_sub_block_strd - 1); 1991 if(u1_tran_form8x8) 1992 { 1993 if(!u1_mb_field_decodingflag) 1994 { 1995 ps_dec->pu1_inv_scan = 1996 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2]; 1997 } 1998 else 1999 { 2000 ps_dec->pu1_inv_scan = 2001 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2]; 2002 } 2003 } 2004 else 2005 { 2006 pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK); 2007 } 2008 u4_n = (u4_top0 + pu1_left_nnz[1] + 1) >> 1; 2009 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 2010 u4_n, ps_dec, &u4_num_coeff); 2011 if(ret != OK) 2012 return ret; 2013 2014 pu1_top_nnz[0] = u4_num_coeff; 2015 u4_subblock_coded = (u4_num_coeff != 0); 2016 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 2017 2018 /*------------------------------------------------------*/ 2019 /* Residual 4x4 decoding: SubBlock 3 */ 2020 /*------------------------------------------------------*/ 2021 u4_idx++; 2022 if(u1_tran_form8x8) 2023 { 2024 if(!u1_mb_field_decodingflag) 2025 { 2026 ps_dec->pu1_inv_scan = 2027 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3]; 2028 } 2029 else 2030 { 2031 ps_dec->pu1_inv_scan = 2032 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3]; 2033 } 2034 } 2035 else 2036 { 2037 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; 2038 } 2039 u4_n = (u4_top1 + u4_num_coeff + 1) >> 1; 2040 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 2041 u4_n, ps_dec, &u4_num_coeff); 2042 if(ret != OK) 2043 return ret; 2044 2045 pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff; 2046 u4_subblock_coded = (u4_num_coeff != 0); 2047 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 2048 2049 ps_dec->pu1_inv_scan = puc_temp; 2050 2051 return OK; 2052 } 2053 2054 /*****************************************************************************/ 2055 /* */ 2056 /* Function Name : ih264d_cavlc_parse_8x8block_top_available */ 2057 /* */ 2058 /* Description : This function does the residual parsing of 4 subblocks */ 2059 /* in a 8x8 block when only top is available for block */ 2060 /* */ 2061 /* Inputs : pi2_coeff_block : pointer to residual block where */ 2062 /* decoded and inverse scan coefficients are updated */ 2063 /* */ 2064 /* u4_sub_block_strd : indicates the number of sublocks */ 2065 /* in a row. It is 4 for luma and 2 for chroma. */ 2066 /* */ 2067 /* u4_isdc : required to indicate 4x4 parse modules if the */ 2068 /* current Mb is I_16x16/chroma DC coded. */ 2069 /* */ 2070 /* ps_dec : pointer to Decstruct (decoder context) */ 2071 /* */ 2072 /* pu1_top_nnz : top nnz pointer */ 2073 /* */ 2074 /* pu1_left_nnz : left nnz pointer */ 2075 /* */ 2076 /* Globals : No */ 2077 /* Processing : Parsing for four subblocks in unrolled, top and left nnz */ 2078 /* are updated on the fly. csbp is set in accordance to */ 2079 /* decoded numcoeff for the subblock index in raster order */ 2080 /* */ 2081 /* Outputs : The updated residue buffer, nnzs and csbp current block */ 2082 /* */ 2083 /* Returns : Returns the coded sub block pattern csbp for the block */ 2084 /* */ 2085 /* Issues : <List any issues or problems with this function> */ 2086 /* */ 2087 /* Revision History: */ 2088 /* */ 2089 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 2090 /* 09 10 2008 Jay Draft */ 2091 /* */ 2092 /*****************************************************************************/ 2093 WORD32 ih264d_cavlc_parse_8x8block_top_available(WORD16 *pi2_coeff_block, 2094 UWORD32 u4_sub_block_strd, 2095 UWORD32 u4_isdc, 2096 dec_struct_t * ps_dec, 2097 UWORD8 *pu1_top_nnz, 2098 UWORD8 *pu1_left_nnz, 2099 UWORD8 u1_tran_form8x8, 2100 UWORD8 u1_mb_field_decodingflag, 2101 UWORD32 *pu4_csbp) 2102 { 2103 UWORD32 u4_num_coeff, u4_n, u4_subblock_coded; 2104 UWORD32 u4_top0, u4_top1; 2105 UWORD32 *pu4_dummy; 2106 WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block, 2107 UWORD32 u4_isdc, 2108 WORD32 u4_n, 2109 struct _DecStruct *ps_dec, 2110 UWORD32 *pu4_dummy) = 2111 ps_dec->pf_cavlc_parse4x4coeff; 2112 UWORD32 u4_idx = 0; 2113 UWORD8 *puc_temp; 2114 WORD32 ret; 2115 2116 *pu4_csbp = 0; 2117 puc_temp = ps_dec->pu1_inv_scan; 2118 2119 /*------------------------------------------------------*/ 2120 /* Residual 4x4 decoding: SubBlock 0 */ 2121 /*------------------------------------------------------*/ 2122 if(u1_tran_form8x8) 2123 { 2124 if(!u1_mb_field_decodingflag) 2125 { 2126 ps_dec->pu1_inv_scan = 2127 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0]; 2128 } 2129 else 2130 { 2131 ps_dec->pu1_inv_scan = 2132 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0]; 2133 } 2134 } 2135 u4_n = pu1_top_nnz[0]; 2136 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 2137 u4_n, ps_dec, &u4_num_coeff); 2138 if(ret != OK) 2139 return ret; 2140 2141 u4_top0 = u4_num_coeff; 2142 u4_subblock_coded = (u4_num_coeff != 0); 2143 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 2144 2145 /*------------------------------------------------------*/ 2146 /* Residual 4x4 decoding: SubBlock 1 */ 2147 /*------------------------------------------------------*/ 2148 u4_idx++; 2149 if(u1_tran_form8x8) 2150 { 2151 if(!u1_mb_field_decodingflag) 2152 { 2153 ps_dec->pu1_inv_scan = 2154 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1]; 2155 } 2156 else 2157 { 2158 ps_dec->pu1_inv_scan = 2159 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1]; 2160 } 2161 } 2162 else 2163 { 2164 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; 2165 } 2166 u4_n = (pu1_top_nnz[1] + u4_num_coeff + 1) >> 1; 2167 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 2168 u4_n, ps_dec, &u4_num_coeff); 2169 if(ret != OK) 2170 return ret; 2171 2172 u4_top1 = pu1_left_nnz[0] = u4_num_coeff; 2173 u4_subblock_coded = (u4_num_coeff != 0); 2174 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 2175 2176 /*------------------------------------------------------*/ 2177 /* Residual 4x4 decoding: SubBlock 2 */ 2178 /*------------------------------------------------------*/ 2179 u4_idx += (u4_sub_block_strd - 1); 2180 if(u1_tran_form8x8) 2181 { 2182 if(!u1_mb_field_decodingflag) 2183 { 2184 ps_dec->pu1_inv_scan = 2185 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2]; 2186 } 2187 else 2188 { 2189 ps_dec->pu1_inv_scan = 2190 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2]; 2191 } 2192 } 2193 else 2194 { 2195 pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK); 2196 } 2197 u4_n = u4_top0; 2198 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 2199 u4_n, ps_dec, &u4_num_coeff); 2200 if(ret != OK) 2201 return ret; 2202 2203 pu1_top_nnz[0] = u4_num_coeff; 2204 u4_subblock_coded = (u4_num_coeff != 0); 2205 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 2206 2207 /*------------------------------------------------------*/ 2208 /* Residual 4x4 decoding: SubBlock 3 */ 2209 /*------------------------------------------------------*/ 2210 u4_idx++; 2211 if(u1_tran_form8x8) 2212 { 2213 if(!u1_mb_field_decodingflag) 2214 { 2215 ps_dec->pu1_inv_scan = 2216 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3]; 2217 } 2218 else 2219 { 2220 ps_dec->pu1_inv_scan = 2221 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3]; 2222 } 2223 } 2224 else 2225 { 2226 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; 2227 } 2228 u4_n = (u4_top1 + u4_num_coeff + 1) >> 1; 2229 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 2230 u4_n, ps_dec, &u4_num_coeff); 2231 if(ret != OK) 2232 return ret; 2233 2234 pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff; 2235 u4_subblock_coded = (u4_num_coeff != 0); 2236 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 2237 2238 ps_dec->pu1_inv_scan = puc_temp; 2239 2240 return OK; 2241 } 2242 2243 /*****************************************************************************/ 2244 /* */ 2245 /* Function Name : ih264d_cavlc_parse_8x8block_none_available */ 2246 /* */ 2247 /* Description : This function does the residual parsing of 4 subblocks */ 2248 /* in a 8x8 block when none of the neigbours are available */ 2249 /* */ 2250 /* Inputs : pi2_coeff_block : pointer to residual block where */ 2251 /* decoded and inverse scan coefficients are updated */ 2252 /* */ 2253 /* u4_sub_block_strd : indicates the number of sublocks */ 2254 /* in a row. It is 4 for luma and 2 for chroma. */ 2255 /* */ 2256 /* u4_isdc : required to indicate 4x4 parse modules if the */ 2257 /* current Mb is I_16x16/chroma DC coded. */ 2258 /* */ 2259 /* ps_dec : pointer to Decstruct (decoder context) */ 2260 /* */ 2261 /* pu1_top_nnz : top nnz pointer */ 2262 /* */ 2263 /* pu1_left_nnz : left nnz pointer */ 2264 /* */ 2265 /* Globals : No */ 2266 /* Processing : Parsing for four subblocks in unrolled, top and left nnz */ 2267 /* are updated on the fly. csbp is set in accordance to */ 2268 /* decoded numcoeff for the subblock index in raster order */ 2269 /* */ 2270 /* Outputs : The updated residue buffer, nnzs and csbp current block */ 2271 /* */ 2272 /* Returns : Returns the coded sub block pattern csbp for the block */ 2273 /* */ 2274 /* Issues : <List any issues or problems with this function> */ 2275 /* */ 2276 /* Revision History: */ 2277 /* */ 2278 /* DD MM YYYY Author(s) Changes (Describe the changes made) */ 2279 /* 09 10 2008 Jay Draft */ 2280 /* */ 2281 /*****************************************************************************/ 2282 WORD32 ih264d_cavlc_parse_8x8block_none_available(WORD16 *pi2_coeff_block, 2283 UWORD32 u4_sub_block_strd, 2284 UWORD32 u4_isdc, 2285 dec_struct_t * ps_dec, 2286 UWORD8 *pu1_top_nnz, 2287 UWORD8 *pu1_left_nnz, 2288 UWORD8 u1_tran_form8x8, 2289 UWORD8 u1_mb_field_decodingflag, 2290 UWORD32 *pu4_csbp) 2291 { 2292 UWORD32 u4_num_coeff, u4_n, u4_subblock_coded; 2293 UWORD32 u4_top0, u4_top1; 2294 UWORD32 *pu4_dummy; 2295 WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block, 2296 UWORD32 u4_isdc, 2297 WORD32 u4_n, 2298 struct _DecStruct *ps_dec, 2299 UWORD32 *pu4_dummy) = 2300 ps_dec->pf_cavlc_parse4x4coeff; 2301 UWORD32 u4_idx = 0; 2302 UWORD8 *puc_temp; 2303 WORD32 ret; 2304 2305 *pu4_csbp = 0; 2306 puc_temp = ps_dec->pu1_inv_scan; 2307 2308 /*------------------------------------------------------*/ 2309 /* Residual 4x4 decoding: SubBlock 0 */ 2310 /*------------------------------------------------------*/ 2311 if(u1_tran_form8x8) 2312 { 2313 if(!u1_mb_field_decodingflag) 2314 { 2315 ps_dec->pu1_inv_scan = 2316 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0]; 2317 } 2318 else 2319 { 2320 ps_dec->pu1_inv_scan = 2321 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0]; 2322 } 2323 } 2324 ret = pf_cavlc_parse4x4coeff[0](pi2_coeff_block, u4_isdc, 0, 2325 ps_dec, &u4_num_coeff); 2326 if(ret != OK) 2327 return ret; 2328 2329 u4_top0 = u4_num_coeff; 2330 u4_subblock_coded = (u4_num_coeff != 0); 2331 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 2332 2333 /*------------------------------------------------------*/ 2334 /* Residual 4x4 decoding: SubBlock 1 */ 2335 /*------------------------------------------------------*/ 2336 u4_idx++; 2337 if(u1_tran_form8x8) 2338 { 2339 if(!u1_mb_field_decodingflag) 2340 { 2341 ps_dec->pu1_inv_scan = 2342 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1]; 2343 } 2344 else 2345 { 2346 ps_dec->pu1_inv_scan = 2347 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1]; 2348 } 2349 } 2350 else 2351 { 2352 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; 2353 } 2354 u4_n = u4_num_coeff; 2355 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 2356 u4_n, ps_dec, &u4_num_coeff); 2357 if(ret != OK) 2358 return ret; 2359 2360 u4_top1 = pu1_left_nnz[0] = u4_num_coeff; 2361 u4_subblock_coded = (u4_num_coeff != 0); 2362 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 2363 2364 /*------------------------------------------------------*/ 2365 /* Residual 4x4 decoding: SubBlock 2 */ 2366 /*------------------------------------------------------*/ 2367 u4_idx += (u4_sub_block_strd - 1); 2368 if(u1_tran_form8x8) 2369 { 2370 if(!u1_mb_field_decodingflag) 2371 { 2372 ps_dec->pu1_inv_scan = 2373 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2]; 2374 } 2375 else 2376 { 2377 ps_dec->pu1_inv_scan = 2378 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2]; 2379 } 2380 } 2381 else 2382 { 2383 pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK); 2384 } 2385 u4_n = u4_top0; 2386 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 2387 u4_n, ps_dec, &u4_num_coeff); 2388 if(ret != OK) 2389 return ret; 2390 2391 pu1_top_nnz[0] = u4_num_coeff; 2392 u4_subblock_coded = (u4_num_coeff != 0); 2393 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 2394 2395 /*------------------------------------------------------*/ 2396 /* Residual 4x4 decoding: SubBlock 3 */ 2397 /*------------------------------------------------------*/ 2398 u4_idx++; 2399 if(u1_tran_form8x8) 2400 { 2401 if(!u1_mb_field_decodingflag) 2402 { 2403 ps_dec->pu1_inv_scan = 2404 (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3]; 2405 } 2406 else 2407 { 2408 ps_dec->pu1_inv_scan = 2409 (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3]; 2410 } 2411 } 2412 else 2413 { 2414 pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; 2415 } 2416 u4_n = (u4_top1 + u4_num_coeff + 1) >> 1; 2417 ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, 2418 u4_n, ps_dec, &u4_num_coeff); 2419 if(ret != OK) 2420 return ret; 2421 2422 pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff; 2423 u4_subblock_coded = (u4_num_coeff != 0); 2424 INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); 2425 2426 ps_dec->pu1_inv_scan = puc_temp; 2427 2428 return OK; 2429 } 2430 2431 /*! 2432 ************************************************************************** 2433 * \if Function name : ih264d_parse_residual4x4_cavlc \endif 2434 * 2435 * \brief 2436 * This function parses CAVLC syntax of a Luma and Chroma AC Residuals. 2437 * 2438 * \return 2439 * 0 on Success and Error code otherwise 2440 ************************************************************************** 2441 */ 2442 2443 WORD32 ih264d_parse_residual4x4_cavlc(dec_struct_t * ps_dec, 2444 dec_mb_info_t *ps_cur_mb_info, 2445 UWORD8 u1_offset) 2446 { 2447 UWORD8 u1_cbp = ps_cur_mb_info->u1_cbp; 2448 UWORD16 ui16_csbp = 0; 2449 UWORD32 u4_nbr_avl; 2450 WORD16 *pi2_residual_buf; 2451 2452 UWORD8 u1_is_top_mb_avail; 2453 UWORD8 u1_is_left_mb_avail; 2454 2455 UWORD8 *pu1_top_nnz = ps_cur_mb_info->ps_curmb->pu1_nnz_y; 2456 UWORD8 *pu1_left_nnz = ps_dec->pu1_left_nnz_y; 2457 WORD16 *pi2_coeff_block = NULL; 2458 UWORD32 *pu4_dummy; 2459 WORD32 ret; 2460 2461 WORD32 (**pf_cavlc_parse_8x8block)(WORD16 *pi2_coeff_block, 2462 UWORD32 u4_sub_block_strd, 2463 UWORD32 u4_isdc, 2464 struct _DecStruct *ps_dec, 2465 UWORD8 *pu1_top_nnz, 2466 UWORD8 *pu1_left_nnz, 2467 UWORD8 u1_tran_form8x8, 2468 UWORD8 u1_mb_field_decodingflag, 2469 UWORD32 *pu4_dummy) = ps_dec->pf_cavlc_parse_8x8block; 2470 2471 2472 { 2473 UWORD8 uc_temp = ps_dec->u1_mb_ngbr_availablity; 2474 u1_is_top_mb_avail = BOOLEAN(uc_temp & TOP_MB_AVAILABLE_MASK); 2475 u1_is_left_mb_avail = BOOLEAN(uc_temp & LEFT_MB_AVAILABLE_MASK); 2476 u4_nbr_avl = (u1_is_top_mb_avail << 1) | u1_is_left_mb_avail; 2477 } 2478 2479 ps_cur_mb_info->u1_qp_div6 = ps_dec->u1_qp_y_div6; 2480 ps_cur_mb_info->u1_qp_rem6 = ps_dec->u1_qp_y_rem6; 2481 ps_cur_mb_info->u1_qpc_div6 = ps_dec->u1_qp_u_div6; 2482 ps_cur_mb_info->u1_qpc_rem6 = ps_dec->u1_qp_u_rem6; 2483 ps_cur_mb_info->u1_qpcr_div6 = ps_dec->u1_qp_v_div6; 2484 ps_cur_mb_info->u1_qpcr_rem6 = ps_dec->u1_qp_v_rem6; 2485 2486 if(u1_cbp & 0xf) 2487 { 2488 pu1_top_nnz[0] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[0]; 2489 pu1_top_nnz[1] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[1]; 2490 pu1_top_nnz[2] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[2]; 2491 pu1_top_nnz[3] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[3]; 2492 2493 /*******************************************************************/ 2494 /* Block 0 residual decoding, check cbp and proceed (subblock = 0) */ 2495 /*******************************************************************/ 2496 if(!(u1_cbp & 0x1)) 2497 { 2498 *(UWORD16 *)(pu1_top_nnz) = 0; 2499 *(UWORD16 *)(pu1_left_nnz) = 0; 2500 2501 } 2502 else 2503 { 2504 UWORD32 u4_temp; 2505 ret = pf_cavlc_parse_8x8block[u4_nbr_avl]( 2506 pi2_coeff_block, 4, u1_offset, ps_dec, pu1_top_nnz, 2507 pu1_left_nnz, ps_cur_mb_info->u1_tran_form8x8, 2508 ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp); 2509 if(ret != OK) 2510 return ret; 2511 ui16_csbp = u4_temp; 2512 } 2513 2514 /*******************************************************************/ 2515 /* Block 1 residual decoding, check cbp and proceed (subblock = 2) */ 2516 /*******************************************************************/ 2517 if(ps_cur_mb_info->u1_tran_form8x8) 2518 { 2519 pi2_coeff_block += 64; 2520 } 2521 else 2522 { 2523 pi2_coeff_block += (2 * NUM_COEFFS_IN_4x4BLK); 2524 } 2525 2526 if(!(u1_cbp & 0x2)) 2527 { 2528 *(UWORD16 *)(pu1_top_nnz + 2) = 0; 2529 *(UWORD16 *)(pu1_left_nnz) = 0; 2530 } 2531 else 2532 { 2533 UWORD32 u4_temp = (u4_nbr_avl | 0x1); 2534 ret = pf_cavlc_parse_8x8block[u4_temp]( 2535 pi2_coeff_block, 4, u1_offset, ps_dec, 2536 (pu1_top_nnz + 2), pu1_left_nnz, 2537 ps_cur_mb_info->u1_tran_form8x8, 2538 ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp); 2539 if(ret != OK) 2540 return ret; 2541 ui16_csbp |= (u4_temp << 2); 2542 } 2543 2544 /*******************************************************************/ 2545 /* Block 2 residual decoding, check cbp and proceed (subblock = 8) */ 2546 /*******************************************************************/ 2547 if(ps_cur_mb_info->u1_tran_form8x8) 2548 { 2549 pi2_coeff_block += 64; 2550 } 2551 else 2552 { 2553 pi2_coeff_block += (6 * NUM_COEFFS_IN_4x4BLK); 2554 } 2555 2556 if(!(u1_cbp & 0x4)) 2557 { 2558 *(UWORD16 *)(pu1_top_nnz) = 0; 2559 *(UWORD16 *)(pu1_left_nnz + 2) = 0; 2560 } 2561 else 2562 { 2563 UWORD32 u4_temp = (u4_nbr_avl | 0x2); 2564 ret = pf_cavlc_parse_8x8block[u4_temp]( 2565 pi2_coeff_block, 4, u1_offset, ps_dec, pu1_top_nnz, 2566 (pu1_left_nnz + 2), ps_cur_mb_info->u1_tran_form8x8, 2567 ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp); 2568 if(ret != OK) 2569 return ret; 2570 ui16_csbp |= (u4_temp << 8); 2571 } 2572 2573 /*******************************************************************/ 2574 /* Block 3 residual decoding, check cbp and proceed (subblock = 10)*/ 2575 /*******************************************************************/ 2576 if(ps_cur_mb_info->u1_tran_form8x8) 2577 { 2578 pi2_coeff_block += 64; 2579 } 2580 else 2581 { 2582 pi2_coeff_block += (2 * NUM_COEFFS_IN_4x4BLK); 2583 } 2584 2585 if(!(u1_cbp & 0x8)) 2586 { 2587 *(UWORD16 *)(pu1_top_nnz + 2) = 0; 2588 *(UWORD16 *)(pu1_left_nnz + 2) = 0; 2589 } 2590 else 2591 { 2592 UWORD32 u4_temp; 2593 ret = pf_cavlc_parse_8x8block[0x3]( 2594 pi2_coeff_block, 4, u1_offset, ps_dec, 2595 (pu1_top_nnz + 2), (pu1_left_nnz + 2), 2596 ps_cur_mb_info->u1_tran_form8x8, 2597 ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp); 2598 if(ret != OK) 2599 return ret; 2600 ui16_csbp |= (u4_temp << 10); 2601 } 2602 } 2603 else 2604 { 2605 *(UWORD32 *)(pu1_top_nnz) = 0; 2606 *(UWORD32 *)(pu1_left_nnz) = 0; 2607 } 2608 2609 ps_cur_mb_info->u2_luma_csbp = ui16_csbp; 2610 ps_cur_mb_info->ps_curmb->u2_luma_csbp = ui16_csbp; 2611 2612 { 2613 UWORD16 u2_chroma_csbp = 0; 2614 ps_cur_mb_info->u2_chroma_csbp = 0; 2615 pu1_top_nnz = ps_cur_mb_info->ps_curmb->pu1_nnz_uv; 2616 pu1_left_nnz = ps_dec->pu1_left_nnz_uv; 2617 2618 u1_cbp >>= 4; 2619 /*--------------------------------------------------------------------*/ 2620 /* if Chroma Component not present OR no ac values present */ 2621 /* Set the values of N to zero */ 2622 /*--------------------------------------------------------------------*/ 2623 if(u1_cbp == CBPC_ALLZERO || u1_cbp == CBPC_ACZERO) 2624 { 2625 *(UWORD32 *)(pu1_top_nnz) = 0; 2626 *(UWORD32 *)(pu1_left_nnz) = 0; 2627 } 2628 2629 if(u1_cbp == CBPC_ALLZERO) 2630 { 2631 return (0); 2632 } 2633 /*--------------------------------------------------------------------*/ 2634 /* Decode Chroma DC values */ 2635 /*--------------------------------------------------------------------*/ 2636 { 2637 WORD32 u4_scale_u; 2638 WORD32 u4_scale_v; 2639 WORD32 i4_mb_inter_inc; 2640 u4_scale_u = ps_dec->pu2_quant_scale_u[0] << ps_dec->u1_qp_u_div6; 2641 u4_scale_v = ps_dec->pu2_quant_scale_v[0] << ps_dec->u1_qp_v_div6; 2642 i4_mb_inter_inc = (!((ps_cur_mb_info->ps_curmb->u1_mb_type == I_4x4_MB) 2643 || (ps_cur_mb_info->ps_curmb->u1_mb_type == I_16x16_MB))) 2644 * 3; 2645 2646 if(ps_dec->s_high_profile.u1_scaling_present) 2647 { 2648 u4_scale_u *= 2649 ps_dec->s_high_profile.i2_scalinglist4x4[i4_mb_inter_inc 2650 + 1][0]; 2651 u4_scale_v *= 2652 ps_dec->s_high_profile.i2_scalinglist4x4[i4_mb_inter_inc 2653 + 2][0]; 2654 2655 } 2656 else 2657 { 2658 u4_scale_u <<= 4; 2659 u4_scale_v <<= 4; 2660 } 2661 2662 ih264d_cavlc_parse_chroma_dc(ps_cur_mb_info,pi2_coeff_block, ps_dec->ps_bitstrm, 2663 u4_scale_u, u4_scale_v, 2664 i4_mb_inter_inc); 2665 } 2666 2667 if(u1_cbp == CBPC_ACZERO) 2668 return (0); 2669 2670 pu1_top_nnz[0] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[0]; 2671 pu1_top_nnz[1] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[1]; 2672 pu1_top_nnz[2] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[2]; 2673 pu1_top_nnz[3] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[3]; 2674 /*--------------------------------------------------------------------*/ 2675 /* Decode Chroma AC values */ 2676 /*--------------------------------------------------------------------*/ 2677 { 2678 UWORD32 u4_temp; 2679 /*****************************************************************/ 2680 /* U Block residual decoding, check cbp and proceed (subblock=0)*/ 2681 /*****************************************************************/ 2682 ret = pf_cavlc_parse_8x8block[u4_nbr_avl]( 2683 pi2_coeff_block, 2, 1, ps_dec, pu1_top_nnz, 2684 pu1_left_nnz, 0, 0, &u4_temp); 2685 if(ret != OK) 2686 return ret; 2687 u2_chroma_csbp = u4_temp; 2688 2689 pi2_coeff_block += MB_CHROM_SIZE; 2690 /*****************************************************************/ 2691 /* V Block residual decoding, check cbp and proceed (subblock=1)*/ 2692 /*****************************************************************/ 2693 ret = pf_cavlc_parse_8x8block[u4_nbr_avl](pi2_coeff_block, 2, 1, 2694 ps_dec, 2695 (pu1_top_nnz + 2), 2696 (pu1_left_nnz + 2), 0, 2697 0, &u4_temp); 2698 if(ret != OK) 2699 return ret; 2700 u2_chroma_csbp |= (u4_temp << 4); 2701 } 2702 2703 ps_cur_mb_info->u2_chroma_csbp = u2_chroma_csbp; 2704 } 2705 return OK; 2706 } 2707
