/*
Reset downsampler instance and clear delay lines
returns status
*/
int
InitIIR21_Resampler(IIR21_RESAMPLER *ReSampler)
{
COUNT_sub_start("InitDownsampler");
INDIRECT(1); MOVE(1);
ReSampler->iirFilter.ptr = 0;
INDIRECT(8); MOVE(4);
ReSampler->iirFilter.coeffIIRa = set1.coeffIIRa;
ReSampler->iirFilter.coeffIIRb = set1.coeffIIRb;
ReSampler->iirFilter.noOffCoeffs = set1.noOffCoeffs;
ReSampler->delay=set1.delay;
assert(ReSampler->iirFilter.noOffCoeffs <= BUFFER_SIZE);
INDIRECT(1); MOVE(1);
ReSampler->ratio = 2;
INDIRECT(1); STORE(1);
ReSampler->pending = 1;
COUNT_sub_end();
return 1;
}
/*
\brief crc calculation
*/
static unsigned long
calcCRC (HANDLE_CRC hCrcBuf, unsigned long bValue, int nBits)
{
int i;
unsigned long bMask = (1UL << (nBits - 1));
FLC_sub_start("calcCRC");
ADD(1); SHIFT(1); /* counting previous operations */
LOOP(1);
for (i = 0; i < nBits; i++, bMask >>= 1) {
unsigned short flag = (hCrcBuf->crcState & hCrcBuf->crcMask) ? 1 : 0;
unsigned short flag1 = (bMask & bValue) ? 1 : 0;
INDIRECT(2); ADD(2); LOGIC(2); BRANCH(2); MOVE(2); /* counting previous operations */
LOGIC(1);
flag ^= flag1;
SHIFT(1); STORE(1);
hCrcBuf->crcState <<= 1;
BRANCH(1);
if (flag)
{
INDIRECT(1); LOGIC(1); STORE(1);
hCrcBuf->crcState ^= hCrcBuf->crcPoly;
}
}
FLC_sub_end();
return (hCrcBuf->crcState);
}
void AacEncClose (struct AAC_ENCODER* hAacEnc)
{
int error=0;
COUNT_sub_start("AacEncClose");
MOVE(1); /* counting previous operation */
BRANCH(1);
if (hAacEnc) {
INDIRECT(1); PTR_INIT(1); FUNC(1);
QCDelete(&hAacEnc->qcKernel);
INDIRECT(1); PTR_INIT(1); FUNC(1);
QCOutDelete(&hAacEnc->qcOut);
INDIRECT(1); PTR_INIT(1); FUNC(1);
error = PsyDelete(&hAacEnc->psyKernel);
INDIRECT(1); PTR_INIT(1); FUNC(1);
error = PsyOutDelete(&hAacEnc->psyOut);
INDIRECT(1); PTR_INIT(1); FUNC(1);
DeleteBitBuffer(&hAacEnc->hBitStream);
PTR_INIT(1);
hAacEnc=0;
}
COUNT_sub_end();
}
static void Z124_lambda(CL_FORM *base)
{
if(CL_SMSTRP(ARG(1)))
{
COPY(INDIRECT(GET_FORM(ARG(0)) + 4), ARG(2));
COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(3));
Ffuncall(ARG(2), 2);
COPY(ARG(2), ARG(0));
}
else
{
if(CL_CONSP(ARG(1)))
{
COPY(GET_CAR(ARG(1)), ARG(2));
if(CL_SYMBOLP(ARG(2)) && GET_SYMBOL(ARG(2)) == SYMBOL(Slisp, 255)) /* CHARACTER-SET */
{
LOAD_SYMBOL(SYMBOL(Slisp, 255), ARG(3)); /* CHARACTER-SET */
COPY(INDIRECT(GET_FORM(ARG(0)) + 4), ARG(4));
COPY(GET_CDR(ARG(1)), ARG(5));
Ffuncall(ARG(4), 2);
mv_count = 1;
ALLOC_CONS(ARG(5), ARG(3), ARG(4), ARG(0));
}
else
{
COPY(ARG(1), ARG(0));
}
}
else
{
COPY(ARG(1), ARG(0));
}
}
}
/*
The function applies the pulse data to the
specified spectral lines.
*/
void CPulseData_Apply(CPulseData *PulseData, /*!< pointer to pulse data side info */
const short *pScaleFactorBandOffsets, /*!< pointer to scalefactor band offsets */
int *coef) /*!< pointer to spectrum */
{
int i,k;
FLC_sub_start("CPulseData_Apply");
INDIRECT(1); BRANCH(1);
if (PulseData->PulseDataPresent)
{
INDIRECT(1); MOVE(1);
k = pScaleFactorBandOffsets[PulseData->PulseStartBand];
PTR_INIT(2); /* PulseData->PulseOffset[i]
PulseData->PulseAmp[i]
*/
LOOP(1);
for (i=0; i<=PulseData->NumberPulse; i++)
{
ADD(1);
k += PulseData->PulseOffset[i];
INDIRECT(1); BRANCH(1); ADD(1); STORE(1);
if (coef [k] > 0) coef[k] += PulseData->PulseAmp[i];
else coef[k] -= PulseData->PulseAmp[i];
}
}
FLC_sub_end();
}
/* apply reduction formula */
static void reduceThresholds(PSY_OUT_CHANNEL psyOutChannel[MAX_CHANNELS],
int ahFlag[MAX_CHANNELS][MAX_GROUPED_SFB],
float thrExp[MAX_CHANNELS][MAX_GROUPED_SFB],
const int nChannels,
const float redVal)
{
int ch, sfb,sfbGrp;
float sfbEn, sfbThr,sfbThrReduced;
COUNT_sub_start("reduceThresholds");
LOOP(1);
for(ch=0; ch<nChannels; ch++) {
PSY_OUT_CHANNEL *psyOutChan = &psyOutChannel[ch];
PTR_INIT(1); /* counting previous operation */
INDIRECT(2); LOOP(1);
for(sfbGrp = 0;sfbGrp < psyOutChan->sfbCnt;sfbGrp+= psyOutChan->sfbPerGroup){
PTR_INIT(5); /* pointers for psyOutChan->sfbMinSnr[sfbGrp+sfb],
psyOutChan->sfbEnergy[sfbGrp+sfb],
psyOutChan->sfbThreshold[sfbGrp+sfb],
thrExp[ch][sfbGrp+sfb],
ahFlag[ch][sfbGrp+sfb]
*/
INDIRECT(1); LOOP(1);
for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++) {
MOVE(2);
sfbEn = psyOutChan->sfbEnergy[sfbGrp+sfb];
sfbThr = psyOutChan->sfbThreshold[sfbGrp+sfb];
ADD(1); BRANCH(1);
if (sfbEn > sfbThr) {
/* threshold reduction formula */
ADD(1); TRANS(1);
sfbThrReduced = (float) pow(thrExp[ch][sfbGrp+sfb]+redVal, invRedExp);
/* avoid holes */
MULT(1); ADD(2); LOGIC(1); BRANCH(1);
if ((sfbThrReduced > psyOutChan->sfbMinSnr[sfbGrp+sfb] * sfbEn) && (ahFlag[ch][sfbGrp+sfb] != NO_AH)){
ADD(1); BRANCH(1); MOVE(1);
sfbThrReduced = max(psyOutChan->sfbMinSnr[sfbGrp+sfb] * sfbEn, sfbThr);
MOVE(1);
ahFlag[ch][sfbGrp+sfb] = AH_ACTIVE;
}
MOVE(1);
psyOutChan->sfbThreshold[sfbGrp+sfb] = sfbThrReduced;
}
}
}
}
COUNT_sub_end();
}
/*!
\brief Delay SBR bitstream
\return none
*/
static void
DelaySbrBitstr(HANDLE_SBR_CONCEAL_DATA hSbrConcealData,
SBRBITSTREAM *hSbrBS,
int *SbrFrameOK)
{
int tmp;
SBRBITSTREAM bs_tmp;
FLC_sub_start("DelaySbrBitstr");
INDIRECT(1); MOVE(1);
tmp = hSbrConcealData->Bitstream->sbrElement[0].ElementID;
INDIRECT(1); MOVE(3);
bs_tmp = hSbrBS[0];
hSbrBS[0] = *(hSbrConcealData->Bitstream);
*(hSbrConcealData->Bitstream) = bs_tmp;
BRANCH(1);
if(!(*SbrFrameOK))
{
MOVE(1);
hSbrConcealData->Bitstream->sbrElement[0].ElementID = tmp;
}
INDIRECT(1); MOVE(2);
tmp = *SbrFrameOK;
*SbrFrameOK = hSbrConcealData->FrameOk;
MOVE(1);
hSbrConcealData->FrameOk = tmp;
FLC_sub_end();
}
/* constants that do not change during successive pe calculations */
static void preparePe(PE_DATA *peData,
PSY_OUT_CHANNEL psyOutChannel[MAX_CHANNELS],
float sfbFormFactor[MAX_CHANNELS][MAX_GROUPED_SFB],
const int nChannels,
const float peOffset)
{
int ch;
COUNT_sub_start("preparePe");
LOOP(1);
for(ch=0; ch<nChannels; ch++) {
PSY_OUT_CHANNEL *psyOutChan = &psyOutChannel[ch];
PTR_INIT(1); /* counting previous operation */
INDIRECT(8); PTR_INIT(1); FUNC(8);
prepareSfbPe(&peData->peChannelData[ch],
psyOutChan->sfbEnergy,
psyOutChan->sfbThreshold,
sfbFormFactor[ch],
psyOutChan->sfbOffsets,
psyOutChan->sfbCnt,
psyOutChan->sfbPerGroup,
psyOutChan->maxSfbPerGroup);
}
INDIRECT(1); MOVE(1);
peData->offset = peOffset;
COUNT_sub_end();
}
/*
The function reads the elements for pulse data from
the bitstream.
*/
void CPulseData_Read(HANDLE_BIT_BUF bs, /*!< pointer to bitstream */
CPulseData *PulseData) /*!< pointer to pulse data side info */
{
int i;
FLC_sub_start("CPulseData_Read");
FUNC(2); INDIRECT(1); STORE(1); BRANCH(1);
if ((PulseData->PulseDataPresent = (char) GetBits(bs,1)))
{
FUNC(2); INDIRECT(2); STORE(1);
PulseData->NumberPulse = (char) GetBits(bs,2);
FUNC(2); INDIRECT(2); STORE(1);
PulseData->PulseStartBand = (char) GetBits(bs,6);
PTR_INIT(2); /* PulseData->PulseOffset[i]
PulseData->PulseAmp[i]
*/
LOOP(1);
for (i=0; i<=PulseData->NumberPulse; i++)
{
FUNC(2); STORE(1);
PulseData->PulseOffset[i] = (char) GetBits(bs,5);
FUNC(2); STORE(1);
PulseData->PulseAmp[i] = (char) GetBits(bs,4);
}
}
FLC_sub_end();
}
/* loudness calculation (threshold to the power of redExp) */
static void calcThreshExp(float thrExp[MAX_CHANNELS][MAX_GROUPED_SFB],
PSY_OUT_CHANNEL psyOutChannel[MAX_CHANNELS],
const int nChannels)
{
int ch, sfb,sfbGrp;
COUNT_sub_start("calcThreshExp");
LOOP(1);
for (ch=0; ch<nChannels; ch++) {
PSY_OUT_CHANNEL *psyOutChan = &psyOutChannel[ch];
PTR_INIT(1); /* counting operation above */
INDIRECT(2); LOOP(1);
for(sfbGrp = 0;sfbGrp < psyOutChan->sfbCnt;sfbGrp+= psyOutChan->sfbPerGroup) {
PTR_INIT(2); /* pointer for thrExp[][],
psyOutChan->sfbThreshold[]
*/
INDIRECT(1); LOOP(1);
for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++) {
TRANS(1); STORE(1);
thrExp[ch][sfbGrp+sfb] = (float) pow(psyOutChan->sfbThreshold[sfbGrp+sfb], redExp);
}
}
}
COUNT_sub_end();
}
/*!
\brief calc attenuation parameters - this has to take place after
the 'QCMain' call because PeSum of the merged l/r-m/s signal
is relevant
\return nothing
****************************************************************************/
void UpdateStereoPreProcess(PSY_OUT_CHANNEL psyOutChannel[MAX_CHANNELS],
QC_OUT_ELEMENT* qcOutElement, /*! provides access to PE */
HANDLE_STEREO_PREPRO hStPrePro,
float weightPeFac /*! ratio of ms PE vs. lr PE */
)
{
COUNT_sub_start("UpdateStereoPreProcess");
INDIRECT(1); BRANCH(1);
if (hStPrePro->stereoAttenuationFlag)
{
float DELTA = 0.1f;
INDIRECT(4); MOVE(4);
hStPrePro->avrgFreqEnergyL = psyOutChannel[0].sfbEnSumLR;
hStPrePro->avrgFreqEnergyR = psyOutChannel[1].sfbEnSumLR;
hStPrePro->avrgFreqEnergyM = psyOutChannel[0].sfbEnSumMS;
hStPrePro->avrgFreqEnergyS = psyOutChannel[1].sfbEnSumMS;
INDIRECT(3); MULT(1); MAC(1); STORE(1);
hStPrePro->smoothedPeSumSum =
DELTA * qcOutElement->pe * weightPeFac + (1 - DELTA) * hStPrePro->smoothedPeSumSum;
}
COUNT_sub_end();
}
static float
AdvanceMAFilter( IIR_FILTER *iirFilter
)
{
float y;
int j;
int ptr = iirFilter->ptr;
int i = ptr + (BUFFER_SIZE-1);
COUNT_sub_start("AdvanceMAFilter");
INDIRECT(1); /* MOVE(1); --> ptr isn't needed */ ADD(1); /* counting previous operations */
INDIRECT(2); MULT(1);
y = (iirFilter->coeffIIRa[0] * iirFilter->ring_buf_2[i & (BUFFER_SIZE-1)]);
PTR_INIT(3); /* iirFilter->noOffCoeffs
iirFilter->coeffIIRa[]
iirFilter->ring_buf_2[]
*/
LOOP(1);
for (j=1; j<iirFilter->noOffCoeffs; j++) {
i--;
MAC(1);
y += (iirFilter->coeffIIRa[j] * iirFilter->ring_buf_2[i & (BUFFER_SIZE-1)]);
}
COUNT_sub_end();
return y;
}
void
qmfInverseFilteringDetector (HANDLE_SBR_INV_FILT_EST hInvFilt,
float ** quotaMatrix,
float *nrgVector,
char* indexVector,
int startIndex,
int stopIndex,
int transientFlag,
INVF_MODE* infVec
)
{
int band;
COUNT_sub_start("qmfInverseFilteringDetector");
PTR_INIT(6); /* hInvFilt->freqBandTableInvFilt[band]
hInvFilt->detectorValues[band]
hInvFilt->prevInvfMode[band]
hInvFilt->prevRegionSbr[band]
hInvFilt->prevRegionOrig[band]
infVec[band]
*/
INDIRECT(1); LOOP(1);
for(band = 0 ; band < hInvFilt->noDetectorBands; band++){
int startChannel = hInvFilt->freqBandTableInvFilt[band];
int stopChannel = hInvFilt->freqBandTableInvFilt[band+1];
MOVE(2); /* counting previous operations */
INDIRECT(1); PTR_INIT(1); FUNC(9);
calculateDetectorValues(quotaMatrix,
indexVector,
nrgVector,
&hInvFilt->detectorValues[band],
startChannel,
stopChannel,
startIndex,
stopIndex
);
INDIRECT(1); PTR_INIT(2); FUNC(6); STORE(1);
infVec[band]= decisionAlgorithm(hInvFilt->detectorParams,
hInvFilt->detectorValues[band],
transientFlag,
hInvFilt->prevInvfMode[band],
&hInvFilt->prevRegionSbr[band],
&hInvFilt->prevRegionOrig[band]);
}
COUNT_sub_end();
}
/*
*
* \brief Perform complex-valued inverse modulation of the subband
* samples stored in rSubband (real part) and iSubband (imaginary
* part) and stores the result in timeOut
*
*/
static void
inverseModulation (float *qmfReal,
float *qmfImag,
HANDLE_SBR_QMF_FILTER_BANK synQmf
)
{
int i, no_synthesis_channels, M;
float r1, i1, r2, i2;
COUNT_sub_start("inverseModulation");
INDIRECT(1); MOVE(1);
no_synthesis_channels = synQmf->no_channels;
MULT(1);
M = no_synthesis_channels / 2;
PTR_INIT(2); /* pointer for qmfReal[],
qmfImag[] */
INDIRECT(1); LOOP(1);
for (i = synQmf->usb; i < no_synthesis_channels; i++) {
MOVE(2);
qmfReal[i]=qmfImag[i]=0;
}
FUNC(2);
cosMod (qmfReal, synQmf);
FUNC(2);
sinMod (qmfImag, synQmf);
PTR_INIT(4); /* pointer for qmfReal[],
qmfImag[],
qmfImag[no_synthesis_channels - 1 - i],
qmfReal[no_synthesis_channels - i - 1] */
LOOP(1);
for (i = 0; i < M; i++) {
MOVE(4);
r1 = qmfReal[i];
i2 = qmfImag[no_synthesis_channels - 1 - i];
r2 = qmfReal[no_synthesis_channels - i - 1];
i1 = qmfImag[i];
ADD(4); STORE(4);
qmfReal[i] = (r1 - i1);
qmfImag[no_synthesis_channels - 1 - i] = -(r1 + i1);
qmfReal[no_synthesis_channels - i - 1] = (r2 - i2);
qmfImag[i] = -(r2 + i2);
}
COUNT_sub_end();
}
void IcsReset(CIcsInfo *pIcsInfo, CStreamInfo *pStreamInfo)
{
COUNT_sub_start("IcsReset");
INDIRECT(2); MOVE(1);
pIcsInfo->Valid = 0;
pIcsInfo->TotalSfBands = 0;
INDIRECT(4); MOVE(2);
pIcsInfo->SamplingRateIndex = pStreamInfo->SamplingRateIndex;
pIcsInfo->Profile = pStreamInfo->Profile;
COUNT_sub_end();
}
static void Z70_lambda(CL_FORM *base)
{
COPY(INDIRECT(GET_FORM(ARG(0)) + 5), ARG(1));
COPY(INDIRECT(GET_FORM(ARG(0)) + 4), ARG(2));
Flt(ARG(1), 2);
if(CL_TRUEP(ARG(1)))
{
COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(1));
Fstringp(ARG(1));
if(CL_TRUEP(ARG(1)))
{
}
else
{
COPY(SYMVAL(Slisp, 58), ARG(1)); /* WRONG_TYPE */
COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(2));
LOAD_SYMBOL(SYMBOL(Slisp, 44), ARG(3)); /* STRING */
Ferror(ARG(1), 3);
}
COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(1));
COPY(INDIRECT(GET_FORM(ARG(0)) + 5), ARG(2));
Frow_major_aref(ARG(1));
COPY(INDIRECT(GET_FORM(ARG(0)) + 5), ARG(2));
F1plus(ARG(2));
COPY(ARG(2), INDIRECT(GET_FORM(ARG(0)) + 5));
COPY(ARG(1), ARG(0));
}
else
{
LOAD_NIL(ARG(0));
}
}
int
dynBitCount(const short *quantSpectrum,
const unsigned short *maxValueInSfb,
const signed short *scalefac,
const int blockType,
const int sfbCnt,
const int maxSfbPerGroup,
const int sfbPerGroup,
const int *sfbOffset,
SECTION_DATA *sectionData)
{
int bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1];
int mergeGainLookUp[MAX_SFB_LONG];
COUNT_sub_start("dynBitCount");
INDIRECT(3); MOVE(3);
sectionData->blockType = blockType;
sectionData->sfbCnt = sfbCnt;
sectionData->sfbPerGroup = sfbPerGroup;
INDIRECT(1); DIV(1); STORE(1);
sectionData->noOfGroups = sfbCnt / sfbPerGroup;
MOVE(1);
sectionData->maxSfbPerGroup = maxSfbPerGroup;
FUNC(7);
noiselessCounter(sectionData,
mergeGainLookUp,
bitLookUp,
quantSpectrum,
maxValueInSfb,
sfbOffset,
blockType);
FUNC(3);
scfCount(scalefac,
maxValueInSfb,
sectionData);
INDIRECT(3); ADD(2); /* counting post-operations */
COUNT_sub_end();
return (sectionData->huffmanBits +
sectionData->sideInfoBits +
sectionData->scalefacBits);
}
/* sum the pe data only for bands where avoid hole is inactive */
static void calcPeNoAH(float *pe,
float *constPart,
float *nActiveLines,
PE_DATA *peData,
int ahFlag[MAX_CHANNELS][MAX_GROUPED_SFB],
PSY_OUT_CHANNEL psyOutChannel[MAX_CHANNELS],
const int nChannels)
{
int ch, sfb,sfbGrp;
COUNT_sub_start("calcPeNoAH");
MOVE(3);
*pe = 0.0f;
*constPart = 0.0f;
*nActiveLines = 0;
LOOP(1);
for(ch=0; ch<nChannels; ch++) {
PSY_OUT_CHANNEL *psyOutChan = &psyOutChannel[ch];
PE_CHANNEL_DATA *peChanData = &peData->peChannelData[ch];
PTR_INIT(2); /* counting previous operations */
INDIRECT(2); LOOP(1);
for(sfbGrp = 0;sfbGrp < psyOutChan->sfbCnt;sfbGrp+= psyOutChan->sfbPerGroup){
PTR_INIT(4); /* pointers for ahFlag[ch][sfbGrp+sfb],
peChanData->sfbPe[sfbGrp+sfb],
peChanData->sfbConstPart[sfbGrp+sfb],
peChanData->sfbNActiveLines[sfbGrp+sfb]
*/
INDIRECT(1); LOOP(1);
for (sfb=0; sfb<psyOutChan->maxSfbPerGroup; sfb++) {
ADD(1); BRANCH(1);
if(ahFlag[ch][sfbGrp+sfb] < AH_ACTIVE) {
ADD(3); STORE(3);
*pe += peChanData->sfbPe[sfbGrp+sfb];
*constPart += peChanData->sfbConstPart[sfbGrp+sfb];
*nActiveLines += peChanData->sfbNActiveLines[sfbGrp+sfb];
}
}
}
}
COUNT_sub_end();
}
/*-----------------------------------------------------------------------------
functionname: AacInitDefaultConfig
description: gives reasonable default configuration
returns: ---
------------------------------------------------------------------------------*/
void AacInitDefaultConfig(AACENC_CONFIG *config)
{
/* we need doing it this way to avoid gcc trouble */
float* tmp = &PsBuf3[0];
COUNT_sub_start("AacInitDefaultConfig");
/* make the pre initialization of the structs flexible */
FUNC(2); LOOP(1); PTR_INIT(1); MOVE(1); STORE(sizeof(AACENC_CONFIG));
memset(config, 0, sizeof(AACENC_CONFIG));
/* default configurations */
INDIRECT(2); MOVE(2);
config->bitRate = 48000;
config->bandWidth = 0;
// THREAD SAFETY
/* quantized spectrum */
quantSpec = (short*) tmp;
/* scratch space for quantization */
expSpec = sbr_envIBuffer; /* FRAME_LEN_LONG values */
quantSpecTmp = (short*) &sbr_envIBuffer[FRAME_LEN_LONG];
/* scalefactors */
scf= (short*) &sbr_envIBuffer[2*FRAME_LEN_LONG]; /*[MAX_CHANNELS*MAX_GROUPED_SFB];*/
/* max spectral values pre sfb */
maxValueInSfb = (unsigned short*) &sbr_envIBuffer[2*FRAME_LEN_LONG+MAX_CHANNELS*MAX_GROUPED_SFB]; /* [MAX_CHANNELS*MAX_GROUPED_SFB]; */
COUNT_sub_end();
}
static void Z77_lambda(CL_FORM *base)
{
COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(2));
if(CL_SYMBOLP(ARG(2)))
{
COPY(SYM_VALUE(ARG(2)), ARG(2));
}
else
{
if(CL_TRUEP(ARG(2)))
{
COPY(SYMVAL(Slisp, 676), ARG(3)); /* SYM_EXPECTED */
COPY(ARG(2), ARG(4));
Ferror(ARG(3), 2);
}
else
{
LOAD_NIL(ARG(2));
}
}
stream_unreadc(ARG(2));
COPY(ARG(1), ARG(3));
Ffuncall(ARG(2), 2);
COPY(ARG(2), ARG(0));
}
static void Z67_lambda(CL_FORM *base)
{
COPY(ARG(1), ARG(2));
COPY(INDIRECT(GET_FORM(ARG(0)) + 4), ARG(3));
Fle(ARG(2), 2);
if(CL_TRUEP(ARG(2)))
{
COPY(ARG(1), INDIRECT(GET_FORM(ARG(0)) + 3));
COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(0));
}
else
{
LOAD_SMSTR((CL_FORM *)&Kmake_string_input_stream1[4], ARG(2)); /* illegal position */
Ferror(ARG(2), 1);
}
}
static void Z36_lambda(CL_FORM *base)
{
COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(3));
COPY(ARG(2), ARG(4));
Ffuncall(ARG(3), 2);
COPY(ARG(3), ARG(0));
}
void CShortBlock_Init(CAacDecoderChannelInfo *pAacDecoderChannelInfo)
{
int group,band;
char *pCodeBook = pAacDecoderChannelInfo->pCodeBook;
short *pScaleFactor = pAacDecoderChannelInfo->pScaleFactor;
COUNT_sub_start("CShortBlock_Init");
INDIRECT(2); PTR_INIT(2); /* counting previous operations */
PTR_INIT(2); /* pCodeBook[]
pScaleFactor[]
*/
LOOP(1);
for (group=0; group<MaximumGroups; group++)
{
LOOP(1);
for (band=0; band<MaximumScaleFactorBandsShort; band++)
{
MOVE(2);
pCodeBook[group*MaximumScaleFactorBandsShort+band] = 0;
pScaleFactor[group*MaximumScaleFactorBandsShort+band] = 0;
}
}
COUNT_sub_end();
}
static void Z86_lambda(CL_FORM *base)
{
COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(2));
if(CL_CONSP(ARG(2)))
{
COPY(GET_CAR(ARG(2)), ARG(2));
}
else
{
if(CL_TRUEP(ARG(2)))
{
LOAD_SMSTR((CL_FORM *)&KClisp[239], ARG(3)); /* ~a is not a list */
COPY(ARG(2), ARG(4));
Ferror(ARG(3), 2);
}
else
{
LOAD_NIL(ARG(2));
}
}
stream_unreadc(ARG(2));
COPY(ARG(1), ARG(3));
Ffuncall(ARG(2), 2);
COPY(ARG(2), ARG(0));
}
void nunion1(CL_FORM *base)
{
CL_FORM *display[1];
GEN_HEAPVAR(ARG(3), ARG(5));
if(CL_TRUEP(ARG(2)))
{
}
else
{
if(CL_TRUEP(INDIRECT(ARG(3))))
{
GEN_CLOSURE(array, ARG(5), 4, Z7_lambda, -1);
COPY(ARG(3), &array[3]);
LOAD_CLOSURE(array, ARG(5));
COPY(ARG(5), ARG(2));
}
else
{
GEN_STATIC_GLOBAL_FUNARG(extern_closure, Feql, 2);
LOAD_GLOBFUN(&extern_closure, ARG(2));
}
}
COPY(ARG(0), ARG(5));
display[0] = ARG(0);
Z6_union_internal(ARG(5), display);
COPY(ARG(5), ARG(0));
}
static int
CalcMergeGain(const SECTION_INFO * section,
int bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],
const int *sideInfoTab,
const int ndx1,
const int ndx2)
{
int SplitBits;
int MergeBits;
int MergeGain;
COUNT_sub_start("CalcMergeGain");
PTR_INIT(4); /* pointers for section[ndx1],
section[ndx2],
bitLookUp[ndx1],
bitLookUp[ndx2]
*/
/*
Bit amount for splitted sections
*/
ADD(1);
SplitBits = section[ndx1].sectionBits + section[ndx2].sectionBits;
ADD(2); INDIRECT(1); FUNC(2);
MergeBits = sideInfoTab[section[ndx1].sfbCnt + section[ndx2].sfbCnt] + findMinMergeBits(bitLookUp[ndx1], bitLookUp[ndx2]);
ADD(1);
MergeGain = SplitBits - MergeBits;
COUNT_sub_end();
return (MergeGain);
}
/*
\brief Reads n bits from Bitbuffer
\return bits
*/
unsigned long
getbits (HANDLE_BIT_BUFFER hBitBuf,
int n)
{
unsigned long ret_value = 0;
assert(n <= 32);
FLC_sub_start("getbits");
MOVE(1); /* counting previous operation */
LOOP(1);
while (n>8) {
ADD(1);
n -= 8;
FUNC(2); SHIFT(1); ADD(1);
ret_value += getbits(hBitBuf,8) << n;
}
INDIRECT(1); ADD(1); BRANCH(1);
if (hBitBuf->buffered_bits <= 8) {
INDIRECT(2); SHIFT(1); LOGIC(1); STORE(1);
hBitBuf->buffer_word = (hBitBuf->buffer_word << 8) | *hBitBuf->char_ptr++;
ADD(1); STORE(1);
hBitBuf->buffered_bits += 8;
}
ADD(1); STORE(1);
hBitBuf->buffered_bits -= n;
SHIFT(2); ADD(2); LOGIC(1);
ret_value +=
(hBitBuf->buffer_word >> hBitBuf->buffered_bits) & ((1 << n) - 1);
INDIRECT(1); ADD(1); STORE(1);
hBitBuf->nrBitsRead += n;
FLC_sub_end();
return (ret_value);
}
char GetWindowGroupLength(CIcsInfo *pIcsInfo, int index)
{
COUNT_sub_start("GetWindowGroupLength");
INDIRECT(1);
COUNT_sub_end();
return pIcsInfo->WindowGroupLength[index];
}
static int findClosestEntry(unsigned char goalSb, unsigned char *v_k_master, unsigned char numMaster, unsigned char direction)
{
int index;
COUNT_sub_start("findClosestEntry");
INDIRECT(1); BRANCH(1);
if( goalSb <= v_k_master[0] ) {
COUNT_sub_end();
return v_k_master[0];
}
INDIRECT(1); BRANCH(1);
if( goalSb >= v_k_master[numMaster] ) {
COUNT_sub_end();
return v_k_master[numMaster];
}
BRANCH(1);
if(direction) {
MOVE(1);
index = 0;
PTR_INIT(1); /* pointer for v_k_master[index] */
ADD(1); LOOP(1);
while( v_k_master[index] < goalSb ) {
ADD(1);
index++;
}
} else {
MOVE(1);
index = numMaster;
PTR_INIT(1); /* pointer for v_k_master[index] */
ADD(1); LOOP(1);
while( v_k_master[index] > goalSb ) {
ADD(1);
index--;
}
}
COUNT_sub_end();
return v_k_master[index];
}
/*****************************************************************************
description: close the envelope coding handle
returns: void
*****************************************************************************/
void
EnvClose (HANDLE_SBR_ENCODER hEnvEnc)
{
int i;
COUNT_sub_start("EnvClose");
BRANCH(1);
if (hEnvEnc != NULL) {
PTR_INIT(1); /* hEnvEnc->hEnvChannel[] */
LOOP(1);
for (i = 0; i < MAX_CHANNELS; i++) {
BRANCH(1);
if (hEnvEnc->hEnvChannel[i] != NULL) {
FUNC(1);
deleteEnvChannel (hEnvEnc->hEnvChannel[i]);
PTR_INIT(1);
hEnvEnc->hEnvChannel[i] = NULL;
}
}
#ifndef MONO_ONLY
INDIRECT(1); BRANCH(1);
if (hEnvEnc->hSynthesisQmfBank)
{
PTR_INIT(1); FUNC(1);
DeleteSynthesisQmfBank ((HANDLE_SBR_QMF_FILTER_BANK*)&hEnvEnc->hSynthesisQmfBank);
}
INDIRECT(1); BRANCH(1);
if (hEnvEnc->hPsEnc)
{
PTR_INIT(1); FUNC(1);
DeletePsEnc(&hEnvEnc->hPsEnc);
}
#endif /* #ifndef MONO_ONLY */
}
COUNT_sub_end();
}
