mirror of
https://github.com/cemu-project/Cemu.git
synced 2024-12-05 23:44:20 +01:00
2720 lines
119 KiB
C
2720 lines
119 KiB
C
|
/******************************************************************************
|
||
|
*
|
||
|
* 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 <string.h>
|
||
|
#include <stdio.h>
|
||
|
|
||
|
#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 : <What inputs does the function take?> */
|
||
|
/* Globals : <Does it use any global variables?> */
|
||
|
/* Processing : <Describe how the function operates - include algorithm */
|
||
|
/* description> */
|
||
|
/* Outputs : <What does the function produce?> */
|
||
|
/* Returns : <What does the function return?> */
|
||
|
/* */
|
||
|
/* Issues : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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 : <What inputs does the function take?> */
|
||
|
/* Globals : <Does it use any global variables?> */
|
||
|
/* Processing : <Describe how the function operates - include algorithm */
|
||
|
/* description> */
|
||
|
/* Outputs : <What does the function produce?> */
|
||
|
/* Returns : <What does the function return?> */
|
||
|
/* */
|
||
|
/* Issues : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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, /*!<TotalCoefficients<<16+trailingones*/
|
||
|
dec_bit_stream_t *ps_bitstrm)
|
||
|
{
|
||
|
UWORD32 u4_total_zeroes;
|
||
|
WORD32 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(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++;
|
||
|
u4_cnt--;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/****************************************************************/
|
||
|
/* 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;
|
||
|
WORD32 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 -= (WORD32)u4_run;
|
||
|
u4_scan_pos -= (WORD32)(u4_run + 1);
|
||
|
}
|
||
|
|
||
|
if (u4_zeroes_left < 0 || u4_scan_pos < 0)
|
||
|
return -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 -= (WORD32)u4_run;
|
||
|
u4_scan_pos -= (WORD32)(u4_run + 1);
|
||
|
}
|
||
|
if (u4_zeroes_left < 0 || u4_scan_pos < 0)
|
||
|
return -1;
|
||
|
/**************************************************************/
|
||
|
/* Decoding Runs End */
|
||
|
/**************************************************************/
|
||
|
|
||
|
/**************************************************************/
|
||
|
/* Copy the remaining coefficients */
|
||
|
/**************************************************************/
|
||
|
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 : <What inputs does the function take?> */
|
||
|
/* Globals : <Does it use any global variables?> */
|
||
|
/* Processing : <Describe how the function operates - include algorithm */
|
||
|
/* description> */
|
||
|
/* Outputs : <What does the function produce?> */
|
||
|
/* Returns : <What does the function return?> */
|
||
|
/* */
|
||
|
/* Issues : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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, /*!<TotalCoefficients<<16+trailingones*/
|
||
|
dec_bit_stream_t *ps_bitstrm )
|
||
|
{
|
||
|
UWORD32 u4_total_zeroes;
|
||
|
WORD32 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(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++;
|
||
|
u4_cnt--;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/****************************************************************/
|
||
|
/* 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;
|
||
|
WORD32 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 -= (WORD32)u4_run;
|
||
|
u4_scan_pos -= (WORD32)(u4_run + 1);
|
||
|
}
|
||
|
if (u4_zeroes_left < 0 || u4_scan_pos < 0)
|
||
|
return -1;
|
||
|
|
||
|
/**************************************************************/
|
||
|
/* Decoding Runs End */
|
||
|
/**************************************************************/
|
||
|
|
||
|
/**************************************************************/
|
||
|
/* Copy the remaining coefficients */
|
||
|
/**************************************************************/
|
||
|
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 : <What inputs does the function take?> */
|
||
|
/* Globals : <Does it use any global variables?> */
|
||
|
/* Processing : <Describe how the function operates - include algorithm */
|
||
|
/* description> */
|
||
|
/* Outputs : <What does the function produce?> */
|
||
|
/* Returns : <What does the function return?> */
|
||
|
/* */
|
||
|
/* Issues : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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++;
|
||
|
u4_cnt--;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/****************************************************************/
|
||
|
/* 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;
|
||
|
WORD32 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 -= (WORD32)u4_run;
|
||
|
u4_scan_pos -= (WORD32)(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++ = (WORD16)(((i_z0 + i_z3) * (WORD32)u4_scale_u) >> 5);
|
||
|
*pi2_coeff_data++ = (WORD16)(((i_z0 - i_z3) * (WORD32)u4_scale_u) >> 5);
|
||
|
*pi2_coeff_data++ = (WORD16)(((i_z1 + i_z2) * (WORD32)u4_scale_u) >> 5);
|
||
|
*pi2_coeff_data++ = (WORD16)(((i_z1 - i_z2) * (WORD32)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++ = (WORD16)(((i_z0 + i_z3) * (WORD32)u4_scale_v) >> 5);
|
||
|
*pi2_coeff_data++ = (WORD16)(((i_z0 - i_z3) * (WORD32)u4_scale_v) >> 5);
|
||
|
*pi2_coeff_data++ = (WORD16)(((i_z1 + i_z2) * (WORD32)u4_scale_v) >> 5);
|
||
|
*pi2_coeff_data++ = (WORD16)(((i_z1 - i_z2) * (WORD32)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 : <What inputs does the function take?> */
|
||
|
/* Globals : <Does it use any global variables?> */
|
||
|
/* Processing : <Describe how the function operates - include algorithm */
|
||
|
/* description> */
|
||
|
/* Outputs : <What does the function produce?> */
|
||
|
/* Returns : <What does the function return?> */
|
||
|
/* */
|
||
|
/* Issues : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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 : <What inputs does the function take?> */
|
||
|
/* Globals : <Does it use any global variables?> */
|
||
|
/* Processing : <Describe how the function operates - include algorithm */
|
||
|
/* description> */
|
||
|
/* Outputs : <What does the function produce?> */
|
||
|
/* Returns : <What does the function return?> */
|
||
|
/* */
|
||
|
/* Issues : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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 : <What inputs does the function take?> */
|
||
|
/* Globals : <Does it use any global variables?> */
|
||
|
/* Processing : <Describe how the function operates - include algorithm */
|
||
|
/* description> */
|
||
|
/* Outputs : <What does the function produce?> */
|
||
|
/* Returns : <What does the function return?> */
|
||
|
/* */
|
||
|
/* Issues : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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 : <What inputs does the function take?> */
|
||
|
/* Globals : <Does it use any global variables?> */
|
||
|
/* Processing : <Describe how the function operates - include algorithm */
|
||
|
/* description> */
|
||
|
/* Outputs : <What does the function produce?> */
|
||
|
/* Returns : <What does the function return?> */
|
||
|
/* */
|
||
|
/* Issues : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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 : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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 : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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 : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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 : <List any issues or problems with this function> */
|
||
|
/* */
|
||
|
/* 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;
|
||
|
}
|