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

unsigned char IsMainProfile(CIcsInfo *pIcsInfo){  FLC_sub_start("IsMainProfile");  INDIRECT(1); ADD(1); BRANCH(1);  FLC_sub_end();  return (pIcsInfo->Profile == ProfileMain);}

int GetWindowsPerFrame(CIcsInfo *pIcsInfo){  FLC_sub_start("GetWindowsPerFrame");  INDIRECT(1); ADD(1); BRANCH(1);  FLC_sub_end();  return (pIcsInfo->WindowSequence == EightShortSequence) ? 8 : 1;}

unsigned char IsShortBlock(CIcsInfo *pIcsInfo){  FLC_sub_start("IsShortBlock");  INDIRECT(1); ADD(1); BRANCH(1);  FLC_sub_end();  return (pIcsInfo->WindowSequence == EightShortSequence);}

void resume_suspension_frame(susp_fr_ptr resume_fr, or_fr_ptr top_or_fr) {  CACHE_REGS  or_fr_ptr or_frame;  sg_fr_ptr sg_frame;  /* copy suspended stacks */  memmove(SuspFr_global_reg(resume_fr),         SuspFr_global_start(resume_fr),         SuspFr_global_size(resume_fr));  memmove(SuspFr_local_reg(resume_fr),         SuspFr_local_start(resume_fr),         SuspFr_local_size(resume_fr));  memmove(SuspFr_trail_reg(resume_fr),         SuspFr_trail_start(resume_fr),         SuspFr_trail_size(resume_fr));  OPTYAP_ERROR_CHECKING(resume_suspension_frame, DepFr_cons_cp(SuspFr_top_dep_fr(resume_fr))->cp_h != SuspFr_global_reg(resume_fr) + SuspFr_global_size(resume_fr));  OPTYAP_ERROR_CHECKING(resume_suspension_frame, DepFr_cons_cp(SuspFr_top_dep_fr(resume_fr))->cp_tr != SuspFr_trail_reg(resume_fr) + SuspFr_trail_size(resume_fr));  OPTYAP_ERROR_CHECKING(resume_suspension_frame, DepFr_cons_cp(SuspFr_top_dep_fr(resume_fr)) != SuspFr_local_reg(resume_fr));  OPTYAP_ERROR_CHECKING(resume_suspension_frame, (void *)Get_LOCAL_top_cp() < SuspFr_local_reg(resume_fr) + SuspFr_local_size(resume_fr));  /* update shared nodes */  or_frame = top_or_fr;  while (or_frame != LOCAL_top_or_fr) {    LOCK_OR_FRAME(or_frame);    OrFr_owners(or_frame)++;    UNLOCK_OR_FRAME(or_frame);    or_frame = OrFr_next_on_stack(or_frame);  }    or_frame = top_or_fr;  while (or_frame != LOCAL_top_or_fr) {    LOCK_OR_FRAME(or_frame);    BITMAP_insert(OrFr_members(or_frame), worker_id);    BRANCH(worker_id, OrFr_depth(or_frame)) = 1;    UNLOCK_OR_FRAME(or_frame);    or_frame = OrFr_next(or_frame);  }  /* adjust top pointers */  LOCAL_top_or_fr = top_or_fr;  SetOrFr_node(top_or_fr, Get_LOCAL_top_cp());  LOCAL_top_sg_fr = SuspFr_top_sg_fr(resume_fr);  LOCAL_top_dep_fr = SuspFr_top_dep_fr(resume_fr);  Set_LOCAL_top_cp_on_stack( GetOrFr_node(SuspFr_top_or_fr_on_stack(resume_fr)) );  sg_frame = LOCAL_top_sg_fr;  while (sg_frame && YOUNGER_CP(SgFr_gen_cp(sg_frame), Get_LOCAL_top_cp_on_stack())) {    SgFr_gen_worker(sg_frame) = worker_id;    sg_frame = SgFr_next(sg_frame);  }  /* adjust freeze registers */  adjust_freeze_registers();  /* free suspension frame */  FREE_SUSPENSION_FRAME(resume_fr);  return;}

