/****************************************************************************** * * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ***************************************************************************** * Originally developed and contributed by Ittiam Systems Pvt. Ltd, Bangalore */ /*! *************************************************************************** * \file ih264d_parse_cavlc.c * * \brief * This file contains UVLC related functions. * * \date * 20/11/2002 * * \author NS *************************************************************************** */ #include #include #include "ih264d_bitstrm.h" #include "ih264d_parse_cavlc.h" #include "ih264d_error_handler.h" #include "ih264d_defs.h" #include "ih264d_debug.h" #include "ih264d_cabac.h" #include "ih264d_structs.h" #include "ih264d_tables.h" #include "ih264d_tables.h" #include "ih264d_mb_utils.h" void ih264d_unpack_coeff4x4_dc_4x4blk(tu_sblk4x4_coeff_data_t *ps_tu_4x4, WORD16 *pi2_out_coeff_data, UWORD8 *pu1_inv_scan); /*****************************************************************************/ /* */ /* Function Name : ih264d_uev */ /* */ /* Description : Reads the unsigned Exp Golomb codec syntax from the */ /* ps_bitstrm as specified in section 9.1 of H264 standard */ /* It also increases bitstream u4_ofst by the number of bits */ /* parsed for UEV decode operation */ /* */ /* Inputs : bitstream base pointer and bitsream u4_ofst in bits */ /* Globals : None */ /* Processing : */ /* Outputs : UEV decoded syntax element and incremented ps_bitstrm u4_ofst */ /* Returns : UEV decoded syntax element */ /* */ /* Issues : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size */ /* for performamce. Caller might have to do error resilence */ /* check for bitstream overflow */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 19 09 2008 Jay Draft */ /* */ /*****************************************************************************/ UWORD32 ih264d_uev(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf) { UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; UWORD32 u4_word, u4_ldz; /***************************************************************/ /* Find leading zeros in next 32 bits */ /***************************************************************/ NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); u4_ldz = CLZ(u4_word); /* Flush the ps_bitstrm */ u4_bitstream_offset += (u4_ldz + 1); /* Read the suffix from the ps_bitstrm */ u4_word = 0; if(u4_ldz) GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz); *pu4_bitstrm_ofst = u4_bitstream_offset; return ((1 << u4_ldz) + u4_word - 1); } /*****************************************************************************/ /* */ /* Function Name : ih264d_sev */ /* */ /* Description : Reads the signed Exp Golomb codec syntax from the ps_bitstrm */ /* as specified in section 9.1 of H264 standard. */ /* It also increases bitstream u4_ofst by the number of bits */ /* parsed for SEV decode operation */ /* */ /* Inputs : bitstream base pointer and bitsream u4_ofst in bits */ /* Globals : None */ /* Processing : */ /* Outputs : SEV decoded syntax element and incremented ps_bitstrm u4_ofst */ /* Returns : SEV decoded syntax element */ /* */ /* Issues : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size */ /* for performamce. Caller might have to do error resilence */ /* check for bitstream overflow */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 19 09 2008 Jay Draft */ /* */ /*****************************************************************************/ WORD32 ih264d_sev(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf) { UWORD32 u4_bitstream_offset = *pu4_bitstrm_ofst; UWORD32 u4_word, u4_ldz, u4_abs_val; /***************************************************************/ /* Find leading zeros in next 32 bits */ /***************************************************************/ NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); u4_ldz = CLZ(u4_word); /* Flush the ps_bitstrm */ u4_bitstream_offset += (u4_ldz + 1); /* Read the suffix from the ps_bitstrm */ u4_word = 0; if(u4_ldz) GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz); *pu4_bitstrm_ofst = u4_bitstream_offset; u4_abs_val = ((1 << u4_ldz) + u4_word) >> 1; if(u4_word & 0x1) return (-(WORD32)u4_abs_val); else return (u4_abs_val); } /*****************************************************************************/ /* */ /* Function Name : get_tev_range_1 */ /* */ /* Description : Reads the TEV Exp Golomb codec syntax from the ps_bitstrm */ /* as specified in section 9.1 of H264 standard. This will */ /* called only when the input range is 1 for TEV decode. */ /* If range is more than 1, then UEV decode is done */ /* */ /* Inputs : bitstream base pointer and bitsream u4_ofst in bits */ /* Globals : None */ /* Processing : */ /* Outputs : TEV decoded syntax element and incremented ps_bitstrm u4_ofst */ /* Returns : TEV decoded syntax element */ /* */ /* Issues : Does not check if ps_bitstrm u4_ofst exceeds max ps_bitstrm i4_size */ /* for performamce. Caller might have to do error resilence */ /* check for bitstream overflow */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 19 09 2008 Jay Draft */ /* */ /*****************************************************************************/ UWORD32 ih264d_tev_range1(UWORD32 *pu4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf) { UWORD32 u4_code; GETBIT(u4_code, *pu4_bitstrm_ofst, pu4_bitstrm_buf); return (!u4_code); } /*! ************************************************************************** * \if Function name : ih264d_uvlc \endif * * \brief * * Reads the unsigned/signed/truncated integer Exp-Golomb-coded syntax element * with the left bit first. The parsing process for this descriptor is specified * in subclause 9.1. * * \param ps_bitstrm : Pointer to Bitstream Structure . * \param u4_range : Range value in case of Truncated Exp-Golomb-code * \param pi_bitstrm_ofst : Pointer to the local copy of Bitstream u4_ofst * \param u1_flag : Flag indicating the case of UEV,SEV or TEV * \param u4_bitstrm_ofst : Local copy of Bitstream u4_ofst * \param pu4_bitstrm_buf : Pointer to the Bitstream buffer * * \return * Returns Code Value. * ************************************************************************** */ WORD32 ih264d_uvlc(dec_bit_stream_t *ps_bitstrm, UWORD32 u4_range, UWORD32 *pi_bitstrm_ofst, UWORD8 u1_flag, UWORD32 u4_bitstrm_ofst, UWORD32 *pu4_bitstrm_buf) { UWORD32 word, word2, cur_bit, cur_word, code_val, code_num, clz; SWITCHOFFTRACE; cur_bit = u4_bitstrm_ofst & 0x1F; cur_word = u4_bitstrm_ofst >> 5; word = pu4_bitstrm_buf[cur_word]; word2 = pu4_bitstrm_buf[cur_word + 1]; if(cur_bit != 0) { word <<= cur_bit; word2 >>= (32 - cur_bit); word |= word2; } if(u1_flag == TEV && u4_range == 1) { word >>= 31; word = 1 - word; (*pi_bitstrm_ofst)++; ps_bitstrm->u4_ofst = *pi_bitstrm_ofst; return (WORD32)word; } //finding clz { UWORD32 ui32_code, ui32_mask; ui32_code = word; ui32_mask = 0x80000000; clz = 0; /* DSP implements this with LMBD instruction */ /* so there we don't need to break the loop */ while(!(ui32_code & ui32_mask)) { clz++; ui32_mask >>= 1; if(0 == ui32_mask) break; } } if(clz == 0) { *pi_bitstrm_ofst = *pi_bitstrm_ofst + (2 * clz) + 1; ps_bitstrm->u4_ofst = *pi_bitstrm_ofst; return 0; } word <<= (clz + 1); word >>= (32 - clz); code_num = (1 << clz) + word - 1; *pi_bitstrm_ofst = *pi_bitstrm_ofst + (2 * clz) + 1; ps_bitstrm->u4_ofst = *pi_bitstrm_ofst; if(u1_flag == TEV || u1_flag == UEV) return (WORD32)code_num; code_val = (code_num + 1) >> 1; if(!(code_num & 0x01)) return -((WORD32)code_val); return (WORD32)code_val; } /*****************************************************************************/ /* */ /* Function Name : ih264d_cavlc_4x4res_block_totalcoeff_1 */ /* */ /* Description : This function does cavlc decoding of 4x4 block residual */ /* coefficient when total coeff is equal to 1. The parsing */ /* is done as defined in section 9.2.2 and 9.2.3 of the */ /* H264 standard. */ /* */ /* Inputs : */ /* Globals : */ /* Processing : */ /* Outputs : */ /* Returns : */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 25 09 2008 Jay Draft */ /* */ /*****************************************************************************/ WORD32 ih264d_cavlc_4x4res_block_totalcoeff_1(UWORD32 u4_isdc, UWORD32 u4_total_coeff_trail_one, dec_bit_stream_t *ps_bitstrm) { UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF; WORD32 i2_level; UWORD32 u4_tot_zero, u4_ldz, u4_scan_pos; tu_sblk4x4_coeff_data_t *ps_tu_4x4; WORD16 *pi2_coeff_data; dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; ps_tu_4x4->u2_sig_coeff_map = 0; pi2_coeff_data = &ps_tu_4x4->ai2_level[0]; if(u4_trailing_ones) { UWORD32 u4_sign; /****************************************************************/ /* Decode Trailing One as in section 9.2.2 */ /****************************************************************/ GETBIT(u4_sign, u4_bitstream_offset, pu4_bitstrm_buf); i2_level = u4_sign ? -1 : 1; } else { /****************************************************************/ /* Decoding Level based on prefix and suffix as in 9.2.2 */ /****************************************************************/ UWORD32 u4_lev_suffix, u4_lev_suffix_size; WORD32 u2_lev_code, u2_abs_value; UWORD32 u4_lev_prefix; /***************************************************************/ /* Find leading zeros in next 32 bits */ /***************************************************************/ FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, pu4_bitstrm_buf); u2_lev_code = (2 + MIN(u4_lev_prefix, 15)); if(14 == u4_lev_prefix) u4_lev_suffix_size = 4; else if(15 <= u4_lev_prefix) { u2_lev_code += 15; u4_lev_suffix_size = u4_lev_prefix - 3; } else u4_lev_suffix_size = 0; //HP_LEVEL_PREFIX if(16 <= u4_lev_prefix) { u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); } if(u4_lev_suffix_size) { GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, u4_lev_suffix_size); u2_lev_code += u4_lev_suffix; } u2_abs_value = (u2_lev_code + 2) >> 1; /*********************************************************/ /* If Level code is odd, level is negative else positive */ /*********************************************************/ i2_level = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; } /****************************************************************/ /* Decoding total zeros as in section 9.2.3, table 9.7 */ /****************************************************************/ FIND_ONE_IN_STREAM_LEN(u4_ldz, u4_bitstream_offset, pu4_bitstrm_buf, 8); if(u4_ldz) { GETBIT(u4_tot_zero, u4_bitstream_offset, pu4_bitstrm_buf); u4_tot_zero = (u4_ldz << 1) - u4_tot_zero; } else u4_tot_zero = 0; /***********************************************************************/ /* Inverse scan and store residual coeff. Update the bitstream u4_ofst */ /***********************************************************************/ u4_scan_pos = u4_tot_zero + u4_isdc; if(u4_scan_pos > 15) return -1; SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); *pi2_coeff_data++ = i2_level; { WORD32 offset; offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4; offset = ALIGN4(offset); ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset); } ps_bitstrm->u4_ofst = u4_bitstream_offset; return 0; } /*****************************************************************************/ /* */ /* Function Name : ih264d_cavlc_4x4res_block_totalcoeff_2to10 */ /* */ /* Description : This function does cavlc decoding of 4x4 block residual */ /* coefficient when total coeffs are between two and ten */ /* inclusive. Parsing is done as defined in section 9.2.2 */ /* and 9.2.3 the H264 standard. */ /* */ /* Inputs : */ /* Globals : */ /* Processing : */ /* Outputs : */ /* Returns : */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 25 09 2008 Jay Draft */ /* */ /*****************************************************************************/ WORD32 ih264d_cavlc_4x4res_block_totalcoeff_2to10(UWORD32 u4_isdc, UWORD32 u4_total_coeff_trail_one, /*!pu4_buffer; UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF; UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16; // To avoid error check at 4x4 level, allocating for 3 extra levels(16+3) // since u4_trailing_ones can at the max be 3. This will be required when // u4_total_coeff is less than u4_trailing_ones WORD16 ai2_level_arr[19]; WORD16 *i2_level_arr = &ai2_level_arr[3]; tu_sblk4x4_coeff_data_t *ps_tu_4x4; WORD16 *pi2_coeff_data; dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; ps_tu_4x4->u2_sig_coeff_map = 0; pi2_coeff_data = &ps_tu_4x4->ai2_level[0]; i = u4_total_coeff - 1; if(u4_trailing_ones) { /*********************************************************************/ /* Decode Trailing Ones */ /* read the sign of T1's and put them in level array */ /*********************************************************************/ UWORD32 u4_signs, u4_cnt = u4_trailing_ones; WORD16 (*ppi2_trlone_lkup)[3] = (WORD16 (*)[3])gai2_ih264d_trailing_one_level; WORD16 *pi2_trlone_lkup; GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt); pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs]; while(u4_cnt--) i2_level_arr[i--] = *pi2_trlone_lkup++; } /****************************************************************/ /* Decoding Levels Begins */ /****************************************************************/ if(i >= 0) { /****************************************************************/ /* First level is decoded outside the loop as it has lot of */ /* special cases. */ /****************************************************************/ UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size; WORD32 u2_lev_code, u2_abs_value; UWORD32 u4_lev_prefix; /***************************************************************/ /* u4_suffix_len = 0, Find leading zeros in next 32 bits */ /***************************************************************/ FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, pu4_bitstrm_buf); /*********************************************************/ /* Special decoding case when trailing ones are 3 */ /*********************************************************/ u2_lev_code = MIN(15, u4_lev_prefix); u2_lev_code += (3 == u4_trailing_ones) ? 0 : 2; if(14 == u4_lev_prefix) u4_lev_suffix_size = 4; else if(15 <= u4_lev_prefix) { u2_lev_code += 15; u4_lev_suffix_size = u4_lev_prefix - 3; } else u4_lev_suffix_size = 0; //HP_LEVEL_PREFIX if(16 <= u4_lev_prefix) { u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); } if(u4_lev_suffix_size) { GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, u4_lev_suffix_size); u2_lev_code += u4_lev_suffix; } u2_abs_value = (u2_lev_code + 2) >> 1; /*********************************************************/ /* If Level code is odd, level is negative else positive */ /*********************************************************/ i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; u4_suffix_len = (u2_abs_value > 3) ? 2 : 1; /*********************************************************/ /* Now loop over the remaining levels */ /*********************************************************/ while(i >= 0) { /***************************************************************/ /* Find leading zeros in next 32 bits */ /***************************************************************/ FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, pu4_bitstrm_buf); u4_lev_suffix_size = (15 <= u4_lev_prefix) ? (u4_lev_prefix - 3) : u4_suffix_len; /*********************************************************/ /* Compute level code using prefix and suffix */ /*********************************************************/ GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, u4_lev_suffix_size); u2_lev_code = (MIN(15,u4_lev_prefix) << u4_suffix_len) + u4_lev_suffix; //HP_LEVEL_PREFIX if(16 <= u4_lev_prefix) { u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); } u2_abs_value = (u2_lev_code + 2) >> 1; /*********************************************************/ /* If Level code is odd, level is negative else positive */ /*********************************************************/ i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; /*********************************************************/ /* Increment suffix length if required */ /*********************************************************/ u4_suffix_len += (u4_suffix_len < 6) ? (u2_abs_value > (3 << (u4_suffix_len - 1))) : 0; } /****************************************************************/ /* Decoding Levels Ends */ /****************************************************************/ } /****************************************************************/ /* Decoding total zeros as in section 9.2.3, table 9.7 */ /****************************************************************/ { UWORD32 u4_index; const UWORD8 (*ppu1_total_zero_lkup)[64] = (const UWORD8 (*)[64])gau1_ih264d_table_total_zero_2to10; NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 6); u4_total_zeroes = ppu1_total_zero_lkup[u4_total_coeff - 2][u4_index]; FLUSHBITS(u4_bitstream_offset, (u4_total_zeroes >> 4)); u4_total_zeroes &= 0xf; } /**************************************************************/ /* Decode the runs and form the coefficient buffer */ /**************************************************************/ { const UWORD8 *pu1_table_runbefore; UWORD32 u4_run; WORD32 k; UWORD32 u4_scan_pos = u4_total_coeff + u4_total_zeroes - 1 + u4_isdc; WORD32 u4_zeroes_left = u4_total_zeroes; k = u4_total_coeff - 1; /**************************************************************/ /* Decoding Runs Begin for zeros left > 6 */ /**************************************************************/ while((u4_zeroes_left > 6) && k) { UWORD32 u4_code; NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3); if(u4_code != 0) { FLUSHBITS(u4_bitstream_offset, 3); u4_run = (7 - u4_code); } else { FIND_ONE_IN_STREAM_LEN(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 11); u4_run = (4 + u4_code); } SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); *pi2_coeff_data++ = i2_level_arr[k--]; u4_zeroes_left -= u4_run; u4_scan_pos -= (u4_run + 1); } /**************************************************************/ /* Decoding Runs for 0 < zeros left <=6 */ /**************************************************************/ pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before; while((u4_zeroes_left > 0) && k) { UWORD32 u4_code; NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3); u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)]; u4_run = u4_code >> 2; FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03)); SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); *pi2_coeff_data++ = i2_level_arr[k--]; u4_zeroes_left -= u4_run; u4_scan_pos -= (u4_run + 1); } /**************************************************************/ /* Decoding Runs End */ /**************************************************************/ /**************************************************************/ /* Copy the remaining coefficients */ /**************************************************************/ if(u4_zeroes_left < 0) return -1; while(k >= 0) { SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); *pi2_coeff_data++ = i2_level_arr[k--]; u4_scan_pos--; } } { WORD32 offset; offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4; offset = ALIGN4(offset); ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset); } ps_bitstrm->u4_ofst = u4_bitstream_offset; return 0; } /*****************************************************************************/ /* */ /* Function Name : ih264d_cavlc_4x4res_block_totalcoeff_11to16 */ /* */ /* Description : This function does cavlc decoding of 4x4 block residual */ /* coefficient when total coeffs are greater than ten. */ /* Parsing is done as defined in section 9.2.2 and 9.2.3 of */ /* the H264 standard. */ /* */ /* Inputs : */ /* Globals : */ /* Processing : */ /* Outputs : */ /* Returns : */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 25 09 2008 Jay Draft */ /* */ /*****************************************************************************/ WORD32 ih264d_cavlc_4x4res_block_totalcoeff_11to16(UWORD32 u4_isdc, UWORD32 u4_total_coeff_trail_one, /*!pu4_buffer; UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF; UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16; // To avoid error check at 4x4 level, allocating for 3 extra levels(16+3) // since u4_trailing_ones can at the max be 3. This will be required when // u4_total_coeff is less than u4_trailing_ones WORD16 ai2_level_arr[19];// WORD16 *i2_level_arr = &ai2_level_arr[3]; tu_sblk4x4_coeff_data_t *ps_tu_4x4; WORD16 *pi2_coeff_data; dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; ps_tu_4x4->u2_sig_coeff_map = 0; pi2_coeff_data = &ps_tu_4x4->ai2_level[0]; i = u4_total_coeff - 1; if(u4_trailing_ones) { /*********************************************************************/ /* Decode Trailing Ones */ /* read the sign of T1's and put them in level array */ /*********************************************************************/ UWORD32 u4_signs, u4_cnt = u4_trailing_ones; WORD16 (*ppi2_trlone_lkup)[3] = (WORD16 (*)[3])gai2_ih264d_trailing_one_level; WORD16 *pi2_trlone_lkup; GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt); pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs]; while(u4_cnt--) i2_level_arr[i--] = *pi2_trlone_lkup++; } /****************************************************************/ /* Decoding Levels Begins */ /****************************************************************/ if(i >= 0) { /****************************************************************/ /* First level is decoded outside the loop as it has lot of */ /* special cases. */ /****************************************************************/ UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size; UWORD16 u2_lev_code, u2_abs_value; UWORD32 u4_lev_prefix; if(u4_trailing_ones < 3) { /*********************************************************/ /* u4_suffix_len = 1 */ /*********************************************************/ /***************************************************************/ /* Find leading zeros in next 32 bits */ /***************************************************************/ FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, pu4_bitstrm_buf); u4_lev_suffix_size = (15 <= u4_lev_prefix) ? (u4_lev_prefix - 3) : 1; GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, u4_lev_suffix_size); u2_lev_code = 2 + (MIN(u4_lev_prefix,15) << 1) + u4_lev_suffix; //HP_LEVEL_PREFIX if(16 <= u4_lev_prefix) { u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); } } else { /*********************************************************/ /*u4_suffix_len = 0 */ /*********************************************************/ /***************************************************************/ /* Find leading zeros in next 32 bits */ /***************************************************************/ FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, pu4_bitstrm_buf); /*********************************************************/ /* Special decoding case when trailing ones are 3 */ /*********************************************************/ u2_lev_code = MIN(15, u4_lev_prefix); u2_lev_code += (3 == u4_trailing_ones) ? 0 : (2); if(14 == u4_lev_prefix) u4_lev_suffix_size = 4; else if(15 <= u4_lev_prefix) { u2_lev_code += 15; u4_lev_suffix_size = (u4_lev_prefix - 3); } else u4_lev_suffix_size = 0; //HP_LEVEL_PREFIX if(16 <= u4_lev_prefix) { u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); } if(u4_lev_suffix_size) { GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, u4_lev_suffix_size); u2_lev_code += u4_lev_suffix; } } u2_abs_value = (u2_lev_code + 2) >> 1; /*********************************************************/ /* If Level code is odd, level is negative else positive */ /*********************************************************/ i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; u4_suffix_len = (u2_abs_value > 3) ? 2 : 1; /*********************************************************/ /* Now loop over the remaining levels */ /*********************************************************/ while(i >= 0) { /***************************************************************/ /* Find leading zeros in next 32 bits */ /***************************************************************/ FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, pu4_bitstrm_buf); u4_lev_suffix_size = (15 <= u4_lev_prefix) ? (u4_lev_prefix - 3) : u4_suffix_len; /*********************************************************/ /* Compute level code using prefix and suffix */ /*********************************************************/ GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, u4_lev_suffix_size); u2_lev_code = (MIN(15,u4_lev_prefix) << u4_suffix_len) + u4_lev_suffix; //HP_LEVEL_PREFIX if(16 <= u4_lev_prefix) { u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); } u2_abs_value = (u2_lev_code + 2) >> 1; /*********************************************************/ /* If Level code is odd, level is negative else positive */ /*********************************************************/ i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; /*********************************************************/ /* Increment suffix length if required */ /*********************************************************/ u4_suffix_len += (u4_suffix_len < 6) ? (u2_abs_value > (3 << (u4_suffix_len - 1))) : 0; } /****************************************************************/ /* Decoding Levels Ends */ /****************************************************************/ } if(u4_total_coeff < (16 - u4_isdc)) { UWORD32 u4_index; const UWORD8 (*ppu1_total_zero_lkup)[16] = (const UWORD8 (*)[16])gau1_ih264d_table_total_zero_11to15; NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 4); u4_total_zeroes = ppu1_total_zero_lkup[u4_total_coeff - 11][u4_index]; FLUSHBITS(u4_bitstream_offset, (u4_total_zeroes >> 4)); u4_total_zeroes &= 0xf; } else u4_total_zeroes = 0; /**************************************************************/ /* Decode the runs and form the coefficient buffer */ /**************************************************************/ { const UWORD8 *pu1_table_runbefore; UWORD32 u4_run; WORD32 k; UWORD32 u4_scan_pos = u4_total_coeff + u4_total_zeroes - 1 + u4_isdc; WORD32 u4_zeroes_left = u4_total_zeroes; k = u4_total_coeff - 1; /**************************************************************/ /* Decoding Runs for 0 < zeros left <=6 */ /**************************************************************/ pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before; while((u4_zeroes_left > 0) && k) { UWORD32 u4_code; NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3); u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)]; u4_run = u4_code >> 2; FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03)); SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); *pi2_coeff_data++ = i2_level_arr[k--]; u4_zeroes_left -= u4_run; u4_scan_pos -= (u4_run + 1); } /**************************************************************/ /* Decoding Runs End */ /**************************************************************/ /**************************************************************/ /* Copy the remaining coefficients */ /**************************************************************/ if(u4_zeroes_left < 0) return -1; while(k >= 0) { SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); *pi2_coeff_data++ = i2_level_arr[k--]; u4_scan_pos--; } } { WORD32 offset; offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4; offset = ALIGN4(offset); ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset); } ps_bitstrm->u4_ofst = u4_bitstream_offset; return 0; } /*****************************************************************************/ /* */ /* Function Name : ih264d_rest_of_residual_cav_chroma_dc_block */ /* */ /* Description : This function does the Cavlc parsing of the bitstream */ /* for chroma dc coefficients */ /* Inputs : */ /* Globals : */ /* Processing : */ /* Outputs : */ /* Returns : */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 15 09 2008 Jay Draft */ /* */ /*****************************************************************************/ void ih264d_rest_of_residual_cav_chroma_dc_block(UWORD32 u4_total_coeff_trail_one, dec_bit_stream_t *ps_bitstrm) { UWORD32 u4_total_zeroes; WORD16 i; UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; UWORD32 u4_trailing_ones = u4_total_coeff_trail_one & 0xFFFF; UWORD32 u4_total_coeff = u4_total_coeff_trail_one >> 16; // To avoid error check at 4x4 level, allocating for 3 extra levels(4+3) // since u4_trailing_ones can at the max be 3. This will be required when // u4_total_coeff is less than u4_trailing_ones WORD16 ai2_level_arr[7];// WORD16 *i2_level_arr = &ai2_level_arr[3]; tu_sblk4x4_coeff_data_t *ps_tu_4x4; WORD16 *pi2_coeff_data; dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; ps_tu_4x4->u2_sig_coeff_map = 0; pi2_coeff_data = &ps_tu_4x4->ai2_level[0]; i = u4_total_coeff - 1; if(u4_trailing_ones) { /*********************************************************************/ /* Decode Trailing Ones */ /* read the sign of T1's and put them in level array */ /*********************************************************************/ UWORD32 u4_signs, u4_cnt = u4_trailing_ones; WORD16 (*ppi2_trlone_lkup)[3] = (WORD16 (*)[3])gai2_ih264d_trailing_one_level; WORD16 *pi2_trlone_lkup; GETBITS(u4_signs, u4_bitstream_offset, pu4_bitstrm_buf, u4_cnt); pi2_trlone_lkup = ppi2_trlone_lkup[(1 << u4_cnt) - 2 + u4_signs]; while(u4_cnt--) i2_level_arr[i--] = *pi2_trlone_lkup++; } /****************************************************************/ /* Decoding Levels Begins */ /****************************************************************/ if(i >= 0) { /****************************************************************/ /* First level is decoded outside the loop as it has lot of */ /* special cases. */ /****************************************************************/ UWORD32 u4_lev_suffix, u4_suffix_len, u4_lev_suffix_size; UWORD16 u2_lev_code, u2_abs_value; UWORD32 u4_lev_prefix; /***************************************************************/ /* u4_suffix_len = 0, Find leading zeros in next 32 bits */ /***************************************************************/ FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, pu4_bitstrm_buf); /*********************************************************/ /* Special decoding case when trailing ones are 3 */ /*********************************************************/ u2_lev_code = MIN(15, u4_lev_prefix); u2_lev_code += (3 == u4_trailing_ones) ? 0 : (2); if(14 == u4_lev_prefix) u4_lev_suffix_size = 4; else if(15 <= u4_lev_prefix) { u2_lev_code += 15; u4_lev_suffix_size = u4_lev_prefix - 3; } else u4_lev_suffix_size = 0; //HP_LEVEL_PREFIX if(16 <= u4_lev_prefix) { u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); } if(u4_lev_suffix_size) { GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, u4_lev_suffix_size); u2_lev_code += u4_lev_suffix; } u2_abs_value = (u2_lev_code + 2) >> 1; /*********************************************************/ /* If Level code is odd, level is negative else positive */ /*********************************************************/ i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; u4_suffix_len = (u2_abs_value > 3) ? 2 : 1; /*********************************************************/ /* Now loop over the remaining levels */ /*********************************************************/ while(i >= 0) { /***************************************************************/ /* Find leading zeros in next 32 bits */ /***************************************************************/ FIND_ONE_IN_STREAM_32(u4_lev_prefix, u4_bitstream_offset, pu4_bitstrm_buf); u4_lev_suffix_size = (15 <= u4_lev_prefix) ? (u4_lev_prefix - 3) : u4_suffix_len; /*********************************************************/ /* Compute level code using prefix and suffix */ /*********************************************************/ GETBITS(u4_lev_suffix, u4_bitstream_offset, pu4_bitstrm_buf, u4_lev_suffix_size); u2_lev_code = (MIN(u4_lev_prefix,15) << u4_suffix_len) + u4_lev_suffix; //HP_LEVEL_PREFIX if(16 <= u4_lev_prefix) { u2_lev_code += ((1 << (u4_lev_prefix - 3)) - 4096); } u2_abs_value = (u2_lev_code + 2) >> 1; /*********************************************************/ /* If Level code is odd, level is negative else positive */ /*********************************************************/ i2_level_arr[i--] = (u2_lev_code & 1) ? -u2_abs_value : u2_abs_value; /*********************************************************/ /* Increment suffix length if required */ /*********************************************************/ u4_suffix_len += (u2_abs_value > (3 << (u4_suffix_len - 1))); } /****************************************************************/ /* Decoding Levels Ends */ /****************************************************************/ } if(u4_total_coeff < 4) { UWORD32 u4_max_ldz = (4 - u4_total_coeff); FIND_ONE_IN_STREAM_LEN(u4_total_zeroes, u4_bitstream_offset, pu4_bitstrm_buf, u4_max_ldz); } else u4_total_zeroes = 0; /**************************************************************/ /* Decode the runs and form the coefficient buffer */ /**************************************************************/ { const UWORD8 *pu1_table_runbefore; UWORD32 u4_run; UWORD32 u4_scan_pos = (u4_total_coeff + u4_total_zeroes - 1); UWORD32 u4_zeroes_left = u4_total_zeroes; i = u4_total_coeff - 1; /**************************************************************/ /* Decoding Runs for 0 < zeros left <=6 */ /**************************************************************/ pu1_table_runbefore = (UWORD8 *)gau1_ih264d_table_run_before; while(u4_zeroes_left && i) { UWORD32 u4_code; NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 3); u4_code = pu1_table_runbefore[u4_code + (u4_zeroes_left << 3)]; u4_run = u4_code >> 2; FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03)); SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); *pi2_coeff_data++ = i2_level_arr[i--]; u4_zeroes_left -= u4_run; u4_scan_pos -= (u4_run + 1); } /**************************************************************/ /* Decoding Runs End */ /**************************************************************/ /**************************************************************/ /* Copy the remaining coefficients */ /**************************************************************/ while(i >= 0) { SET_BIT(ps_tu_4x4->u2_sig_coeff_map, u4_scan_pos); *pi2_coeff_data++ = i2_level_arr[i--]; u4_scan_pos--; } } { WORD32 offset; offset = (UWORD8 *)pi2_coeff_data - (UWORD8 *)ps_tu_4x4; offset = ALIGN4(offset); ps_dec->pv_parse_tu_coeff_data = (void *)((UWORD8 *)ps_dec->pv_parse_tu_coeff_data + offset); } ps_bitstrm->u4_ofst = u4_bitstream_offset; } /*! ************************************************************************** * \if Function name : CavlcParsingInvScanInvQuant \endif * * \brief * This function do cavlc parsing of coefficient tokens for any block * type except chromDc and depending * on whenther any coefficients to be parsed calls module * RestOfResidualBlockCavlc. * * \return * Returns total number of non-zero coefficients. * ************************************************************************** */ WORD32 ih264d_cavlc_parse4x4coeff_n0to7(WORD16 *pi2_coeff_block, UWORD32 u4_isdc, /* is it a DC block */ WORD32 u4_n, dec_struct_t *ps_dec, UWORD32 *pu4_total_coeff) { dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm; UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; UWORD32 u4_code, u4_index, u4_ldz; const UWORD16 *pu2_code = (const UWORD16*)gau2_ih264d_code_gx; const UWORD16 *pu2_offset_num_vlc = (const UWORD16 *)gau2_ih264d_offset_num_vlc_tab; UWORD32 u4_offset_num_vlc = pu2_offset_num_vlc[u4_n]; UNUSED(pi2_coeff_block); *pu4_total_coeff = 0; FIND_ONE_IN_STREAM_32(u4_ldz, u4_bitstream_offset, pu4_bitstrm_buf); NEXTBITS(u4_index, u4_bitstream_offset, pu4_bitstrm_buf, 3); u4_index += (u4_ldz << 3); u4_index += u4_offset_num_vlc; u4_index = MIN(u4_index, 303); u4_code = pu2_code[u4_index]; FLUSHBITS(u4_bitstream_offset, (u4_code & 0x03)); ps_bitstrm->u4_ofst = u4_bitstream_offset; *pu4_total_coeff = (u4_code >> 4); if(*pu4_total_coeff) { UWORD32 u4_trailing_ones, u4_offset, u4_total_coeff_tone; const UWORD8 *pu1_offset = (UWORD8 *)gau1_ih264d_total_coeff_fn_ptr_offset; WORD32 ret; u4_trailing_ones = ((u4_code >> 2) & 0x03); u4_offset = pu1_offset[*pu4_total_coeff - 1]; u4_total_coeff_tone = (*pu4_total_coeff << 16) | u4_trailing_ones; ret = ps_dec->pf_cavlc_4x4res_block[u4_offset](u4_isdc, u4_total_coeff_tone, ps_bitstrm); if(ret != 0) return ERROR_CAVLC_NUM_COEFF_T; } return OK; } WORD32 ih264d_cavlc_parse4x4coeff_n8(WORD16 *pi2_coeff_block, UWORD32 u4_isdc, /* is it a DC block */ WORD32 u4_n, dec_struct_t *ps_dec, UWORD32 *pu4_total_coeff) { dec_bit_stream_t *ps_bitstrm = ps_dec->ps_bitstrm; UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; UWORD32 u4_code; UNUSED(u4_n); UNUSED(pi2_coeff_block); GETBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 6); ps_bitstrm->u4_ofst = u4_bitstream_offset; *pu4_total_coeff = 0; if(u4_code != 3) { UWORD8 *pu1_offset = (UWORD8 *)gau1_ih264d_total_coeff_fn_ptr_offset; UWORD32 u4_trailing_ones, u4_offset, u4_total_coeff_tone; *pu4_total_coeff = (u4_code >> 2) + 1; u4_trailing_ones = u4_code & 0x03; u4_offset = pu1_offset[*pu4_total_coeff - 1]; u4_total_coeff_tone = (*pu4_total_coeff << 16) | u4_trailing_ones; ps_dec->pf_cavlc_4x4res_block[u4_offset](u4_isdc, u4_total_coeff_tone, ps_bitstrm); } return OK; } /*! ************************************************************************** * \if Function name : ih264d_cavlc_parse_chroma_dc \endif * * \brief * This function do cavlc parsing of coefficient tokens chromDc block * and depending on whenther any coefficients to be parsed calls module * ih264d_rest_of_residual_cav_chroma_dc_block. * * \return * Returns total number of non-zero coefficients. * ************************************************************************** */ void ih264d_cavlc_parse_chroma_dc(dec_mb_info_t *ps_cur_mb_info, WORD16 *pi2_coeff_block, dec_bit_stream_t *ps_bitstrm, UWORD32 u4_scale_u, UWORD32 u4_scale_v, WORD32 i4_mb_inter_inc) { UWORD32 u4_total_coeff, u4_trailing_ones, u4_total_coeff_tone, u4_code; UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; UWORD32 u4_bitstream_offset = ps_bitstrm->u4_ofst; const UWORD8 *pu1_cav_chromdc = (const UWORD8*)gau1_ih264d_cav_chromdc_vld; UNUSED(i4_mb_inter_inc); /******************************************************************/ /* Chroma DC Block for U component */ /******************************************************************/ NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 8); u4_code = pu1_cav_chromdc[u4_code]; FLUSHBITS(u4_bitstream_offset, ((u4_code & 0x7) + 1)); ps_bitstrm->u4_ofst = u4_bitstream_offset; u4_total_coeff = (u4_code >> 5); if(u4_total_coeff) { WORD32 i_z0, i_z1, i_z2, i_z3; tu_sblk4x4_coeff_data_t *ps_tu_4x4; dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; WORD16 ai2_dc_coef[4]; UWORD8 pu1_inv_scan[4] = { 0, 1, 2, 3 }; WORD16 *pi2_coeff_data = (WORD16 *)ps_dec->pv_parse_tu_coeff_data; ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; u4_trailing_ones = ((u4_code >> 3) & 0x3); u4_total_coeff_tone = (u4_total_coeff << 16) | u4_trailing_ones; ih264d_rest_of_residual_cav_chroma_dc_block(u4_total_coeff_tone, ps_bitstrm); ai2_dc_coef[0] = 0; ai2_dc_coef[1] = 0; ai2_dc_coef[2] = 0; ai2_dc_coef[3] = 0; ih264d_unpack_coeff4x4_dc_4x4blk(ps_tu_4x4, ai2_dc_coef, pu1_inv_scan); /*-------------------------------------------------------------------*/ /* Inverse 2x2 transform and scaling of chroma DC */ /*-------------------------------------------------------------------*/ i_z0 = (ai2_dc_coef[0] + ai2_dc_coef[2]); i_z1 = (ai2_dc_coef[0] - ai2_dc_coef[2]); i_z2 = (ai2_dc_coef[1] - ai2_dc_coef[3]); i_z3 = (ai2_dc_coef[1] + ai2_dc_coef[3]); /*-----------------------------------------------------------*/ /* Scaling and storing the values back */ /*-----------------------------------------------------------*/ *pi2_coeff_data++ = ((i_z0 + i_z3) * u4_scale_u) >> 5; *pi2_coeff_data++ = ((i_z0 - i_z3) * u4_scale_u) >> 5; *pi2_coeff_data++ = ((i_z1 + i_z2) * u4_scale_u) >> 5; *pi2_coeff_data++ = ((i_z1 - i_z2) * u4_scale_u) >> 5; ps_dec->pv_parse_tu_coeff_data = (void *)pi2_coeff_data; SET_BIT(ps_cur_mb_info->u1_yuv_dc_block_flag,1); } /******************************************************************/ /* Chroma DC Block for V component */ /******************************************************************/ pi2_coeff_block += 64; u4_bitstream_offset = ps_bitstrm->u4_ofst; NEXTBITS(u4_code, u4_bitstream_offset, pu4_bitstrm_buf, 8); u4_code = pu1_cav_chromdc[u4_code]; FLUSHBITS(u4_bitstream_offset, ((u4_code & 0x7) + 1)); ps_bitstrm->u4_ofst = u4_bitstream_offset; u4_total_coeff = (u4_code >> 5); if(u4_total_coeff) { WORD32 i_z0, i_z1, i_z2, i_z3; tu_sblk4x4_coeff_data_t *ps_tu_4x4; dec_struct_t *ps_dec = (dec_struct_t *)ps_bitstrm->pv_codec_handle; WORD16 ai2_dc_coef[4]; UWORD8 pu1_inv_scan[4] = { 0, 1, 2, 3 }; WORD16 *pi2_coeff_data = (WORD16 *)ps_dec->pv_parse_tu_coeff_data; ps_tu_4x4 = (tu_sblk4x4_coeff_data_t *)ps_dec->pv_parse_tu_coeff_data; u4_trailing_ones = ((u4_code >> 3) & 0x3); u4_total_coeff_tone = (u4_total_coeff << 16) | u4_trailing_ones; ih264d_rest_of_residual_cav_chroma_dc_block(u4_total_coeff_tone, ps_bitstrm); ai2_dc_coef[0] = 0; ai2_dc_coef[1] = 0; ai2_dc_coef[2] = 0; ai2_dc_coef[3] = 0; ih264d_unpack_coeff4x4_dc_4x4blk(ps_tu_4x4, ai2_dc_coef, pu1_inv_scan); /*-------------------------------------------------------------------*/ /* Inverse 2x2 transform and scaling of chroma DC */ /*-------------------------------------------------------------------*/ i_z0 = (ai2_dc_coef[0] + ai2_dc_coef[2]); i_z1 = (ai2_dc_coef[0] - ai2_dc_coef[2]); i_z2 = (ai2_dc_coef[1] - ai2_dc_coef[3]); i_z3 = (ai2_dc_coef[1] + ai2_dc_coef[3]); /*-----------------------------------------------------------*/ /* Scaling and storing the values back */ /*-----------------------------------------------------------*/ *pi2_coeff_data++ = ((i_z0 + i_z3) * u4_scale_v) >> 5; *pi2_coeff_data++ = ((i_z0 - i_z3) * u4_scale_v) >> 5; *pi2_coeff_data++ = ((i_z1 + i_z2) * u4_scale_v) >> 5; *pi2_coeff_data++ = ((i_z1 - i_z2) * u4_scale_v) >> 5; ps_dec->pv_parse_tu_coeff_data = (void *)pi2_coeff_data; SET_BIT(ps_cur_mb_info->u1_yuv_dc_block_flag,2); } } /*****************************************************************************/ /* */ /* Function Name : ih264d_parse_pmb_ref_index_cavlc_range1 */ /* */ /* Description : This function does the Cavlc TEV range =1 parsing of */ /* reference index for a P MB. Range is 1 when */ /* num_ref_idx_active_minus1 is 0 */ /* */ /* Inputs : */ /* Globals : */ /* Processing : */ /* Outputs : */ /* Returns : */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 19 09 2008 Jay Draft */ /* */ /*****************************************************************************/ void ih264d_parse_pmb_ref_index_cavlc_range1(UWORD32 u4_num_part, /* Number of partitions in MB */ dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */ WORD8 *pi1_ref_idx, /* pointer to reference index array */ UWORD32 u4_num_ref_idx_active_minus1 /* Not used for range 1 */ ) { UWORD32 u4_i; UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst; UNUSED(u4_num_ref_idx_active_minus1); for(u4_i = 0; u4_i < u4_num_part; u4_i++) { UWORD32 u4_ref_idx; u4_ref_idx = ih264d_tev_range1(pu4_bitstream_off, pu4_bitstrm_buf); /* Storing Reference Idx Information */ pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx; } } /*****************************************************************************/ /* */ /* Function Name : ih264d_parse_pmb_ref_index_cavlc */ /* */ /* Description : This function does the Cavlc TEV range > 1 parsing of */ /* reference index for a P MB. */ /* Range > 1 when num_ref_idx_active_minus1 > 0 */ /* */ /* Inputs : */ /* Globals : */ /* Processing : */ /* Outputs : */ /* Returns : */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 19 09 2008 Jay Draft */ /* */ /*****************************************************************************/ WORD32 ih264d_parse_pmb_ref_index_cavlc(UWORD32 u4_num_part, /* Number of partitions in MB */ dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */ WORD8 *pi1_ref_idx, /* pointer to reference index array */ UWORD32 u4_num_ref_idx_active_minus1 /* Number of active references - 1 */ ) { UWORD32 u4_i; UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst; for(u4_i = 0; u4_i < u4_num_part; u4_i++) { UWORD32 u4_ref_idx; //Inlined ih264d_uev UWORD32 u4_bitstream_offset = *pu4_bitstream_off; UWORD32 u4_word, u4_ldz; /***************************************************************/ /* Find leading zeros in next 32 bits */ /***************************************************************/ NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); u4_ldz = CLZ(u4_word); /* Flush the ps_bitstrm */ u4_bitstream_offset += (u4_ldz + 1); /* Read the suffix from the ps_bitstrm */ u4_word = 0; if(u4_ldz) GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz); *pu4_bitstream_off = u4_bitstream_offset; u4_ref_idx = ((1 << u4_ldz) + u4_word - 1); //Inlined ih264d_uev if(u4_ref_idx > u4_num_ref_idx_active_minus1) return ERROR_REF_IDX; /* Storing Reference Idx Information */ pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx; } return OK; } /*****************************************************************************/ /* */ /* Function Name : ih264d_parse_bmb_ref_index_cavlc_range1 */ /* */ /* Description : This function does the Cavlc TEV range =1 parsing of */ /* reference index for a B MB. Range is 1 when */ /* num_ref_idx_active_minus1 is 0 */ /* */ /* Inputs : */ /* Globals : */ /* Processing : */ /* Outputs : */ /* Returns : */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 19 09 2008 Jay Draft */ /* */ /*****************************************************************************/ void ih264d_parse_bmb_ref_index_cavlc_range1(UWORD32 u4_num_part, /* Number of partitions in MB */ dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */ WORD8 *pi1_ref_idx, /* pointer to reference index array */ UWORD32 u4_num_ref_idx_active_minus1 /* Not used for range 1 */ ) { UWORD32 u4_i; UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst; UNUSED(u4_num_ref_idx_active_minus1); for(u4_i = 0; u4_i < u4_num_part; u4_i++) { if(pi1_ref_idx[u4_i] > -1) { UWORD32 u4_ref_idx; u4_ref_idx = ih264d_tev_range1(pu4_bitstream_off, pu4_bitstrm_buf); /* Storing Reference Idx Information */ pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx; } } } /*****************************************************************************/ /* */ /* Function Name : ih264d_parse_bmb_ref_index_cavlc */ /* */ /* Description : This function does the Cavlc TEV range > 1 parsing of */ /* reference index for a B MB. */ /* Range > 1 when num_ref_idx_active_minus1 > 0 */ /* */ /* Inputs : */ /* Globals : */ /* Processing : */ /* Outputs : */ /* Returns : */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 19 09 2008 Jay Draft */ /* */ /*****************************************************************************/ WORD32 ih264d_parse_bmb_ref_index_cavlc(UWORD32 u4_num_part, /* Number of partitions in MB */ dec_bit_stream_t *ps_bitstrm, /* Pointer to bitstream Structure. */ WORD8 *pi1_ref_idx, /* pointer to reference index array */ UWORD32 u4_num_ref_idx_active_minus1 /* Number of active references - 1 */ ) { UWORD32 u4_i; UWORD32 *pu4_bitstrm_buf = ps_bitstrm->pu4_buffer; UWORD32 *pu4_bitstream_off = &ps_bitstrm->u4_ofst; for(u4_i = 0; u4_i < u4_num_part; u4_i++) { if(pi1_ref_idx[u4_i] > -1) { UWORD32 u4_ref_idx; //inlining ih264d_uev UWORD32 u4_bitstream_offset = *pu4_bitstream_off; UWORD32 u4_word, u4_ldz; /***************************************************************/ /* Find leading zeros in next 32 bits */ /***************************************************************/ NEXTBITS_32(u4_word, u4_bitstream_offset, pu4_bitstrm_buf); u4_ldz = CLZ(u4_word); /* Flush the ps_bitstrm */ u4_bitstream_offset += (u4_ldz + 1); /* Read the suffix from the ps_bitstrm */ u4_word = 0; if(u4_ldz) GETBITS(u4_word, u4_bitstream_offset, pu4_bitstrm_buf, u4_ldz); *pu4_bitstream_off = u4_bitstream_offset; u4_ref_idx = ((1 << u4_ldz) + u4_word - 1); //inlining ih264d_uev if(u4_ref_idx > u4_num_ref_idx_active_minus1) return ERROR_REF_IDX; /* Storing Reference Idx Information */ pi1_ref_idx[u4_i] = (WORD8)u4_ref_idx; } } return OK; } /*****************************************************************************/ /* */ /* Function Name : ih264d_cavlc_parse_8x8block_both_available */ /* */ /* Description : This function does the residual parsing of 4 subblocks */ /* in a 8x8 block when both top and left are available */ /* */ /* Inputs : pi2_coeff_block : pointer to residual block where */ /* decoded and inverse scan coefficients are updated */ /* */ /* u4_sub_block_strd : indicates the number of sublocks */ /* in a row. It is 4 for luma and 2 for chroma. */ /* */ /* u4_isdc : required to indicate 4x4 parse modules if the */ /* current Mb is I_16x16/chroma DC coded. */ /* */ /* ps_dec : pointer to Decstruct (decoder context) */ /* */ /* pu1_top_nnz : top nnz pointer */ /* */ /* pu1_left_nnz : left nnz pointer */ /* */ /* Globals : No */ /* Processing : Parsing for four subblocks in unrolled, top and left nnz */ /* are updated on the fly. csbp is set in accordance to */ /* decoded numcoeff for the subblock index in raster order */ /* */ /* Outputs : The updated residue buffer, nnzs and csbp current block */ /* */ /* Returns : Returns the coded sub block pattern csbp for the block */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 09 10 2008 Jay Draft */ /* */ /*****************************************************************************/ WORD32 ih264d_cavlc_parse_8x8block_both_available(WORD16 *pi2_coeff_block, UWORD32 u4_sub_block_strd, UWORD32 u4_isdc, dec_struct_t * ps_dec, UWORD8 *pu1_top_nnz, UWORD8 *pu1_left_nnz, UWORD8 u1_tran_form8x8, UWORD8 u1_mb_field_decodingflag, UWORD32 *pu4_csbp) { UWORD32 u4_num_coeff, u4_n, u4_subblock_coded; UWORD32 u4_top0, u4_top1; UWORD32 *pu4_dummy; WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block, UWORD32 u4_isdc, WORD32 u4_n, struct _DecStruct *ps_dec, UWORD32 *pu4_dummy) = ps_dec->pf_cavlc_parse4x4coeff; UWORD32 u4_idx = 0; UWORD8 *puc_temp; WORD32 ret; *pu4_csbp = 0; /* need to change the inverse scan matrices here */ puc_temp = ps_dec->pu1_inv_scan; /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 0 */ /*------------------------------------------------------*/ if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0]; } } u4_n = (pu1_top_nnz[0] + pu1_left_nnz[0] + 1) >> 1; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; u4_top0 = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 1 */ /*------------------------------------------------------*/ u4_idx++; if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1]; } } else { pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; } u4_n = (pu1_top_nnz[1] + u4_num_coeff + 1) >> 1; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; u4_top1 = pu1_left_nnz[0] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 2 */ /*------------------------------------------------------*/ u4_idx += (u4_sub_block_strd - 1); if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2]; } } else { pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK); } u4_n = (u4_top0 + pu1_left_nnz[1] + 1) >> 1; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; pu1_top_nnz[0] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 3 */ /*------------------------------------------------------*/ u4_idx++; if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3]; } } else { pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; } u4_n = (u4_top1 + u4_num_coeff + 1) >> 1; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); ps_dec->pu1_inv_scan = puc_temp; return OK; } /*****************************************************************************/ /* */ /* Function Name : ih264d_cavlc_parse_8x8block_left_available */ /* */ /* Description : This function does the residual parsing of 4 subblocks */ /* in a 8x8 block when only left is available for block */ /* */ /* Inputs : pi2_coeff_block : pointer to residual block where */ /* decoded and inverse scan coefficients are updated */ /* */ /* u4_sub_block_strd : indicates the number of sublocks */ /* in a row. It is 4 for luma and 2 for chroma. */ /* */ /* u4_isdc : required to indicate 4x4 parse modules if the */ /* current Mb is I_16x16/chroma DC coded. */ /* */ /* ps_dec : pointer to Decstruct (decoder context) */ /* */ /* pu1_top_nnz : top nnz pointer */ /* */ /* pu1_left_nnz : left nnz pointer */ /* */ /* Globals : No */ /* Processing : Parsing for four subblocks in unrolled, top and left nnz */ /* are updated on the fly. csbp is set in accordance to */ /* decoded numcoeff for the subblock index in raster order */ /* */ /* Outputs : The updated residue buffer, nnzs and csbp current block */ /* */ /* Returns : Returns the coded sub block pattern csbp for the block */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 09 10 2008 Jay Draft */ /* */ /*****************************************************************************/ WORD32 ih264d_cavlc_parse_8x8block_left_available(WORD16 *pi2_coeff_block, UWORD32 u4_sub_block_strd, UWORD32 u4_isdc, dec_struct_t * ps_dec, UWORD8 *pu1_top_nnz, UWORD8 *pu1_left_nnz, UWORD8 u1_tran_form8x8, UWORD8 u1_mb_field_decodingflag, UWORD32 *pu4_csbp) { UWORD32 u4_num_coeff, u4_n, u4_subblock_coded; UWORD32 u4_top0, u4_top1; UWORD32 *pu4_dummy; WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block, UWORD32 u4_isdc, WORD32 u4_n, struct _DecStruct *ps_dec, UWORD32 *pu4_dummy) = ps_dec->pf_cavlc_parse4x4coeff; UWORD32 u4_idx = 0; UWORD8 *puc_temp; WORD32 ret; *pu4_csbp = 0; puc_temp = ps_dec->pu1_inv_scan; /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 0 */ /*------------------------------------------------------*/ if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0]; } } u4_n = pu1_left_nnz[0]; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; u4_top0 = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 1 */ /*------------------------------------------------------*/ u4_idx++; if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1]; } } else { pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; } u4_n = u4_num_coeff; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; u4_top1 = pu1_left_nnz[0] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 2 */ /*------------------------------------------------------*/ u4_idx += (u4_sub_block_strd - 1); if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2]; } } else { pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK); } u4_n = (u4_top0 + pu1_left_nnz[1] + 1) >> 1; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; pu1_top_nnz[0] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 3 */ /*------------------------------------------------------*/ u4_idx++; if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3]; } } else { pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; } u4_n = (u4_top1 + u4_num_coeff + 1) >> 1; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); ps_dec->pu1_inv_scan = puc_temp; return OK; } /*****************************************************************************/ /* */ /* Function Name : ih264d_cavlc_parse_8x8block_top_available */ /* */ /* Description : This function does the residual parsing of 4 subblocks */ /* in a 8x8 block when only top is available for block */ /* */ /* Inputs : pi2_coeff_block : pointer to residual block where */ /* decoded and inverse scan coefficients are updated */ /* */ /* u4_sub_block_strd : indicates the number of sublocks */ /* in a row. It is 4 for luma and 2 for chroma. */ /* */ /* u4_isdc : required to indicate 4x4 parse modules if the */ /* current Mb is I_16x16/chroma DC coded. */ /* */ /* ps_dec : pointer to Decstruct (decoder context) */ /* */ /* pu1_top_nnz : top nnz pointer */ /* */ /* pu1_left_nnz : left nnz pointer */ /* */ /* Globals : No */ /* Processing : Parsing for four subblocks in unrolled, top and left nnz */ /* are updated on the fly. csbp is set in accordance to */ /* decoded numcoeff for the subblock index in raster order */ /* */ /* Outputs : The updated residue buffer, nnzs and csbp current block */ /* */ /* Returns : Returns the coded sub block pattern csbp for the block */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 09 10 2008 Jay Draft */ /* */ /*****************************************************************************/ WORD32 ih264d_cavlc_parse_8x8block_top_available(WORD16 *pi2_coeff_block, UWORD32 u4_sub_block_strd, UWORD32 u4_isdc, dec_struct_t * ps_dec, UWORD8 *pu1_top_nnz, UWORD8 *pu1_left_nnz, UWORD8 u1_tran_form8x8, UWORD8 u1_mb_field_decodingflag, UWORD32 *pu4_csbp) { UWORD32 u4_num_coeff, u4_n, u4_subblock_coded; UWORD32 u4_top0, u4_top1; UWORD32 *pu4_dummy; WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block, UWORD32 u4_isdc, WORD32 u4_n, struct _DecStruct *ps_dec, UWORD32 *pu4_dummy) = ps_dec->pf_cavlc_parse4x4coeff; UWORD32 u4_idx = 0; UWORD8 *puc_temp; WORD32 ret; *pu4_csbp = 0; puc_temp = ps_dec->pu1_inv_scan; /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 0 */ /*------------------------------------------------------*/ if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0]; } } u4_n = pu1_top_nnz[0]; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; u4_top0 = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 1 */ /*------------------------------------------------------*/ u4_idx++; if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1]; } } else { pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; } u4_n = (pu1_top_nnz[1] + u4_num_coeff + 1) >> 1; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; u4_top1 = pu1_left_nnz[0] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 2 */ /*------------------------------------------------------*/ u4_idx += (u4_sub_block_strd - 1); if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2]; } } else { pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK); } u4_n = u4_top0; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; pu1_top_nnz[0] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 3 */ /*------------------------------------------------------*/ u4_idx++; if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3]; } } else { pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; } u4_n = (u4_top1 + u4_num_coeff + 1) >> 1; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); ps_dec->pu1_inv_scan = puc_temp; return OK; } /*****************************************************************************/ /* */ /* Function Name : ih264d_cavlc_parse_8x8block_none_available */ /* */ /* Description : This function does the residual parsing of 4 subblocks */ /* in a 8x8 block when none of the neigbours are available */ /* */ /* Inputs : pi2_coeff_block : pointer to residual block where */ /* decoded and inverse scan coefficients are updated */ /* */ /* u4_sub_block_strd : indicates the number of sublocks */ /* in a row. It is 4 for luma and 2 for chroma. */ /* */ /* u4_isdc : required to indicate 4x4 parse modules if the */ /* current Mb is I_16x16/chroma DC coded. */ /* */ /* ps_dec : pointer to Decstruct (decoder context) */ /* */ /* pu1_top_nnz : top nnz pointer */ /* */ /* pu1_left_nnz : left nnz pointer */ /* */ /* Globals : No */ /* Processing : Parsing for four subblocks in unrolled, top and left nnz */ /* are updated on the fly. csbp is set in accordance to */ /* decoded numcoeff for the subblock index in raster order */ /* */ /* Outputs : The updated residue buffer, nnzs and csbp current block */ /* */ /* Returns : Returns the coded sub block pattern csbp for the block */ /* */ /* Issues : */ /* */ /* Revision History: */ /* */ /* DD MM YYYY Author(s) Changes (Describe the changes made) */ /* 09 10 2008 Jay Draft */ /* */ /*****************************************************************************/ WORD32 ih264d_cavlc_parse_8x8block_none_available(WORD16 *pi2_coeff_block, UWORD32 u4_sub_block_strd, UWORD32 u4_isdc, dec_struct_t * ps_dec, UWORD8 *pu1_top_nnz, UWORD8 *pu1_left_nnz, UWORD8 u1_tran_form8x8, UWORD8 u1_mb_field_decodingflag, UWORD32 *pu4_csbp) { UWORD32 u4_num_coeff, u4_n, u4_subblock_coded; UWORD32 u4_top0, u4_top1; UWORD32 *pu4_dummy; WORD32 (**pf_cavlc_parse4x4coeff)(WORD16 *pi2_coeff_block, UWORD32 u4_isdc, WORD32 u4_n, struct _DecStruct *ps_dec, UWORD32 *pu4_dummy) = ps_dec->pf_cavlc_parse4x4coeff; UWORD32 u4_idx = 0; UWORD8 *puc_temp; WORD32 ret; *pu4_csbp = 0; puc_temp = ps_dec->pu1_inv_scan; /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 0 */ /*------------------------------------------------------*/ if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[0]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[0]; } } ret = pf_cavlc_parse4x4coeff[0](pi2_coeff_block, u4_isdc, 0, ps_dec, &u4_num_coeff); if(ret != OK) return ret; u4_top0 = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 1 */ /*------------------------------------------------------*/ u4_idx++; if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[1]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[1]; } } else { pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; } u4_n = u4_num_coeff; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; u4_top1 = pu1_left_nnz[0] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 2 */ /*------------------------------------------------------*/ u4_idx += (u4_sub_block_strd - 1); if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[2]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[2]; } } else { pi2_coeff_block += ((u4_sub_block_strd - 1) * NUM_COEFFS_IN_4x4BLK); } u4_n = u4_top0; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; pu1_top_nnz[0] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); /*------------------------------------------------------*/ /* Residual 4x4 decoding: SubBlock 3 */ /*------------------------------------------------------*/ u4_idx++; if(u1_tran_form8x8) { if(!u1_mb_field_decodingflag) { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_prog8x8_cavlc[3]; } else { ps_dec->pu1_inv_scan = (UWORD8*)gau1_ih264d_inv_scan_int8x8_cavlc[3]; } } else { pi2_coeff_block += NUM_COEFFS_IN_4x4BLK; } u4_n = (u4_top1 + u4_num_coeff + 1) >> 1; ret = pf_cavlc_parse4x4coeff[(u4_n > 7)](pi2_coeff_block, u4_isdc, u4_n, ps_dec, &u4_num_coeff); if(ret != OK) return ret; pu1_top_nnz[1] = pu1_left_nnz[1] = u4_num_coeff; u4_subblock_coded = (u4_num_coeff != 0); INSERT_BIT(*pu4_csbp, u4_idx, u4_subblock_coded); ps_dec->pu1_inv_scan = puc_temp; return OK; } /*! ************************************************************************** * \if Function name : ih264d_parse_residual4x4_cavlc \endif * * \brief * This function parses CAVLC syntax of a Luma and Chroma AC Residuals. * * \return * 0 on Success and Error code otherwise ************************************************************************** */ WORD32 ih264d_parse_residual4x4_cavlc(dec_struct_t * ps_dec, dec_mb_info_t *ps_cur_mb_info, UWORD8 u1_offset) { UWORD8 u1_cbp = ps_cur_mb_info->u1_cbp; UWORD16 ui16_csbp = 0; UWORD32 u4_nbr_avl; WORD16 *pi2_residual_buf; UWORD8 u1_is_top_mb_avail; UWORD8 u1_is_left_mb_avail; UWORD8 *pu1_top_nnz = ps_cur_mb_info->ps_curmb->pu1_nnz_y; UWORD8 *pu1_left_nnz = ps_dec->pu1_left_nnz_y; WORD16 *pi2_coeff_block = NULL; UWORD32 *pu4_dummy; WORD32 ret; WORD32 (**pf_cavlc_parse_8x8block)(WORD16 *pi2_coeff_block, UWORD32 u4_sub_block_strd, UWORD32 u4_isdc, struct _DecStruct *ps_dec, UWORD8 *pu1_top_nnz, UWORD8 *pu1_left_nnz, UWORD8 u1_tran_form8x8, UWORD8 u1_mb_field_decodingflag, UWORD32 *pu4_dummy) = ps_dec->pf_cavlc_parse_8x8block; { UWORD8 uc_temp = ps_dec->u1_mb_ngbr_availablity; u1_is_top_mb_avail = BOOLEAN(uc_temp & TOP_MB_AVAILABLE_MASK); u1_is_left_mb_avail = BOOLEAN(uc_temp & LEFT_MB_AVAILABLE_MASK); u4_nbr_avl = (u1_is_top_mb_avail << 1) | u1_is_left_mb_avail; } ps_cur_mb_info->u1_qp_div6 = ps_dec->u1_qp_y_div6; ps_cur_mb_info->u1_qp_rem6 = ps_dec->u1_qp_y_rem6; ps_cur_mb_info->u1_qpc_div6 = ps_dec->u1_qp_u_div6; ps_cur_mb_info->u1_qpc_rem6 = ps_dec->u1_qp_u_rem6; ps_cur_mb_info->u1_qpcr_div6 = ps_dec->u1_qp_v_div6; ps_cur_mb_info->u1_qpcr_rem6 = ps_dec->u1_qp_v_rem6; if(u1_cbp & 0xf) { pu1_top_nnz[0] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[0]; pu1_top_nnz[1] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[1]; pu1_top_nnz[2] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[2]; pu1_top_nnz[3] = ps_cur_mb_info->ps_top_mb->pu1_nnz_y[3]; /*******************************************************************/ /* Block 0 residual decoding, check cbp and proceed (subblock = 0) */ /*******************************************************************/ if(!(u1_cbp & 0x1)) { *(UWORD16 *)(pu1_top_nnz) = 0; *(UWORD16 *)(pu1_left_nnz) = 0; } else { UWORD32 u4_temp; ret = pf_cavlc_parse_8x8block[u4_nbr_avl]( pi2_coeff_block, 4, u1_offset, ps_dec, pu1_top_nnz, pu1_left_nnz, ps_cur_mb_info->u1_tran_form8x8, ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp); if(ret != OK) return ret; ui16_csbp = u4_temp; } /*******************************************************************/ /* Block 1 residual decoding, check cbp and proceed (subblock = 2) */ /*******************************************************************/ if(ps_cur_mb_info->u1_tran_form8x8) { pi2_coeff_block += 64; } else { pi2_coeff_block += (2 * NUM_COEFFS_IN_4x4BLK); } if(!(u1_cbp & 0x2)) { *(UWORD16 *)(pu1_top_nnz + 2) = 0; *(UWORD16 *)(pu1_left_nnz) = 0; } else { UWORD32 u4_temp = (u4_nbr_avl | 0x1); ret = pf_cavlc_parse_8x8block[u4_temp]( pi2_coeff_block, 4, u1_offset, ps_dec, (pu1_top_nnz + 2), pu1_left_nnz, ps_cur_mb_info->u1_tran_form8x8, ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp); if(ret != OK) return ret; ui16_csbp |= (u4_temp << 2); } /*******************************************************************/ /* Block 2 residual decoding, check cbp and proceed (subblock = 8) */ /*******************************************************************/ if(ps_cur_mb_info->u1_tran_form8x8) { pi2_coeff_block += 64; } else { pi2_coeff_block += (6 * NUM_COEFFS_IN_4x4BLK); } if(!(u1_cbp & 0x4)) { *(UWORD16 *)(pu1_top_nnz) = 0; *(UWORD16 *)(pu1_left_nnz + 2) = 0; } else { UWORD32 u4_temp = (u4_nbr_avl | 0x2); ret = pf_cavlc_parse_8x8block[u4_temp]( pi2_coeff_block, 4, u1_offset, ps_dec, pu1_top_nnz, (pu1_left_nnz + 2), ps_cur_mb_info->u1_tran_form8x8, ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp); if(ret != OK) return ret; ui16_csbp |= (u4_temp << 8); } /*******************************************************************/ /* Block 3 residual decoding, check cbp and proceed (subblock = 10)*/ /*******************************************************************/ if(ps_cur_mb_info->u1_tran_form8x8) { pi2_coeff_block += 64; } else { pi2_coeff_block += (2 * NUM_COEFFS_IN_4x4BLK); } if(!(u1_cbp & 0x8)) { *(UWORD16 *)(pu1_top_nnz + 2) = 0; *(UWORD16 *)(pu1_left_nnz + 2) = 0; } else { UWORD32 u4_temp; ret = pf_cavlc_parse_8x8block[0x3]( pi2_coeff_block, 4, u1_offset, ps_dec, (pu1_top_nnz + 2), (pu1_left_nnz + 2), ps_cur_mb_info->u1_tran_form8x8, ps_cur_mb_info->u1_mb_field_decodingflag, &u4_temp); if(ret != OK) return ret; ui16_csbp |= (u4_temp << 10); } } else { *(UWORD32 *)(pu1_top_nnz) = 0; *(UWORD32 *)(pu1_left_nnz) = 0; } ps_cur_mb_info->u2_luma_csbp = ui16_csbp; ps_cur_mb_info->ps_curmb->u2_luma_csbp = ui16_csbp; { UWORD16 u2_chroma_csbp = 0; ps_cur_mb_info->u2_chroma_csbp = 0; pu1_top_nnz = ps_cur_mb_info->ps_curmb->pu1_nnz_uv; pu1_left_nnz = ps_dec->pu1_left_nnz_uv; u1_cbp >>= 4; /*--------------------------------------------------------------------*/ /* if Chroma Component not present OR no ac values present */ /* Set the values of N to zero */ /*--------------------------------------------------------------------*/ if(u1_cbp == CBPC_ALLZERO || u1_cbp == CBPC_ACZERO) { *(UWORD32 *)(pu1_top_nnz) = 0; *(UWORD32 *)(pu1_left_nnz) = 0; } if(u1_cbp == CBPC_ALLZERO) { return (0); } /*--------------------------------------------------------------------*/ /* Decode Chroma DC values */ /*--------------------------------------------------------------------*/ { WORD32 u4_scale_u; WORD32 u4_scale_v; WORD32 i4_mb_inter_inc; u4_scale_u = ps_dec->pu2_quant_scale_u[0] << ps_dec->u1_qp_u_div6; u4_scale_v = ps_dec->pu2_quant_scale_v[0] << ps_dec->u1_qp_v_div6; i4_mb_inter_inc = (!((ps_cur_mb_info->ps_curmb->u1_mb_type == I_4x4_MB) || (ps_cur_mb_info->ps_curmb->u1_mb_type == I_16x16_MB))) * 3; if(ps_dec->s_high_profile.u1_scaling_present) { u4_scale_u *= ps_dec->s_high_profile.i2_scalinglist4x4[i4_mb_inter_inc + 1][0]; u4_scale_v *= ps_dec->s_high_profile.i2_scalinglist4x4[i4_mb_inter_inc + 2][0]; } else { u4_scale_u <<= 4; u4_scale_v <<= 4; } ih264d_cavlc_parse_chroma_dc(ps_cur_mb_info,pi2_coeff_block, ps_dec->ps_bitstrm, u4_scale_u, u4_scale_v, i4_mb_inter_inc); } if(u1_cbp == CBPC_ACZERO) return (0); pu1_top_nnz[0] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[0]; pu1_top_nnz[1] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[1]; pu1_top_nnz[2] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[2]; pu1_top_nnz[3] = ps_cur_mb_info->ps_top_mb->pu1_nnz_uv[3]; /*--------------------------------------------------------------------*/ /* Decode Chroma AC values */ /*--------------------------------------------------------------------*/ { UWORD32 u4_temp; /*****************************************************************/ /* U Block residual decoding, check cbp and proceed (subblock=0)*/ /*****************************************************************/ ret = pf_cavlc_parse_8x8block[u4_nbr_avl]( pi2_coeff_block, 2, 1, ps_dec, pu1_top_nnz, pu1_left_nnz, 0, 0, &u4_temp); if(ret != OK) return ret; u2_chroma_csbp = u4_temp; pi2_coeff_block += MB_CHROM_SIZE; /*****************************************************************/ /* V Block residual decoding, check cbp and proceed (subblock=1)*/ /*****************************************************************/ ret = pf_cavlc_parse_8x8block[u4_nbr_avl](pi2_coeff_block, 2, 1, ps_dec, (pu1_top_nnz + 2), (pu1_left_nnz + 2), 0, 0, &u4_temp); if(ret != OK) return ret; u2_chroma_csbp |= (u4_temp << 4); } ps_cur_mb_info->u2_chroma_csbp = u2_chroma_csbp; } return OK; }