PSY_DYNAMIC *GetRam_aacEnc_PsyDynamic (int n, UCHAR* dynamic_RAM) {
FDK_ASSERT(dynamic_RAM!=0);
return ((PSY_DYNAMIC*) (dynamic_RAM + P_BUF_1 + n*sizeof(PSY_DYNAMIC)));
}
INT *GetRam_aacEnc_BitLookUp(int n, UCHAR* dynamic_RAM) {
FDK_ASSERT(dynamic_RAM!=0);
return ((INT*) (dynamic_RAM + P_BUF_1));
}
static
TRANSPORTDEC_ERROR synchronization(
HANDLE_TRANSPORTDEC hTp,
INT *pHeaderBits
)
{
TRANSPORTDEC_ERROR err = TRANSPORTDEC_OK, errFirstFrame = TRANSPORTDEC_OK;
HANDLE_FDK_BITSTREAM hBs = &hTp->bitStream[0];
INT syncLayerFrameBits = 0; /* Length of sync layer frame (i.e. LOAS) */
INT rawDataBlockLength = 0, rawDataBlockLengthPrevious;
INT totalBits;
INT headerBits = 0, headerBitsFirstFrame = 0, headerBitsPrevious;
INT numFramesTraversed = 0, fTraverseMoreFrames, fConfigFound = (hTp->flags & TPDEC_CONFIG_FOUND), startPosFirstFrame = -1;
INT numRawDataBlocksFirstFrame = 0, numRawDataBlocksPrevious, globalFramePosFirstFrame = 0, rawDataBlockLengthFirstFrame = 0;
INT ignoreBufferFullness = hTp->flags & (TPDEC_LOST_FRAMES_PENDING|TPDEC_IGNORE_BUFFERFULLNESS|TPDEC_SYNCOK);
/* Synch parameters */
INT syncLength; /* Length of sync word in bits */
UINT syncWord; /* Sync word to be found */
UINT syncMask; /* Mask for sync word (for adding one bit, so comprising one bit less) */
C_ALLOC_SCRATCH_START(contextFirstFrame, transportdec_parser_t, 1);
totalBits = (INT)FDKgetValidBits(hBs);
if (totalBits <= 0) {
err = TRANSPORTDEC_NOT_ENOUGH_BITS;
goto bail;
}
fTraverseMoreFrames = (hTp->flags & (TPDEC_MINIMIZE_DELAY|TPDEC_EARLY_CONFIG)) && ! (hTp->flags & TPDEC_SYNCOK);
/* Set transport specific sync parameters */
switch (hTp->transportFmt) {
case TT_MP4_ADTS:
syncWord = ADTS_SYNCWORD;
syncLength = ADTS_SYNCLENGTH;
break;
case TT_MP4_LOAS:
syncWord = 0x2B7;
syncLength = 11;
break;
default:
syncWord = 0;
syncLength = 0;
break;
}
syncMask = (1<<syncLength)-1;
do {
INT bitsAvail = 0; /* Bits available in bitstream buffer */
INT checkLengthBits; /* Helper to check remaining bits and buffer boundaries */
UINT synch; /* Current sync word read from bitstream */
headerBitsPrevious = headerBits;
bitsAvail = (INT)FDKgetValidBits(hBs);
if (hTp->numberOfRawDataBlocks == 0) {
/* search synchword */
FDK_ASSERT( (bitsAvail % TPDEC_SYNCSKIP) == 0);
if ((bitsAvail-syncLength) < TPDEC_SYNCSKIP) {
err = TRANSPORTDEC_NOT_ENOUGH_BITS;
headerBits = 0;
} else {
synch = FDKreadBits(hBs, syncLength);
if ( !(hTp->flags & TPDEC_SYNCOK) ) {
for (; (bitsAvail-syncLength) >= TPDEC_SYNCSKIP; bitsAvail-=TPDEC_SYNCSKIP) {
if (synch == syncWord) {
break;
}
synch = ((synch << TPDEC_SYNCSKIP) & syncMask) | FDKreadBits(hBs, TPDEC_SYNCSKIP);
}
}
if (synch != syncWord) {
/* No correct syncword found. */
err = TRANSPORTDEC_SYNC_ERROR;
} else {
err = TRANSPORTDEC_OK;
}
headerBits = syncLength;
}
} else {
headerBits = 0;
}
/* Save previous raw data block data */
rawDataBlockLengthPrevious = rawDataBlockLength;
numRawDataBlocksPrevious = hTp->numberOfRawDataBlocks;
/* Parse transport header (raw data block granularity) */
if (err == TRANSPORTDEC_OK )
{
err = transportDec_readHeader(
hTp,
hBs,
syncLength,
ignoreBufferFullness,
&rawDataBlockLength,
&fTraverseMoreFrames,
&syncLayerFrameBits,
&fConfigFound,
&headerBits
);
}
bitsAvail -= headerBits;
checkLengthBits = syncLayerFrameBits;
/* Check if the whole frame would fit the bitstream buffer */
if (err == TRANSPORTDEC_OK) {
if ( (checkLengthBits+headerBits) > ((TRANSPORTDEC_INBUF_SIZE<<3)-7) ) {
/* We assume that the size of the transport bit buffer has been
chosen to meet all system requirements, thus this condition
is considered a synchronisation error. */
err = TRANSPORTDEC_SYNC_ERROR;
} else {
if ( bitsAvail < checkLengthBits ) {
err = TRANSPORTDEC_NOT_ENOUGH_BITS;
}
}
}
if (err == TRANSPORTDEC_NOT_ENOUGH_BITS) {
break;
}
if (err == TRANSPORTDEC_SYNC_ERROR) {
int bits;
/* Enforce re-sync of transport headers. */
hTp->numberOfRawDataBlocks = 0;
/* Ensure that the bit amount lands at a multiple of TPDEC_SYNCSKIP */
bits = (bitsAvail + headerBits) % TPDEC_SYNCSKIP;
/* Rewind - TPDEC_SYNCSKIP, in order to look for a synch one bit ahead next time. */
FDKpushBiDirectional(hBs, -(headerBits - TPDEC_SYNCSKIP) + bits);
bitsAvail += headerBits - TPDEC_SYNCSKIP - bits;
headerBits = 0;
}
/* Frame traversal */
if ( fTraverseMoreFrames )
{
/* Save parser context for early config discovery "rewind all frames" */
if ( (hTp->flags & TPDEC_EARLY_CONFIG) && !(hTp->flags & TPDEC_MINIMIZE_DELAY))
{
/* ignore buffer fullness if just traversing additional frames for ECD */
ignoreBufferFullness = 1;
/* Save context in order to return later */
if ( err == TRANSPORTDEC_OK && startPosFirstFrame == -1 ) {
startPosFirstFrame = FDKgetValidBits(hBs);
numRawDataBlocksFirstFrame = hTp->numberOfRawDataBlocks;
globalFramePosFirstFrame = hTp->globalFramePos;
rawDataBlockLengthFirstFrame = rawDataBlockLength;
headerBitsFirstFrame = headerBits;
errFirstFrame = err;
FDKmemcpy(contextFirstFrame, &hTp->parser, sizeof(transportdec_parser_t));
}
/* Break when config was found or it is not possible anymore to find a config */
if (startPosFirstFrame != -1 && (fConfigFound || err != TRANSPORTDEC_OK))
{
/* In case of ECD and sync error, do not rewind anywhere. */
if (err == TRANSPORTDEC_SYNC_ERROR)
{
startPosFirstFrame = -1;
fConfigFound = 0;
numFramesTraversed = 0;
}
break;
}
}
if (err == TRANSPORTDEC_OK) {
FDKpushFor(hBs, rawDataBlockLength);
bitsAvail -= rawDataBlockLength;
numFramesTraversed++;
/* Ignore error here itentionally. */
transportDec_AdjustEndOfAccessUnit(hTp);
}
}
} while ( fTraverseMoreFrames || (err == TRANSPORTDEC_SYNC_ERROR && !(hTp->flags & TPDEC_SYNCOK)));
/* Restore context in case of ECD frame traversal */
if ( startPosFirstFrame != -1 && (fConfigFound || err != TRANSPORTDEC_OK) ) {
FDKpushBiDirectional(hBs, FDKgetValidBits(hBs) - startPosFirstFrame);
FDKmemcpy(&hTp->parser, contextFirstFrame, sizeof(transportdec_parser_t));
hTp->numberOfRawDataBlocks = numRawDataBlocksFirstFrame;
hTp->globalFramePos = globalFramePosFirstFrame;
rawDataBlockLength = rawDataBlockLengthFirstFrame;
headerBits = headerBitsFirstFrame;
err = errFirstFrame;
numFramesTraversed = 0;
}
/* Additional burst data mode buffer fullness check. */
if ( !(hTp->flags & (TPDEC_LOST_FRAMES_PENDING|TPDEC_IGNORE_BUFFERFULLNESS|TPDEC_SYNCOK)) && err == TRANSPORTDEC_OK) {
err = additionalHoldOffNeeded(hTp, transportDec_GetBufferFullness(hTp), FDKgetValidBits(hBs) - syncLayerFrameBits);
if (err == TRANSPORTDEC_NOT_ENOUGH_BITS) {
hTp->holdOffFrames++;
}
}
/* Rewind for retry because of not enough bits */
if (err == TRANSPORTDEC_NOT_ENOUGH_BITS) {
FDKpushBack(hBs, headerBits);
headerBits = 0;
}
else {
/* reset hold off frame counter */
hTp->holdOffFrames = 0;
}
/* Return to last good frame in case of frame traversal but not ECD. */
if (numFramesTraversed > 0) {
FDKpushBack(hBs, rawDataBlockLengthPrevious);
if (err != TRANSPORTDEC_OK) {
hTp->numberOfRawDataBlocks = numRawDataBlocksPrevious;
headerBits = headerBitsPrevious;
}
err = TRANSPORTDEC_OK;
}
bail:
hTp->auLength[0] = rawDataBlockLength;
/* Detect pointless TRANSPORTDEC_NOT_ENOUGH_BITS error case, were the bit buffer is already full,
or no new burst packet fits. Recover by advancing the bit buffer. */
if ( (TRANSPORTDEC_NOT_ENOUGH_BITS == err) && (FDKgetValidBits(hBs) >= ((TRANSPORTDEC_INBUF_SIZE*8 - ((hTp->avgBitRate*hTp->burstPeriod)/1000)) - 7)) )
{
FDKpushFor(hBs, TPDEC_SYNCSKIP);
err = TRANSPORTDEC_SYNC_ERROR;
}
if (err == TRANSPORTDEC_OK) {
hTp->flags |= TPDEC_SYNCOK;
}
if (fConfigFound) {
hTp->flags |= TPDEC_CONFIG_FOUND;
}
if (pHeaderBits != NULL) {
*pHeaderBits = headerBits;
}
if (err == TRANSPORTDEC_SYNC_ERROR) {
hTp->flags &= ~TPDEC_SYNCOK;
}
C_ALLOC_SCRATCH_END(contextFirstFrame, transportdec_parser_t, 1);
return err;
}
/**
* \brief Synchronize to stream and estimate the amount of missing access units due
* to a current synchronization error in case of constant average bit rate.
*/
static
TRANSPORTDEC_ERROR transportDec_readStream ( HANDLE_TRANSPORTDEC hTp, const UINT layer )
{
TRANSPORTDEC_ERROR error = TRANSPORTDEC_OK;
HANDLE_FDK_BITSTREAM hBs = &hTp->bitStream[layer];
INT nAU = -1;
INT headerBits;
INT bitDistance, bfDelta;
/* Obtain distance to next synch word */
bitDistance = FDKgetValidBits(hBs);
error = synchronization(hTp, &headerBits);
bitDistance -= FDKgetValidBits(hBs);
FDK_ASSERT(bitDistance >= 0);
if (error == TRANSPORTDEC_SYNC_ERROR || (hTp->flags & TPDEC_LOST_FRAMES_PENDING))
{
/* Check if estimating lost access units is feasible. */
if (hTp->avgBitRate > 0 && hTp->asc[0].m_samplesPerFrame > 0 && hTp->asc[0].m_samplingFrequency > 0)
{
if (error == TRANSPORTDEC_OK)
{
int aj;
aj = transportDec_GetBufferFullness(hTp);
if (aj > 0) {
bfDelta = aj;
} else {
bfDelta = 0;
}
/* sync was ok: last of a series of bad access units. */
hTp->flags &= ~TPDEC_LOST_FRAMES_PENDING;
/* Add up bitDistance until end of the current frame. Later we substract
this frame from the grand total, since this current successfully synchronized
frame should not be skipped of course; but it must be accounted into the
bufferfulness math. */
bitDistance += hTp->auLength[0];
} else {
if ( !(hTp->flags & TPDEC_LOST_FRAMES_PENDING) ) {
/* sync not ok: one of many bad access units. */
hTp->flags |= TPDEC_LOST_FRAMES_PENDING;
bfDelta = - (INT)hTp->lastValidBufferFullness;
} else {
bfDelta = 0;
}
}
{
int num, denom;
/* Obtain estimate of number of lost frames */
num = hTp->asc[0].m_samplingFrequency * (bfDelta + bitDistance) + hTp->remainder;
denom = hTp->avgBitRate * hTp->asc[0].m_samplesPerFrame;
if (num > 0) {
nAU = num / denom;
hTp->remainder = num % denom;
} else {
hTp->remainder = num;
}
if (error == TRANSPORTDEC_OK)
{
/* Final adjustment of remainder, taken -1 into account because current
frame should not be skipped, thus substract -1 or do nothing instead
of +1-1 accordingly. */
if ( (denom - hTp->remainder) >= hTp->remainder ) {
nAU--;
}
if (nAU < 0) {
/* There was one frame too much concealed, so unfortunately we will have to skip one good frame. */
transportDec_EndAccessUnit(hTp);
error = synchronization(hTp, &headerBits);
nAU = -1;
#ifdef DEBUG
FDKprintf("ERROR: Bufferfullness accounting failed. remainder=%d, nAU=%d\n", hTp->remainder, nAU);
#endif
}
hTp->remainder = 0;
/* Enforce last missed frames to be concealed. */
if (nAU > 0) {
FDKpushBack(hBs, headerBits);
}
}
}
}
}
/* Be sure that lost frames are handled correctly. This is necessary due to some
sync error sequences where later it turns out that there is not enough data, but
the bits upto the sync word are discarded, thus causing a value of nAU > 0 */
if (nAU > 0) {
error = TRANSPORTDEC_SYNC_ERROR;
}
hTp->missingAccessUnits = nAU;
return error;
}
/*******************************************************************************
Functionname: subbandTPApply
******************************************************************************/
SACDEC_ERROR subbandTPApply(spatialDec *self, const SPATIAL_BS_FRAME *frame) {
FIXP_DBL *qmfOutputRealDry[MAX_OUTPUT_CHANNELS];
FIXP_DBL *qmfOutputImagDry[MAX_OUTPUT_CHANNELS];
FIXP_DBL *qmfOutputRealWet[MAX_OUTPUT_CHANNELS];
FIXP_DBL *qmfOutputImagWet[MAX_OUTPUT_CHANNELS];
FIXP_DBL DryEner[MAX_INPUT_CHANNELS];
FIXP_DBL scale[MAX_OUTPUT_CHANNELS];
FIXP_DBL DryEnerLD64[MAX_INPUT_CHANNELS];
FIXP_DBL WetEnerLD64[MAX_OUTPUT_CHANNELS];
FIXP_DBL DryEner0 = FL2FXCONST_DBL(0.0f);
FIXP_DBL WetEnerX, damp, tmp;
FIXP_DBL dmxReal0, dmxImag0;
int skipChannels[MAX_OUTPUT_CHANNELS];
int n, ch, cplxBands, cplxHybBands;
int dry_scale_dmx, wet_scale_dmx;
int i_LF, i_RF;
HANDLE_STP_DEC hStpDec;
const FIXP_CFG *pBP;
int nrgScale = (2 * self->clipProtectGainSF__FDK);
hStpDec = self->hStpDec;
/* set scalefactor and loop counter */
FDK_ASSERT(SF_DRY >= 1);
{
cplxBands = BP_GF_SIZE;
cplxHybBands = self->hybridBands;
dry_scale_dmx = (2 * SF_DRY) - 2;
wet_scale_dmx = 2;
}
/* setup pointer for forming the direct downmix signal */
for (ch = 0; ch < self->numOutputChannels; ch++) {
qmfOutputRealDry[ch] = &self->hybOutputRealDry__FDK[ch][7];
qmfOutputRealWet[ch] = &self->hybOutputRealWet__FDK[ch][7];
qmfOutputImagDry[ch] = &self->hybOutputImagDry__FDK[ch][7];
qmfOutputImagWet[ch] = &self->hybOutputImagWet__FDK[ch][7];
}
/* clear skipping flag for all output channels */
FDKmemset(skipChannels, 0, self->numOutputChannels * sizeof(int));
/* set scale values to zero */
FDKmemset(scale, 0, self->numOutputChannels * sizeof(FIXP_DBL));
/* update normalisation energy with latest smoothed energy */
if (hStpDec->update_old_ener == STP_UPDATE_ENERGY_RATE) {
hStpDec->update_old_ener = 1;
for (ch = 0; ch < self->numInputChannels; ch++) {
hStpDec->oldDryEnerLD64[ch] =
CalcLdData(hStpDec->runDryEner[ch] + ABS_THR__FDK);
}
for (ch = 0; ch < self->numOutputChannels; ch++) {
hStpDec->oldWetEnerLD64[ch] =
CalcLdData(hStpDec->runWetEner[ch] + ABS_THR2__FDK);
}
} else {
hStpDec->update_old_ener++;
}
/* get channel configuration */
switch (self->treeConfig) {
case TREE_212:
i_LF = 0;
i_RF = 1;
break;
default:
return MPS_WRONG_TREECONFIG;
}
/* form the 'direct' downmix signal */
pBP = hStpDec->BP_GF - BP_GF_START;
switch (self->treeConfig) {
case TREE_212:
for (n = BP_GF_START; n < cplxBands; n++) {
dmxReal0 = qmfOutputRealDry[i_LF][n] + qmfOutputRealDry[i_RF][n];
dmxImag0 = qmfOutputImagDry[i_LF][n] + qmfOutputImagDry[i_RF][n];
DRY_ENER_SUM_CPLX(DryEner0, dmxReal0, dmxImag0, n);
}
DRY_ENER_WEIGHT(DryEner0);
break;
default:;
}
DryEner[0] = DryEner0;
/* normalise the 'direct' signals */
for (ch = 0; ch < self->numInputChannels; ch++) {
DryEner[ch] = DryEner[ch] << (nrgScale);
hStpDec->runDryEner[ch] =
fMult(STP_LPF_COEFF1__FDK, hStpDec->runDryEner[ch]) +
fMult(ONE_MINUS_STP_LPF_COEFF1__FDK, DryEner[ch]);
if (DryEner[ch] != FL2FXCONST_DBL(0.0f)) {
DryEnerLD64[ch] =
fixMax((CalcLdData(DryEner[ch]) - hStpDec->oldDryEnerLD64[ch]),
FL2FXCONST_DBL(-0.484375f));
} else {
DryEnerLD64[ch] = FL2FXCONST_DBL(-0.484375f);
}
}
if (self->treeConfig == TREE_212) {
for (; ch < MAX_INPUT_CHANNELS; ch++) {
DryEnerLD64[ch] = FL2FXCONST_DBL(-0.484375f);
}
}
/* normalise the 'diffuse' signals */
pBP = hStpDec->BP_GF - BP_GF_START;
for (ch = 0; ch < self->numOutputChannels; ch++) {
if (skipChannels[ch]) {
continue;
}
WetEnerX = FL2FXCONST_DBL(0.0f);
for (n = BP_GF_START; n < cplxBands; n++) {
tmp = fPow2Div2(qmfOutputRealWet[ch][n] << SF_WET);
tmp += fPow2Div2(qmfOutputImagWet[ch][n] << SF_WET);
WetEnerX += fMultDiv2(tmp, pBP[n]);
}
WET_ENER_WEIGHT(WetEnerX);
WetEnerX = WetEnerX << (nrgScale);
hStpDec->runWetEner[ch] =
fMult(STP_LPF_COEFF1__FDK, hStpDec->runWetEner[ch]) +
fMult(ONE_MINUS_STP_LPF_COEFF1__FDK, WetEnerX);
if (WetEnerX == FL2FXCONST_DBL(0.0f)) {
WetEnerLD64[ch] = FL2FXCONST_DBL(-0.484375f);
} else {
WetEnerLD64[ch] =
fixMax((CalcLdData(WetEnerX) - hStpDec->oldWetEnerLD64[ch]),
FL2FXCONST_DBL(-0.484375f));
}
}
/* compute scale factor for the 'diffuse' signals */
switch (self->treeConfig) {
case TREE_212:
if (DryEner[0] != FL2FXCONST_DBL(0.0f)) {
CALC_WET_SCALE(0, i_LF);
CALC_WET_SCALE(0, i_RF);
}
break;
default:;
}
damp = FL2FXCONST_DBL(0.1f / (1 << SF_SCALE));
for (ch = 0; ch < self->numOutputChannels; ch++) {
/* damp the scaling factor */
scale[ch] = damp + fMult(FL2FXCONST_DBL(0.9f), scale[ch]);
/* limiting the scale factor */
if (scale[ch] > STP_SCALE_LIMIT__FDK) {
scale[ch] = STP_SCALE_LIMIT__FDK;
}
if (scale[ch] < ONE_DIV_STP_SCALE_LIMIT__FDK) {
scale[ch] = ONE_DIV_STP_SCALE_LIMIT__FDK;
}
/* low pass filter the scaling factor */
scale[ch] =
fMult(STP_LPF_COEFF2__FDK, scale[ch]) +
fMult(ONE_MINUS_STP_LPF_COEFF2__FDK, hStpDec->prev_tp_scale[ch]);
hStpDec->prev_tp_scale[ch] = scale[ch];
}
/* combine 'direct' and scaled 'diffuse' signal */
FDK_ASSERT((HP_SIZE - 3 + 10 - 1) == PC_NUM_HYB_BANDS);
const SCHAR *channlIndex = row2channelSTP[self->treeConfig];
for (ch = 0; ch < self->numOutputChannels; ch++) {
int no_scaling;
no_scaling = !frame->tempShapeEnableChannelSTP[channlIndex[ch]];
if (no_scaling) {
combineSignalCplx(
&self->hybOutputRealDry__FDK[ch][self->tp_hybBandBorder],
&self->hybOutputImagDry__FDK[ch][self->tp_hybBandBorder],
&self->hybOutputRealWet__FDK[ch][self->tp_hybBandBorder],
&self->hybOutputImagWet__FDK[ch][self->tp_hybBandBorder],
cplxHybBands - self->tp_hybBandBorder);
} else {
FIXP_DBL scaleX;
scaleX = scale[ch];
pBP = hStpDec->BP - self->tp_hybBandBorder;
/* Band[HP_SIZE-3+10-1] needs not to be processed in
combineSignalCplxScale1(), because pB[HP_SIZE-3+10-1] would be 1.0 */
combineSignalCplxScale1(
&self->hybOutputRealDry__FDK[ch][self->tp_hybBandBorder],
&self->hybOutputImagDry__FDK[ch][self->tp_hybBandBorder],
&self->hybOutputRealWet__FDK[ch][self->tp_hybBandBorder],
&self->hybOutputImagWet__FDK[ch][self->tp_hybBandBorder],
&pBP[self->tp_hybBandBorder], scaleX,
(HP_SIZE - 3 + 10 - 1) - self->tp_hybBandBorder);
{
combineSignalCplxScale2(
&self->hybOutputRealDry__FDK[ch][HP_SIZE - 3 + 10 - 1],
&self->hybOutputImagDry__FDK[ch][HP_SIZE - 3 + 10 - 1],
&self->hybOutputRealWet__FDK[ch][HP_SIZE - 3 + 10 - 1],
&self->hybOutputImagWet__FDK[ch][HP_SIZE - 3 + 10 - 1], scaleX,
cplxHybBands - (HP_SIZE - 3 + 10 - 1));
}
}
}
return (SACDEC_ERROR)MPS_OK;
;
}
int adtsWrite_EncodeHeader(HANDLE_ADTS hAdts,
HANDLE_FDK_BITSTREAM hBitStream,
int buffer_fullness,
int frame_length)
{
INT crcIndex = 0;
hAdts->headerBits = adtsWrite_GetHeaderBits(hAdts);
FDK_ASSERT(((frame_length+hAdts->headerBits)/8)<0x2000); /*13 bit*/
FDK_ASSERT(buffer_fullness<0x800); /* 11 bit */
if (!hAdts->protection_absent) {
FDKcrcReset(&hAdts->crcInfo);
}
if (hAdts->currentBlock == 0) {
FDKresetBitbuffer(hBitStream, BS_WRITER);
}
hAdts->subFrameStartBit = FDKgetValidBits(hBitStream);
/* Skip new header if this is raw data block 1..n */
if (hAdts->currentBlock == 0)
{
FDKresetBitbuffer(hBitStream, BS_WRITER);
if (hAdts->num_raw_blocks == 0) {
crcIndex = adtsWrite_CrcStartReg(hAdts, hBitStream, 0);
}
/* fixed header */
FDKwriteBits(hBitStream, 0xFFF, 12);
FDKwriteBits(hBitStream, hAdts->mpeg_id, 1);
FDKwriteBits(hBitStream, hAdts->layer, 2);
FDKwriteBits(hBitStream, hAdts->protection_absent, 1);
FDKwriteBits(hBitStream, hAdts->profile, 2);
FDKwriteBits(hBitStream, hAdts->sample_freq_index, 4);
FDKwriteBits(hBitStream, hAdts->private_bit, 1);
FDKwriteBits(hBitStream, getChannelConfig(hAdts->channel_mode), 3);
FDKwriteBits(hBitStream, hAdts->original, 1);
FDKwriteBits(hBitStream, hAdts->home, 1);
/* variable header */
FDKwriteBits(hBitStream, hAdts->copyright_id, 1);
FDKwriteBits(hBitStream, hAdts->copyright_start, 1);
FDKwriteBits(hBitStream, (frame_length + hAdts->headerBits)>>3, 13);
FDKwriteBits(hBitStream, buffer_fullness, 11);
FDKwriteBits(hBitStream, hAdts->num_raw_blocks, 2);
if (!hAdts->protection_absent) {
int i;
/* End header CRC portion for single raw data block and write dummy zero values for unknown fields. */
if (hAdts->num_raw_blocks == 0) {
adtsWrite_CrcEndReg(hAdts, hBitStream, crcIndex);
} else {
for (i=0; i<hAdts->num_raw_blocks; i++) {
FDKwriteBits(hBitStream, 0, 16);
}
}
FDKwriteBits(hBitStream, 0, 16);
}
} /* End of ADTS header */
static void CTns_Filter (FIXP_DBL *spec, int size, int inc, FIXP_TCC coeff [], int order)
{
// - Simple all-pole filter of order "order" defined by
// y(n) = x(n) - a(2)*y(n-1) - ... - a(order+1)*y(n-order)
//
// - The state variables of the filter are initialized to zero every time
//
// - The output data is written over the input data ("in-place operation")
//
// - An input vector of "size" samples is processed and the index increment
// to the next data sample is given by "inc"
int i,j,N;
FIXP_DBL *pSpec;
FIXP_DBL maxVal=FL2FXCONST_DBL(0.0);
INT s;
FDK_ASSERT(order <= TNS_MAXIMUM_ORDER);
C_ALLOC_SCRATCH_START(state, FIXP_DBL, TNS_MAXIMUM_ORDER);
FDKmemclear(state, order*sizeof(FIXP_DBL));
for (i=0; i<size; i++) {
maxVal = fixMax(maxVal,fixp_abs(spec[i]));
}
if ( maxVal > FL2FXCONST_DBL(0.03125*0.70710678118) )
s = fixMax(CntLeadingZeros(maxVal)-6,0);
else
s = fixMax(CntLeadingZeros(maxVal)-5,0);
s = fixMin(s,2);
s = s-1;
if (inc == -1)
pSpec = &spec[size - 1];
else
pSpec = &spec[0];
FIXP_TCC *pCoeff;
#define FIRST_PART_FLTR \
FIXP_DBL x, *pState = state; \
pCoeff = coeff; \
\
if (s < 0) \
x = (pSpec [0]>>1) + fMultDiv2 (*pCoeff++, pState [0]) ; \
else \
x = (pSpec [0]<<s) + fMultDiv2 (*pCoeff++, pState [0]) ;
#define INNER_FLTR_INLINE \
x = fMultAddDiv2 (x, *pCoeff, pState [1]); \
pState [0] = pState [1] - (fMultDiv2 (*pCoeff++, x) <<2) ; \
pState++;
#define LAST_PART_FLTR \
if (s < 0) \
*pSpec = x << 1; \
else \
*pSpec = x >> s; \
*pState =(-x) << 1; \
pSpec += inc ;
if (order>8)
{
N = (order-1)&7;
for (i = size ; i != 0 ; i--)
{
FIRST_PART_FLTR
for (j = N; j > 0 ; j--) { INNER_FLTR_INLINE }
INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE
INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE INNER_FLTR_INLINE
LAST_PART_FLTR
}
} else if (order>4) {
int CProgramConfig_GetElementTable(
const CProgramConfig *pPce,
MP4_ELEMENT_ID elList[],
const INT elListSize,
UCHAR *pChMapIdx
)
{
int i, el = 0;
FDK_ASSERT(elList != NULL);
FDK_ASSERT(pChMapIdx != NULL);
*pChMapIdx = 0;
if ( elListSize
< pPce->NumFrontChannelElements + pPce->NumSideChannelElements + pPce->NumBackChannelElements + pPce->NumLfeChannelElements
)
{
return 0;
}
for (i=0; i < pPce->NumFrontChannelElements; i++)
{
elList[el++] = (pPce->FrontElementIsCpe[i]) ? ID_CPE : ID_SCE;
}
for (i=0; i < pPce->NumSideChannelElements; i++)
{
elList[el++] = (pPce->SideElementIsCpe[i]) ? ID_CPE : ID_SCE;
}
for (i=0; i < pPce->NumBackChannelElements; i++)
{
elList[el++] = (pPce->BackElementIsCpe[i]) ? ID_CPE : ID_SCE;
}
for (i=0; i < pPce->NumLfeChannelElements; i++)
{
elList[el++] = ID_LFE;
}
/* Find an corresponding channel configuration if possible */
switch (pPce->NumChannels) {
case 1: case 2: case 3: case 4: case 5: case 6:
/* One and two channels have no alternatives. The other ones are mapped directly to the
corresponding channel config. Because of legacy reasons or for lack of alternative mappings. */
*pChMapIdx = pPce->NumChannels;
break;
case 7:
{
C_ALLOC_SCRATCH_START(tmpPce, CProgramConfig, 1);
/* Create a PCE for the config to test ... */
CProgramConfig_GetDefault(tmpPce, 11);
/* ... and compare it with the given one. */
*pChMapIdx = (!(CProgramConfig_Compare(pPce, tmpPce)&0xE)) ? 11 : 0;
/* If compare result is 0 or 1 we can be sure that it is channel config 11. */
C_ALLOC_SCRATCH_END(tmpPce, CProgramConfig, 1);
}
break;
case 8:
{ /* Try the four possible 7.1ch configurations. One after the other. */
UCHAR testCfg[4] = { 32, 14, 12, 7};
C_ALLOC_SCRATCH_START(tmpPce, CProgramConfig, 1);
for (i=0; i<4; i+=1) {
/* Create a PCE for the config to test ... */
CProgramConfig_GetDefault(tmpPce, testCfg[i]);
/* ... and compare it with the given one. */
if (!(CProgramConfig_Compare(pPce, tmpPce)&0xE)) {
/* If the compare result is 0 or 1 than the two channel configurations match. */
/* Explicit mapping of 7.1 side channel configuration to 7.1 rear channel mapping. */
*pChMapIdx = (testCfg[i]==32) ? 12 : testCfg[i];
}
}
C_ALLOC_SCRATCH_END(tmpPce, CProgramConfig, 1);
}
break;
default:
/* The PCE does not match any predefined channel configuration. */
*pChMapIdx = 0;
break;
}
return el;
}
void CProgramConfig_GetDefault( CProgramConfig *pPce,
const UINT channelConfig )
{
FDK_ASSERT(pPce != NULL);
/* Init PCE */
CProgramConfig_Init(pPce);
pPce->Profile = 1; /* Set AAC LC because it is the only supported object type. */
switch (channelConfig) {
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
case 32: /* 7.1 side channel configuration as defined in FDK_audio.h */
pPce->NumFrontChannelElements = 2;
pPce->FrontElementIsCpe[0] = 0;
pPce->FrontElementIsCpe[1] = 1;
pPce->NumSideChannelElements = 1;
pPce->SideElementIsCpe[0] = 1;
pPce->NumBackChannelElements = 1;
pPce->BackElementIsCpe[0] = 1;
pPce->NumLfeChannelElements = 1;
pPce->NumChannels = 8;
pPce->NumEffectiveChannels = 7;
pPce->isValid = 1;
break;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
case 12: /* 3/0/4.1ch surround back */
pPce->BackElementIsCpe[1] = 1;
pPce->NumChannels += 1;
pPce->NumEffectiveChannels += 1;
case 11: /* 3/0/3.1ch */
pPce->NumFrontChannelElements += 2;
pPce->FrontElementIsCpe[0] = 0;
pPce->FrontElementIsCpe[1] = 1;
pPce->NumBackChannelElements += 2;
pPce->BackElementIsCpe[0] = 1;
pPce->BackElementIsCpe[1] += 0;
pPce->NumLfeChannelElements += 1;
pPce->NumChannels += 7;
pPce->NumEffectiveChannels += 6;
pPce->isValid = 1;
break;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
case 14: /* 2/0/0-3/0/2-0.1ch front height */
pPce->FrontElementHeightInfo[2] = 1; /* Top speaker */
case 7: /* 5/0/2.1ch front */
pPce->NumFrontChannelElements += 1;
pPce->FrontElementIsCpe[2] = 1;
pPce->NumChannels += 2;
pPce->NumEffectiveChannels += 2;
case 6: /* 3/0/2.1ch */
pPce->NumLfeChannelElements += 1;
pPce->NumChannels += 1;
case 5: /* 3/0/2.0ch */
case 4: /* 3/0/1.0ch */
pPce->NumBackChannelElements += 1;
pPce->BackElementIsCpe[0] = (channelConfig>4) ? 1 : 0;
pPce->NumChannels += (channelConfig>4) ? 2 : 1;
pPce->NumEffectiveChannels += (channelConfig>4) ? 2 : 1;
case 3: /* 3/0/0.0ch */
pPce->NumFrontChannelElements += 1;
pPce->FrontElementIsCpe[1] = 1;
pPce->NumChannels += 2;
pPce->NumEffectiveChannels += 2;
case 1: /* 1/0/0.0ch */
pPce->NumFrontChannelElements += 1;
pPce->FrontElementIsCpe[0] = 0;
pPce->NumChannels += 1;
pPce->NumEffectiveChannels += 1;
pPce->isValid = 1;
break;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
case 2: /* 2/0/0.ch */
pPce->NumFrontChannelElements = 1;
pPce->FrontElementIsCpe[0] = 1;
pPce->NumChannels += 2;
pPce->NumEffectiveChannels += 2;
pPce->isValid = 1;
break;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
default:
pPce->isValid = 0; /* To be explicit! */
break;
}
if (pPce->isValid) {
/* Create valid element instance tags */
int el, elTagSce = 0, elTagCpe = 0;
for (el = 0; el < pPce->NumFrontChannelElements; el += 1) {
pPce->FrontElementTagSelect[el] = (pPce->FrontElementIsCpe[el]) ? elTagCpe++ : elTagSce++;
}
for (el = 0; el < pPce->NumSideChannelElements; el += 1) {
pPce->SideElementTagSelect[el] = (pPce->SideElementIsCpe[el]) ? elTagCpe++ : elTagSce++;
}
for (el = 0; el < pPce->NumBackChannelElements; el += 1) {
pPce->BackElementTagSelect[el] = (pPce->BackElementIsCpe[el]) ? elTagCpe++ : elTagSce++;
}
elTagSce = 0;
for (el = 0; el < pPce->NumLfeChannelElements; el += 1) {
pPce->LfeElementTagSelect[el] = elTagSce++;
}
}
}
/*
* Arbitrary order bitstream parser
*/
AAC_DECODER_ERROR CChannelElement_Read(
HANDLE_FDK_BITSTREAM hBs, CAacDecoderChannelInfo *pAacDecoderChannelInfo[],
CAacDecoderStaticChannelInfo *pAacDecoderStaticChannelInfo[],
const AUDIO_OBJECT_TYPE aot, SamplingRateInfo *pSamplingRateInfo,
const UINT flags, const UINT elFlags, const UINT frame_length,
const UCHAR numberOfChannels, const SCHAR epConfig,
HANDLE_TRANSPORTDEC pTpDec) {
AAC_DECODER_ERROR error = AAC_DEC_OK;
const element_list_t *list;
int i, ch, decision_bit;
int crcReg1 = -1, crcReg2 = -1;
int cplxPred;
int ind_sw_cce_flag = 0, num_gain_element_lists = 0;
FDK_ASSERT((numberOfChannels == 1) || (numberOfChannels == 2));
/* Get channel element sequence table */
list = getBitstreamElementList(aot, epConfig, numberOfChannels, 0, elFlags);
if (list == NULL) {
error = AAC_DEC_UNSUPPORTED_FORMAT;
goto bail;
}
CTns_Reset(&pAacDecoderChannelInfo[0]->pDynData->TnsData);
/* Set common window to 0 by default. If signalized in the bit stream it will
* be overwritten later explicitely */
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow = 0;
if (flags & (AC_USAC | AC_RSVD50 | AC_RSV603DA)) {
pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_active = 0;
pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_on_lr = 0;
}
if (numberOfChannels == 2) {
CTns_Reset(&pAacDecoderChannelInfo[1]->pDynData->TnsData);
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow = 0;
}
cplxPred = 0;
if (pAacDecoderStaticChannelInfo != NULL) {
if (elFlags & AC_EL_USAC_CP_POSSIBLE) {
pAacDecoderChannelInfo[0]->pComData->jointStereoData.cplx_pred_flag = 0;
cplxPred = 1;
}
}
if (0 || (flags & (AC_ELD | AC_SCALABLE))) {
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow = 1;
if (numberOfChannels == 2) {
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow =
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow;
}
}
/* Iterate through sequence table */
i = 0;
ch = 0;
decision_bit = 0;
do {
switch (list->id[i]) {
case element_instance_tag:
pAacDecoderChannelInfo[0]->ElementInstanceTag = FDKreadBits(hBs, 4);
if (numberOfChannels == 2) {
pAacDecoderChannelInfo[1]->ElementInstanceTag =
pAacDecoderChannelInfo[0]->ElementInstanceTag;
}
break;
case common_window:
decision_bit =
pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.CommonWindow =
FDKreadBits(hBs, 1);
if (numberOfChannels == 2) {
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow =
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow;
}
break;
case ics_info:
/* store last window sequence (utilized in complex stereo prediction)
* before reading new channel-info */
if (cplxPred) {
if (pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow) {
pAacDecoderStaticChannelInfo[0]
->pCpeStaticData->jointStereoPersistentData.winSeqPrev =
pAacDecoderChannelInfo[0]->icsInfo.WindowSequence;
pAacDecoderStaticChannelInfo[0]
->pCpeStaticData->jointStereoPersistentData.winShapePrev =
pAacDecoderChannelInfo[0]->icsInfo.WindowShape;
}
}
/* Read individual channel info */
error = IcsRead(hBs, &pAacDecoderChannelInfo[ch]->icsInfo,
pSamplingRateInfo, flags);
if (elFlags & AC_EL_LFE &&
GetWindowSequence(&pAacDecoderChannelInfo[ch]->icsInfo) !=
BLOCK_LONG) {
error = AAC_DEC_PARSE_ERROR;
break;
}
if (numberOfChannels == 2 &&
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow) {
pAacDecoderChannelInfo[1]->icsInfo =
pAacDecoderChannelInfo[0]->icsInfo;
}
break;
case common_max_sfb:
if (FDKreadBit(hBs) == 0) {
error = IcsReadMaxSfb(hBs, &pAacDecoderChannelInfo[1]->icsInfo,
pSamplingRateInfo);
}
break;
case ltp_data_present:
if (FDKreadBits(hBs, 1) != 0) {
error = AAC_DEC_UNSUPPORTED_PREDICTION;
}
break;
case ms:
INT max_sfb_ste;
INT max_sfb_ste_clear;
max_sfb_ste = GetScaleMaxFactorBandsTransmitted(
&pAacDecoderChannelInfo[0]->icsInfo,
&pAacDecoderChannelInfo[1]->icsInfo);
max_sfb_ste_clear = 64;
pAacDecoderChannelInfo[0]->icsInfo.max_sfb_ste = (UCHAR)max_sfb_ste;
pAacDecoderChannelInfo[1]->icsInfo.max_sfb_ste = (UCHAR)max_sfb_ste;
if (flags & (AC_USAC | AC_RSV603DA) &&
pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.CommonWindow ==
0) {
Clean_Complex_Prediction_coefficients(
&pAacDecoderStaticChannelInfo[0]
->pCpeStaticData->jointStereoPersistentData,
GetWindowGroups(&pAacDecoderChannelInfo[0]->icsInfo), 0, 64);
}
if (CJointStereo_Read(
hBs, &pAacDecoderChannelInfo[0]->pComData->jointStereoData,
GetWindowGroups(&pAacDecoderChannelInfo[0]->icsInfo),
max_sfb_ste, max_sfb_ste_clear,
/* jointStereoPersistentData and cplxPredictionData are only
available/allocated if cplxPred is active. */
((cplxPred == 0) || (pAacDecoderStaticChannelInfo == NULL))
? NULL
: &pAacDecoderStaticChannelInfo[0]
->pCpeStaticData->jointStereoPersistentData,
((cplxPred == 0) || (pAacDecoderChannelInfo[0] == NULL))
? NULL
: pAacDecoderChannelInfo[0]
->pComStaticData->cplxPredictionData,
cplxPred,
GetScaleFactorBandsTotal(&pAacDecoderChannelInfo[0]->icsInfo),
GetWindowSequence(&pAacDecoderChannelInfo[0]->icsInfo),
flags)) {
error = AAC_DEC_PARSE_ERROR;
}
break;
case global_gain:
pAacDecoderChannelInfo[ch]->pDynData->RawDataInfo.GlobalGain =
(UCHAR)FDKreadBits(hBs, 8);
break;
case section_data:
error = CBlock_ReadSectionData(hBs, pAacDecoderChannelInfo[ch],
pSamplingRateInfo, flags);
break;
case scale_factor_data_usac:
pAacDecoderChannelInfo[ch]->currAliasingSymmetry = 0;
/* Set active sfb codebook indexes to HCB_ESC to make them "active" */
CChannel_CodebookTableInit(
pAacDecoderChannelInfo[ch]); /* equals ReadSectionData(self,
bs) in float soft. block.c
line: ~599 */
/* Note: The missing "break" is intentional here, since we need to call
* CBlock_ReadScaleFactorData(). */
FDK_FALLTHROUGH;
case scale_factor_data:
if (flags & AC_ER_RVLC) {
/* read RVLC data from bitstream (error sens. cat. 1) */
CRvlc_Read(pAacDecoderChannelInfo[ch], hBs);
} else {
error = CBlock_ReadScaleFactorData(pAacDecoderChannelInfo[ch], hBs,
flags);
}
break;
case pulse:
if (CPulseData_Read(
hBs,
&pAacDecoderChannelInfo[ch]->pDynData->specificTo.aac.PulseData,
pSamplingRateInfo->ScaleFactorBands_Long, /* pulse data is only
allowed to be
present in long
blocks! */
(void *)&pAacDecoderChannelInfo[ch]->icsInfo,
frame_length) != 0) {
error = AAC_DEC_DECODE_FRAME_ERROR;
}
break;
case tns_data_present:
CTns_ReadDataPresentFlag(
hBs, &pAacDecoderChannelInfo[ch]->pDynData->TnsData);
if (elFlags & AC_EL_LFE &&
pAacDecoderChannelInfo[ch]->pDynData->TnsData.DataPresent) {
error = AAC_DEC_PARSE_ERROR;
}
break;
case tns_data:
/* tns_data_present is checked inside CTns_Read(). */
error = CTns_Read(hBs, &pAacDecoderChannelInfo[ch]->pDynData->TnsData,
&pAacDecoderChannelInfo[ch]->icsInfo, flags);
break;
case gain_control_data:
break;
case gain_control_data_present:
if (FDKreadBits(hBs, 1)) {
error = AAC_DEC_UNSUPPORTED_GAIN_CONTROL_DATA;
}
break;
case tw_data:
break;
case common_tw:
break;
case tns_data_present_usac:
if (pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_active) {
CTns_ReadDataPresentUsac(
hBs, &pAacDecoderChannelInfo[0]->pDynData->TnsData,
&pAacDecoderChannelInfo[1]->pDynData->TnsData,
&pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_on_lr,
&pAacDecoderChannelInfo[0]->icsInfo, flags, elFlags,
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow);
} else {
pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_on_lr =
(UCHAR)1;
}
break;
case core_mode:
decision_bit = FDKreadBits(hBs, 1);
pAacDecoderChannelInfo[ch]->data.usac.core_mode = decision_bit;
if ((ch == 1) && (pAacDecoderChannelInfo[0]->data.usac.core_mode !=
pAacDecoderChannelInfo[1]->data.usac.core_mode)) {
/* StereoCoreToolInfo(core_mode[ch] ) */
pAacDecoderChannelInfo[0]->pDynData->RawDataInfo.CommonWindow = 0;
pAacDecoderChannelInfo[1]->pDynData->RawDataInfo.CommonWindow = 0;
}
break;
case tns_active:
pAacDecoderChannelInfo[0]->pDynData->specificTo.usac.tns_active =
FDKreadBit(hBs);
break;
case noise:
if (elFlags & AC_EL_USAC_NOISE) {
pAacDecoderChannelInfo[ch]
->pDynData->specificTo.usac.fd_noise_level_and_offset =
FDKreadBits(hBs, 3 + 5); /* Noise level */
}
break;
case lpd_channel_stream:
{
error = CLpdChannelStream_Read(/* = lpd_channel_stream() */
hBs, pAacDecoderChannelInfo[ch],
pAacDecoderStaticChannelInfo[ch],
pSamplingRateInfo, flags);
}
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_LPD;
break;
case fac_data: {
int fFacDatPresent = FDKreadBit(hBs);
/* Wee need a valid fac_data[0] even if no FAC data is present (as
* temporal buffer) */
pAacDecoderChannelInfo[ch]->data.usac.fac_data[0] =
pAacDecoderChannelInfo[ch]->data.usac.fac_data0;
if (fFacDatPresent) {
if (elFlags & AC_EL_LFE) {
error = AAC_DEC_PARSE_ERROR;
break;
}
/* FAC data present, this frame is FD, so the last mode had to be
* ACELP. */
if (pAacDecoderStaticChannelInfo[ch]->last_core_mode != LPD ||
pAacDecoderStaticChannelInfo[ch]->last_lpd_mode != 0) {
pAacDecoderChannelInfo[ch]->data.usac.core_mode_last = LPD;
pAacDecoderChannelInfo[ch]->data.usac.lpd_mode_last = 0;
/* We can't change the past! So look to the future and go ahead! */
}
CLpd_FAC_Read(hBs, pAacDecoderChannelInfo[ch]->data.usac.fac_data[0],
pAacDecoderChannelInfo[ch]->data.usac.fac_data_e,
CLpd_FAC_getLength(
IsLongBlock(&pAacDecoderChannelInfo[ch]->icsInfo),
pAacDecoderChannelInfo[ch]->granuleLength),
1, 0);
} else {
if (pAacDecoderStaticChannelInfo[ch]->last_core_mode == LPD &&
pAacDecoderStaticChannelInfo[ch]->last_lpd_mode == 0) {
/* ACELP to FD transitons without FAC are possible. That is why we
zero it out (i.e FAC will not be considered in the subsequent
calculations */
FDKmemclear(pAacDecoderChannelInfo[ch]->data.usac.fac_data0,
LFAC * sizeof(FIXP_DBL));
}
}
} break;
case esc2_rvlc:
if (flags & AC_ER_RVLC) {
CRvlc_Decode(pAacDecoderChannelInfo[ch],
pAacDecoderStaticChannelInfo[ch], hBs);
}
break;
case esc1_hcr:
if (flags & AC_ER_HCR) {
CHcr_Read(hBs, pAacDecoderChannelInfo[ch],
numberOfChannels == 2 ? ID_CPE : ID_SCE);
}
break;
case spectral_data:
error = CBlock_ReadSpectralData(hBs, pAacDecoderChannelInfo[ch],
pSamplingRateInfo, flags);
if (flags & AC_ELD) {
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_ELDFB;
} else {
if (flags & AC_HDAAC) {
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_INTIMDCT;
} else {
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_IMDCT;
}
}
break;
case ac_spectral_data:
error = CBlock_ReadAcSpectralData(
hBs, pAacDecoderChannelInfo[ch], pAacDecoderStaticChannelInfo[ch],
pSamplingRateInfo, frame_length, flags);
pAacDecoderChannelInfo[ch]->renderMode = AACDEC_RENDER_IMDCT;
break;
case coupled_elements: {
int num_coupled_elements, c;
ind_sw_cce_flag = FDKreadBit(hBs);
num_coupled_elements = FDKreadBits(hBs, 3);
for (c = 0; c < (num_coupled_elements + 1); c++) {
int cc_target_is_cpe;
num_gain_element_lists++;
cc_target_is_cpe = FDKreadBit(hBs); /* cc_target_is_cpe[c] */
FDKreadBits(hBs, 4); /* cc_target_tag_select[c] */
if (cc_target_is_cpe) {
int cc_l, cc_r;
cc_l = FDKreadBit(hBs); /* cc_l[c] */
cc_r = FDKreadBit(hBs); /* cc_r[c] */
if (cc_l && cc_r) {
num_gain_element_lists++;
}
}
}
FDKreadBit(hBs); /* cc_domain */
FDKreadBit(hBs); /* gain_element_sign */
FDKreadBits(hBs, 2); /* gain_element_scale */
} break;
case gain_element_lists: {
const CodeBookDescription *hcb;
UCHAR *pCodeBook;
int c;
hcb = &AACcodeBookDescriptionTable[BOOKSCL];
pCodeBook = pAacDecoderChannelInfo[ch]->pDynData->aCodeBook;
for (c = 1; c < num_gain_element_lists; c++) {
int cge;
if (ind_sw_cce_flag) {
cge = 1;
} else {
cge = FDKreadBits(hBs, 1); /* common_gain_element_present[c] */
}
if (cge) {
/* Huffman */
CBlock_DecodeHuffmanWord(
hBs, hcb); /* hcod_sf[common_gain_element[c]] 1..19 */
} else {
int g, sfb;
for (g = 0;
g < GetWindowGroups(&pAacDecoderChannelInfo[ch]->icsInfo);
g++) {
for (sfb = 0; sfb < GetScaleFactorBandsTransmitted(
&pAacDecoderChannelInfo[ch]->icsInfo);
sfb++) {
if (pCodeBook[sfb] != ZERO_HCB) {
/* Huffman */
CBlock_DecodeHuffmanWord(
hBs,
hcb); /* hcod_sf[dpcm_gain_element[c][g][sfb]] 1..19 */
}
}
}
}
}
} break;
/* CRC handling */
case adtscrc_start_reg1:
if (pTpDec != NULL) {
crcReg1 = transportDec_CrcStartReg(pTpDec, 192);
}
break;
case adtscrc_start_reg2:
if (pTpDec != NULL) {
crcReg2 = transportDec_CrcStartReg(pTpDec, 128);
}
break;
case adtscrc_end_reg1:
case drmcrc_end_reg:
if (pTpDec != NULL) {
transportDec_CrcEndReg(pTpDec, crcReg1);
crcReg1 = -1;
}
break;
case adtscrc_end_reg2:
if (crcReg1 != -1) {
error = AAC_DEC_DECODE_FRAME_ERROR;
} else if (pTpDec != NULL) {
transportDec_CrcEndReg(pTpDec, crcReg2);
crcReg2 = -1;
}
break;
case drmcrc_start_reg:
if (pTpDec != NULL) {
crcReg1 = transportDec_CrcStartReg(pTpDec, 0);
}
break;
/* Non data cases */
case next_channel:
ch = (ch + 1) % numberOfChannels;
break;
case link_sequence:
list = list->next[decision_bit];
i = -1;
break;
default:
error = AAC_DEC_UNSUPPORTED_FORMAT;
break;
}
if (error != AAC_DEC_OK) {
goto bail;
}
i++;
} while (list->id[i] != end_of_sequence);
for (ch = 0; ch < numberOfChannels; ch++) {
if (pAacDecoderChannelInfo[ch]->renderMode == AACDEC_RENDER_IMDCT ||
pAacDecoderChannelInfo[ch]->renderMode == AACDEC_RENDER_ELDFB) {
/* Shows which bands are empty. */
UCHAR *band_is_noise =
pAacDecoderChannelInfo[ch]->pDynData->band_is_noise;
FDKmemset(band_is_noise, (UCHAR)1, sizeof(UCHAR) * (8 * 16));
error = CBlock_InverseQuantizeSpectralData(
pAacDecoderChannelInfo[ch], pSamplingRateInfo, band_is_noise, 1);
if (error != AAC_DEC_OK) {
return error;
}
if (elFlags & AC_EL_USAC_NOISE) {
CBlock_ApplyNoise(pAacDecoderChannelInfo[ch], pSamplingRateInfo,
&pAacDecoderStaticChannelInfo[ch]->nfRandomSeed,
band_is_noise);
} /* if (elFlags & AC_EL_USAC_NOISE) */
}
}
bail:
if (crcReg1 != -1 || crcReg2 != -1) {
if (error == AAC_DEC_OK) {
error = AAC_DEC_DECODE_FRAME_ERROR;
}
if (crcReg1 != -1) {
transportDec_CrcEndReg(pTpDec, crcReg1);
}
if (crcReg2 != -1) {
transportDec_CrcEndReg(pTpDec, crcReg2);
}
}
return error;
}
void CJointStereo_ApplyMS(
CAacDecoderChannelInfo *pAacDecoderChannelInfo[2],
const SHORT *pScaleFactorBandOffsets,
const UCHAR *pWindowGroupLength,
const int windowGroups,
const int scaleFactorBandsTransmittedL,
const int scaleFactorBandsTransmittedR
)
{
CJointStereoData *pJointStereoData = &pAacDecoderChannelInfo[L]->pComData->jointStereoData;
int window, group, scaleFactorBandsTransmitted;
FDK_ASSERT(scaleFactorBandsTransmittedL == scaleFactorBandsTransmittedR);
scaleFactorBandsTransmitted = scaleFactorBandsTransmittedL;
for (window = 0, group = 0; group < windowGroups; group++)
{
UCHAR groupMask = 1 << group;
for (int groupwin=0; groupwin<pWindowGroupLength[group]; groupwin++, window++)
{
int band;
FIXP_DBL *leftSpectrum, *rightSpectrum;
SHORT *leftScale = &pAacDecoderChannelInfo[L]->pDynData->aSfbScale[window*16];
SHORT *rightScale = &pAacDecoderChannelInfo[R]->pDynData->aSfbScale[window*16];
leftSpectrum = SPEC(pAacDecoderChannelInfo[L]->pSpectralCoefficient, window, pAacDecoderChannelInfo[L]->granuleLength);
rightSpectrum = SPEC(pAacDecoderChannelInfo[R]->pSpectralCoefficient, window, pAacDecoderChannelInfo[R]->granuleLength);
for (band=0; band<scaleFactorBandsTransmitted; band++)
{
if (pJointStereoData->MsUsed[band] & groupMask)
{
int lScale=leftScale[band];
int rScale=rightScale[band];
int commonScale=lScale > rScale ? lScale:rScale;
/* ISO/IEC 14496-3 Chapter 4.6.8.1.1 :
M/S joint channel coding can only be used if common_window is ‘1’. */
FDK_ASSERT(GetWindowSequence(&pAacDecoderChannelInfo[L]->icsInfo) == GetWindowSequence(&pAacDecoderChannelInfo[R]->icsInfo));
FDK_ASSERT(GetWindowShape(&pAacDecoderChannelInfo[L]->icsInfo) == GetWindowShape(&pAacDecoderChannelInfo[R]->icsInfo));
commonScale++;
leftScale[band]=commonScale;
rightScale[band]=commonScale;
lScale = fMin(DFRACT_BITS-1, commonScale - lScale);
rScale = fMin(DFRACT_BITS-1, commonScale - rScale);
FDK_ASSERT(lScale >= 0 && rScale >= 0);
for (int index=pScaleFactorBandOffsets[band]; index<pScaleFactorBandOffsets[band+1]; index++)
{
FIXP_DBL leftCoefficient = leftSpectrum [index] ;
FIXP_DBL rightCoefficient = rightSpectrum [index] ;
leftCoefficient >>= lScale ;
rightCoefficient >>= rScale ;
leftSpectrum [index] = leftCoefficient + rightCoefficient ;
rightSpectrum [index] = leftCoefficient - rightCoefficient ;
}
}
}
}
}