/* constants that do not change during successive pe calculations */void prepareSfbPe(PE_CHANNEL_DATA *peChanData,                  const float *sfbEnergy,                  const float *sfbThreshold,                  const float *sfbFormFactor,                  const int     *sfbOffset,                  const int     sfbCnt,                  const int     sfbPerGroup,                  const int     maxSfbPerGroup){   int sfbGrp,sfb;   int sfbWidth;   float avgFormFactor;   COUNT_sub_start("prepareSfbPe");   LOOP(1);   for(sfbGrp = 0;sfbGrp < sfbCnt;sfbGrp+=sfbPerGroup){    PTR_INIT(6); /* pointers for sfbEnergy[],                                 sfbThreshold[],                                 sfbOffset[],                                 sfbFormFactor[],                                 peChanData->sfbNLines[],                                 peChanData->sfbLdEnergy[]                 */    LOOP(1);    for (sfb=0; sfb<maxSfbPerGroup; sfb++) {      ADD(1); BRANCH(1);      if (sfbEnergy[sfbGrp+sfb] > sfbThreshold[sfbGrp+sfb]) {         ADD(1);         sfbWidth = sfbOffset[sfbGrp+sfb+1] - sfbOffset[sfbGrp+sfb];         /* estimate number of active lines */         DIV(1); TRANS(1);         avgFormFactor = (float) pow(sfbEnergy[sfbGrp+sfb]/(float)sfbWidth, 0.25f);         DIV(1); STORE(1);         peChanData->sfbNLines[sfbGrp+sfb] =         sfbFormFactor[sfbGrp+sfb]/avgFormFactor;          /* ld(sfbEn) */         TRANS(1); MULT(1); STORE(1);         peChanData->sfbLdEnergy[sfbGrp+sfb] = (float) (log(sfbEnergy[sfbGrp+sfb]) * LOG2_1);      }      else {         MOVE(2);         peChanData->sfbNLines[sfbGrp+sfb] = 0.0f;         peChanData->sfbLdEnergy[sfbGrp+sfb] = 0.0f;      }    }   }   COUNT_sub_end();}

int CAacDecoderInit(AACDECODER self,                    int samplingRate,                    int bitrate){  int i;  int numEntries = sizeof(SamplingRateInfoTable)/sizeof(SamplingRateInfo);  COUNT_sub_start("CAacDecoderInit");  MOVE(1); /* counting previous operation */  BRANCH(1);  if (!self)  {    COUNT_sub_end();    return -1;  }  INDIRECT(1); MOVE(1);  self->pStreamInfo->SamplingRate  = samplingRate;    PTR_INIT(1); /* SamplingRateInfoTable[i] */  LOOP(1);  for (i=0; i<numEntries; i++)  {    ADD(1); BRANCH(1);    if (samplingRate == SamplingRateInfoTable[i].SamplingFrequency)      break;  }  ADD(1); BRANCH(1);  if (i == numEntries)  {    COUNT_sub_end();    return -1;  }  MOVE(2);  self->pStreamInfo->SamplingRateIndex = i;  self->pStreamInfo->BitRate = bitrate;  COUNT_sub_end();    return 0;}

