--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/videoeditorengine/mp3aacManipLib/AACGain/src/huffdec3.cpp Fri Jan 29 14:08:33 2010 +0200
@@ -0,0 +1,491 @@
+/*
+* Copyright (c) 2010 Ixonos Plc.
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - Initial contribution
+*
+* Contributors:
+* Ixonos Plc
+*
+* Description:
+*
+*/
+
+
+/**************************************************************************
+ huffdec3.cpp - Huffman decoding and inverse scaling routines for AAC decoder.
+
+ Author(s): Juha Ojanpera
+ Copyright (c) 2000-2004 by Nokia Research Center, Speech and Audio Systems.
+ *************************************************************************/
+
+/*-- Projetc Headers. --*/
+#include "tool2.h"
+#include "dec_huf.h"
+
+/**************************************************************************
+ Title: DecodeSpectralCodeword
+
+ Purpose: Decodes one spectral Huffman codeword from the bitstream.
+
+ Usage: y = DecodeSpectralCodeword(huf_info, bs)
+
+ Input: huf_info - Huffman codebook parameters
+ bs - bitstream parameters
+
+ Output: y - decoded Huffman index
+
+ Author(s): Juha Ojanpera
+ *************************************************************************/
+
+INLINE uint32
+DecodeSpectralCodeword(Huffman_DecInfo *huf_info, TBitStream *bs)
+{
+ int16 len;
+ int32 codeword, items;
+ const Huffman_DecCode *huf_code;
+
+ items = 1;
+ huf_code = huf_info->huf;
+
+ /*-- The first 5 LSB bits contain the length of codeword. --*/
+ codeword = (int32) BsGetBits(bs, (int16)(huf_code->huf_param & 31));
+
+ while(items < huf_info->cb_len && codeword != huf_code->codeword)
+ {
+ items++;
+ huf_code++;
+
+ len = (int16) (huf_code->huf_param & 31);
+ if(len)
+ {
+ codeword <<= len;
+ codeword |= BsGetBits(bs, len);
+ }
+ }
+
+ /*-- Remove the length part from the decoded symbol. --*/
+ return (huf_code->huf_param >> 5);
+}
+
+const uint32 hCbBitMask[20] =
+{0x0, 0x1, 0x3, 0x7, 0xF, 0x1F, 0x3F, 0x7F, 0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF,
+0x1FFFL, 0x3FFFL, 0x7FFFL, 0xFFFFL, 0x1FFFFL, 0x3FFFFL, 0x7FFFFL};
+
+/**************************************************************************
+ Title: DecodeSfCodeword
+
+ Purpose: Decodes one scalefactor Huffman codeword from the bitstream.
+
+ Usage: y = DecodeCodeword(huf_info, bs)
+
+ Input: huf_info - Huffman codebook parameters
+ bs - bitstream parameters
+
+ Output: y - decoded Huffman index
+
+ Explanation: The Huffman parameters are packed as follows :
+
+ bits 0 - 4 : Length of codeword
+ 5 - 23 : Huffman codeword
+ 24 - 31 : Huffman symbol
+
+ Author(s): Juha Ojanpera
+ *************************************************************************/
+
+INLINE uint32
+DecodeSfCodeword(Huffman_DecSfInfo *huf_info, TBitStream *bs)
+{
+#define SFCW_MASK ((1 << 19) - 1)
+#define EXTRACT_SFCW(x) ((x >> 5) & SFCW_MASK)
+ int16 bitsLeft;
+ uint32 lookaheadBits;
+ int32 codeword, len, items;
+ const uint32 *sf_param = huf_info->sf_param;
+
+ items = 1;
+
+ /*-- Maximum codeword length is 19 bits! --*/
+ lookaheadBits = BsLookAhead(bs, 19);
+ bitsLeft = (int16) (19 - (*sf_param & 31));
+ codeword = lookaheadBits >> bitsLeft;
+
+ while(items < huf_info->cb_len && codeword != (int32) EXTRACT_SFCW(*sf_param))
+ {
+ items++;
+ sf_param++;
+
+ len = (int16) (*sf_param & 31);
+ if(len)
+ {
+ bitsLeft -= len;
+ codeword <<= len;
+ codeword |= (lookaheadBits >> bitsLeft) & hCbBitMask[len];
+ }
+ }
+
+ BsSkipNBits(bs, 19 - bitsLeft);
+
+ return (*sf_param >> 24);
+}
+
+uint32
+GetHcb(Huffman_DecSfInfo *huf_info, TBitStream *bs)
+{
+ return (DecodeSfCodeword(huf_info, bs));
+}
+
+/**************************************************************************
+ Title: huf_sfac
+
+ Purpose: Reads scalefactors from the bitstream.
+
+ Usage: y = huf_sfac(bs, cip, group, cb_map, global_gain, factors, max_sfb)
+
+ Input: bs - bitstream parameters
+ cip :
+ info - block (long/short) parameters
+ group - grouping info
+ cb_map - codebook for each sfb
+ global_gain - start value for the difference decoding of scalefactors
+ max_sfb - max # of sfb's present in this channel
+
+ Output: y - TRUE on success, FALSE otherwise
+ cip :
+ is_present - TRUE if IS stereo is used, FALSE otherwise
+
+ Author(s): Juha Ojanpera
+ *************************************************************************/
+
+int16
+huf_sfac(TBitStream *bs, TCh_Info *cip, uint8 *group, uint8 *cb_map,
+ int16 global_gain, int16 *factors, uint8 max_sfb)
+{
+ Huffman_DecSfInfo *sf_huf;
+ int16 i, b, bb, n, is_pos;
+ int16 noise_pcm_flag, noise_nrg;
+
+ sf_huf = cip->sf_huf;
+
+ noise_pcm_flag = 1;
+
+ /*
+ * Scale factors are dpcm relative to global gain,
+ * intensity positions are dpcm relative to zero
+ */
+ is_pos = 0;
+ noise_nrg = (int16) (global_gain - NOISE_OFFSET);
+ cip->is_present = cip->pns_present = FALSE;
+
+ /*-- Get scale factors. --*/
+ n = cip->info->sfb_per_sbk[0];
+ for(b = 0, bb = 0; b < cip->info->nsbk; )
+ {
+ b = *group++;
+ for(i = 0; i < max_sfb; i++)
+ {
+ switch(cb_map[i])
+ {
+ /*-- Zero book. --*/
+ case ZERO_HCB:
+ factors[i] = 0;
+ break;
+
+ /*-- Invalid books. --*/
+ case BOOKSCL:
+ return (FALSE);
+
+ /*-- Intensity books. --*/
+ case INTENSITY_HCB:
+ case INTENSITY_HCB2:
+ cip->is_present = TRUE;
+ is_pos = (int16) (is_pos + DecodeSfCodeword(sf_huf, bs) - MIDFAC);
+ factors[i] = is_pos;
+ break;
+
+ /*-- Noise books. --*/
+ case NOISE_HCB:
+ cip->pns_present = TRUE;
+ if(noise_pcm_flag)
+ {
+ noise_pcm_flag = 0;
+ noise_nrg = (int16) (noise_nrg + BsGetBits(bs, NOISE_PCM_BITS) - NOISE_PCM_OFFSET);
+ }
+ else
+ noise_nrg = (int16) (noise_nrg + DecodeSfCodeword(sf_huf, bs) - MIDFAC);
+
+ factors[i] = noise_nrg;
+ break;
+
+ /*-- Spectral books. --*/
+ default:
+ global_gain = (int16) (global_gain + DecodeSfCodeword(sf_huf, bs) - MIDFAC);
+ factors[i] = (int16) (global_gain & TEXP_MASK);
+ break;
+ }
+ }
+
+ /*-- Expand short block grouping. --*/
+ if(!cip->info->islong)
+ for(bb++; bb < b; bb++)
+ {
+ COPY_MEMORY(factors + n, factors, n * sizeof(int16));
+ factors += n;
+ }
+ cb_map += n; factors += n;
+ }
+
+ return (TRUE);
+}
+
+/**************************************************************************
+ Title: unpack_index...
+
+ Purpose: Translates Huffman index into n-tuple spectral values.
+
+ Usage: unpack_index(index, quant)
+
+ Input: index - decoded Huffman index
+
+ Output: quant - quantized spectral values
+
+ Explanation: The index contains already the translated n-tuple spectral
+ values due to computational reasons. The unpacking routines
+ will only extract the codebook dependent bit fields within
+ 'index' to obtain the quantized values.
+
+ Author(s): Juha Ojanpera
+ *************************************************************************/
+
+/*
+ * 2-tuple, quantized values are unsigned.
+ */
+INLINE void
+unpack_index2noOff(uint32 index, int16 *quant)
+{
+ quant[0] = (index >> 5) & 31; quant[1] = index & 31;
+}
+
+/*
+ * 2-tuple, quantized values are signed.
+ */
+INLINE void
+unpack_index2Off(uint32 index, int16 *quant)
+{
+ quant[0] = (index >> 4) & 7; if(index & 128) quant[0] = -quant[0];
+ quant[1] = index & 7; if(index & 8) quant[1] = -quant[1];
+}
+
+/*
+ * 4-tuple, quantized values are unsigned.
+ */
+INLINE void
+unpack_index4noOff(uint32 index, int16 *quant)
+{
+ quant[0] = (index >> 6) & 3; quant[1] = (index >> 4) & 3;
+ quant[2] = (index >> 2) & 3; quant[3] = index & 3;
+}
+
+/*
+ * 4-tuple, quantized values are signed.
+ */
+INLINE void
+unpack_index4Off(uint32 index, int16 *quant)
+{
+ quant[0] = (index >> 6) & 1; if(index & 128) quant[0] = -quant[0];
+ quant[1] = (index >> 4) & 1; if(index & 32) quant[1] = -quant[1];
+ quant[2] = (index >> 2) & 1; if(index & 8) quant[2] = -quant[2];
+ quant[3] = index & 1; if(index & 2) quant[3] = -quant[3];
+}
+
+/*
+ * Reads, at maximum, 2 sign bits from the bitstream.
+ */
+INLINE void
+get_sign_bits2(int16 *q, TBitStream *bs)
+{
+ /*-- 1 signals negative, as in 2's complement. --*/
+ if(q[0]) { if(BsGetBits(bs, 1)) q[0] = -q[0]; }
+ if(q[1]) { if(BsGetBits(bs, 1)) q[1] = -q[1]; }
+}
+
+/*
+ * Reads, at maximum, 4 sign bits from the bitstream.
+ */
+INLINE void
+get_sign_bits4(int16 *q, TBitStream *bs)
+{
+ /*-- 1 signals negative, as in 2's complement. --*/
+ if(q[0]) { if(BsGetBits(bs, 1)) q[0] = -q[0]; }
+ if(q[1]) { if(BsGetBits(bs, 1)) q[1] = -q[1]; }
+ if(q[2]) { if(BsGetBits(bs, 1)) q[2] = -q[2]; }
+ if(q[3]) { if(BsGetBits(bs, 1)) q[3] = -q[3]; }
+}
+
+/**************************************************************************
+ Title: getescape
+
+ Purpose: Decodes escape sequences for codebook 11.
+
+ Usage: y = getescape(bs, q)
+
+ Input: bs - bitstream parameters
+ q - decoded quantized value (0-16)
+
+ Output: y - actual quantized value
+
+ Author(s): Juha Ojanpera
+ *************************************************************************/
+
+INLINE int16
+getescape(TBitStream *bs, int16 q)
+{
+ int16 i;
+
+ i = q;
+
+ /*-- Value 16 is used to indicate that the actual value is escape coded. --*/
+ if(q == 16 || q == -16)
+ {
+ /*
+ * The length of escape sequence, according to the AAC standard,
+ * is less than 24 bits.
+ */
+ for(i = 4; i < 24; i++)
+ if(BsGetBits(bs, 1) == 0)
+ break;
+
+ i = (int16) (BsGetBits(bs, i) + (1 << i));
+ if(q < 0)
+ i = -i;
+ }
+
+ return (i);
+}
+
+/**************************************************************************
+ Title: huf_spec
+
+ Purpose: Huffman decodes and inverse scales quantized spectral values.
+
+ Usage: y = huf_spec(bs, info, nsect, sect, quant, huf, parseOnly)
+
+ Input: bs - bitstream parameters
+ info - block (long/short) parameters
+ nsect - # of sections present in this channel
+ sect - sectioning (codebook and length of section) info
+ huf - Spectral Huffman tables
+ parseOnly - 1 if bitstream need to be only parsed, 0 otherwise
+
+ Output: y - # of spectral bins decoded
+ quant - quantized spectral coefficients
+
+ Author(s): Juha Ojanpera
+ *************************************************************************/
+
+int16
+huf_spec(TBitStream *bs, CInfo *info, int16 nsect, uint8 *sect, int16 *quant,
+ Huffman_DecInfo **huf, uint8 parseOnly)
+{
+ uint32 temp;
+ int16 i, j, k, stop, *qp;
+
+ qp = quant;
+ for(k = 0, i = nsect; i; i--, sect += 2)
+ {
+ register Huffman_DecInfo *huf_info;
+ int16 table = sect[0];
+ int16 top = sect[1];
+
+ if(top > 200 || top < 1) goto error_exit;
+
+ stop = info->bk_sfb_top[top - 1];
+
+ switch(table)
+ {
+ /*-- 4-tuple signed quantized coefficients. --*/
+ case 1:
+ case 2:
+ huf_info = huf[table - 1];
+ for (j = k; j < stop; j += 4, qp += 4)
+ {
+ temp = DecodeSpectralCodeword(huf_info, bs);
+ if(!parseOnly) unpack_index4Off(temp, qp);
+ }
+ break;
+
+ /*-- 4-tuple unsigned quantized coefficients. --*/
+ case 3:
+ case 4:
+ huf_info = huf[table - 1];
+ for (j = k; j < stop; j += 4, qp += 4)
+ {
+ temp = DecodeSpectralCodeword(huf_info, bs);
+ unpack_index4noOff(temp, qp);
+ get_sign_bits4(qp, bs);
+ }
+ break;
+
+ /*-- 2-tuple unsigned quantized coefficients. --*/
+ case 5:
+ case 6:
+ huf_info = huf[table - 1];
+ for (j = k; j < stop; j += 2, qp += 2)
+ {
+ temp = DecodeSpectralCodeword(huf_info, bs);
+ if(!parseOnly) unpack_index2Off(temp, qp);
+ }
+ break;
+
+ /*-- 2-tuple signed quantized coefficients. --*/
+ case 7:
+ case 8:
+ case 9:
+ case 10:
+ huf_info = huf[table - 1];
+ for (j = k; j < stop; j += 2, qp += 2)
+ {
+ temp = DecodeSpectralCodeword(huf_info, bs);
+ unpack_index2noOff(temp, qp);
+ get_sign_bits2(qp, bs);
+ }
+ break;
+
+ /*-- 2-tuple signed quantized coefficients (escape codebook). --*/
+ case 11:
+ huf_info = huf[table - 1];
+ for (j = k; j < stop; j += 2, qp += 2)
+ {
+ temp = DecodeSpectralCodeword(huf_info, bs);
+ unpack_index2noOff(temp, qp);
+ get_sign_bits2(qp, bs);
+ qp[0] = getescape(bs, qp[0]);
+ qp[1] = getescape(bs, qp[1]);
+ }
+ break;
+
+ default:
+ if(stop > k)
+ {
+ if(!parseOnly) ZERO_MEMORY(qp, (stop - k) * sizeof(int16));
+ qp = quant + stop;
+ }
+ else goto error_exit;
+ break;
+ }
+ k = stop;
+ }
+
+ if(!parseOnly) if(k < LN2) ZERO_MEMORY(quant + k, (LN2 - k) * sizeof(int16));
+
+ return (k);
+
+ error_exit:
+
+ return (0);
+}