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); }