int IIR21_Downsample(IIR21_RESAMPLER *DownSampler,                 float *inSamples,                 int numInSamples,                 int inStride,                 float *outSamples,                 int *numOutSamples,                 int outStride               ){  int i;  *numOutSamples=0;  COUNT_sub_start("Downsample");  MOVE(1); /* counting previous operations */  PTR_INIT(2); /* pointer for inSamples[],                              outSamples[]               */  LOOP(1);   for(i=0;i<numInSamples;i++){    float iirOut;#ifdef NEWIIR    FUNC(2);    AdvanceARFilter(&(DownSampler->iirFilter), inSamples[i*inStride]);#else    FUNC(2);    iirOut = AdvanceIIRFilter(&(DownSampler->iirFilter), inSamples[i*inStride]);#endif    ADD(1);    DownSampler->pending++;    ADD(1); BRANCH(1);    if(DownSampler->pending == DownSampler->ratio){#ifdef NEWIIR      FUNC(1);      outSamples[(*numOutSamples)*outStride] = AdvanceMAFilter(&(DownSampler->iirFilter));;#else      MOVE(1);      outSamples[(*numOutSamples)*outStride] = iirOut;#endif      (*numOutSamples)++;      MOVE(1);      DownSampler->pending=0;    }  }  COUNT_sub_end();  return 1;}

int bcf_trim_alleles(const bcf_hdr_t *header, bcf1_t *line){    int i;    bcf_fmt_t *gt = bcf_get_fmt(header, line, "GT");    if ( !gt ) return 0;    int *ac = (int*) calloc(line->n_allele,sizeof(int));    // check if all alleles are populated    #define BRANCH(type_t,vector_end) { /        for (i=0; i<line->n_sample; i++) /        { /            type_t *p = (type_t*) (gt->p + i*gt->size); /            int ial; /            for (ial=0; ial<gt->n; ial++) /            { /                if ( p[ial]==vector_end ) break; /* smaller ploidy */ /                if ( bcf_gt_is_missing(p[ial]) ) continue; /* missing allele */ /                if ( (p[ial]>>1)-1 >= line->n_allele ) { free(ac); return -1; } /                ac[(p[ial]>>1)-1]++; /            } /        } /    }    switch (gt->type) {        case BCF_BT_INT8:  BRANCH(int8_t,  bcf_int8_vector_end); break;        case BCF_BT_INT16: BRANCH(int16_t, bcf_int16_vector_end); break;        case BCF_BT_INT32: BRANCH(int32_t, bcf_int32_vector_end); break;        default: fprintf(stderr, "[E::%s] todo: %d at %s:%d/n", __func__, gt->type, header->id[BCF_DT_CTG][line->rid].key, line->pos+1); exit(1); break;    }    #undef BRANCH    int nrm = 0;    kbitset_t *rm_set = kbs_init(line->n_allele);    for (i=1; i<line->n_allele; i++)    {        if ( !ac[i] ) { kbs_insert(rm_set, i); nrm++; }    }    free(ac);    if ( nrm ) bcf_remove_allele_set(header, line, rm_set);    kbs_destroy(rm_set);    return nrm;}

static intfindRegion(float currVal,           const float* borders,           const int numBorders,           int prevRegion           ){  int i;  COUNT_sub_start("findRegion");  ADD(1); BRANCH(1);  if(currVal < borders[0])  {    COUNT_sub_end();    return 0;  }  PTR_INIT(1); /* borders[] */  LOOP(1);  for(i = 1; i < numBorders; i++){    ADD(2); LOGIC(1); BRANCH(1);    if( currVal >= borders[i-1] && currVal < borders[i])    {      COUNT_sub_end();      return i;    }  }  ADD(1); BRANCH(1);  if(currVal > borders[numBorders-1])  {    COUNT_sub_end();    return numBorders;  }  COUNT_sub_end();  return 0;}

void bcf_fmt_array(kstring_t *s, int n, int type, void *data){	int j = 0;	if (n == 0) {		kputc('.', s);		return;	}    if (type == BCF_BT_CHAR)     {        char *p = (char*)data;        for (j = 0; j < n && *p; ++j, ++p) kputc(*p, s);    }    else    {        #define BRANCH(type_t, is_missing, kprint) {/            type_t *p = (type_t *) data; /            for (j=0; j<n && !(is_missing); j++) p++; /            if ( j ) /            { /                p = (type_t *) data; /                for (j=0; j<n; j++, p++) /                { /                    if ( j ) kputc(',', s); /                    if ( is_missing ) kputc('.', s); /                    else kprint; /                } /                if (n && j == 0) kputc('.', s); /            } /            else kputc('.', s); /        }        switch (type) {            case BCF_BT_INT8:  BRANCH(int8_t,  *p==INT8_MIN,  kputw(*p, s)); break;            case BCF_BT_INT16: BRANCH(int16_t, *p==INT16_MIN, kputw(*p, s)); break;            case BCF_BT_INT32: BRANCH(int32_t, *p==INT32_MIN, kputw(*p, s)); break;            case BCF_BT_FLOAT: BRANCH(float,  *(uint32_t*)p==bcf_missing_float, ksprintf(s, "%g", *p)); break;            default: fprintf(stderr,"todo: type %d/n", type); exit(1); break;        }        #undef BRANCH    }}

bcf1_t *process(bcf1_t *rec){    int nval = 0, i, j, nret = bcf_get_format_values(in_hdr,rec,"GP",(void**)&buf,&nbuf,gp_type);    if ( nret<0 )    {        if (!nskip_gp) fprintf(stderr, "[impute-info.c] Warning: info tag not added to sites without GP tag/n");        nskip_gp++;        return rec; // require FORMAT/GP tag, return site unchanged    }    nret /= rec->n_sample;    if ( nret != 3 )    {        if (!nskip_dip) fprintf(stderr, "[impute-info.c] Warning: info tag not added to sites that are not biallelic diploid/n");        nskip_dip++;        return rec; // require biallelic diploid, return site unchanged    }    double esum = 0, e2sum = 0, fsum = 0;    #define BRANCH(type_t,is_missing,is_vector_end) /    { /        type_t *ptr = (type_t*) buf; /        for (i=0; i<rec->n_sample; i++) /        { /            double vals[3] = {0,0,0}; /            for (j=0; j<nret; j++) /            { /                if ( is_missing || is_vector_end ) break; /                vals[j] = ptr[j]; /            } /            esum  += vals[1] + 2*vals[2]; /            e2sum += (vals[1] + 2*vals[2]) * (vals[1] + 2*vals[2]); /            fsum  += vals[1] + 4*vals[2]; /            ptr   += nret; /            nval++; /        } /    }    switch (gp_type)    {        case BCF_HT_INT:  BRANCH(int32_t,ptr[j]==bcf_int32_missing,ptr[j]==bcf_int32_vector_end); break;        case BCF_HT_REAL: BRANCH(float,bcf_float_is_missing(ptr[j]),bcf_float_is_vector_end(ptr[j])); break;    }    #undef BRANCH    double theta = esum / (2 * (double)nval);    float info  = (theta>0 && theta<1) ? (float)(1 - (fsum - e2sum) / (2 * (double)nval * theta * (1.0 - theta))) : 1;    bcf_update_info_float(out_hdr, rec, "INFO", &info, 1);    nrec++;    return rec;}

static voidgmStage1(SECTION_INFO * section,         int bitLookUp[MAX_SFB_LONG][CODE_BOOK_ESC_NDX + 1],         const int maxSfb,         const int *sideInfoTab){  int mergeStart = 0, mergeEnd;  COUNT_sub_start("gmStage1");  MOVE(1); /* counting previous operations */  LOOP(1);  do  {    PTR_INIT(4); /* pointers for section[mergeStart]                                 section[mergeEnd]                                 bitLookUp[mergeStart]                                 bitLookUp[mergeEnd]                 */    ADD(1); LOOP(1);    for (mergeEnd = mergeStart + 1; mergeEnd < maxSfb; mergeEnd++)    {      ADD(1); BRANCH(1);      if (section[mergeStart].codeBook != section[mergeEnd].codeBook)        break;      ADD(1); STORE(1);      section[mergeStart].sfbCnt++;      ADD(1); STORE(1);      section[mergeStart].sectionBits += section[mergeEnd].sectionBits;      FUNC(2);      mergeBitLookUp(bitLookUp[mergeStart], bitLookUp[mergeEnd]);    }    INDIRECT(1); ADD(1); STORE(1);    section[mergeStart].sectionBits += sideInfoTab[section[mergeStart].sfbCnt];    MOVE(1);    section[mergeEnd - 1].sfbStart = section[mergeStart].sfbStart;    MOVE(1);    mergeStart = mergeEnd;  } while (mergeStart < maxSfb);  COUNT_sub_end();}

int q_share_work(int worker_p) {  LOCK_OR_FRAME(LOCAL_top_or_fr);  if (Get_REMOTE_prune_request(worker_p)) {    /* worker p with prune request */    UNLOCK_OR_FRAME(LOCAL_top_or_fr);    return FALSE;  }#ifdef YAPOR_ERRORS  if (OrFr_pend_prune_cp(LOCAL_top_or_fr) &&      BRANCH_LTT(worker_p, OrFr_depth(LOCAL_top_or_fr)) < OrFr_pend_prune_ltt(LOCAL_top_or_fr))    YAPOR_ERROR_MESSAGE("prune ltt > worker_p branch ltt (q_share_work)");#endif /* YAPOR_ERRORS */  /* there is no pending prune with worker p at right --> safe move to worker p branch */  BRANCH(worker_id, OrFr_depth(LOCAL_top_or_fr)) = BRANCH(worker_p, OrFr_depth(LOCAL_top_or_fr));  LOCAL_prune_request = NULL;  UNLOCK_OR_FRAME(LOCAL_top_or_fr);  /* make sharing request */  LOCK_WORKER(worker_p);  if (BITMAP_member(GLOBAL_bm_idle_workers, worker_p) ||       REMOTE_share_request(worker_p) != MAX_WORKERS) {    /* worker p is idle or has another request */    UNLOCK_WORKER(worker_p);    return FALSE;  }  REMOTE_share_request(worker_p) = worker_id;  UNLOCK_WORKER(worker_p);  /* wait for an answer */  while (LOCAL_reply_signal == ready);  if (LOCAL_reply_signal == no_sharing) {    /* sharing request refused */    LOCAL_reply_signal = ready;    return FALSE;  }  /* exit this process */  exit(0);}

void ZBRANCH(){    SWAP();    if (pop(PSP) == 0)    {        BRANCH();    }    else    {	DROP();    }}

/* 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();}

void SpreadingMax(const int    pbCnt,                  const float *maskLowFactor,                  const float *maskHighFactor,                  float       *pbSpreadedEnergy){   int i;   COUNT_sub_start("SpreadingMax");   /* slope to higher frequencies */   PTR_INIT(2); /* pointers for pbSpreadedEnergy[],                                maskHighFactor[]                */   LOOP(1);   for (i=1; i<pbCnt; i++) {      MULT(1); ADD(1); BRANCH(1); MOVE(1);      pbSpreadedEnergy[i] = max(pbSpreadedEnergy[i],                                maskHighFactor[i] * pbSpreadedEnergy[i-1]);   }   /* slope to lower frequencies */   PTR_INIT(2); /* pointers for pbSpreadedEnergy[],                                maskLowFactor[]                */   LOOP(1);   for (i=pbCnt-2; i>=0; i--) {      MULT(1); ADD(1); BRANCH(1); MOVE(1);      pbSpreadedEnergy[i] = max(pbSpreadedEnergy[i],                                maskLowFactor[i] * pbSpreadedEnergy[i+1]);   }   COUNT_sub_end();}

void make_root_choice_point(void) {  if (worker_id == 0) {    LOCAL_top_cp = GLOBAL_root_cp = OrFr_node(GLOBAL_root_or_fr) = B;  } else {    B = LOCAL_top_cp = GLOBAL_root_cp;    B->cp_tr = TR = ((choiceptr) (worker_offset(0) + (CELL)(B)))->cp_tr;  }  B->cp_h = H0;  B->cp_ap = GETWORK;  B->cp_or_fr = GLOBAL_root_or_fr;  LOCAL_top_or_fr = GLOBAL_root_or_fr;  LOCAL_load = 0;  LOCAL_prune_request = NULL;  BRANCH(worker_id, 0) = 0;  return;}

voidDeleteTonCorrParamExtr (HANDLE_SBR_TON_CORR_EST hTonCorr){  COUNT_sub_start("DeleteTonCorrParamExtr");  BRANCH(1);  if (hTonCorr) {   INDIRECT(1); PTR_INIT(1); FUNC(1);   deleteInvFiltDetector (&hTonCorr->sbrInvFilt);  }  COUNT_sub_end();}

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

static int initElement (ELEMENT_INFO* elInfo, ELEMENT_TYPE elType) {  int error=0;  COUNT_sub_start("initElement");  MOVE(1); /* counting previous operations */  INDIRECT(1); MOVE(1);  elInfo->elType=elType;  BRANCH(2);  switch(elInfo->elType) {  case ID_SCE:    INDIRECT(1); MOVE(1);    elInfo->nChannelsInEl=1;    INDIRECT(1); MOVE(1);    elInfo->ChannelIndex[0]=0;    INDIRECT(2); STORE(1);    elInfo->instanceTag=0;    break;  case ID_CPE:    INDIRECT(1); MOVE(1);    elInfo->nChannelsInEl=2;    INDIRECT(2); MOVE(2);    elInfo->ChannelIndex[0]=0;    elInfo->ChannelIndex[1]=1;    INDIRECT(1); STORE(1);    elInfo->instanceTag=0;    break;  default:    MOVE(1);    error=1;  }  COUNT_sub_end();  return error;}

void make_root_choice_point(void) {  if (worker_id == 0) {    LOCAL_top_cp = GLOBAL_root_cp = OrFr_node(GLOBAL_root_or_fr) = B;    B->cp_h = H0;    B->cp_ap = GETWORK;    B->cp_or_fr = GLOBAL_root_or_fr;  } else {    B = LOCAL_top_cp = GLOBAL_root_cp;    TR = B->cp_tr;  }  LOCAL_top_or_fr = GLOBAL_root_or_fr;  LOCAL_load = 0;  LOCAL_prune_request = NULL;  BRANCH(worker_id, 0) = 0;  H_FZ = (CELL *) LOCAL_GlobalBase;  B_FZ = (choiceptr) LOCAL_LocalBase;  TR_FZ = (tr_fr_ptr) LOCAL_TrailBase;}

const short *GetScaleFactorBandOffsets(CIcsInfo *pIcsInfo){  COUNT_sub_start("GetScaleFactorBandOffsets");  FUNC(1); BRANCH(1);  if (IsLongBlock(pIcsInfo))  {    INDIRECT(1);    COUNT_sub_end();    return SamplingRateInfoTable[pIcsInfo->SamplingRateIndex].ScaleFactorBands_Long;  }  else  {    INDIRECT(1);    COUNT_sub_end();    return SamplingRateInfoTable[pIcsInfo->SamplingRateIndex].ScaleFactorBands_Short;  }}

static voidmergeBitLookUp(int *bc1, const int *bc2){  int j;  COUNT_sub_start("mergeBitLookUp");  PTR_INIT(2); /* pointers for bc1[],                               bc2[]               */  LOOP(1);  for (j = 0; j <= CODE_BOOK_ESC_NDX; j++)  {    ADD(2); BRANCH(1); MOVE(1);    bc1[j] = min(bc1[j] + bc2[j], INVALID_BITCOUNT);  }  COUNT_sub_end();}

/*****************************************************************************    functionname: atan_approx    description:  Calculates atan , val >=0    returns:      approx of atan(val), error is less then 0.5 %    input:    output:*****************************************************************************/static float atan_approx(float val){  COUNT_sub_start("atan_approx");  ADD(1); BRANCH(1);  if(val < (float)1.0)  {    DIV(1); MULT(2); ADD(1); /* counting post-operations */    COUNT_sub_end();    return(val/((float)1.0f+(float)0.280872f*val*val));  }  else  {    DIV(1); MULT(1); ADD(2); /* counting post-operations */    COUNT_sub_end();    return((float)1.57079633f-val/((float)0.280872f +val*val));  }}

static float calcBitSpend(float fillLevel,                          const float clipLow,                          const float clipHigh,                          const float minBitSpend,                          const float maxBitSpend){   float bitspend;   COUNT_sub_start("calcBitSpend");   ADD(2); BRANCH(2); MOVE(2);   fillLevel = max(fillLevel, clipLow);   fillLevel = min(fillLevel, clipHigh);   ADD(4); DIV(1); MULT(1);   bitspend = minBitSpend + ((maxBitSpend-minBitSpend) / (clipHigh-clipLow)) *                            (fillLevel-clipLow);   COUNT_sub_end();   return (bitspend);}

static float calcBitSave(float fillLevel,                         const float clipLow,                         const float clipHigh,                         const float minBitSave,                         const float maxBitSave){   float bitsave;   COUNT_sub_start("calcBitSave");   ADD(2); BRANCH(2); MOVE(2);   fillLevel = max(fillLevel, clipLow);   fillLevel = min(fillLevel, clipHigh);   ADD(4); DIV(1); MULT(1);   bitsave = maxBitSave - ((maxBitSave-minBitSave) / (clipHigh-clipLow)) *                          (fillLevel-clipLow);   COUNT_sub_end();   return (bitsave);}

static int countMsMaskBits(int   sfbCnt,                           int   sfbPerGroup,                           int   maxSfbPerGroup,                           struct TOOLSINFO *toolsInfo){  int msBits=0,sfbOff,sfb;  COUNT_sub_start("countMsMaskBits");  MOVE(1); /* counting previous operation */  INDIRECT(1); BRANCH(2);  switch(toolsInfo->msDigest)  {    case MS_NONE:    case MS_ALL:    break;    case MS_SOME:      LOOP(1);      for(sfbOff = 0; sfbOff < sfbCnt; sfbOff+=sfbPerGroup)      {        LOOP(1);        for(sfb=0; sfb<maxSfbPerGroup; sfb++)        {        ADD(1);        msBits++;        }      }    break;  }  COUNT_sub_end();  return(msBits);}

void make_root_choice_point(void) {  if (worker_id == 0) {    LOCAL_top_cp = GLOBAL_root_cp = OrFr_node(GLOBAL_root_or_fr) = B;  } else {    B = LOCAL_top_cp = GLOBAL_root_cp;    B->cp_tr = TR = ((choiceptr) (worker_offset(0) + (CELL)(B)))->cp_tr;  }  //  B->cp_h = H0;  B->cp_ap = GETWORK;  B->cp_or_fr = GLOBAL_root_or_fr;  LOCAL_top_or_fr = GLOBAL_root_or_fr;  LOCAL_load = 0;  Set_LOCAL_prune_request(NULL);  BRANCH(worker_id, 0) = 0;#ifdef TABLING_INNER_CUTS  LOCAL_pruning_scope = NULL;#endif /* TABLING_INNER_CUTS */#ifdef TABLING  LOCAL_top_cp_on_stack = LOCAL_top_cp;  adjust_freeze_registers();#endif /* TABLING */  return;}

/***************************************************************************** description:  frees memory of one SBR channel returns:      void*****************************************************************************/static voiddeleteEnvChannel (HANDLE_ENV_CHANNEL hEnvCut){  COUNT_sub_start("deleteEnvChannel");  BRANCH(1);  if (hEnvCut) {    INDIRECT(1); PTR_INIT(1); FUNC(1);    deleteFrameInfoGenerator (&hEnvCut->SbrEnvFrame);    INDIRECT(1); PTR_INIT(1); FUNC(1);    deleteQmfBank (&hEnvCut->sbrQmf);    INDIRECT(1); PTR_INIT(1); FUNC(1);    deleteSbrCodeEnvelope (&hEnvCut->sbrCodeEnvelope);    INDIRECT(1); PTR_INIT(1); FUNC(1);    deleteSbrCodeEnvelope (&hEnvCut->sbrCodeNoiseFloor);    INDIRECT(1); PTR_INIT(1); FUNC(1);    deleteSbrTransientDetector (&hEnvCut->sbrTransientDetector);    INDIRECT(1); PTR_INIT(1); FUNC(1);    deleteExtractSbrEnvelope (&hEnvCut->sbrExtractEnvelope);    INDIRECT(1); PTR_INIT(1); FUNC(1);    DeleteTonCorrParamExtr(&hEnvCut->TonCorr);  }  COUNT_sub_end();}

/* Process 2OP Integer instructions */bool eval_2OP_Int(struct lilith* vm, struct Instruction* c){	#ifdef DEBUG	char Name[20] = "ILLEGAL_2OP";	#endif	switch(c->raw_XOP)	{		case 0x0000: /* NEG */		{			#ifdef DEBUG			strncpy(Name, "NEG", 19);			#elif TRACE			record_trace("NEG");			#endif			NEG(vm, c);			break;		}		case 0x0001: /* ABS */		{			#ifdef DEBUG			strncpy(Name, "ABS", 19);			#elif TRACE			record_trace("ABS");			#endif			ABS(vm, c);			break;		}		case 0x0002: /* NABS */		{			#ifdef DEBUG			strncpy(Name, "NABS", 19);			#elif TRACE			record_trace("NABS");			#endif			NABS(vm, c);			break;		}		case 0x0003: /* SWAP */		{			#ifdef DEBUG			strncpy(Name, "SWAP", 19);			#elif TRACE			record_trace("SWAP");			#endif			SWAP(vm, c);			break;		}		case 0x0004: /* COPY */		{			#ifdef DEBUG			strncpy(Name, "COPY", 19);			#elif TRACE			record_trace("COPY");			#endif			COPY(vm, c);			break;		}		case 0x0005: /* MOVE */		{			#ifdef DEBUG			strncpy(Name, "MOVE", 19);			#elif TRACE			record_trace("MOVE");			#endif			MOVE(vm, c);			break;		}		case 0x0006: /* NOT */		{			#ifdef DEBUG			strncpy(Name, "NOT", 19);			#elif TRACE			record_trace("NOT");			#endif			NOT(vm, c);			break;		}		case 0x0100: /* BRANCH */		{			#ifdef DEBUG			strncpy(Name, "BRANCH", 19);			#elif TRACE			record_trace("BRANCH");			#endif			BRANCH(vm, c);			break;		}		case 0x0101: /* CALL */		{			#ifdef DEBUG//.........这里部分代码省略.........