fenix/fdk-aac
1
0
Fork 0
mirror of https://github.com/mstorsjo/fdk-aac.git synced 2025-01-31 07:55:22 +01:00
Code Issues Projects Releases Wiki Activity

Merge pi-qpr1-release PQ1A.181105.017.A1 to pi-platform-release

Browse Source 
Change-Id: If3ff263d4f628f2c6d4ad3c28d0571284ca1f56d
This commit is contained in:
Bill Yi 2018-11-28 18:34:17 -08:00
commit a342c8b68c
14 changed files with 118 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
libAACdec/src/aacdec_hcr.cpp
View File

@ -134,17 +134,18 @@ static void DeriveNumberOfExtendedSortedSectionsInSets(
USHORT *pNumExtendedSortedSectionsInSets, USHORT *pNumExtendedSortedSectionsInSets,
int numExtendedSortedSectionsInSetsIdx); int numExtendedSortedSectionsInSetsIdx);
static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, INT quantSpecCoef, static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
INT *pLeftStartOfSegment, INT quantSpecCoef, INT *pLeftStartOfSegment,
SCHAR *pRemainingBitsInSegment, SCHAR *pRemainingBitsInSegment,
int *pNumDecodedBits); int *pNumDecodedBits);
static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM bs, UINT codebookDim, static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
const SCHAR *pQuantVal, FIXP_DBL *pQuantSpecCoef, UINT codebookDim, const SCHAR *pQuantVal,
int *quantSpecCoefIdx, INT *pLeftStartOfSegment, FIXP_DBL *pQuantSpecCoef, int *quantSpecCoefIdx,
INT *pLeftStartOfSegment,
SCHAR *pRemainingBitsInSegment, int *pNumDecodedBits); SCHAR *pRemainingBitsInSegment, int *pNumDecodedBits);
static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM bs, static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
const UINT *pCurrentTree, const UINT *pCurrentTree,
const SCHAR *pQuantValBase, const SCHAR *pQuantValBase,
INT *pLeftStartOfSegment, INT *pLeftStartOfSegment,
@ -291,7 +292,7 @@ UINT HcrInit(H_HCR_INFO pHcr, CAacDecoderChannelInfo *pAacDecoderChannelInfo,
SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient); SPEC_LONG(pAacDecoderChannelInfo->pSpectralCoefficient);
FDKsyncCache(bs); FDKsyncCache(bs);
pHcr->decInOut.bitstreamIndex = FDKgetBitCnt(bs); pHcr->decInOut.bitstreamAnchor = (INT)FDKgetValidBits(bs);
if (!IsLongBlock(&pAacDecoderChannelInfo->icsInfo)) /* short block */ if (!IsLongBlock(&pAacDecoderChannelInfo->icsInfo)) /* short block */
{ {
@ -436,7 +437,7 @@ UINT HcrDecoder(H_HCR_INFO pHcr, CAacDecoderChannelInfo *pAacDecoderChannelInfo,
int pTmp5; int pTmp5;
INT bitCntOffst; INT bitCntOffst;
INT saveBitCnt = FDKgetBitCnt(bs); /* save bitstream position */ INT saveBitCnt = (INT)FDKgetValidBits(bs); /* save bitstream position */
HcrCalcNumCodeword(pHcr); HcrCalcNumCodeword(pHcr);
@ -487,7 +488,7 @@ UINT HcrDecoder(H_HCR_INFO pHcr, CAacDecoderChannelInfo *pAacDecoderChannelInfo,
pSamplingRateInfo); pSamplingRateInfo);
/* restore bitstream position */ /* restore bitstream position */
bitCntOffst = saveBitCnt - FDKgetBitCnt(bs); bitCntOffst = (INT)FDKgetValidBits(bs) - saveBitCnt;
if (bitCntOffst) { if (bitCntOffst) {
FDKpushBiDirectional(bs, bitCntOffst); FDKpushBiDirectional(bs, bitCntOffst);
} }
@ -815,7 +816,6 @@ static void HcrPrepareSegmentationGrid(H_HCR_INFO pHcr) {
INT *pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment; INT *pLeftStartOfSegment = pHcr->segmentInfo.pLeftStartOfSegment;
INT *pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment; INT *pRightStartOfSegment = pHcr->segmentInfo.pRightStartOfSegment;
SCHAR *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment; SCHAR *pRemainingBitsInSegment = pHcr->segmentInfo.pRemainingBitsInSegment;
INT bitstreamIndex = pHcr->decInOut.bitstreamIndex;
const UCHAR *pMaxCwLength = aMaxCwLen; const UCHAR *pMaxCwLength = aMaxCwLen;
for (i = numSortedSection; i != 0; i--) { for (i = numSortedSection; i != 0; i--) {
@ -825,7 +825,7 @@ static void HcrPrepareSegmentationGrid(H_HCR_INFO pHcr) {
for (j = *pNumSortedCodewordInSection; j != 0; j--) { for (j = *pNumSortedCodewordInSection; j != 0; j--) {
/* width allows a new segment */ /* width allows a new segment */
intermediateResult = bitstreamIndex + segmentStart; intermediateResult = segmentStart;
if ((segmentStart + segmentWidth) <= lengthOfReorderedSpectralData) { if ((segmentStart + segmentWidth) <= lengthOfReorderedSpectralData) {
/* store segment start, segment length and increment the number of /* store segment start, segment length and increment the number of
* segments */ * segments */
@ -841,12 +841,11 @@ static void HcrPrepareSegmentationGrid(H_HCR_INFO pHcr) {
pLeftStartOfSegment--; pLeftStartOfSegment--;
pRightStartOfSegment--; pRightStartOfSegment--;
pRemainingBitsInSegment--; pRemainingBitsInSegment--;
segmentStart = *pLeftStartOfSegment - bitstreamIndex; segmentStart = *pLeftStartOfSegment;
lastSegmentWidth = lengthOfReorderedSpectralData - segmentStart; lastSegmentWidth = lengthOfReorderedSpectralData - segmentStart;
*pRemainingBitsInSegment = lastSegmentWidth; *pRemainingBitsInSegment = lastSegmentWidth;
*pRightStartOfSegment = *pRightStartOfSegment = segmentStart + lastSegmentWidth - 1;
bitstreamIndex + segmentStart + lastSegmentWidth - 1;
endFlag = 1; endFlag = 1;
break; break;
} }
@ -1071,9 +1070,9 @@ static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr) {
numDecodedBits = 0; numDecodedBits = 0;
/* decode PCW_BODY */ /* decode PCW_BODY */
pQuantVal = pQuantVal = DecodePCW_Body(
DecodePCW_Body(bs, pCurrentTree, pQuantValBase, pLeftStartOfSegment, bs, pHcr->decInOut.bitstreamAnchor, pCurrentTree, pQuantValBase,
pRemainingBitsInSegment, &numDecodedBits); pLeftStartOfSegment, pRemainingBitsInSegment, &numDecodedBits);
/* result is written out here because NO sign bits follow the body */ /* result is written out here because NO sign bits follow the body */
for (i = dimension; i != 0; i--) { for (i = dimension; i != 0; i--) {
@ -1115,14 +1114,14 @@ static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr) {
int err; int err;
numDecodedBits = 0; numDecodedBits = 0;
pQuantVal = pQuantVal = DecodePCW_Body(
DecodePCW_Body(bs, pCurrentTree, pQuantValBase, pLeftStartOfSegment, bs, pHcr->decInOut.bitstreamAnchor, pCurrentTree, pQuantValBase,
pRemainingBitsInSegment, &numDecodedBits); pLeftStartOfSegment, pRemainingBitsInSegment, &numDecodedBits);
err = DecodePCW_Sign( err = DecodePCW_Sign(
bs, dimension, pQuantVal, pQuantizedSpectralCoefficients, bs, pHcr->decInOut.bitstreamAnchor, dimension, pQuantVal,
&quantizedSpectralCoefficientsIdx, pLeftStartOfSegment, pQuantizedSpectralCoefficients, &quantizedSpectralCoefficientsIdx,
pRemainingBitsInSegment, &numDecodedBits); pLeftStartOfSegment, pRemainingBitsInSegment, &numDecodedBits);
if (err != 0) { if (err != 0) {
return; return;
} }
@ -1157,14 +1156,14 @@ static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr) {
numDecodedBits = 0; numDecodedBits = 0;
/* decode PCW_BODY */ /* decode PCW_BODY */
pQuantVal = pQuantVal = DecodePCW_Body(
DecodePCW_Body(bs, pCurrentTree, pQuantValBase, pLeftStartOfSegment, bs, pHcr->decInOut.bitstreamAnchor, pCurrentTree, pQuantValBase,
pRemainingBitsInSegment, &numDecodedBits); pLeftStartOfSegment, pRemainingBitsInSegment, &numDecodedBits);
err = DecodePCW_Sign( err = DecodePCW_Sign(
bs, dimension, pQuantVal, pQuantizedSpectralCoefficients, bs, pHcr->decInOut.bitstreamAnchor, dimension, pQuantVal,
&quantizedSpectralCoefficientsIdx, pLeftStartOfSegment, pQuantizedSpectralCoefficients, &quantizedSpectralCoefficientsIdx,
pRemainingBitsInSegment, &numDecodedBits); pLeftStartOfSegment, pRemainingBitsInSegment, &numDecodedBits);
if (err != 0) { if (err != 0) {
return; return;
} }
@ -1177,7 +1176,7 @@ static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr) {
(FIXP_DBL)ESCAPE_VALUE) { (FIXP_DBL)ESCAPE_VALUE) {
pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] =
(FIXP_DBL)DecodeEscapeSequence( (FIXP_DBL)DecodeEscapeSequence(
bs, bs, pHcr->decInOut.bitstreamAnchor,
pQuantizedSpectralCoefficients pQuantizedSpectralCoefficients
[quantizedSpectralCoefficientsIdx], [quantizedSpectralCoefficientsIdx],
pLeftStartOfSegment, pRemainingBitsInSegment, pLeftStartOfSegment, pRemainingBitsInSegment,
@ -1193,7 +1192,7 @@ static void DecodePCWs(HANDLE_FDK_BITSTREAM bs, H_HCR_INFO pHcr) {
(FIXP_DBL)ESCAPE_VALUE) { (FIXP_DBL)ESCAPE_VALUE) {
pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] = pQuantizedSpectralCoefficients[quantizedSpectralCoefficientsIdx] =
(FIXP_DBL)DecodeEscapeSequence( (FIXP_DBL)DecodeEscapeSequence(
bs, bs, pHcr->decInOut.bitstreamAnchor,
pQuantizedSpectralCoefficients pQuantizedSpectralCoefficients
[quantizedSpectralCoefficientsIdx], [quantizedSpectralCoefficientsIdx],
pLeftStartOfSegment, pRemainingBitsInSegment, pLeftStartOfSegment, pRemainingBitsInSegment,
@ -1331,7 +1330,7 @@ void CarryBitToBranchValue(UCHAR carryBit, UINT treeNode, UINT *branchValue,
spectral coefficients spectral coefficients
-------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------
*/ */
static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM bs, static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
const UINT *pCurrentTree, const UINT *pCurrentTree,
const SCHAR *pQuantValBase, const SCHAR *pQuantValBase,
INT *pLeftStartOfSegment, INT *pLeftStartOfSegment,
@ -1349,7 +1348,7 @@ static const SCHAR *DecodePCW_Body(HANDLE_FDK_BITSTREAM bs,
/* decode whole PCW-codeword-body */ /* decode whole PCW-codeword-body */
while (1) { while (1) {
carryBit = HcrGetABitFromBitstream(bs, pLeftStartOfSegment, carryBit = HcrGetABitFromBitstream(bs, bsAnchor, pLeftStartOfSegment,
pLeftStartOfSegment, /* dummy */ pLeftStartOfSegment, /* dummy */
FROM_LEFT_TO_RIGHT); FROM_LEFT_TO_RIGHT);
*pRemainingBitsInSegment -= 1; *pRemainingBitsInSegment -= 1;
@ -1384,8 +1383,8 @@ value == 16, a escapeSequence is decoded in two steps:
-------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------
*/ */
static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, INT quantSpecCoef, static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
INT *pLeftStartOfSegment, INT quantSpecCoef, INT *pLeftStartOfSegment,
SCHAR *pRemainingBitsInSegment, SCHAR *pRemainingBitsInSegment,
int *pNumDecodedBits) { int *pNumDecodedBits) {
UINT i; UINT i;
@ -1396,7 +1395,7 @@ static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, INT quantSpecCoef,
/* decode escape prefix */ /* decode escape prefix */
while (1) { while (1) {
carryBit = HcrGetABitFromBitstream(bs, pLeftStartOfSegment, carryBit = HcrGetABitFromBitstream(bs, bsAnchor, pLeftStartOfSegment,
pLeftStartOfSegment, /* dummy */ pLeftStartOfSegment, /* dummy */
FROM_LEFT_TO_RIGHT); FROM_LEFT_TO_RIGHT);
*pRemainingBitsInSegment -= 1; *pRemainingBitsInSegment -= 1;
@ -1412,7 +1411,7 @@ static INT DecodeEscapeSequence(HANDLE_FDK_BITSTREAM bs, INT quantSpecCoef,
/* decode escape word */ /* decode escape word */
for (i = escapeOnesCounter; i != 0; i--) { for (i = escapeOnesCounter; i != 0; i--) {
carryBit = HcrGetABitFromBitstream(bs, pLeftStartOfSegment, carryBit = HcrGetABitFromBitstream(bs, bsAnchor, pLeftStartOfSegment,
pLeftStartOfSegment, /* dummy */ pLeftStartOfSegment, /* dummy */
FROM_LEFT_TO_RIGHT); FROM_LEFT_TO_RIGHT);
*pRemainingBitsInSegment -= 1; *pRemainingBitsInSegment -= 1;
@ -1441,9 +1440,10 @@ the last of eight function of HCR)
line) line)
-------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------
*/ */
static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM bs, UINT codebookDim, static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
const SCHAR *pQuantVal, FIXP_DBL *pQuantSpecCoef, UINT codebookDim, const SCHAR *pQuantVal,
int *quantSpecCoefIdx, INT *pLeftStartOfSegment, FIXP_DBL *pQuantSpecCoef, int *quantSpecCoefIdx,
INT *pLeftStartOfSegment,
SCHAR *pRemainingBitsInSegment, SCHAR *pRemainingBitsInSegment,
int *pNumDecodedBits) { int *pNumDecodedBits) {
UINT i; UINT i;
@ -1453,7 +1453,7 @@ static int DecodePCW_Sign(HANDLE_FDK_BITSTREAM bs, UINT codebookDim,
for (i = codebookDim; i != 0; i--) { for (i = codebookDim; i != 0; i--) {
quantSpecCoef = *pQuantVal++; quantSpecCoef = *pQuantVal++;
if (quantSpecCoef != 0) { if (quantSpecCoef != 0) {
carryBit = HcrGetABitFromBitstream(bs, pLeftStartOfSegment, carryBit = HcrGetABitFromBitstream(bs, bsAnchor, pLeftStartOfSegment,
pLeftStartOfSegment, /* dummy */ pLeftStartOfSegment, /* dummy */
FROM_LEFT_TO_RIGHT); FROM_LEFT_TO_RIGHT);
*pRemainingBitsInSegment -= 1; *pRemainingBitsInSegment -= 1;

7
libAACdec/src/aacdec_hcr_bit.cpp
View File

@ -132,13 +132,14 @@ read direction. It is called very often, therefore it makes sense to inline it
return: - bit from bitstream return: - bit from bitstream
-------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------
*/ */
UINT HcrGetABitFromBitstream(HANDLE_FDK_BITSTREAM bs, INT *pLeftStartOfSegment, UINT HcrGetABitFromBitstream(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
INT *pLeftStartOfSegment,
INT *pRightStartOfSegment, UCHAR readDirection) { INT *pRightStartOfSegment, UCHAR readDirection) {
UINT bit; UINT bit;
INT readBitOffset; INT readBitOffset;
if (readDirection == FROM_LEFT_TO_RIGHT) { if (readDirection == FROM_LEFT_TO_RIGHT) {
readBitOffset = *pLeftStartOfSegment - FDKgetBitCnt(bs); readBitOffset = (INT)FDKgetValidBits(bs) - bsAnchor + *pLeftStartOfSegment;
if (readBitOffset) { if (readBitOffset) {
FDKpushBiDirectional(bs, readBitOffset); FDKpushBiDirectional(bs, readBitOffset);
} }
@ -147,7 +148,7 @@ UINT HcrGetABitFromBitstream(HANDLE_FDK_BITSTREAM bs, INT *pLeftStartOfSegment,
*pLeftStartOfSegment += 1; *pLeftStartOfSegment += 1;
} else { } else {
readBitOffset = *pRightStartOfSegment - FDKgetBitCnt(bs); readBitOffset = (INT)FDKgetValidBits(bs) - bsAnchor + *pRightStartOfSegment;
if (readBitOffset) { if (readBitOffset) {
FDKpushBiDirectional(bs, readBitOffset); FDKpushBiDirectional(bs, readBitOffset);
} }

3
libAACdec/src/aacdec_hcr_bit.h
View File

@ -107,7 +107,8 @@ amm-info@iis.fraunhofer.de
UCHAR ToggleReadDirection(UCHAR readDirection); UCHAR ToggleReadDirection(UCHAR readDirection);
UINT HcrGetABitFromBitstream(HANDLE_FDK_BITSTREAM bs, INT *pLeftStartOfSegment, UINT HcrGetABitFromBitstream(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
INT *pLeftStartOfSegment,
INT *pRightStartOfSegment, UCHAR readDirection); INT *pRightStartOfSegment, UCHAR readDirection);
#endif /* AACDEC_HCR_BIT_H */ #endif /* AACDEC_HCR_BIT_H */

2
libAACdec/src/aacdec_hcr_types.h
View File

@ -350,7 +350,7 @@ typedef struct {
SHORT lengthOfReorderedSpectralData; SHORT lengthOfReorderedSpectralData;
SHORT numSection; SHORT numSection;
SHORT *pNumLineInSect; SHORT *pNumLineInSect;
INT bitstreamIndex; INT bitstreamAnchor;
SCHAR lengthOfLongestCodeword; SCHAR lengthOfLongestCodeword;
UCHAR *pCodebook; UCHAR *pCodebook;
} HCR_INPUT_OUTPUT; } HCR_INPUT_OUTPUT;

42
libAACdec/src/aacdec_hcrs.cpp
View File

@ -615,9 +615,9 @@ UINT Hcr_State_BODY_ONLY(HANDLE_FDK_BITSTREAM bs, void *ptr) {
for (; pRemainingBitsInSegment[segmentOffset] > 0; for (; pRemainingBitsInSegment[segmentOffset] > 0;
pRemainingBitsInSegment[segmentOffset] -= 1) { pRemainingBitsInSegment[segmentOffset] -= 1) {
carryBit = HcrGetABitFromBitstream(bs, &pLeftStartOfSegment[segmentOffset], carryBit = HcrGetABitFromBitstream(
&pRightStartOfSegment[segmentOffset], bs, pHcr->decInOut.bitstreamAnchor, &pLeftStartOfSegment[segmentOffset],
readDirection); &pRightStartOfSegment[segmentOffset], readDirection);
CarryBitToBranchValue(carryBit, /* make a step in decoding tree */ CarryBitToBranchValue(carryBit, /* make a step in decoding tree */
treeNode, &branchValue, &branchNode); treeNode, &branchValue, &branchNode);
@ -749,9 +749,9 @@ UINT Hcr_State_BODY_SIGN__BODY(HANDLE_FDK_BITSTREAM bs, void *ptr) {
for (; pRemainingBitsInSegment[segmentOffset] > 0; for (; pRemainingBitsInSegment[segmentOffset] > 0;
pRemainingBitsInSegment[segmentOffset] -= 1) { pRemainingBitsInSegment[segmentOffset] -= 1) {
carryBit = HcrGetABitFromBitstream(bs, &pLeftStartOfSegment[segmentOffset], carryBit = HcrGetABitFromBitstream(
&pRightStartOfSegment[segmentOffset], bs, pHcr->decInOut.bitstreamAnchor, &pLeftStartOfSegment[segmentOffset],
readDirection); &pRightStartOfSegment[segmentOffset], readDirection);
CarryBitToBranchValue(carryBit, /* make a step in decoding tree */ CarryBitToBranchValue(carryBit, /* make a step in decoding tree */
treeNode, &branchValue, &branchNode); treeNode, &branchValue, &branchNode);
@ -884,9 +884,9 @@ UINT Hcr_State_BODY_SIGN__SIGN(HANDLE_FDK_BITSTREAM bs, void *ptr) {
/* loop for sign bit decoding */ /* loop for sign bit decoding */
for (; pRemainingBitsInSegment[segmentOffset] > 0; for (; pRemainingBitsInSegment[segmentOffset] > 0;
pRemainingBitsInSegment[segmentOffset] -= 1) { pRemainingBitsInSegment[segmentOffset] -= 1) {
carryBit = HcrGetABitFromBitstream(bs, &pLeftStartOfSegment[segmentOffset], carryBit = HcrGetABitFromBitstream(
&pRightStartOfSegment[segmentOffset], bs, pHcr->decInOut.bitstreamAnchor, &pLeftStartOfSegment[segmentOffset],
readDirection); &pRightStartOfSegment[segmentOffset], readDirection);
cntSign -= cntSign -=
1; /* decrement sign counter because one sign bit has been read */ 1; /* decrement sign counter because one sign bit has been read */
@ -997,9 +997,9 @@ UINT Hcr_State_BODY_SIGN_ESC__BODY(HANDLE_FDK_BITSTREAM bs, void *ptr) {
for (; pRemainingBitsInSegment[segmentOffset] > 0; for (; pRemainingBitsInSegment[segmentOffset] > 0;
pRemainingBitsInSegment[segmentOffset] -= 1) { pRemainingBitsInSegment[segmentOffset] -= 1) {
carryBit = HcrGetABitFromBitstream(bs, &pLeftStartOfSegment[segmentOffset], carryBit = HcrGetABitFromBitstream(
&pRightStartOfSegment[segmentOffset], bs, pHcr->decInOut.bitstreamAnchor, &pLeftStartOfSegment[segmentOffset],
readDirection); &pRightStartOfSegment[segmentOffset], readDirection);
/* make a step in tree */ /* make a step in tree */
CarryBitToBranchValue(carryBit, treeNode, &branchValue, &branchNode); CarryBitToBranchValue(carryBit, treeNode, &branchValue, &branchNode);
@ -1159,9 +1159,9 @@ UINT Hcr_State_BODY_SIGN_ESC__SIGN(HANDLE_FDK_BITSTREAM bs, void *ptr) {
/* loop for sign bit decoding */ /* loop for sign bit decoding */
for (; pRemainingBitsInSegment[segmentOffset] > 0; for (; pRemainingBitsInSegment[segmentOffset] > 0;
pRemainingBitsInSegment[segmentOffset] -= 1) { pRemainingBitsInSegment[segmentOffset] -= 1) {
carryBit = HcrGetABitFromBitstream(bs, &pLeftStartOfSegment[segmentOffset], carryBit = HcrGetABitFromBitstream(
&pRightStartOfSegment[segmentOffset], bs, pHcr->decInOut.bitstreamAnchor, &pLeftStartOfSegment[segmentOffset],
readDirection); &pRightStartOfSegment[segmentOffset], readDirection);
/* decrement sign counter because one sign bit has been read */ /* decrement sign counter because one sign bit has been read */
cntSign -= 1; cntSign -= 1;
@ -1314,9 +1314,9 @@ UINT Hcr_State_BODY_SIGN_ESC__ESC_PREFIX(HANDLE_FDK_BITSTREAM bs, void *ptr) {
/* decode escape prefix */ /* decode escape prefix */
for (; pRemainingBitsInSegment[segmentOffset] > 0; for (; pRemainingBitsInSegment[segmentOffset] > 0;
pRemainingBitsInSegment[segmentOffset] -= 1) { pRemainingBitsInSegment[segmentOffset] -= 1) {
carryBit = HcrGetABitFromBitstream(bs, &pLeftStartOfSegment[segmentOffset], carryBit = HcrGetABitFromBitstream(
&pRightStartOfSegment[segmentOffset], bs, pHcr->decInOut.bitstreamAnchor, &pLeftStartOfSegment[segmentOffset],
readDirection); &pRightStartOfSegment[segmentOffset], readDirection);
/* count ones and store sum in escapePrefixUp */ /* count ones and store sum in escapePrefixUp */
if (carryBit == 1) { if (carryBit == 1) {
@ -1435,9 +1435,9 @@ UINT Hcr_State_BODY_SIGN_ESC__ESC_WORD(HANDLE_FDK_BITSTREAM bs, void *ptr) {
/* decode escape word */ /* decode escape word */
for (; pRemainingBitsInSegment[segmentOffset] > 0; for (; pRemainingBitsInSegment[segmentOffset] > 0;
pRemainingBitsInSegment[segmentOffset] -= 1) { pRemainingBitsInSegment[segmentOffset] -= 1) {
carryBit = HcrGetABitFromBitstream(bs, &pLeftStartOfSegment[segmentOffset], carryBit = HcrGetABitFromBitstream(
&pRightStartOfSegment[segmentOffset], bs, pHcr->decInOut.bitstreamAnchor, &pLeftStartOfSegment[segmentOffset],
readDirection); &pRightStartOfSegment[segmentOffset], readDirection);
/* build escape word */ /* build escape word */
escapeWord <<= escapeWord <<=

25
libAACdec/src/aacdecoder.cpp
View File

@ -2519,8 +2519,14 @@ LINKSPEC_CPP AAC_DECODER_ERROR CAacDecoder_DecodeFrame(
if (!(self->flags[0] & if (!(self->flags[0] &
(AC_USAC | AC_RSVD50 | AC_RSV603DA | AC_ELD | AC_SCALABLE | AC_ER))) (AC_USAC | AC_RSVD50 | AC_RSV603DA | AC_ELD | AC_SCALABLE | AC_ER)))
type = (MP4_ELEMENT_ID)FDKreadBits(bs, 3); type = (MP4_ELEMENT_ID)FDKreadBits(bs, 3);
else else {
if (element_count >= (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1)) {
self->frameOK = 0;
ErrorStatus = AAC_DEC_PARSE_ERROR;
break;
}
type = self->elements[element_count]; type = self->elements[element_count];
}
if ((self->flags[streamIndex] & (AC_USAC | AC_RSVD50) && if ((self->flags[streamIndex] & (AC_USAC | AC_RSVD50) &&
element_count == 0) || element_count == 0) ||
@ -2564,6 +2570,11 @@ LINKSPEC_CPP AAC_DECODER_ERROR CAacDecoder_DecodeFrame(
case ID_USAC_SCE: case ID_USAC_SCE:
case ID_USAC_CPE: case ID_USAC_CPE:
case ID_USAC_LFE: case ID_USAC_LFE:
if (element_count >= (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1)) {
self->frameOK = 0;
ErrorStatus = AAC_DEC_PARSE_ERROR;
break;
}
el_channels = CAacDecoder_GetELChannels( el_channels = CAacDecoder_GetELChannels(
type, self->usacStereoConfigIndex[element_count]); type, self->usacStereoConfigIndex[element_count]);
@ -2795,12 +2806,24 @@ LINKSPEC_CPP AAC_DECODER_ERROR CAacDecoder_DecodeFrame(
} break; } break;
case ID_EXT: case ID_EXT:
if (element_count >= (3 * ((8) * 2) + (((8) * 2)) / 2 + 4 * (1) + 1)) {
self->frameOK = 0;
ErrorStatus = AAC_DEC_PARSE_ERROR;
break;
}
ErrorStatus = aacDecoder_ParseExplicitMpsAndSbr( ErrorStatus = aacDecoder_ParseExplicitMpsAndSbr(
self, bs, previous_element, previous_element_index, element_count, self, bs, previous_element, previous_element_index, element_count,
el_cnt); el_cnt);
break; break;
case ID_USAC_EXT: { case ID_USAC_EXT: {
if ((element_count - element_count_prev_streams) >=
TP_USAC_MAX_ELEMENTS) {
self->frameOK = 0;
ErrorStatus = AAC_DEC_PARSE_ERROR;
break;
}
/* parse extension element payload /* parse extension element payload
q.v. rsv603daExtElement() ISO/IEC DIS 23008-3 Table 30 q.v. rsv603daExtElement() ISO/IEC DIS 23008-3 Table 30
or UsacExElement() ISO/IEC FDIS 23003-3:2011(E) Table 21 or UsacExElement() ISO/IEC FDIS 23003-3:2011(E) Table 21

29
libAACdec/src/rvlc.cpp
View File

@ -168,13 +168,14 @@ static void rvlcInit(CErRvlcInfo *pRvlc,
/* set base bitstream ptr to the RVL-coded part (start of RVLC data (ESC 2)) /* set base bitstream ptr to the RVL-coded part (start of RVLC data (ESC 2))
*/ */
FDKsyncCache(bs); FDKsyncCache(bs);
pRvlc->bsAnchor = (INT)FDKgetValidBits(bs);
pRvlc->bitstreamIndexRvlFwd = FDKgetBitCnt( pRvlc->bitstreamIndexRvlFwd =
bs); /* first bit within RVL coded block as start address for forward 0; /* first bit within RVL coded block as start address for forward
decoding */ decoding */
pRvlc->bitstreamIndexRvlBwd = FDKgetBitCnt(bs) + pRvlc->length_of_rvlc_sf - pRvlc->bitstreamIndexRvlBwd =
1; /* last bit within RVL coded block as start pRvlc->length_of_rvlc_sf - 1; /* last bit within RVL coded block as start
address for backward decoding */ address for backward decoding */
/* skip RVLC-bitstream-part -- pointing now to escapes (if present) or to TNS /* skip RVLC-bitstream-part -- pointing now to escapes (if present) or to TNS
* data (if present) */ * data (if present) */
@ -183,7 +184,7 @@ static void rvlcInit(CErRvlcInfo *pRvlc,
if (pRvlc->sf_escapes_present != 0) { if (pRvlc->sf_escapes_present != 0) {
/* locate internal bitstream ptr at escapes (which is the second part) */ /* locate internal bitstream ptr at escapes (which is the second part) */
FDKsyncCache(bs); FDKsyncCache(bs);
pRvlc->bitstreamIndexEsc = FDKgetBitCnt(bs); pRvlc->bitstreamIndexEsc = pRvlc->bsAnchor - (INT)FDKgetValidBits(bs);
/* skip escapeRVLC-bitstream-part -- pointing to TNS data (if present) to /* skip escapeRVLC-bitstream-part -- pointing to TNS data (if present) to
* make decoder continue */ * make decoder continue */
@ -259,8 +260,9 @@ static SCHAR rvlcDecodeEscapeWord(CErRvlcInfo *pRvlc, HANDLE_FDK_BITSTREAM bs) {
treeNode = *pEscTree; /* init at starting node */ treeNode = *pEscTree; /* init at starting node */
for (i = MAX_LEN_RVLC_ESCAPE_WORD - 1; i >= 0; i--) { for (i = MAX_LEN_RVLC_ESCAPE_WORD - 1; i >= 0; i--) {
carryBit = rvlcReadBitFromBitstream(bs, /* get next bit */ carryBit =
pBitstreamIndexEsc, FWD); rvlcReadBitFromBitstream(bs, /* get next bit */
pRvlc->bsAnchor, pBitstreamIndexEsc, FWD);
CarryBitToBranchValue(carryBit, /* huffman decoding, do a single step in CarryBitToBranchValue(carryBit, /* huffman decoding, do a single step in
huffman decoding tree */ huffman decoding tree */
@ -370,8 +372,9 @@ SCHAR decodeRVLCodeword(HANDLE_FDK_BITSTREAM bs, CErRvlcInfo *pRvlc) {
UINT treeNode = *pRvlCodeTree; UINT treeNode = *pRvlCodeTree;
for (i = MAX_LEN_RVLC_CODE_WORD - 1; i >= 0; i--) { for (i = MAX_LEN_RVLC_CODE_WORD - 1; i >= 0; i--) {
carryBit = rvlcReadBitFromBitstream(bs, /* get next bit */ carryBit =
pBitstrIndxRvl, direction); rvlcReadBitFromBitstream(bs, /* get next bit */
pRvlc->bsAnchor, pBitstrIndxRvl, direction);
CarryBitToBranchValue(carryBit, /* huffman decoding, do a single step in CarryBitToBranchValue(carryBit, /* huffman decoding, do a single step in
huffman decoding tree */ huffman decoding tree */
@ -1140,7 +1143,7 @@ void CRvlc_Decode(CAacDecoderChannelInfo *pAacDecoderChannelInfo,
rvlcInit(pRvlc, pAacDecoderChannelInfo, bs); rvlcInit(pRvlc, pAacDecoderChannelInfo, bs);
/* save bitstream position */ /* save bitstream position */
saveBitCnt = FDKgetBitCnt(bs); saveBitCnt = (INT)FDKgetValidBits(bs);
if (pRvlc->sf_escapes_present) if (pRvlc->sf_escapes_present)
rvlcDecodeEscapes( rvlcDecodeEscapes(
@ -1155,7 +1158,7 @@ void CRvlc_Decode(CAacDecoderChannelInfo *pAacDecoderChannelInfo,
pAacDecoderChannelInfo->data.aac.PnsData.PnsActive = pRvlc->noise_used; pAacDecoderChannelInfo->data.aac.PnsData.PnsActive = pRvlc->noise_used;
/* restore bitstream position */ /* restore bitstream position */
bitCntOffst = saveBitCnt - FDKgetBitCnt(bs); bitCntOffst = (INT)FDKgetValidBits(bs) - saveBitCnt;
if (bitCntOffst) { if (bitCntOffst) {
FDKpushBiDirectional(bs, bitCntOffst); FDKpushBiDirectional(bs, bitCntOffst);
} }

1
libAACdec/src/rvlc_info.h
View File

@ -164,6 +164,7 @@ typedef struct {
UCHAR direction; UCHAR direction;
/* bitstream indices */ /* bitstream indices */
INT bsAnchor; /* hcr bit buffer reference index */
INT bitstreamIndexRvlFwd; /* base address of RVL-coded-scalefactor data (ESC INT bitstreamIndexRvlFwd; /* base address of RVL-coded-scalefactor data (ESC
2) for forward decoding */ 2) for forward decoding */
INT bitstreamIndexRvlBwd; /* base address of RVL-coded-scalefactor data (ESC INT bitstreamIndexRvlBwd; /* base address of RVL-coded-scalefactor data (ESC

6
libAACdec/src/rvlcbit.cpp
View File

@ -123,10 +123,10 @@ read direction. It is called very often, therefore it makes sense to inline it
-------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------
*/ */
UCHAR rvlcReadBitFromBitstream(HANDLE_FDK_BITSTREAM bs, INT *pPosition, UCHAR rvlcReadBitFromBitstream(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
UCHAR readDirection) { INT *pPosition, UCHAR readDirection) {
UINT bit; UINT bit;
INT readBitOffset = *pPosition - FDKgetBitCnt(bs); INT readBitOffset = (INT)FDKgetValidBits(bs) - bsAnchor + *pPosition;
if (readBitOffset) { if (readBitOffset) {
FDKpushBiDirectional(bs, readBitOffset); FDKpushBiDirectional(bs, readBitOffset);

4
libAACdec/src/rvlcbit.h
View File

@ -105,7 +105,7 @@ amm-info@iis.fraunhofer.de
#include "rvlc.h" #include "rvlc.h"
UCHAR rvlcReadBitFromBitstream(HANDLE_FDK_BITSTREAM bs, INT *pPosition, UCHAR rvlcReadBitFromBitstream(HANDLE_FDK_BITSTREAM bs, const INT bsAnchor,
UCHAR readDirection); INT *pPosition, UCHAR readDirection);
#endif /* RVLCBIT_H */ #endif /* RVLCBIT_H */

6
libFDK/include/FDK_bitbuffer.h
View File

@ -113,7 +113,6 @@ typedef struct {
UINT ValidBits; UINT ValidBits;
UINT ReadOffset; UINT ReadOffset;
UINT WriteOffset; UINT WriteOffset;
UINT BitCnt;
UINT BitNdx; UINT BitNdx;
UCHAR *Buffer; UCHAR *Buffer;
@ -159,15 +158,10 @@ void FDK_pushBack(HANDLE_FDK_BITBUF hBitBuffer, const UINT numberOfBits,
void FDK_pushForward(HANDLE_FDK_BITBUF hBitBuffer, const UINT numberOfBits, void FDK_pushForward(HANDLE_FDK_BITBUF hBitBuffer, const UINT numberOfBits,
UCHAR config); UCHAR config);
void FDK_byteAlign(HANDLE_FDK_BITBUF hBitBuffer, UCHAR config);
UINT FDK_getValidBits(HANDLE_FDK_BITBUF hBitBuffer); UINT FDK_getValidBits(HANDLE_FDK_BITBUF hBitBuffer);
INT FDK_getFreeBits(HANDLE_FDK_BITBUF hBitBuffer); INT FDK_getFreeBits(HANDLE_FDK_BITBUF hBitBuffer);
void FDK_setBitCnt(HANDLE_FDK_BITBUF hBitBuffer, const UINT value);
INT FDK_getBitCnt(HANDLE_FDK_BITBUF hBitBuffer);
void FDK_Feed(HANDLE_FDK_BITBUF hBitBuffer, const UCHAR inputBuffer[], void FDK_Feed(HANDLE_FDK_BITBUF hBitBuffer, const UCHAR inputBuffer[],
const UINT bufferSize, UINT *bytesValid); const UINT bufferSize, UINT *bytesValid);

46
libFDK/include/FDK_bitstream.h
View File

@ -480,21 +480,6 @@ FDK_INLINE void FDKsyncCacheBwd(HANDLE_FDK_BITSTREAM hBitStream) {
hBitStream->CacheWord = 0; hBitStream->CacheWord = 0;
} }
/**
* \brief Byte Alignment Function.
* This function performs the byte_alignment() syntactic function on the
* input stream, i.e. some bits will be discarded/padded so that the next bits
* to be read/written will be aligned on a byte boundary with respect to
* the bit position 0.
*
* \param hBitStream HANDLE_FDK_BITSTREAM handle
* \return void
*/
FDK_INLINE void FDKbyteAlign(HANDLE_FDK_BITSTREAM hBitStream) {
FDKsyncCache(hBitStream);
FDK_byteAlign(&hBitStream->hBitBuf, (UCHAR)hBitStream->ConfigCache);
}
/** /**
* \brief Byte Alignment Function with anchor * \brief Byte Alignment Function with anchor
* This function performs the byte_alignment() syntactic function on the * This function performs the byte_alignment() syntactic function on the
@ -603,37 +588,6 @@ FDK_INLINE INT FDKgetFreeBits(HANDLE_FDK_BITSTREAM hBitStream) {
return FDK_getFreeBits(&hBitStream->hBitBuf); return FDK_getFreeBits(&hBitStream->hBitBuf);
} }
/**
* \brief reset bitcounter in bitBuffer to zero.
* \param hBitStream HANDLE_FDK_BITSTREAM handle
* \return void
*/
FDK_INLINE void FDKresetBitCnt(HANDLE_FDK_BITSTREAM hBitStream) {
FDKsyncCache(hBitStream);
FDK_setBitCnt(&hBitStream->hBitBuf, 0);
}
/**
* \brief set bitcoutner in bitBuffer to given value.
* \param hBitStream HANDLE_FDK_BITSTREAM handle
* \param value new value to be assigned to the bit counter
* \return void
*/
FDK_INLINE void FDKsetBitCnt(HANDLE_FDK_BITSTREAM hBitStream, UINT value) {
FDKsyncCache(hBitStream);
FDK_setBitCnt(&hBitStream->hBitBuf, value);
}
/**
* \brief get bitcounter state from bitBuffer.
* \param hBitStream HANDLE_FDK_BITSTREAM handle
* \return current bit counter value
*/
FDK_INLINE INT FDKgetBitCnt(HANDLE_FDK_BITSTREAM hBitStream) {
FDKsyncCache(hBitStream);
return FDK_getBitCnt(&hBitStream->hBitBuf);
}
/** /**
* \brief Fill the BitBuffer with a number of input bytes from external source. * \brief Fill the BitBuffer with a number of input bytes from external source.
* The bytesValid variable returns the number of ramaining valid bytes in * The bytesValid variable returns the number of ramaining valid bytes in

29
libFDK/src/FDK_bitbuffer.cpp
View File

@ -128,7 +128,6 @@ void FDK_InitBitBuffer(HANDLE_FDK_BITBUF hBitBuf, UCHAR *pBuffer, UINT bufSize,
hBitBuf->ValidBits = validBits; hBitBuf->ValidBits = validBits;
hBitBuf->ReadOffset = 0; hBitBuf->ReadOffset = 0;
hBitBuf->WriteOffset = 0; hBitBuf->WriteOffset = 0;
hBitBuf->BitCnt = 0;
hBitBuf->BitNdx = 0; hBitBuf->BitNdx = 0;
hBitBuf->Buffer = pBuffer; hBitBuf->Buffer = pBuffer;
@ -151,7 +150,6 @@ void FDK_ResetBitBuffer(HANDLE_FDK_BITBUF hBitBuf) {
hBitBuf->ValidBits = 0; hBitBuf->ValidBits = 0;
hBitBuf->ReadOffset = 0; hBitBuf->ReadOffset = 0;
hBitBuf->WriteOffset = 0; hBitBuf->WriteOffset = 0;
hBitBuf->BitCnt = 0;
hBitBuf->BitNdx = 0; hBitBuf->BitNdx = 0;
} }
@ -161,7 +159,6 @@ INT FDK_get(HANDLE_FDK_BITBUF hBitBuf, const UINT numberOfBits) {
UINT bitOffset = hBitBuf->BitNdx & 0x07; UINT bitOffset = hBitBuf->BitNdx & 0x07;
hBitBuf->BitNdx = (hBitBuf->BitNdx + numberOfBits) & (hBitBuf->bufBits - 1); hBitBuf->BitNdx = (hBitBuf->BitNdx + numberOfBits) & (hBitBuf->bufBits - 1);
hBitBuf->BitCnt += numberOfBits;
hBitBuf->ValidBits -= numberOfBits; hBitBuf->ValidBits -= numberOfBits;
UINT byteMask = hBitBuf->bufSize - 1; UINT byteMask = hBitBuf->bufSize - 1;
@ -184,7 +181,6 @@ INT FDK_get(HANDLE_FDK_BITBUF hBitBuf, const UINT numberOfBits) {
INT FDK_get32(HANDLE_FDK_BITBUF hBitBuf) { INT FDK_get32(HANDLE_FDK_BITBUF hBitBuf) {
UINT BitNdx = hBitBuf->BitNdx + 32; UINT BitNdx = hBitBuf->BitNdx + 32;
hBitBuf->BitNdx = BitNdx & (hBitBuf->bufBits - 1); hBitBuf->BitNdx = BitNdx & (hBitBuf->bufBits - 1);
hBitBuf->BitCnt += 32;
hBitBuf->ValidBits = (UINT)((INT)hBitBuf->ValidBits - (INT)32); hBitBuf->ValidBits = (UINT)((INT)hBitBuf->ValidBits - (INT)32);
UINT byteOffset = (BitNdx - 1) >> 3; UINT byteOffset = (BitNdx - 1) >> 3;
@ -223,7 +219,6 @@ INT FDK_getBwd(HANDLE_FDK_BITBUF hBitBuf, const UINT numberOfBits) {
int i; int i;
hBitBuf->BitNdx = (hBitBuf->BitNdx - numberOfBits) & (hBitBuf->bufBits - 1); hBitBuf->BitNdx = (hBitBuf->BitNdx - numberOfBits) & (hBitBuf->bufBits - 1);
hBitBuf->BitCnt -= numberOfBits;
hBitBuf->ValidBits += numberOfBits; hBitBuf->ValidBits += numberOfBits;
UINT tx = hBitBuf->Buffer[(byteOffset - 3) & byteMask] << 24 | UINT tx = hBitBuf->Buffer[(byteOffset - 3) & byteMask] << 24 |
@ -256,7 +251,6 @@ void FDK_put(HANDLE_FDK_BITBUF hBitBuf, UINT value, const UINT numberOfBits) {
UINT bitOffset = hBitBuf->BitNdx & 0x7; UINT bitOffset = hBitBuf->BitNdx & 0x7;
hBitBuf->BitNdx = (hBitBuf->BitNdx + numberOfBits) & (hBitBuf->bufBits - 1); hBitBuf->BitNdx = (hBitBuf->BitNdx + numberOfBits) & (hBitBuf->bufBits - 1);
hBitBuf->BitCnt += numberOfBits;
hBitBuf->ValidBits += numberOfBits; hBitBuf->ValidBits += numberOfBits;
UINT byteMask = hBitBuf->bufSize - 1; UINT byteMask = hBitBuf->bufSize - 1;
@ -307,7 +301,6 @@ void FDK_putBwd(HANDLE_FDK_BITBUF hBitBuf, UINT value,
int i; int i;
hBitBuf->BitNdx = (hBitBuf->BitNdx - numberOfBits) & (hBitBuf->bufBits - 1); hBitBuf->BitNdx = (hBitBuf->BitNdx - numberOfBits) & (hBitBuf->bufBits - 1);
hBitBuf->BitCnt -= numberOfBits;
hBitBuf->ValidBits -= numberOfBits; hBitBuf->ValidBits -= numberOfBits;
/* in place turn around */ /* in place turn around */
@ -344,7 +337,6 @@ void FDK_putBwd(HANDLE_FDK_BITBUF hBitBuf, UINT value,
#ifndef FUNCTION_FDK_pushBack #ifndef FUNCTION_FDK_pushBack
void FDK_pushBack(HANDLE_FDK_BITBUF hBitBuf, const UINT numberOfBits, void FDK_pushBack(HANDLE_FDK_BITBUF hBitBuf, const UINT numberOfBits,
UCHAR config) { UCHAR config) {
hBitBuf->BitCnt = (UINT)((INT)hBitBuf->BitCnt - (INT)numberOfBits);
hBitBuf->ValidBits = hBitBuf->ValidBits =
(config == 0) ? (UINT)((INT)hBitBuf->ValidBits + (INT)numberOfBits) (config == 0) ? (UINT)((INT)hBitBuf->ValidBits + (INT)numberOfBits)
: ((UINT)((INT)hBitBuf->ValidBits - (INT)numberOfBits)); : ((UINT)((INT)hBitBuf->ValidBits - (INT)numberOfBits));
@ -355,7 +347,6 @@ void FDK_pushBack(HANDLE_FDK_BITBUF hBitBuf, const UINT numberOfBits,
void FDK_pushForward(HANDLE_FDK_BITBUF hBitBuf, const UINT numberOfBits, void FDK_pushForward(HANDLE_FDK_BITBUF hBitBuf, const UINT numberOfBits,
UCHAR config) { UCHAR config) {
hBitBuf->BitCnt = (UINT)((INT)hBitBuf->BitCnt + (INT)numberOfBits);
hBitBuf->ValidBits = hBitBuf->ValidBits =
(config == 0) ? ((UINT)((INT)hBitBuf->ValidBits - (INT)numberOfBits)) (config == 0) ? ((UINT)((INT)hBitBuf->ValidBits - (INT)numberOfBits))
: (UINT)((INT)hBitBuf->ValidBits + (INT)numberOfBits); : (UINT)((INT)hBitBuf->ValidBits + (INT)numberOfBits);
@ -363,19 +354,6 @@ void FDK_pushForward(HANDLE_FDK_BITBUF hBitBuf, const UINT numberOfBits,
(UINT)((INT)hBitBuf->BitNdx + (INT)numberOfBits) & (hBitBuf->bufBits - 1); (UINT)((INT)hBitBuf->BitNdx + (INT)numberOfBits) & (hBitBuf->bufBits - 1);
} }
void FDK_byteAlign(HANDLE_FDK_BITBUF hBitBuf, UCHAR config) {
INT alignment = hBitBuf->BitCnt & 0x07;
if (alignment) {
if (config == 0)
FDK_pushForward(hBitBuf, 8 - alignment, config); /* BS_READER */
else
FDK_put(hBitBuf, 0, 8 - alignment); /* BS_WRITER */
}
hBitBuf->BitCnt = 0;
}
#ifndef FUNCTION_FDK_getValidBits #ifndef FUNCTION_FDK_getValidBits
UINT FDK_getValidBits(HANDLE_FDK_BITBUF hBitBuf) { return hBitBuf->ValidBits; } UINT FDK_getValidBits(HANDLE_FDK_BITBUF hBitBuf) { return hBitBuf->ValidBits; }
#endif /* #ifndef FUNCTION_FDK_getValidBits */ #endif /* #ifndef FUNCTION_FDK_getValidBits */
@ -384,12 +362,6 @@ INT FDK_getFreeBits(HANDLE_FDK_BITBUF hBitBuf) {
return (hBitBuf->bufBits - hBitBuf->ValidBits); return (hBitBuf->bufBits - hBitBuf->ValidBits);
} }
void FDK_setBitCnt(HANDLE_FDK_BITBUF hBitBuf, const UINT value) {
hBitBuf->BitCnt = value;
}
INT FDK_getBitCnt(HANDLE_FDK_BITBUF hBitBuf) { return hBitBuf->BitCnt; }
void FDK_Feed(HANDLE_FDK_BITBUF hBitBuf, const UCHAR *RESTRICT inputBuffer, void FDK_Feed(HANDLE_FDK_BITBUF hBitBuf, const UCHAR *RESTRICT inputBuffer,
const UINT bufferSize, UINT *bytesValid) { const UINT bufferSize, UINT *bytesValid) {
inputBuffer = &inputBuffer[bufferSize - *bytesValid]; inputBuffer = &inputBuffer[bufferSize - *bytesValid];
@ -438,7 +410,6 @@ void CopyAlignedBlock(HANDLE_FDK_BITBUF h_BitBufSrc, UCHAR *RESTRICT dstBuffer,
h_BitBufSrc->BitNdx = h_BitBufSrc->BitNdx =
(h_BitBufSrc->BitNdx + bToRead) & (h_BitBufSrc->bufBits - 1); (h_BitBufSrc->BitNdx + bToRead) & (h_BitBufSrc->bufBits - 1);
h_BitBufSrc->BitCnt += bToRead;
h_BitBufSrc->ValidBits -= bToRead; h_BitBufSrc->ValidBits -= bToRead;
} }

4
libMpegTPDec/src/tpdec_asc.cpp
View File

@ -2102,7 +2102,9 @@ TRANSPORTDEC_ERROR AudioSpecificConfig_Parse(
self->m_aot = getAOT(bs); self->m_aot = getAOT(bs);
self->m_samplingFrequency = self->m_samplingFrequency =
getSampleRate(bs, &self->m_samplingFrequencyIndex, 4); getSampleRate(bs, &self->m_samplingFrequencyIndex, 4);
if (self->m_samplingFrequency <= 0) { if (self->m_samplingFrequency <= 0 ||
(self->m_samplingFrequency > 96000 && self->m_aot != 39) ||
self->m_samplingFrequency > 4 * 96000) {
return TRANSPORTDEC_PARSE_ERROR; return TRANSPORTDEC_PARSE_ERROR;
} }