自学教程：C++ INDIRECT函数代码示例

/*  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 longcalcCRC (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 voidDelaySbrBitstr(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 floatAdvanceMAFilter( 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;}

voidqmfInverseFilteringDetector (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 voidinverseModulation (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));	}}

intdynBitCount(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 intCalcMergeGain(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 longgetbits (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*****************************************************************************/voidEnvClose (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();}