static void sym_initg(Symbol sym, int tkind, int r1, int r2) /*;sym_initg*/
{
/* initialize the fields of a symbol used only by the code generator */
if (tkind<=0) { /* if want to indicate type_size not defined */
TYPE_SIZE(sym) = -1;
}
else {
TYPE_KIND(sym) = tkind; /* type kind */
TYPE_SIZE(sym) = su_size(tkind); /* storage units needed*/
}
S_SEGMENT(sym) = r1;
S_OFFSET(sym) = r2;
/* Note that the correct values of offsets for most of the standard
* symbols are set by procedure main_data_segment() in glib.c
*/
/* The following default value of MISC (happily) also corresponds to
* setting CONTAINS_TASK(sym) to FALSE.
*/
MISC(sym) = (char *) 0;
}
static void scfCount(const short *scalefacGain,
const unsigned short *maxValueInSfb,
SECTION_DATA * sectionData)
{
/* counter */
int i = 0; /* section counter */
int j = 0; /* sfb counter */
int k = 0; /* current section auxiliary counter */
int m = 0; /* other section auxiliary counter */
int n = 0; /* other sfb auxiliary counter */
/* further variables */
int lastValScf = 0;
int deltaScf = 0;
int found = 0;
int scfSkipCounter = 0;
COUNT_sub_start("scfCount");
MOVE(9); /* counting previous operations */
INDIRECT(1); MOVE(1);
sectionData->scalefacBits = 0;
BRANCH(1);
if (scalefacGain == NULL) {
COUNT_sub_end();
return;
}
INDIRECT(1); MOVE(2);
lastValScf = 0;
sectionData->firstScf = 0;
PTR_INIT(1); /* sectionData->section[] */
INDIRECT(1); LOOP(1);
for (i = 0; i < sectionData->noOfSections; i++) {
ADD(1); BRANCH(1);
if (sectionData->section[i].codeBook != CODE_BOOK_ZERO_NO) {
INDIRECT(1); MOVE(1);
sectionData->firstScf = sectionData->section[i].sfbStart;
INDIRECT(1); MOVE(1);
lastValScf = scalefacGain[sectionData->firstScf];
break;
}
}
PTR_INIT(1); /* sectionData->section[] */
INDIRECT(1); LOOP(1);
for (i = 0; i < sectionData->noOfSections; i++) {
ADD(2); LOGIC(1); BRANCH(1);
if ((sectionData->section[i].codeBook != CODE_BOOK_ZERO_NO) &&
(sectionData->section[i].codeBook != CODE_BOOK_PNS_NO)) {
PTR_INIT(2); /* maxValueInSfb[]
scalefacGain[]
*/
ADD(1); LOOP(1);
for (j = sectionData->section[i].sfbStart;
j < sectionData->section[i].sfbStart + sectionData->section[i].sfbCnt;
j++) {
BRANCH(1);
if (maxValueInSfb[j] == 0) {
MOVE(1);
found = 0;
BRANCH(1);
if (scfSkipCounter == 0) {
ADD(3); BRANCH(1);
if (j == (sectionData->section[i].sfbStart + sectionData->section[i].sfbCnt - 1) ) {
MOVE(1);
found = 0;
}
else {
PTR_INIT(2); /* maxValueInSfb[]
scalefacGain[]
*/
LOOP(1);
for (k = (j+1); k < sectionData->section[i].sfbStart + sectionData->section[i].sfbCnt; k++) {
BRANCH(1);
if (maxValueInSfb[k] != 0) {
MOVE(1);
found = 1;
ADD(2); MISC(1); BRANCH(1);
if ( (abs(scalefacGain[k] - lastValScf)) < CODE_BOOK_SCF_LAV) {
MOVE(1);
deltaScf = 0;
}
else {
ADD(1); MULT(1);
deltaScf = -(scalefacGain[j] - lastValScf);
MOVE(2);
lastValScf = scalefacGain[j];
scfSkipCounter = 0;
}
break;
}
/* count scalefactor skip */
ADD(1);
scfSkipCounter = scfSkipCounter + 1;
}
}
/* search for the next maxValueInSfb[] != 0 in all other sections */
PTR_INIT(1); /* sectionData->section[] */
INDIRECT(1); LOOP(1);
for (m = (i+1); (m < sectionData->noOfSections) && (found == 0); m++) {
ADD(2); LOGIC(1); BRANCH(1);
if ((sectionData->section[m].codeBook != CODE_BOOK_ZERO_NO) &&
(sectionData->section[m].codeBook != CODE_BOOK_PNS_NO)) {
PTR_INIT(2); /* maxValueInSfb[]
scalefacGain[]
*/
LOOP(1);
for (n = sectionData->section[m].sfbStart;
n < sectionData->section[m].sfbStart + sectionData->section[m].sfbCnt;
n++) {
BRANCH(1);
if (maxValueInSfb[n] != 0) {
MOVE(1);
found = 1;
ADD(2); MISC(1); BRANCH(1);
if ( (abs(scalefacGain[n] - lastValScf)) < CODE_BOOK_SCF_LAV) {
MOVE(1);
deltaScf = 0;
}
else {
ADD(1); MULT(1);
deltaScf = -(scalefacGain[j] - lastValScf);
MOVE(2);
lastValScf = scalefacGain[j];
scfSkipCounter = 0;
}
break;
}
ADD(1);
scfSkipCounter = scfSkipCounter + 1;
}
}
}
BRANCH(1);
if (found == 0) {
MOVE(2);
deltaScf = 0;
scfSkipCounter = 0;
}
}
else {
MOVE(1);
deltaScf = 0;
ADD(1);
scfSkipCounter = scfSkipCounter - 1;
}
}
else {
ADD(1); MULT(1);
deltaScf = -(scalefacGain[j] - lastValScf);
MOVE(1);
lastValScf = scalefacGain[j];
}
INDIRECT(1); FUNC(1); ADD(1); STORE(1);
sectionData->scalefacBits += bitCountScalefactorDelta(deltaScf);
}
}
}
COUNT_sub_end();
}
/*!
\brief do an appropriate attenuation on the side channel of a stereo
signal
\return nothing
****************************************************************************/
void ApplyStereoPreProcess(HANDLE_STEREO_PREPRO hStPrePro, /*!st.-preproc handle */
int nChannels, /*! total number of channels */
ELEMENT_INFO *elemInfo,
float *timeData, /*! lr time data (modified) */
int granuleLen) /*! num. samples to be processed */
{
/* inplace operation on inData ! */
float SMRatio, StoM;
float LRRatio, LtoR, deltaLtoR, deltaNrg;
float EnImpact, PeImpact, PeNorm;
float Att, AttAimed;
float maxInc, maxDec, swiftfactor;
float DELTA=0.1f;
float fac = hStPrePro->stereoAttFac;
float mPart, upper, div;
float lFac,rFac;
int i;
COUNT_sub_start("ApplyStereoPreProcess");
INDIRECT(1); MOVE(2); /* counting previous operations */
INDIRECT(1); BRANCH(1);
if (!hStPrePro->stereoAttenuationFlag) {
COUNT_sub_end();
return;
}
/* calc L/R ratio */
INDIRECT(1); MULT(3); ADD(1);
mPart = 2.0f * hStPrePro->avrgFreqEnergyM * (1.0f - fac*fac);
INDIRECT(2); ADD(4); MULT(2); MAC(2);
upper = hStPrePro->avrgFreqEnergyL * (1.0f+fac) + hStPrePro->avrgFreqEnergyR * (1.0f-fac) - mPart;
div = hStPrePro->avrgFreqEnergyR * (1.0f+fac) + hStPrePro->avrgFreqEnergyL * (1.0f-fac) - mPart;
LOGIC(1); BRANCH(1);
if (div == 0.0f || upper == 0.0f) {
INDIRECT(1); MOVE(1);
LtoR = hStPrePro->LRMax;
}
else {
DIV(1); MISC(1);
LRRatio = (float) fabs ( upper / div ) ;
TRANS(1); MULT(1); MISC(1);
LtoR = (float) fabs(10.0 * log10(LRRatio));
}
/* calc delta energy to previous frame */
INDIRECT(3); ADD(3); DIV(1);
deltaNrg = ( hStPrePro->avrgFreqEnergyL + hStPrePro->avrgFreqEnergyR + 1.0f) /
( hStPrePro->lastNrgLR + 1.0f );
TRANS(1); MULT(1); MISC(1);
deltaNrg = (float) (fabs(10.0 * log10(deltaNrg)));
/* Smooth S/M over time */
INDIRECT(2); ADD(2); DIV(1);
SMRatio = (hStPrePro->avrgFreqEnergyS + 1.0f) / (hStPrePro->avrgFreqEnergyM + 1.0f);
TRANS(1); MULT(1);
StoM = (float) (10.0 * log10(SMRatio));
INDIRECT(2); MULT(1); MAC(1); STORE(1);
hStPrePro->avgStoM = DELTA * StoM + (1-DELTA) * hStPrePro->avgStoM;
MOVE(1);
EnImpact = 1.0f;
INDIRECT(2); ADD(1); BRANCH(1);
if (hStPrePro->avgStoM > hStPrePro->SMMin) {
INDIRECT(1); ADD(1); BRANCH(1);
if (hStPrePro->avgStoM > hStPrePro->SMMax) {
MOVE(1);
EnImpact = 0.0f;
}
else {
ADD(2); DIV(1);
EnImpact = (hStPrePro->SMMax - hStPrePro->avgStoM) / (hStPrePro->SMMax - hStPrePro->SMMin);
}
}
INDIRECT(1); ADD(1); BRANCH(1);
if (LtoR > hStPrePro->LRMin) {
INDIRECT(1); ADD(1); BRANCH(1);
if ( LtoR > hStPrePro->LRMax) {
MOVE(1);
EnImpact = 0.0f;
}
else {
ADD(2); DIV(1); MULT(1);
EnImpact *= (hStPrePro->LRMax - LtoR) / (hStPrePro->LRMax - hStPrePro->LRMin);
}
}
MOVE(1);
PeImpact = 0.0f;
INDIRECT(2); MULT(1);
PeNorm = hStPrePro->smoothedPeSumSum * hStPrePro->normPeFac;
INDIRECT(1); ADD(1); BRANCH(1);
if ( PeNorm > hStPrePro->PeMin ) {
INDIRECT(1); ADD(2); DIV(1);
PeImpact= ((PeNorm - hStPrePro->PeMin) / (hStPrePro->PeCrit - hStPrePro->PeMin));
}
INDIRECT(1); ADD(1); BRANCH(1);
if (PeImpact > hStPrePro->PeImpactMax) {
MOVE(1);
PeImpact = hStPrePro->PeImpactMax;
}
INDIRECT(1); MULT(2);
AttAimed = EnImpact * PeImpact * hStPrePro->ImpactFactor;
INDIRECT(1); ADD(1); BRANCH(1);
if (AttAimed > hStPrePro->stereoAttMax) {
MOVE(1);
AttAimed = hStPrePro->stereoAttMax;
}
/* only accept changes if they are large enough */
INDIRECT(1); ADD(2); MISC(1); LOGIC(1); BRANCH(1);
if ( fabs(AttAimed - hStPrePro->stereoAttenuation) < 1.0f && AttAimed != 0.0f) {
MOVE(1);
AttAimed = hStPrePro->stereoAttenuation;
}
MOVE(1);
Att = AttAimed;
INDIRECT(1); ADD(1); MULT(1); BRANCH(1); /* max() */ ADD(2); DIV(1); MULT(1);
swiftfactor = (6.0f + hStPrePro->stereoAttenuation) / (10.0f + LtoR) * max(1.0f, 0.2f * deltaNrg );
INDIRECT(1); ADD(2); BRANCH(1); MOVE(1);
deltaLtoR = max(3.0f, LtoR - hStPrePro->lastLtoR );
MULT(2); DIV(1);
maxDec = deltaLtoR * deltaLtoR / 9.0f * swiftfactor;
ADD(1); BRANCH(1); MOVE(1);
maxDec = min( maxDec, 5.0f );
INDIRECT(1); MULT(1);
maxDec *= hStPrePro->stereoAttenuationDec;
INDIRECT(1); MULT(1); ADD(1); BRANCH(1);
if (maxDec > hStPrePro->stereoAttenuation * 0.8f) {
MOVE(1);
maxDec = hStPrePro->stereoAttenuation * 0.8f;
}
INDIRECT(1); ADD(2); BRANCH(1); MOVE(1);
deltaLtoR = max(3.0f, hStPrePro->lastLtoR - LtoR );
MULT(2); DIV(1);
maxInc = deltaLtoR * deltaLtoR / 9.0f * swiftfactor;
ADD(1); BRANCH(1); MOVE(1);
maxInc = min( maxInc, 5.0f );
INDIRECT(1); MULT(1);
maxInc *= hStPrePro->stereoAttenuationInc;
INDIRECT(1); MULT(1); ADD(1); BRANCH(1);
if (maxDec > hStPrePro->stereoAttenuation * 0.8f) {
MOVE(1);
maxDec = hStPrePro->stereoAttenuation * 0.8f;
}
INDIRECT(1); ADD(2); BRANCH(1); MOVE(1);
deltaLtoR = max(3.0f, hStPrePro->lastLtoR - LtoR );
MULT(2); DIV(1);
maxInc = deltaLtoR * deltaLtoR / 9.0f * swiftfactor;
ADD(1); BRANCH(1); MOVE(1);
maxInc = min( maxInc, 5.0f );
INDIRECT(1); MULT(1);
maxInc *= hStPrePro->stereoAttenuationInc;
INDIRECT(1); ADD(2); BRANCH(1);
if (Att > hStPrePro->stereoAttenuation + maxInc) {
MOVE(1);
Att = hStPrePro->stereoAttenuation + maxInc;
}
INDIRECT(1); ADD(2); BRANCH(1);
if (Att < hStPrePro->stereoAttenuation - maxDec) {
MOVE(1);
Att = hStPrePro->stereoAttenuation - maxDec;
}
INDIRECT(2); BRANCH(1); MOVE(1);
if (hStPrePro->ConstAtt == 0) hStPrePro->stereoAttenuation = Att;
else hStPrePro->stereoAttenuation = hStPrePro->ConstAtt;
/* perform attenuation of Side Channel */
INDIRECT(2); MULT(1); TRANS(1); STORE(1);
hStPrePro->stereoAttFac = (float) pow(10.0f, 0.05f*(-hStPrePro->stereoAttenuation ));
INDIRECT(1); ADD(2); MULT(2);
lFac = 0.5f * (1.0f + hStPrePro->stereoAttFac);
rFac = 0.5f * (1.0f - hStPrePro->stereoAttFac);
PTR_INIT(2); /* pointer for timeData[nChannels * i + elemInfo->ChannelIndex[0]],
timeData[nChannels * i + elemInfo->ChannelIndex[1]]
*/
LOOP(1);
for (i = 0; i < granuleLen; i++){
float L = lFac * timeData[nChannels * i+elemInfo->ChannelIndex[0]] + rFac * timeData[nChannels * i + elemInfo->ChannelIndex[1]];
float R = rFac * timeData[nChannels * i+elemInfo->ChannelIndex[0]] + lFac * timeData[nChannels * i + elemInfo->ChannelIndex[1]];
MULT(2); MAC(2); /* counting operations above */
MOVE(2);
timeData[nChannels * i + elemInfo->ChannelIndex[0]]= L;
timeData[nChannels * i + elemInfo->ChannelIndex[1]]= R;
}
INDIRECT(1); MOVE(1);
hStPrePro->lastLtoR = LtoR;
INDIRECT(3); ADD(1); STORE(1);
hStPrePro->lastNrgLR = hStPrePro->avrgFreqEnergyL + hStPrePro->avrgFreqEnergyR;
COUNT_sub_end();
}
static void adaptThresholdsToPe(PSY_OUT_CHANNEL psyOutChannel[MAX_CHANNELS],
PSY_OUT_ELEMENT* psyOutElement,
PE_DATA *peData,
const int nChannels,
const float desiredPe,
AH_PARAM *ahParam,
MINSNR_ADAPT_PARAM *msaParam)
{
float noRedPe, redPe, redPeNoAH;
float constPart, constPartNoAH;
float nActiveLines, nActiveLinesNoAH;
float desiredPeNoAH;
float avgThrExp, redVal;
int ahFlag[MAX_CHANNELS][MAX_GROUPED_SFB];
float thrExp[MAX_CHANNELS][MAX_GROUPED_SFB];
int iter;
COUNT_sub_start("adaptThresholdsToPe");
FUNC(3);
calcThreshExp(thrExp, psyOutChannel, nChannels);
FUNC(3);
adaptMinSnr(psyOutChannel, msaParam, nChannels);
FUNC(5);
initAvoidHoleFlag(ahFlag, psyOutChannel, psyOutElement, nChannels, ahParam);
INDIRECT(3); MOVE(3);
noRedPe = peData->pe;
constPart = peData->constPart;
nActiveLines = peData->nActiveLines;
MULT(1); ADD(1); DIV(1); TRANS(1);
avgThrExp = (float)pow(2.0f, (constPart - noRedPe)/(invRedExp*nActiveLines));
/* MULT(1); calculated above */ ADD(2); DIV(1); TRANS(1);
redVal = (float)pow(2.0f, (constPart - desiredPe)/(invRedExp*nActiveLines)) -
avgThrExp;
BRANCH(1); MOVE(1);
redVal = max(0.0f, redVal);
FUNC(5);
reduceThresholds(psyOutChannel, ahFlag, thrExp, nChannels, redVal);
FUNC(3);
calcPe(peData, psyOutChannel, nChannels);
INDIRECT(1); MOVE(1);
redPe = peData->pe;
MOVE(1);
iter = 0;
LOOP(1);
do {
PTR_INIT(3); FUNC(7);
calcPeNoAH(&redPeNoAH, &constPartNoAH, &nActiveLinesNoAH,
peData, ahFlag, psyOutChannel, nChannels);
ADD(2); BRANCH(1); MOVE(1);
desiredPeNoAH = max(desiredPe - (redPe - redPeNoAH), 0);
BRANCH(1);
if (nActiveLinesNoAH > 0) {
MULT(1); ADD(1); DIV(1); TRANS(1);
avgThrExp = (float)pow(2.0f, (constPartNoAH - redPeNoAH) / (invRedExp*nActiveLinesNoAH));
/* MULT(1); calculated above */ ADD(3); DIV(1); TRANS(1);
redVal += (float)pow(2.0f, (constPartNoAH - desiredPeNoAH) / (invRedExp*nActiveLinesNoAH))
- avgThrExp;
BRANCH(1); MOVE(1);
redVal = max(0.0f, redVal);
FUNC(5);
reduceThresholds(psyOutChannel, ahFlag, thrExp, nChannels, redVal);
}
FUNC(3);
calcPe(peData, psyOutChannel, nChannels);
INDIRECT(1); MOVE(1);
redPe = peData->pe;
ADD(1);
iter++;
ADD(3); MISC(1); MULT(1); LOGIC(1); /* while() condition */
} while ((fabs(redPe - desiredPe) > (0.05f)*desiredPe) && (iter < 2));
MULT(1); ADD(1); BRANCH(1);
if (redPe < 1.15f*desiredPe) {
ADD(1); FUNC(7);
correctThresh(psyOutChannel, ahFlag, peData, thrExp, redVal,
nChannels, desiredPe - redPe);
}
else {
MULT(1); FUNC(5);
reduceMinSnr(psyOutChannel, peData, ahFlag, nChannels, 1.05f*desiredPe);
MULT(1); FUNC(7);
allowMoreHoles(psyOutChannel, psyOutElement, peData, ahFlag,
ahParam, nChannels, 1.05f*desiredPe);
}
COUNT_sub_end();
}
static int
resetPatch(HANDLE_SBR_TON_CORR_EST hTonCorr,
int xposctrl,
int highBandStartSb,
int channelOffset,
unsigned char *v_k_master,
int numMaster,
int fs,
int noChannels)
{
int patch,k,i;
int targetStopBand;
PATCH_PARAM *patchParam = hTonCorr->patchParam;
int sbGuard = hTonCorr->guard;
int sourceStartBand;
int patchDistance;
int numBandsInPatch;
int lsb = v_k_master[0];
int usb = v_k_master[numMaster];
int xoverOffset = highBandStartSb - v_k_master[0];
int goalSb;
COUNT_sub_start("resetPatch");
INDIRECT(3); PTR_INIT(1); MOVE(3); ADD(1); /* counting previous operations */
ADD(1); BRANCH(1);
if (xposctrl == 1) {
ADD(1);
lsb += xoverOffset;
MOVE(1);
xoverOffset = 0;
}
MULT(2); DIV(1); ADD(1);
goalSb = (int)( 2 * noChannels * 16000.0f / fs + 0.5f );
FUNC(4);
goalSb = findClosestEntry(goalSb, v_k_master, numMaster, 1);
INDIRECT(1); ADD(1);
sourceStartBand = hTonCorr->shiftStartSb + xoverOffset;
ADD(1);
targetStopBand = lsb + xoverOffset;
MOVE(1);
patch = 0;
PTR_INIT(1); /* patchParam[patch] */
LOOP(1);
while(targetStopBand < usb) {
ADD(1); BRANCH(1);
if (patch >= MAX_NUM_PATCHES)
{
COUNT_sub_end();
return(1);
}
MOVE(1);
patchParam[patch].guardStartBand = targetStopBand;
ADD(1);
targetStopBand += sbGuard;
MOVE(1);
patchParam[patch].targetStartBand = targetStopBand;
ADD(1);
numBandsInPatch = goalSb - targetStopBand;
ADD(2); BRANCH(1);
if ( numBandsInPatch >= lsb - sourceStartBand ) {
ADD(1);
patchDistance = targetStopBand - sourceStartBand;
LOGIC(1);
patchDistance = patchDistance & ~1;
ADD(2);
numBandsInPatch = lsb - (targetStopBand - patchDistance);
ADD(2); FUNC(4);
numBandsInPatch = findClosestEntry(targetStopBand + numBandsInPatch, v_k_master, numMaster, 0) -
targetStopBand;
}
ADD(2);
patchDistance = numBandsInPatch + targetStopBand - lsb;
ADD(1); LOGIC(1);
patchDistance = (patchDistance + 1) & ~1;
BRANCH(1);
if (numBandsInPatch <= 0) {
ADD(1);
patch--;
} else {
ADD(1); STORE(1);
patchParam[patch].sourceStartBand = targetStopBand - patchDistance;
MOVE(2);
patchParam[patch].targetBandOffs = patchDistance;
patchParam[patch].numBandsInPatch = numBandsInPatch;
ADD(1); STORE(1);
patchParam[patch].sourceStopBand = patchParam[patch].sourceStartBand + numBandsInPatch;
ADD(1);
targetStopBand += patchParam[patch].numBandsInPatch;
}
INDIRECT(1); MOVE(1);
sourceStartBand = hTonCorr->shiftStartSb;
ADD(2); MISC(1); BRANCH(1);
if( abs(targetStopBand - goalSb) < 3) {
MOVE(1);
goalSb = usb;
}
ADD(1);
patch++;
}
ADD(1);
patch--;
ADD(1); LOGIC(1); BRANCH(1);
if ( patchParam[patch].numBandsInPatch < 3 && patch > 0 ) {
ADD(1);
patch--;
ADD(1);
targetStopBand = patchParam[patch].targetStartBand + patchParam[patch].numBandsInPatch;
}
INDIRECT(1); ADD(1); STORE(1);
hTonCorr->noOfPatches = patch + 1;
PTR_INIT(1); /* hTonCorr->indexVector[] */
INDIRECT(1); LOOP(1);
for(k = 0; k < hTonCorr->patchParam[0].guardStartBand; k++)
{
MOVE(1);
hTonCorr->indexVector[k] = k;
}
PTR_INIT(1); /* hTonCorr->patchParam[] */
INDIRECT(1); LOOP(1);
for(i = 0; i < hTonCorr->noOfPatches; i++)
{
int sourceStart = hTonCorr->patchParam[i].sourceStartBand;
int targetStart = hTonCorr->patchParam[i].targetStartBand;
int numberOfBands = hTonCorr->patchParam[i].numBandsInPatch;
int startGuardBand = hTonCorr->patchParam[i].guardStartBand;
MOVE(4); /* counting previous operations */
PTR_INIT(1); /* hTonCorr->indexVector[] */
ADD(1); LOOP(1);
for(k = 0; k < (targetStart- startGuardBand); k++)
{
MULT(1); STORE(1);
hTonCorr->indexVector[startGuardBand+k] = -1;
}
PTR_INIT(1); /* hTonCorr->indexVector[] */
LOOP(1);
for(k = 0; k < numberOfBands; k++)
{
ADD(1); STORE(1);
hTonCorr->indexVector[targetStart+k] = sourceStart+k;
}
}
COUNT_sub_end();
return (0);
}
