summaryrefslogtreecommitdiffstats
path: root/libAACdec/src/aacdec_hcrs.cpp
diff options
context:
space:
mode:
authorDave Burke <daveburke@google.com>2012-04-17 09:51:45 -0700
committerDave Burke <daveburke@google.com>2012-04-17 23:04:43 -0700
commit9bf37cc9712506b2483650c82d3c41152337ef7e (patch)
tree77db44e2bae06e3d144b255628be2b7a55c581d3 /libAACdec/src/aacdec_hcrs.cpp
parenta37315fe10ee143d6d0b28c19d41a476a23e63ea (diff)
downloadODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.tar.gz
ODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.tar.bz2
ODR-AudioEnc-9bf37cc9712506b2483650c82d3c41152337ef7e.zip
Fraunhofer AAC codec.
License boilerplate update to follow. Change-Id: I2810460c11a58b6d148d84673cc031f3685e79b5
Diffstat (limited to 'libAACdec/src/aacdec_hcrs.cpp')
-rw-r--r--libAACdec/src/aacdec_hcrs.cpp1344
1 files changed, 1344 insertions, 0 deletions
diff --git a/libAACdec/src/aacdec_hcrs.cpp b/libAACdec/src/aacdec_hcrs.cpp
new file mode 100644
index 0000000..da8928e
--- /dev/null
+++ b/libAACdec/src/aacdec_hcrs.cpp
@@ -0,0 +1,1344 @@
+/***************************** MPEG-4 AAC Decoder ***************************
+
+ (C) Copyright Fraunhofer IIS 2000-2008
+ All Rights Reserved
+
+ Please be advised that this software and/or program delivery is
+ Confidential Information of Fraunhofer and subject to and covered by the
+
+ Fraunhofer IIS Software Evaluation Agreement
+ between Google Inc. and Fraunhofer
+ effective and in full force since March 1, 2012.
+
+ You may use this software and/or program only under the terms and
+ conditions described in the above mentioned Fraunhofer IIS Software
+ Evaluation Agreement. Any other and/or further use requires a separate agreement.
+
+
+ $Id$
+ Author(s): Robert Weidner (DSP Solutions)
+ Description: HCR Decoder: Prepare decoding of non-PCWs, segmentation- and
+ bitfield-handling, HCR-Statemachine
+
+ This software and/or program is protected by copyright law and international
+ treaties. Any reproduction or distribution of this software and/or program,
+ or any portion of it, may result in severe civil and criminal penalties, and
+ will be prosecuted to the maximum extent possible under law.
+
+*******************************************************************************/
+
+#include "aacdec_hcrs.h"
+
+
+#include "aacdec_hcr.h"
+
+#include "aacdec_hcr_bit.h"
+#include "aac_rom.h"
+#include "aac_ram.h"
+
+
+static UINT InitSegmentBitfield(UINT *pNumSegment,
+ SCHAR *pRemainingBitsInSegment,
+ UINT *pSegmentBitfield,
+ UCHAR *pNumWordForBitfield,
+ USHORT *pNumBitValidInLastWord);
+
+static void InitNonPCWSideInformationForCurrentSet(H_HCR_INFO pHcr);
+
+static INT ModuloValue(INT input, INT bufferlength);
+
+static void ClearBitFromBitfield(STATEFUNC *ptrState,
+ UINT offset,
+ UINT *pBitfield);
+
+
+/*---------------------------------------------------------------------------------------------
+ description: This function decodes all non-priority codewords (non-PCWs) by using a
+ state-machine.
+-------------------------------------------------------------------------------------------- */
+void DecodeNonPCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr)
+{
+ UINT numValidSegment;
+ INT segmentOffset;
+ INT codewordOffsetBase;
+ INT codewordOffset;
+ UINT trial;
+
+ UINT *pNumSegment;
+ SCHAR *pRemainingBitsInSegment;
+ UINT *pSegmentBitfield;
+ UCHAR *pNumWordForBitfield;
+ USHORT *pNumBitValidInLastWord;
+ UINT *pCodewordBitfield;
+ INT bitfieldWord;
+ INT bitInWord;
+ UINT tempWord;
+ UINT interMediateWord;
+ INT tempBit;
+ INT carry;
+
+ UINT numCodeword;
+ UCHAR numSet;
+ UCHAR currentSet;
+ UINT codewordInSet;
+ UINT remainingCodewordsInSet;
+ SCHAR *pSta;
+ UINT ret;
+
+ pNumSegment = &(pHcr->segmentInfo.numSegment);
+ pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
+ pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield;
+ pNumWordForBitfield = &(pHcr->segmentInfo.numWordForBitfield);
+ pNumBitValidInLastWord = &(pHcr->segmentInfo.pNumBitValidInLastWord);
+ pSta = pHcr->nonPcwSideinfo.pSta;
+
+ numValidSegment = InitSegmentBitfield(pNumSegment,
+ pRemainingBitsInSegment,
+ pSegmentBitfield,
+ pNumWordForBitfield,
+ pNumBitValidInLastWord);
+
+ if ( numValidSegment != 0 ) {
+ numCodeword = pHcr->sectionInfo.numCodeword;
+ numSet = ((numCodeword - 1) / *pNumSegment) + 1;
+
+
+ pHcr->segmentInfo.readDirection = FROM_RIGHT_TO_LEFT;
+
+ /* Process sets subsequently */
+ for ( currentSet = 1; currentSet < numSet ; currentSet++ ) {
+
+
+
+ /* step 1 */
+ numCodeword -= *pNumSegment; /* number of remaining non PCWs [for all sets] */
+ if ( numCodeword < *pNumSegment ) {
+ codewordInSet = numCodeword; /* for last set */
+ }
+ else {
+ codewordInSet = *pNumSegment; /* for all sets except last set */
+ }
+
+ /* step 2 */
+ /* prepare array 'CodewordBitfield'; as much ones are written from left in all words, as much decodedCodewordInSetCounter nonPCWs exist in this set */
+ tempWord = 0xFFFFFFFF;
+ pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield;
+
+ for ( bitfieldWord = *pNumWordForBitfield; bitfieldWord !=0; bitfieldWord-- ) { /* loop over all used words */
+ if ( codewordInSet > NUMBER_OF_BIT_IN_WORD ) { /* more codewords than number of bits => fill ones */
+ /* fill a whole word with ones */
+ *pCodewordBitfield++ = tempWord;
+ codewordInSet -= NUMBER_OF_BIT_IN_WORD; /* subtract number of bits */
+ }
+ else {
+ /* prepare last tempWord */
+ for (remainingCodewordsInSet = codewordInSet; remainingCodewordsInSet < NUMBER_OF_BIT_IN_WORD ; remainingCodewordsInSet++ ) {
+ tempWord = tempWord & ~(1 << (NUMBER_OF_BIT_IN_WORD-1-remainingCodewordsInSet)); /* set a zero at bit number (NUMBER_OF_BIT_IN_WORD-1-i) in tempWord */
+ }
+ *pCodewordBitfield++ = tempWord;
+ tempWord = 0x00000000;
+ }
+ }
+ pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield;
+
+ /* step 3 */
+ /* build non-PCW sideinfo for each non-PCW of the current set */
+ InitNonPCWSideInformationForCurrentSet(pHcr);
+
+ /* step 4 */
+ /* decode all non-PCWs belonging to this set */
+
+ /* loop over trials */
+ codewordOffsetBase = 0;
+ for ( trial = *pNumSegment; trial > 0; trial-- ) {
+
+ /* loop over number of words in bitfields */
+ segmentOffset = 0; /* start at zero in every segment */
+ pHcr->segmentInfo.segmentOffset = segmentOffset; /* store in structure for states */
+ codewordOffset = codewordOffsetBase;
+ pHcr->nonPcwSideinfo.codewordOffset = codewordOffset; /* store in structure for states */
+
+ for ( bitfieldWord=0; bitfieldWord < *pNumWordForBitfield; bitfieldWord++ ) {
+
+ /* derive tempWord with bitwise and */
+ tempWord = pSegmentBitfield[bitfieldWord] & pCodewordBitfield[bitfieldWord];
+
+ /* if tempWord is not zero, decode something */
+ if ( tempWord != 0 ) {
+
+
+ /* loop over all bits in tempWord; start state machine if & is true */
+ for ( bitInWord = NUMBER_OF_BIT_IN_WORD; bitInWord > 0; bitInWord-- ) {
+
+ interMediateWord = ((UINT)1 << (bitInWord-1) );
+ if ( ( tempWord & interMediateWord ) == interMediateWord ) {
+
+ /* get state and start state machine */
+ pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]];
+
+ while(pHcr->nonPcwSideinfo.pState) {
+ ret = ((STATEFUNC) pHcr->nonPcwSideinfo.pState)(bs, pHcr);
+#if STATE_MACHINE_ERROR_CHECK
+ if ( ret != 0 ) {
+ return;
+ }
+#endif
+ }
+ }
+
+ /* update both offsets */
+ segmentOffset += 1; /* add NUMBER_OF_BIT_IN_WORD times one */
+ pHcr->segmentInfo.segmentOffset = segmentOffset;
+ codewordOffset += 1; /* add NUMBER_OF_BIT_IN_WORD times one */
+ codewordOffset = ModuloValue(codewordOffset,*pNumSegment); /* index of the current codeword lies within modulo range */
+ pHcr->nonPcwSideinfo.codewordOffset = codewordOffset;
+ }
+ }
+ else {
+ segmentOffset += NUMBER_OF_BIT_IN_WORD; /* add NUMBER_OF_BIT_IN_WORD at once */
+ pHcr->segmentInfo.segmentOffset = segmentOffset;
+ codewordOffset += NUMBER_OF_BIT_IN_WORD; /* add NUMBER_OF_BIT_IN_WORD at once */
+ codewordOffset = ModuloValue(codewordOffset,*pNumSegment); /* index of the current codeword lies within modulo range */
+ pHcr->nonPcwSideinfo.codewordOffset = codewordOffset;
+ }
+ } /* end of bitfield word loop */
+
+ /* decrement codeword - pointer */
+ codewordOffsetBase -= 1;
+ codewordOffsetBase = ModuloValue(codewordOffsetBase,*pNumSegment); /* index of the current codeword base lies within modulo range */
+
+ /* rotate numSegment bits in codewordBitfield */
+ /* rotation of *numSegment bits in bitfield of codewords (circle-rotation) */
+ /* get last valid bit */
+ tempBit = pCodewordBitfield[*pNumWordForBitfield-1] & (1 << (NUMBER_OF_BIT_IN_WORD - *pNumBitValidInLastWord));
+ tempBit = tempBit >> (NUMBER_OF_BIT_IN_WORD - *pNumBitValidInLastWord);
+
+ /* write zero into place where tempBit was fetched from */
+ pCodewordBitfield[*pNumWordForBitfield-1] = pCodewordBitfield[*pNumWordForBitfield-1] & ~(1 << (NUMBER_OF_BIT_IN_WORD - *pNumBitValidInLastWord));
+
+ /* rotate last valid word */
+ pCodewordBitfield[*pNumWordForBitfield-1] = pCodewordBitfield[*pNumWordForBitfield-1] >> 1;
+
+ /* transfare carry bit 0 from current word into bitposition 31 from next word and rotate current word */
+ for ( bitfieldWord = *pNumWordForBitfield-2; bitfieldWord > -1 ; bitfieldWord-- ) {
+ /* get carry (=bit at position 0) from current word */
+ carry = pCodewordBitfield[bitfieldWord] & 1;
+
+ /* put the carry bit at position 31 into word right from current word */
+ pCodewordBitfield[bitfieldWord+1] = pCodewordBitfield[bitfieldWord+1] | (carry << (NUMBER_OF_BIT_IN_WORD-1));
+
+ /* shift current word */
+ pCodewordBitfield[bitfieldWord] = pCodewordBitfield[bitfieldWord] >> 1;
+ }
+
+ /* put tempBit into free bit-position 31 from first word */
+ pCodewordBitfield[0] = pCodewordBitfield[0] | (tempBit << (NUMBER_OF_BIT_IN_WORD-1));
+
+ } /* end of trial loop */
+
+ /* toggle read direction */
+ pHcr->segmentInfo.readDirection = ToggleReadDirection(pHcr->segmentInfo.readDirection);
+
+ }
+ /* end of set loop */
+
+ /* all non-PCWs of this spectrum are decoded */
+ }
+
+ /* all PCWs and all non PCWs are decoded. They are unbacksorted in output buffer. Here is the Interface with comparing QSCs to asm decoding */
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ description: This function prepares the bitfield used for the
+ segments. The list is set up once to be used in all following sets. If a
+ segment is decoded empty, the according bit from the Bitfield is removed.
+-----------------------------------------------------------------------------------------------
+ return: numValidSegment = the number of valid segments
+-------------------------------------------------------------------------------------------- */
+static UINT InitSegmentBitfield(UINT *pNumSegment,
+ SCHAR *pRemainingBitsInSegment,
+ UINT *pSegmentBitfield,
+ UCHAR *pNumWordForBitfield,
+ USHORT *pNumBitValidInLastWord)
+{
+ SHORT i;
+ USHORT r;
+ UCHAR bitfieldWord;
+ UINT tempWord;
+ USHORT numValidSegment;
+
+ *pNumWordForBitfield = ((*pNumSegment-1) >> THIRTYTWO_LOG_DIV_TWO_LOG) + 1;
+
+ /* loop over all words, which are completely used or only partial */
+ /* bit in pSegmentBitfield is zero if segment is empty; bit in pSegmentBitfield is one if segment is not empty */
+ numValidSegment = 0;
+ *pNumBitValidInLastWord = *pNumSegment;
+
+ /* loop over words */
+ for ( bitfieldWord=0; bitfieldWord < *pNumWordForBitfield - 1; bitfieldWord++ ) {
+ tempWord = 0xFFFFFFFF; /* set ones */
+ r = bitfieldWord << THIRTYTWO_LOG_DIV_TWO_LOG;
+ for ( i=0; i < NUMBER_OF_BIT_IN_WORD; i++) {
+ if ( pRemainingBitsInSegment[r + i] == 0 ) {
+ tempWord = tempWord & ~(1 << (NUMBER_OF_BIT_IN_WORD-1-i)); /* set a zero at bit number (NUMBER_OF_BIT_IN_WORD-1-i) in tempWord */
+ }
+ else {
+ numValidSegment += 1; /* count segments which are not empty */
+ }
+ }
+ pSegmentBitfield[bitfieldWord] = tempWord; /* store result */
+ *pNumBitValidInLastWord -= NUMBER_OF_BIT_IN_WORD; /* calculate number of zeros on LSB side in the last word */
+ }
+
+
+ /* calculate last word: prepare special tempWord */
+ tempWord = 0xFFFFFFFF;
+ for ( i=0; i < ( NUMBER_OF_BIT_IN_WORD - *pNumBitValidInLastWord ); i++ ) {
+ tempWord = tempWord & ~(1 << i); /* clear bit i in tempWord */
+ }
+
+ /* calculate last word */
+ r = bitfieldWord << THIRTYTWO_LOG_DIV_TWO_LOG;
+ for ( i=0; i<*pNumBitValidInLastWord; i++) {
+ if ( pRemainingBitsInSegment[r + i] == 0 ) {
+ tempWord = tempWord & ~(1 << (NUMBER_OF_BIT_IN_WORD-1-i)); /* set a zero at bit number (NUMBER_OF_BIT_IN_WORD-1-i) in tempWord */
+ }
+ else {
+ numValidSegment += 1; /* count segments which are not empty */
+ }
+ }
+ pSegmentBitfield[bitfieldWord] = tempWord; /* store result */
+
+
+
+ return numValidSegment;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ description: This function sets up sideinfo for the non-PCW decoder (for the current set).
+---------------------------------------------------------------------------------------------*/
+static void InitNonPCWSideInformationForCurrentSet(H_HCR_INFO pHcr)
+{
+ USHORT i,k;
+ UCHAR codebookDim;
+ UINT startNode;
+
+ UCHAR *pCodebook = pHcr->nonPcwSideinfo.pCodebook;
+ UINT *iNode = pHcr->nonPcwSideinfo.iNode;
+ UCHAR *pCntSign = pHcr->nonPcwSideinfo.pCntSign;
+ USHORT *iResultPointer = pHcr->nonPcwSideinfo.iResultPointer;
+ UINT *pEscapeSequenceInfo = pHcr->nonPcwSideinfo.pEscapeSequenceInfo;
+ SCHAR *pSta = pHcr->nonPcwSideinfo.pSta;
+ USHORT *pNumExtendedSortedCodewordInSection = pHcr->sectionInfo.pNumExtendedSortedCodewordInSection;
+ int numExtendedSortedCodewordInSectionIdx = pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx;
+ UCHAR *pExtendedSortedCodebook = pHcr->sectionInfo.pExtendedSortedCodebook;
+ int extendedSortedCodebookIdx = pHcr->sectionInfo.extendedSortedCodebookIdx;
+ USHORT *pNumExtendedSortedSectionsInSets = pHcr->sectionInfo.pNumExtendedSortedSectionsInSets;
+ int numExtendedSortedSectionsInSetsIdx = pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx;
+ FIXP_DBL *pQuantizedSpectralCoefficients = SPEC_LONG(pHcr->decInOut.pQuantizedSpectralCoefficientsBase);
+ int quantizedSpectralCoefficientsIdx = pHcr->decInOut.quantizedSpectralCoefficientsIdx;
+ const UCHAR *pCbDimension = pHcr->tableInfo.pCbDimension;
+ int iterationCounter = 0;
+
+ /* loop over number of extended sorted sections in the current set so all codewords sideinfo variables within this set can be prepared for decoding */
+ for ( i=pNumExtendedSortedSectionsInSets[numExtendedSortedSectionsInSetsIdx]; i != 0; i-- ) {
+
+ codebookDim = pCbDimension[pExtendedSortedCodebook[extendedSortedCodebookIdx]];
+ startNode = *aHuffTable[pExtendedSortedCodebook[extendedSortedCodebookIdx]];
+
+ for ( k = pNumExtendedSortedCodewordInSection[numExtendedSortedCodewordInSectionIdx]; k != 0; k-- ) {
+ iterationCounter++;
+ if (iterationCounter > (1024>>2)) {
+ return;
+ }
+ *pSta++ = aCodebook2StartInt[pExtendedSortedCodebook[extendedSortedCodebookIdx]];
+ *pCodebook++ = pExtendedSortedCodebook[extendedSortedCodebookIdx];
+ *iNode++ = startNode;
+ *pCntSign++ = 0;
+ *iResultPointer++ = quantizedSpectralCoefficientsIdx;
+ *pEscapeSequenceInfo++ = 0;
+ quantizedSpectralCoefficientsIdx += codebookDim; /* update pointer by codebookDim --> point to next starting value for writing out */
+ if (quantizedSpectralCoefficientsIdx >= 1024) {
+ return;
+ }
+ }
+ numExtendedSortedCodewordInSectionIdx++; /* inc ptr for next ext sort sec in current set */
+ extendedSortedCodebookIdx++; /* inc ptr for next ext sort sec in current set */
+ if (numExtendedSortedCodewordInSectionIdx >= (MAX_SFB_HCR+MAX_HCR_SETS) || extendedSortedCodebookIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) {
+ return;
+ }
+ }
+ numExtendedSortedSectionsInSetsIdx++; /* inc ptr for next set of non-PCWs */
+ if (numExtendedSortedCodewordInSectionIdx >= (MAX_SFB_HCR+MAX_HCR_SETS)) {
+ return;
+ }
+
+ /* Write back indexes */
+ pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = numExtendedSortedCodewordInSectionIdx;
+ pHcr->sectionInfo.extendedSortedCodebookIdx = extendedSortedCodebookIdx;
+ pHcr->sectionInfo.numExtendedSortedSectionsInSetsIdx = numExtendedSortedSectionsInSetsIdx;
+ pHcr->sectionInfo.numExtendedSortedCodewordInSectionIdx = numExtendedSortedCodewordInSectionIdx;
+ pHcr->decInOut.quantizedSpectralCoefficientsIdx = quantizedSpectralCoefficientsIdx;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ description: This function returns the input value if the value is in the
+ range of bufferlength. If <input> is smaller, one bufferlength is added,
+ if <input> is bigger one bufferlength is subtracted.
+-----------------------------------------------------------------------------------------------
+ return: modulo result
+-------------------------------------------------------------------------------------------- */
+static INT ModuloValue(INT input, INT bufferlength)
+{
+ if ( input > (bufferlength - 1) ) {
+ return (input - bufferlength);
+ }
+ if ( input < 0 ) {
+ return (input + bufferlength);
+ }
+ return input;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ description: This function clears a bit from current bitfield and
+ switches off the statemachine.
+
+ A bit is cleared in two cases:
+ a) a codeword is decoded, then a bit is cleared in codeword bitfield
+ b) a segment is decoded empty, then a bit is cleared in segment bitfield
+-------------------------------------------------------------------------------------------- */
+static void ClearBitFromBitfield(STATEFUNC *ptrState,
+ UINT offset,
+ UINT *pBitfield)
+{
+ UINT numBitfieldWord;
+ UINT numBitfieldBit;
+
+ /* get both values needed for clearing the bit */
+ numBitfieldWord = offset >> THIRTYTWO_LOG_DIV_TWO_LOG; /* int = wordNr */
+ numBitfieldBit = offset - (numBitfieldWord << THIRTYTWO_LOG_DIV_TWO_LOG); /* fract = bitNr */
+
+ /* clear a bit in bitfield */
+ pBitfield[numBitfieldWord] = pBitfield[numBitfieldWord] & ~(1 << (NUMBER_OF_BIT_IN_WORD-1 - numBitfieldBit));
+
+ /* switch off state machine because codeword is decoded and/or because segment is empty */
+ *ptrState = NULL;
+}
+
+
+
+/* =========================================================================================
+ the states of the statemachine
+ ========================================================================================= */
+
+
+/*---------------------------------------------------------------------------------------------
+ description: Decodes the body of a codeword. This State is used for codebooks 1,2,5 and 6.
+ No sign bits are decoded, because the table of the quantized spectral values
+ has got a valid sign at the quantized spectral lines.
+-----------------------------------------------------------------------------------------------
+ output: Two or four quantizes spectral values written at position where pResultPointr
+ points to
+-----------------------------------------------------------------------------------------------
+ return: 0
+-------------------------------------------------------------------------------------------- */
+UINT Hcr_State_BODY_ONLY(HANDLE_FDK_BITSTREAM bs, void *ptr)
+{
+ H_HCR_INFO pHcr = (H_HCR_INFO)ptr;
+ UINT *pSegmentBitfield;
+ UINT *pCodewordBitfield;
+ UINT segmentOffset;
+ FIXP_DBL *pResultBase;
+ UINT *iNode;
+ USHORT *iResultPointer;
+ UINT codewordOffset;
+ UINT branchNode;
+ UINT branchValue;
+ UINT iQSC;
+ UINT treeNode;
+ UCHAR carryBit;
+ USHORT *pLeftStartOfSegment;
+ USHORT *pRightStartOfSegment;
+ SCHAR *pRemainingBitsInSegment;
+ UCHAR readDirection;
+ UCHAR *pCodebook;
+ UCHAR dimCntr;
+ const UINT *pCurrentTree;
+ const UCHAR *pCbDimension;
+ const SCHAR *pQuantVal;
+ const SCHAR *pQuantValBase;
+
+ pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
+ pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment;
+ pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment;
+ readDirection = pHcr->segmentInfo.readDirection;
+ pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield;
+ pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield;
+ segmentOffset = pHcr->segmentInfo.segmentOffset;
+
+ pCodebook = pHcr->nonPcwSideinfo.pCodebook;
+ iNode = pHcr->nonPcwSideinfo.iNode;
+ pResultBase = pHcr->nonPcwSideinfo.pResultBase;
+ iResultPointer = pHcr->nonPcwSideinfo.iResultPointer;
+ codewordOffset = pHcr->nonPcwSideinfo.codewordOffset;
+
+ pCbDimension = pHcr->tableInfo.pCbDimension;
+
+ treeNode = iNode[codewordOffset];
+ pCurrentTree = aHuffTable[pCodebook[codewordOffset]];
+
+
+ for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) {
+
+ carryBit = HcrGetABitFromBitstream( bs,
+ &pLeftStartOfSegment[segmentOffset],
+ &pRightStartOfSegment[segmentOffset],
+ readDirection);
+
+ CarryBitToBranchValue(carryBit, /* make a step in decoding tree */
+ treeNode,
+ &branchValue,
+ &branchNode);
+
+ /* if end of branch reached write out lines and count bits needed for sign, otherwise store node in codeword sideinfo */
+ if ((branchNode & TEST_BIT_10) == TEST_BIT_10) { /* test bit 10 ; ==> body is complete */
+ pQuantValBase = aQuantTable[pCodebook[codewordOffset]]; /* get base address of quantized values belonging to current codebook */
+ pQuantVal = pQuantValBase + branchValue; /* set pointer to first valid line [of 2 or 4 quantized values] */
+
+ iQSC = iResultPointer[codewordOffset]; /* get position of first line for writing out result */
+
+ for ( dimCntr = pCbDimension[pCodebook[codewordOffset]]; dimCntr != 0; dimCntr-- ) {
+ pResultBase[iQSC++] = (FIXP_DBL)*pQuantVal++; /* write out 2 or 4 lines into spectrum; no Sign bits available in this state */
+ }
+
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */
+ pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */
+ break; /* end of branch in tree reached i.e. a whole nonPCW-Body is decoded */
+ }
+ else { /* body is not decoded completely: */
+ treeNode = *(pCurrentTree + branchValue); /* update treeNode for further step in decoding tree */
+ }
+ }
+ iNode[codewordOffset] = treeNode; /* store updated treeNode because maybe decoding of codeword body not finished yet */
+
+ if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */
+
+#if STATE_MACHINE_ERROR_CHECK
+ if ( pRemainingBitsInSegment[segmentOffset] < 0 ) {
+ pHcr->decInOut.errorLog |= STATE_ERROR_BODY_ONLY;
+ return BODY_ONLY;
+ }
+#endif
+ }
+
+ return STOP_THIS_STATE;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ description: Decodes the codeword body, writes out result and counts the number of quantized
+ spectral values, which are different form zero. For those values sign bits are
+ needed.
+
+ If sign bit counter cntSign is different from zero, switch to next state to
+ decode sign Bits there.
+ If sign bit counter cntSign is zero, no sign bits are needed and codeword is
+ decoded.
+-----------------------------------------------------------------------------------------------
+ output: Two or four written quantizes spectral values written at position where
+ pResultPointr points to. The signs of those lines may be wrong. If the signs
+ [on just one signle sign] is wrong, the next state will correct it.
+-----------------------------------------------------------------------------------------------
+ return: 0
+-------------------------------------------------------------------------------------------- */
+UINT Hcr_State_BODY_SIGN__BODY(HANDLE_FDK_BITSTREAM bs, void *ptr)
+{
+ H_HCR_INFO pHcr = (H_HCR_INFO)ptr;
+ SCHAR *pRemainingBitsInSegment;
+ USHORT *pLeftStartOfSegment;
+ USHORT *pRightStartOfSegment;
+ UCHAR readDirection;
+ UINT *pSegmentBitfield;
+ UINT *pCodewordBitfield;
+ UINT segmentOffset;
+
+ UCHAR *pCodebook;
+ UINT *iNode;
+ UCHAR *pCntSign;
+ FIXP_DBL *pResultBase;
+ USHORT *iResultPointer;
+ UINT codewordOffset;
+
+ UINT iQSC;
+ UINT cntSign;
+ UCHAR dimCntr;
+ UCHAR carryBit;
+ SCHAR *pSta;
+ UINT treeNode;
+ UINT branchValue;
+ UINT branchNode;
+ const UCHAR *pCbDimension;
+ const UINT *pCurrentTree;
+ const SCHAR *pQuantValBase;
+ const SCHAR *pQuantVal;
+
+ pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
+ pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment;
+ pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment;
+ readDirection = pHcr->segmentInfo.readDirection;
+ pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield;
+ pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield;
+ segmentOffset = pHcr->segmentInfo.segmentOffset;
+
+ pCodebook = pHcr->nonPcwSideinfo.pCodebook;
+ iNode = pHcr->nonPcwSideinfo.iNode;
+ pCntSign = pHcr->nonPcwSideinfo.pCntSign;
+ pResultBase = pHcr->nonPcwSideinfo.pResultBase;
+ iResultPointer = pHcr->nonPcwSideinfo.iResultPointer;
+ codewordOffset = pHcr->nonPcwSideinfo.codewordOffset;
+ pSta = pHcr->nonPcwSideinfo.pSta;
+
+ pCbDimension = pHcr->tableInfo.pCbDimension;
+
+ treeNode = iNode[codewordOffset];
+ pCurrentTree = aHuffTable[pCodebook[codewordOffset]];
+
+
+ for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) {
+
+ carryBit = HcrGetABitFromBitstream( bs,
+ &pLeftStartOfSegment[segmentOffset],
+ &pRightStartOfSegment[segmentOffset],
+ readDirection);
+
+ CarryBitToBranchValue(carryBit, /* make a step in decoding tree */
+ treeNode,
+ &branchValue,
+ &branchNode);
+
+ /* if end of branch reached write out lines and count bits needed for sign, otherwise store node in codeword sideinfo */
+ if ((branchNode & TEST_BIT_10) == TEST_BIT_10) { /* test bit 10 ; if set body complete */
+ /* body completely decoded; branchValue is valid, set pQuantVal to first (of two or four) quantized spectral coefficients */
+ pQuantValBase = aQuantTable[pCodebook[codewordOffset]]; /* get base address of quantized values belonging to current codebook */
+ pQuantVal = pQuantValBase + branchValue; /* set pointer to first valid line [of 2 or 4 quantized values] */
+
+ iQSC = iResultPointer[codewordOffset]; /* get position of first line for writing result */
+
+ /* codeword decoding result is written out here: Write out 2 or 4 quantized spectral values with probably */
+ /* wrong sign and count number of values which are different from zero for sign bit decoding [which happens in next state] */
+ cntSign = 0;
+ for ( dimCntr = pCbDimension[pCodebook[codewordOffset]]; dimCntr != 0; dimCntr-- ) {
+ pResultBase[iQSC++] = (FIXP_DBL)*pQuantVal; /* write quant. spec. coef. into spectrum */
+ if ( *pQuantVal++ != 0 ) {
+ cntSign += 1;
+ }
+ }
+
+ if ( cntSign == 0 ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */
+ }
+ else {
+ pCntSign[codewordOffset] = cntSign; /* write sign count result into codewordsideinfo of current codeword */
+ pSta[codewordOffset] = BODY_SIGN__SIGN; /* change state */
+ pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; /* get state from separate array of cw-sideinfo */
+ }
+ pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */
+ break; /* end of branch in tree reached i.e. a whole nonPCW-Body is decoded */
+ }
+ else {/* body is not decoded completely: */
+ treeNode = *(pCurrentTree + branchValue); /* update treeNode for further step in decoding tree */
+ }
+ }
+ iNode[codewordOffset] = treeNode; /* store updated treeNode because maybe decoding of codeword body not finished yet */
+
+ if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */
+
+#if STATE_MACHINE_ERROR_CHECK
+ if ( pRemainingBitsInSegment[segmentOffset] < 0 ) {
+ pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN__BODY;
+ return BODY_SIGN__BODY;
+ }
+#endif
+ }
+
+ return STOP_THIS_STATE;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ description: This state decodes the sign bits belonging to a codeword. The state is called
+ as often in different "trials" until pCntSgn[codewordOffset] is zero.
+-----------------------------------------------------------------------------------------------
+ output: The two or four quantizes spectral values (written in previous state) have
+ now the correct sign.
+-----------------------------------------------------------------------------------------------
+ return: 0
+-------------------------------------------------------------------------------------------- */
+UINT Hcr_State_BODY_SIGN__SIGN(HANDLE_FDK_BITSTREAM bs, void *ptr)
+{
+ H_HCR_INFO pHcr = (H_HCR_INFO)ptr;
+ SCHAR *pRemainingBitsInSegment;
+ USHORT *pLeftStartOfSegment;
+ USHORT *pRightStartOfSegment;
+ UCHAR readDirection;
+ UINT *pSegmentBitfield;
+ UINT *pCodewordBitfield;
+ UINT segmentOffset;
+
+ UCHAR *pCntSign;
+ FIXP_DBL *pResultBase;
+ USHORT *iResultPointer;
+ UINT codewordOffset;
+ UCHAR carryBit;
+ UINT iQSC;
+ UCHAR cntSign;
+
+ pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
+ pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment;
+ pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment;
+ readDirection = pHcr->segmentInfo.readDirection;
+ pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield;
+ pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield;
+ segmentOffset = pHcr->segmentInfo.segmentOffset;
+
+ pCntSign = pHcr->nonPcwSideinfo.pCntSign;
+ pResultBase = pHcr->nonPcwSideinfo.pResultBase;
+ iResultPointer = pHcr->nonPcwSideinfo.iResultPointer;
+ codewordOffset = pHcr->nonPcwSideinfo.codewordOffset;
+ iQSC = iResultPointer[codewordOffset];
+ cntSign = pCntSign[codewordOffset];
+
+
+
+ /* loop for sign bit decoding */
+ for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) {
+
+ carryBit = HcrGetABitFromBitstream( bs,
+ &pLeftStartOfSegment[segmentOffset],
+ &pRightStartOfSegment[segmentOffset],
+ readDirection);
+ cntSign -= 1; /* decrement sign counter because one sign bit has been read */
+
+ /* search for a line (which was decoded in previous state) which is not zero. [This value will get a sign] */
+ while ( pResultBase[iQSC] == (FIXP_DBL)0 ) {
+ iQSC++; /* points to current value different from zero */
+ }
+
+ /* put sign together with line; if carryBit is zero, the sign is ok already; no write operation necessary in this case */
+ if ( carryBit != 0 ) {
+ pResultBase[iQSC] = -pResultBase[iQSC]; /* carryBit = 1 --> minus */
+ }
+
+ iQSC++; /* update pointer to next (maybe valid) value */
+
+ if ( cntSign == 0 ) { /* if (cntSign==0) ==> set state CODEWORD_DECODED */
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */
+ pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */
+ break; /* whole nonPCW-Body and according sign bits are decoded */
+ }
+ }
+ pCntSign[codewordOffset] = cntSign;
+ iResultPointer[codewordOffset] = iQSC; /* store updated pResultPointer */
+
+ if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */
+
+#if STATE_MACHINE_ERROR_CHECK
+ if ( pRemainingBitsInSegment[segmentOffset] < 0 ) {
+ pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN__SIGN;
+ return BODY_SIGN__SIGN;
+ }
+#endif
+ }
+
+ return STOP_THIS_STATE;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ description: Decodes the codeword body in case of codebook is 11. Writes out resulting
+ two or four lines [with probably wrong sign] and counts the number of
+ lines, which are different form zero. This information is needed in next
+ state where sign bits will be decoded, if necessary.
+ If sign bit counter cntSign is zero, no sign bits are needed and codeword is
+ decoded completely.
+-----------------------------------------------------------------------------------------------
+ output: Two lines (quantizes spectral coefficients) which are probably wrong. The
+ sign may be wrong and if one or two values is/are 16, the following states
+ will decode the escape sequence to correct the values which are wirtten here.
+-----------------------------------------------------------------------------------------------
+ return: 0
+-------------------------------------------------------------------------------------------- */
+UINT Hcr_State_BODY_SIGN_ESC__BODY(HANDLE_FDK_BITSTREAM bs, void *ptr)
+{
+ H_HCR_INFO pHcr = (H_HCR_INFO)ptr;
+ SCHAR *pRemainingBitsInSegment;
+ USHORT *pLeftStartOfSegment;
+ USHORT *pRightStartOfSegment;
+ UCHAR readDirection;
+ UINT *pSegmentBitfield;
+ UINT *pCodewordBitfield;
+ UINT segmentOffset;
+
+ UINT *iNode;
+ UCHAR *pCntSign;
+ FIXP_DBL *pResultBase;
+ USHORT *iResultPointer;
+ UINT codewordOffset;
+
+ UCHAR carryBit;
+ UINT iQSC;
+ UINT cntSign;
+ UINT dimCntr;
+ UINT treeNode;
+ SCHAR *pSta;
+ UINT branchNode;
+ UINT branchValue;
+ const UINT *pCurrentTree;
+ const SCHAR *pQuantValBase;
+ const SCHAR *pQuantVal;
+
+ pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
+ pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment;
+ pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment;
+ readDirection = pHcr->segmentInfo.readDirection;
+ pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield;
+ pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield;
+ segmentOffset = pHcr->segmentInfo.segmentOffset;
+
+ iNode = pHcr->nonPcwSideinfo.iNode;
+ pCntSign = pHcr->nonPcwSideinfo.pCntSign;
+ pResultBase = pHcr->nonPcwSideinfo.pResultBase;
+ iResultPointer = pHcr->nonPcwSideinfo.iResultPointer;
+ codewordOffset = pHcr->nonPcwSideinfo.codewordOffset;
+ pSta = pHcr->nonPcwSideinfo.pSta;
+
+ treeNode = iNode[codewordOffset];
+ pCurrentTree = aHuffTable[ESCAPE_CODEBOOK];
+
+
+ for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) {
+
+ carryBit = HcrGetABitFromBitstream( bs,
+ &pLeftStartOfSegment[segmentOffset],
+ &pRightStartOfSegment[segmentOffset],
+ readDirection);
+
+ /* make a step in tree */
+ CarryBitToBranchValue(carryBit,
+ treeNode,
+ &branchValue,
+ &branchNode);
+
+ /* if end of branch reached write out lines and count bits needed for sign, otherwise store node in codeword sideinfo */
+ if ((branchNode & TEST_BIT_10) == TEST_BIT_10) { /* test bit 10 ; if set body complete */
+
+ /* body completely decoded; branchValue is valid */
+ /* set pQuantVol to first (of two or four) quantized spectral coefficients */
+ pQuantValBase = aQuantTable[ESCAPE_CODEBOOK]; /* get base address of quantized values belonging to current codebook */
+ pQuantVal = pQuantValBase + branchValue; /* set pointer to first valid line [of 2 or 4 quantized values] */
+
+ /* make backup from original resultPointer in node storage for state BODY_SIGN_ESC__SIGN */
+ iNode[codewordOffset] = iResultPointer[codewordOffset];
+
+ /* get position of first line for writing result */
+ iQSC = iResultPointer[codewordOffset];
+
+ /* codeword decoding result is written out here: Write out 2 or 4 quantized spectral values with probably */
+ /* wrong sign and count number of values which are different from zero for sign bit decoding [which happens in next state] */
+ cntSign = 0;
+
+ for ( dimCntr = DIMENSION_OF_ESCAPE_CODEBOOK; dimCntr != 0; dimCntr-- ) {
+ pResultBase[iQSC++] = (FIXP_DBL)*pQuantVal; /* write quant. spec. coef. into spectrum */
+ if ( *pQuantVal++ != 0 ) {
+ cntSign += 1;
+ }
+ }
+
+ if ( cntSign == 0 ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */
+ /* codeword decoded */
+ }
+ else {
+ /* write sign count result into codewordsideinfo of current codeword */
+ pCntSign[codewordOffset] = cntSign;
+ pSta[codewordOffset] = BODY_SIGN_ESC__SIGN; /* change state */
+ pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; /* get state from separate array of cw-sideinfo */
+ }
+ pRemainingBitsInSegment[segmentOffset] -= 1; /* the last reinitialzation of for loop counter (see above) is done here */
+ break; /* end of branch in tree reached i.e. a whole nonPCW-Body is decoded */
+ }
+ else { /* body is not decoded completely: */
+ /* update treeNode for further step in decoding tree and store updated treeNode because maybe no more bits left in segment */
+ treeNode = *(pCurrentTree + branchValue);
+ iNode[codewordOffset] = treeNode;
+ }
+ }
+
+ if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */
+
+#if STATE_MACHINE_ERROR_CHECK
+ if ( pRemainingBitsInSegment[segmentOffset] < 0 ) {
+ pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN_ESC__BODY;
+ return BODY_SIGN_ESC__BODY;
+ }
+#endif
+ }
+
+ return STOP_THIS_STATE;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ description: This state decodes the sign bits, if a codeword of codebook 11 needs some.
+ A flag named 'flagB' in codeword sideinfo is set, if the second line of
+ quantized spectral values is 16. The 'flagB' is used in case of decoding
+ of a escape sequence is necessary as far as the second line is concerned.
+
+ If only the first line needs an escape sequence, the flagB is cleared.
+ If only the second line needs an escape sequence, the flagB is not used.
+
+ For storing sideinfo in case of escape sequence decoding one single word
+ can be used for both escape sequences because they are decoded not at the
+ same time:
+
+
+ bit 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0
+ ===== == == =========== =========== ===================================
+ ^ ^ ^ ^ ^ ^
+ | | | | | |
+ res. flagA flagB escapePrefixUp escapePrefixDown escapeWord
+
+-----------------------------------------------------------------------------------------------
+ output: Two lines with correct sign. If one or two values is/are 16, the lines are
+ not valid, otherwise they are.
+-----------------------------------------------------------------------------------------------
+ return: 0
+-------------------------------------------------------------------------------------------- */
+UINT Hcr_State_BODY_SIGN_ESC__SIGN(HANDLE_FDK_BITSTREAM bs, void *ptr)
+{
+ H_HCR_INFO pHcr = (H_HCR_INFO)ptr;
+ SCHAR *pRemainingBitsInSegment;
+ USHORT *pLeftStartOfSegment;
+ USHORT *pRightStartOfSegment;
+ UCHAR readDirection;
+ UINT *pSegmentBitfield;
+ UINT *pCodewordBitfield;
+ UINT segmentOffset;
+
+ UINT *iNode;
+ UCHAR *pCntSign;
+ FIXP_DBL *pResultBase;
+ USHORT *iResultPointer;
+ UINT *pEscapeSequenceInfo;
+ UINT codewordOffset;
+
+ UINT iQSC;
+ UCHAR cntSign;
+ UINT flagA;
+ UINT flagB;
+ UINT flags;
+ UCHAR carryBit;
+ SCHAR *pSta;
+
+ pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
+ pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment;
+ pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment;
+ readDirection = pHcr->segmentInfo.readDirection;
+ pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield;
+ pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield;
+ segmentOffset = pHcr->segmentInfo.segmentOffset;
+
+ iNode = pHcr->nonPcwSideinfo.iNode;
+ pCntSign = pHcr->nonPcwSideinfo.pCntSign;
+ pResultBase = pHcr->nonPcwSideinfo.pResultBase;
+ iResultPointer = pHcr->nonPcwSideinfo.iResultPointer;
+ pEscapeSequenceInfo = pHcr->nonPcwSideinfo.pEscapeSequenceInfo;
+ codewordOffset = pHcr->nonPcwSideinfo.codewordOffset;
+ pSta = pHcr->nonPcwSideinfo.pSta;
+
+ iQSC = iResultPointer[codewordOffset];
+ cntSign = pCntSign[codewordOffset];
+
+
+ /* loop for sign bit decoding */
+ for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) {
+
+ carryBit = HcrGetABitFromBitstream( bs,
+ &pLeftStartOfSegment[segmentOffset],
+ &pRightStartOfSegment[segmentOffset],
+ readDirection);
+
+ /* decrement sign counter because one sign bit has been read */
+ cntSign -= 1;
+ pCntSign[codewordOffset] = cntSign;
+
+ /* get a quantized spectral value (which was decoded in previous state) which is not zero. [This value will get a sign] */
+ while ( pResultBase[iQSC] == (FIXP_DBL)0 ) {
+ iQSC++;
+ }
+ iResultPointer[codewordOffset] = iQSC;
+
+ /* put negative sign together with quantized spectral value; if carryBit is zero, the sign is ok already; no write operation necessary in this case */
+ if ( carryBit != 0 ) {
+ pResultBase[iQSC] = - pResultBase[iQSC]; /* carryBit = 1 --> minus */
+ }
+ iQSC++; /* update index to next (maybe valid) value */
+ iResultPointer[codewordOffset] = iQSC;
+
+ if ( cntSign == 0 ) {
+ /* all sign bits are decoded now */
+ pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */
+
+ /* check decoded values if codeword is decoded: Check if one or two escape sequences 16 follow */
+
+ /* step 0 */
+ /* restore pointer to first decoded quantized value [ = original pResultPointr] from index iNode prepared in State_BODY_SIGN_ESC__BODY */
+ iQSC = iNode[codewordOffset];
+
+ /* step 1 */
+ /* test first value if escape sequence follows */
+ flagA = 0; /* for first possible escape sequence */
+ if ( fixp_abs(pResultBase[iQSC++]) == (FIXP_DBL)ESCAPE_VALUE ) {
+ flagA = 1;
+ }
+
+ /* step 2 */
+ /* test second value if escape sequence follows */
+ flagB = 0; /* for second possible escape sequence */
+ if ( fixp_abs(pResultBase[iQSC]) == (FIXP_DBL)ESCAPE_VALUE ) {
+ flagB = 1;
+ }
+
+
+ /* step 3 */
+ /* evaluate flag result and go on if necessary */
+ if ( !flagA && !flagB ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */
+ }
+ else {
+ /* at least one of two lines is 16 */
+ /* store both flags at correct positions in non PCW codeword sideinfo pEscapeSequenceInfo[codewordOffset] */
+ flags = 0;
+ flags = flagA << POSITION_OF_FLAG_A;
+ flags |= (flagB << POSITION_OF_FLAG_B);
+ pEscapeSequenceInfo[codewordOffset] = flags;
+
+
+ /* set next state */
+ pSta[codewordOffset] = BODY_SIGN_ESC__ESC_PREFIX;
+ pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; /* get state from separate array of cw-sideinfo */
+
+ /* set result pointer to the first line of the two decoded lines */
+ iResultPointer[codewordOffset] = iNode[codewordOffset];
+
+ if ( !flagA && flagB ) {
+ /* update pResultPointr ==> state Stat_BODY_SIGN_ESC__ESC_WORD writes to correct position. Second value is the one and only escape value */
+ iQSC = iResultPointer[codewordOffset];
+ iQSC++;
+ iResultPointer[codewordOffset] = iQSC;
+ }
+
+ } /* at least one of two lines is 16 */
+ break; /* nonPCW-Body at cb 11 and according sign bits are decoded */
+
+ } /* if ( cntSign == 0 ) */
+ } /* loop over remaining Bits in segment */
+
+ if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */
+
+#if STATE_MACHINE_ERROR_CHECK
+ if ( pRemainingBitsInSegment[segmentOffset] < 0 ) {
+ pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN_ESC__SIGN;
+ return BODY_SIGN_ESC__SIGN;
+ }
+#endif
+
+ }
+ return STOP_THIS_STATE;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ description: Decode escape prefix of first or second escape sequence. The escape prefix
+ consists of ones. The following zero is also decoded here.
+-----------------------------------------------------------------------------------------------
+ output: If the single separator-zero which follows the escape-prefix-ones is not yet decoded:
+ The value 'escapePrefixUp' in word pEscapeSequenceInfo[codewordOffset] is updated.
+
+ If the single separator-zero which follows the escape-prefix-ones is decoded:
+ Two updated values 'escapePrefixUp' and 'escapePrefixDown' in word
+ pEscapeSequenceInfo[codewordOffset]. This State is finished. Switch to next state.
+-----------------------------------------------------------------------------------------------
+ return: 0
+-------------------------------------------------------------------------------------------- */
+UINT Hcr_State_BODY_SIGN_ESC__ESC_PREFIX(HANDLE_FDK_BITSTREAM bs, void *ptr)
+{
+ H_HCR_INFO pHcr = (H_HCR_INFO)ptr;
+ SCHAR *pRemainingBitsInSegment;
+ USHORT *pLeftStartOfSegment;
+ USHORT *pRightStartOfSegment;
+ UCHAR readDirection;
+ UINT *pSegmentBitfield;
+ UINT segmentOffset;
+ UINT *pEscapeSequenceInfo;
+ UINT codewordOffset;
+ UCHAR carryBit;
+ UINT escapePrefixUp;
+ SCHAR *pSta;
+
+ pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
+ pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment;
+ pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment;
+ readDirection = pHcr->segmentInfo.readDirection;
+ pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield;
+ segmentOffset = pHcr->segmentInfo.segmentOffset;
+ pEscapeSequenceInfo = pHcr->nonPcwSideinfo.pEscapeSequenceInfo;
+ codewordOffset = pHcr->nonPcwSideinfo.codewordOffset;
+ pSta = pHcr->nonPcwSideinfo.pSta;
+
+ escapePrefixUp = (pEscapeSequenceInfo[codewordOffset] & MASK_ESCAPE_PREFIX_UP) >> LSB_ESCAPE_PREFIX_UP;
+
+
+ /* decode escape prefix */
+ for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) {
+
+ carryBit = HcrGetABitFromBitstream( bs,
+ &pLeftStartOfSegment[segmentOffset],
+ &pRightStartOfSegment[segmentOffset],
+ readDirection);
+
+ /* count ones and store sum in escapePrefixUp */
+ if ( carryBit == 1 ) {
+ escapePrefixUp += 1; /* update conter for ones */
+
+ /* store updated counter in sideinfo of current codeword */
+ pEscapeSequenceInfo[codewordOffset] &= ~MASK_ESCAPE_PREFIX_UP; /* delete old escapePrefixUp */
+ escapePrefixUp <<= LSB_ESCAPE_PREFIX_UP; /* shift to correct position */
+ pEscapeSequenceInfo[codewordOffset] |= escapePrefixUp; /* insert new escapePrefixUp */
+ escapePrefixUp >>= LSB_ESCAPE_PREFIX_UP; /* shift back down */
+ }
+ else { /* separator [zero] reached */
+ pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */
+ escapePrefixUp += 4; /* if escape_separator '0' appears, add 4 and ==> break */
+
+ /* store escapePrefixUp in pEscapeSequenceInfo[codewordOffset] at bit position escapePrefixUp */
+ pEscapeSequenceInfo[codewordOffset] &= ~MASK_ESCAPE_PREFIX_UP; /* delete old escapePrefixUp */
+ escapePrefixUp <<= LSB_ESCAPE_PREFIX_UP; /* shift to correct position */
+ pEscapeSequenceInfo[codewordOffset] |= escapePrefixUp; /* insert new escapePrefixUp */
+ escapePrefixUp >>= LSB_ESCAPE_PREFIX_UP; /* shift back down */
+
+ /* store escapePrefixUp in pEscapeSequenceInfo[codewordOffset] at bit position escapePrefixDown */
+ pEscapeSequenceInfo[codewordOffset] &= ~MASK_ESCAPE_PREFIX_DOWN; /* delete old escapePrefixDown */
+ escapePrefixUp <<= LSB_ESCAPE_PREFIX_DOWN; /* shift to correct position */
+ pEscapeSequenceInfo[codewordOffset] |= escapePrefixUp; /* insert new escapePrefixDown */
+ escapePrefixUp >>= LSB_ESCAPE_PREFIX_DOWN; /* shift back down */
+
+ pSta[codewordOffset] = BODY_SIGN_ESC__ESC_WORD; /* set next state */
+ pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; /* get state from separate array of cw-sideinfo */
+ break;
+ }
+ }
+
+ if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */
+
+#if STATE_MACHINE_ERROR_CHECK
+ if ( pRemainingBitsInSegment[segmentOffset] < 0 ) {
+ pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN_ESC__ESC_PREFIX;
+ return BODY_SIGN_ESC__ESC_PREFIX;
+ }
+#endif
+ }
+
+ return STOP_THIS_STATE;
+}
+
+
+/*---------------------------------------------------------------------------------------------
+ description: Decode escapeWord of escape sequence. If the escape sequence is decoded
+ completely, assemble quantized-spectral-escape-coefficient and replace the
+ previous decoded 16 by the new value.
+ Test flagB. If flagB is set, the second escape sequence must be decoded. If
+ flagB is not set, the codeword is decoded and the state machine is switched
+ off.
+-----------------------------------------------------------------------------------------------
+ output: Two lines with valid sign. At least one of both lines has got the correct
+ value.
+-----------------------------------------------------------------------------------------------
+ return: 0
+-------------------------------------------------------------------------------------------- */
+UINT Hcr_State_BODY_SIGN_ESC__ESC_WORD(HANDLE_FDK_BITSTREAM bs, void *ptr)
+{
+ H_HCR_INFO pHcr = (H_HCR_INFO)ptr;
+ SCHAR *pRemainingBitsInSegment;
+ USHORT *pLeftStartOfSegment;
+ USHORT *pRightStartOfSegment;
+ UCHAR readDirection;
+ UINT *pSegmentBitfield;
+ UINT *pCodewordBitfield;
+ UINT segmentOffset;
+
+ FIXP_DBL *pResultBase;
+ USHORT *iResultPointer;
+ UINT *pEscapeSequenceInfo;
+ UINT codewordOffset;
+
+ UINT escapeWord;
+ UINT escapePrefixDown;
+ UINT escapePrefixUp;
+ UCHAR carryBit;
+ UINT iQSC;
+ INT sign;
+ UINT flagA;
+ UINT flagB;
+ SCHAR *pSta;
+
+ pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
+ pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment;
+ pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment;
+ readDirection = pHcr->segmentInfo.readDirection;
+ pSegmentBitfield = pHcr->segmentInfo.pSegmentBitfield;
+ pCodewordBitfield = pHcr->segmentInfo.pCodewordBitfield;
+ segmentOffset = pHcr->segmentInfo.segmentOffset;
+
+ pResultBase = pHcr->nonPcwSideinfo.pResultBase;
+ iResultPointer = pHcr->nonPcwSideinfo.iResultPointer;
+ pEscapeSequenceInfo = pHcr->nonPcwSideinfo.pEscapeSequenceInfo;
+ codewordOffset = pHcr->nonPcwSideinfo.codewordOffset;
+ pSta = pHcr->nonPcwSideinfo.pSta;
+
+ escapeWord = pEscapeSequenceInfo[codewordOffset] & MASK_ESCAPE_WORD;
+ escapePrefixDown = (pEscapeSequenceInfo[codewordOffset] & MASK_ESCAPE_PREFIX_DOWN) >> LSB_ESCAPE_PREFIX_DOWN;
+
+
+ /* decode escape word */
+ for ( ; pRemainingBitsInSegment[segmentOffset] > 0 ; pRemainingBitsInSegment[segmentOffset] -= 1 ) {
+
+ carryBit = HcrGetABitFromBitstream( bs,
+ &pLeftStartOfSegment[segmentOffset],
+ &pRightStartOfSegment[segmentOffset],
+ readDirection);
+
+ /* build escape word */
+ escapeWord <<= 1; /* left shift previous decoded part of escapeWord by on bit */
+ escapeWord = escapeWord | carryBit; /* assemble escape word by bitwise or */
+
+ /* decrement counter for length of escape word because one more bit was decoded */
+ escapePrefixDown -= 1;
+
+ /* store updated escapePrefixDown */
+ pEscapeSequenceInfo[codewordOffset] &= ~MASK_ESCAPE_PREFIX_DOWN; /* delete old escapePrefixDown */
+ escapePrefixDown <<= LSB_ESCAPE_PREFIX_DOWN; /* shift to correct position */
+ pEscapeSequenceInfo[codewordOffset] |= escapePrefixDown; /* insert new escapePrefixDown */
+ escapePrefixDown >>= LSB_ESCAPE_PREFIX_DOWN; /* shift back */
+
+
+ /* store updated escapeWord */
+ pEscapeSequenceInfo[codewordOffset] &= ~MASK_ESCAPE_WORD; /* delete old escapeWord */
+ pEscapeSequenceInfo[codewordOffset] |= escapeWord; /* insert new escapeWord */
+
+
+ if ( escapePrefixDown == 0 ) {
+ pRemainingBitsInSegment[segmentOffset] -= 1; /* last reinitialzation of for loop counter (see above) is done here */
+
+ /* escape sequence decoded. Assemble escape-line and replace original line */
+
+ /* step 0 */
+ /* derive sign */
+ iQSC = iResultPointer[codewordOffset];
+ sign = (pResultBase[iQSC] >= (FIXP_DBL)0) ? 1 : -1; /* get sign of escape value 16 */
+
+ /* step 1 */
+ /* get escapePrefixUp */
+ escapePrefixUp = (pEscapeSequenceInfo[codewordOffset] & MASK_ESCAPE_PREFIX_UP) >> LSB_ESCAPE_PREFIX_UP;
+
+ /* step 2 */
+ /* calculate escape value */
+ pResultBase[iQSC] = (FIXP_DBL)(sign * (((INT) 1 << escapePrefixUp) + escapeWord));
+
+ /* get both flags from sideinfo (flags are not shifted to the lsb-position) */
+ flagA = pEscapeSequenceInfo[codewordOffset] & MASK_FLAG_A;
+ flagB = pEscapeSequenceInfo[codewordOffset] & MASK_FLAG_B;
+
+ /* step 3 */
+ /* clear the whole escape sideinfo word */
+ pEscapeSequenceInfo[codewordOffset] = 0;
+
+ /* change state in dependence of flag flagB */
+ if ( flagA != 0 ) {
+ /* first escape sequence decoded; previous decoded 16 has been replaced by valid line */
+
+ /* clear flagA in sideinfo word because this escape sequence has already beed decoded */
+ pEscapeSequenceInfo[codewordOffset] &= ~MASK_FLAG_A;
+
+ if ( flagB == 0 ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */
+ }
+ else {
+ /* updated pointer to next and last 16 */
+ iQSC++;
+ iResultPointer[codewordOffset] = iQSC;
+
+ /* change state */
+ pSta[codewordOffset] = BODY_SIGN_ESC__ESC_PREFIX;
+ pHcr->nonPcwSideinfo.pState = aStateConstant2State[pSta[codewordOffset]]; /* get state from separate array of cw-sideinfo */
+ }
+ }
+ else {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pCodewordBitfield); /* clear a bit in bitfield and switch off statemachine */
+ }
+ break;
+ }
+ }
+
+ if ( pRemainingBitsInSegment[segmentOffset] <= 0 ) {
+ ClearBitFromBitfield(&(pHcr->nonPcwSideinfo.pState),
+ segmentOffset,
+ pSegmentBitfield); /* clear a bit in bitfield and switch off statemachine */
+
+#if STATE_MACHINE_ERROR_CHECK
+ if ( pRemainingBitsInSegment[segmentOffset] < 0 ) {
+ pHcr->decInOut.errorLog |= STATE_ERROR_BODY_SIGN_ESC__ESC_WORD;
+ return BODY_SIGN_ESC__ESC_WORD;
+ }
+#endif
+ }
+
+ return STOP_THIS_STATE;
+}
+