C++ DIV函数代码示例

/* 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
xavs_cqm_init (xavs_t * h)
{
  int def_quant8[64][64];
  int def_dequant8[64][64];
  int q, i, i_list;
  int pos;
  int deadzone[4] = { h->param.analyse.i_luma_deadzone[0],
    h->param.analyse.i_luma_deadzone[1],
    32 - 11, 32 - 21
  };                            /*intra Y; inter Y; intra C; inter C */
  int max_qp_err = -1;

  //initial the dequant and quant table with q for 8x8 
  for (q = 0; q < 64; q++)
  {
    for (i = 0; i < 64; i++)
    {
      def_dequant8[q][i] = dequant8_table[q];
      def_quant8[q][i] = quant8_scale[i];
    }
  }

  //i_list =0 Intra Y ; i_list = 1 inter Y ; i_list =2 Intra C ; i_list =3 Inter C;
  for (i_list = 0; i_list < 4; i_list++)
  {
    for (q = 0; q < 64; q++)
    {
      for (pos = 0; pos < 64; pos++)
      {
        int xx = pos % 8;
        int yy = pos / 8;
        int mf;
        h->dequant8_mf[i_list][q][yy][xx] = DIV (def_dequant8[q][pos] * 16, h->pps->scaling_list[i_list][pos]);
        h->quant8_mf[i_list][q][pos] = mf = DIV (def_quant8[q][pos] * 16, h->pps->scaling_list[i_list][pos]);

        //here the deadzone is a value from 0~32 2~5  
        //deadzone 1/2, deadzone should be 0.5 * 1<<15  = (1<<5) * (1<<9)
        //typical value intra  f=(1<<15)*10/31  inter  f=(1<<15)*10/62
        if (i_list % 2 == 0)    /*intra */
          h->quant8_bias[i_list][q][pos] = XAVS_MIN (deadzone[i_list] << 9, (1 << 15) * 10 / 31);
        else                    /*inter */
          h->quant8_bias[i_list][q][pos] = XAVS_MIN (deadzone[i_list] << 9, (1 << 15) * 10 / 62);
      }
    }
  }

  if (!h->mb.b_lossless && max_qp_err >= h->param.rc.i_qp_min)
  {
    xavs_log (h, XAVS_LOG_ERROR, "Quantization overflow.\n");
    xavs_log (h, XAVS_LOG_ERROR, "Your CQM is incompatible with QP < %d, but min QP is set to %d\n", max_qp_err + 1, h->param.rc.i_qp_min);

    return -1;
  }
  return 0;
}

static void  reducec(NUM_TYPE* l1,NUM_TYPE * l2)
{ NUM_TYPE    c, i1, i2;

   i1 = ABS(*l1); i2 = ABS(*l2);
   if (i2 > i1) { c = i1; i1 = i2; i2 = c; }
   while (i2 != 0) { c = i2; i2 = REST(i1,i2); i1 = c; }
   (*l1) = DIV(*l1,i1);
   (*l2) = DIV(*l2,i1);

}

ulong get_timer_raw(void)
{
	ulong now = DIV(READ_TIMER);

	if (now >= lastinc) {
		/* normal mode */
		timestamp += now - lastinc;
	} else {
		/* overflow ... */
		timestamp += now + DIV(TIMER_LOAD_VAL) - lastinc;
	}
	lastinc = now;
	return timestamp;
}

    aravdebug(const char * userfile, int lineno, const char *PATH) {

        dataPath = getenv("DLOG_OUTPUT_FOLDER") + std::string(PATH);

        //llvm::errs()<<"Data path ::"<<dataPath;
        datatempPath = dataPath + ".temp";
//		tagPath = dataPath + ".tag";

        std::string syscall = "rm -f " + dataPath;

        int status = system(syscall.c_str());
        if (status < 0)
            std::cout << "DLOG Error: " << strerror(errno) << '\n';

        OS.reset((new llvm::raw_fd_ostream(datatempPath.c_str(), ErrorInfo)));

        llvm::errs() << ErrorInfo;

        id = gid++;

        //llvm::errs()<<"created DLOG with id "<<id<<"\n";
        tagset.insert("SYSTEM");
        (*OS) << DIV("SYSTEM")<< "Created Debugger " << GREEN(id)
              << CALLINFO
              << EDIV;

        tagset.insert("CALLINFO");

        (*OS).flush();
    }

void tmr0_init(void)
{
    // Select asynchronous timer 0 operation to use external 32.768 kHz crystal
    BIT_SET_HI(ASSR,AS0);

    // Reset time
    TCNT0 = 0;

    // Calculate and set period
    OCR0 = (uint16)DIV(((F_RTC/8)*TMR0_PERIOD_MS),1000) - 1;

    /* Start timer 0 with clock prescaler CLK/8 and CTC Mode ("Clear Timer on Compare")*/
    /* Resolution is 244.14 us */
    /* Maximum period is 62.5 ms */
    TCCR0 = TMR0_TCCR0_VALUE;

    // Wait for "update busy" flags to clear
    while(ASSR&((1<<TCN0UB)|(1<<OCR0UB)|(1<<TCR0UB)))
    {
        ;
    }

    // Enable interrupt on compare match
    BIT_SET_HI(TIMSK,OCIE0);
}

static void calcPeCorrection(float *correctionFac,
                             const float peAct,
                             const float peLast, 
                             const int bitsLast) 
{
  COUNT_sub_start("calcPeCorrection");

  ADD(4); FUNC(1); FUNC(1); MULT(4); LOGIC(4); BRANCH(1);
  if ((bitsLast > 0) && (peAct < (float)1.5f*peLast) && (peAct > (float)0.7f*peLast) &&
      ((float)1.2f*bits2pe((float)bitsLast) > peLast) && 
      ((float)0.65f*bits2pe((float)bitsLast) < peLast))
  {
    float newFac = peLast / bits2pe((float)bitsLast);

    FUNC(1); DIV(1); /* counting previous operation */

    /* dead zone */
    ADD(1); BRANCH(1);
    if (newFac < (float)1.0f) {

      MULT(1); ADD(1); BRANCH(1); MOVE(1);
      newFac = min((float)1.1f*newFac, (float)1.0f);

      ADD(1); BRANCH(1); MOVE(1);
      newFac = max(newFac, (float)0.85f);
    }
    else {
      MULT(1); ADD(1); BRANCH(1); MOVE(1);
      newFac = max((float)0.9f*newFac, (float)1.0f);

      ADD(1); BRANCH(1); MOVE(1);
      newFac = min(newFac, (float)1.15f);
    }
    ADD(4); LOGIC(3); BRANCH(1);
    if (((newFac > (float)1.0f) && (*correctionFac < (float)1.0f)) ||
        ((newFac < (float)1.0f) && (*correctionFac > (float)1.0f))) {

      MOVE(1);
      *correctionFac = (float)1.0f;
    }

    /* faster adaptation towards 1.0, slower in the other direction */
    ADD(3); LOGIC(3); BRANCH(1); /* if() */ MULT(1); MAC(1); STORE(1);
    if ((*correctionFac < (float)1.0f && newFac < *correctionFac) ||
        (*correctionFac > (float)1.0f && newFac > *correctionFac))
      *correctionFac = (float)0.85f * (*correctionFac) + (float)0.15f * newFac;
    else
      *correctionFac = (float)0.7f * (*correctionFac) + (float)0.3f * newFac;

    ADD(2); BRANCH(2); MOVE(2);
    *correctionFac = min(*correctionFac, (float)1.15f);
    *correctionFac = max(*correctionFac, (float)0.85f);
  }
  else {
    MOVE(1);
    *correctionFac = (float)1.0f;
  }

  COUNT_sub_end();
}

	void llvm_print(const char *userfile, int lineno, T &obj, const char* tag,
			ADDON addon = ADDON())
	{

		std::string unformatted = llvm_to_str(obj);
		std::string formatted = dlog_format_string_to_html(unformatted);

		if (outputmode == DLOG_OUTPUT_BOTH || outputmode == DLOG_OUTPUT_FILE)

		{
			tag_handler(tag);
			fdata << DIV(
					tag) << BOLD("<br>Tag : ") << RED(tag) << NBSP << br << CALLINFO
			<< BROWN(addon.getString()) << NBSP << NBSP
			<< BOLD(" Data : <br>") << formatted << EDIV;
		}
		if (outputmode == DLOG_OUTPUT_BOTH || outputmode == DLOG_OUTPUT_STDOUT)
		{
			std::cout << "Tag : " << tag << "\t";
			if (addon.getString().length() != 0)
			std::cout << "\t Addon: " << addon.getString() << "\n";
			std::cout << unformatted << "\n";
		}

		fdata.flush();
	}

/*
  The function creates the interpolated spectral data according to the 
  energy of the last good frame and the current (good) frame.
*/
void CConcealment_InterpolateBuffer (float       *spectrum,
                                     float       *enPrev,
                                     float       *enAct,
                                     int          sfbCnt,
                                     const short *pSfbOffset)
{
  int    sfb, line = 0;
  float  multiplier;

  FLC_sub_start("CConcealment_InterpolateBuffer");

  MOVE(1); /* counting previous operation */

  PTR_INIT(3); /* enAct[]
                  enPrev[]
                  spectrum[]
               */
  LOOP(1);
  for(sfb = 0; sfb < sfbCnt; sfb++) {

    DIV(1); TRANS(1);
    multiplier = (float) pow(enAct[sfb] / enPrev[sfb], 0.25f);

    LOOP(1);
    for(; line < pSfbOffset[sfb+1]; line++) {

      MULT(1); STORE(1);
      spectrum [line] = spectrum[line] * multiplier;
    }
  }

  FLC_sub_end();
}

static Value *binaryExprInterp(Node *node, void *parser)
{
#ifndef NDEBUG
	assert(node->type == NT_BINARY_EXPR);
#endif
	BinaryExpr *e = (BinaryExpr *)node;
#ifdef LOG_INTERP
	logInterpPrefix(parser);
	rawlog("binaryExprInterp\n");
	((Parser *)parser)->interpDepth++;
#endif
	assert(e->lhs && e->rhs);
	Value *lhs = e->lhs->interp(e->lhs, parser);
	Value *rhs = e->rhs->interp(e->rhs, parser);
	switch (e->op) {
	case TK_ADD: e->value = ADD(lhs, rhs, e->value); break; /* + */
	case TK_SUB: e->value = SUB(lhs, rhs, e->value); break; /* - */
	case TK_MUL: e->value = MUL(lhs, rhs, e->value); break; /* * */
	case TK_DIV: e->value = DIV(lhs, rhs, e->value); break; /* / */
	default:
		assert(0);
		break;
	}
#ifdef LOG_INTERP
	logInterpPrefix(parser);
	rawlog("%s\n", token2str(e->op));
	((Parser *)parser)->interpDepth--;
#endif
	return e->value;
}

/*!

  \brief  Is SBR setting available.
  \return a flag indicating success: yes (1) or no (0)

****************************************************************************/
unsigned int
IsSbrSettingAvail (unsigned int bitrate,
                   unsigned int numOutputChannels,
                   unsigned int sampleRateInput,
                   unsigned int *sampleRateCore
                   )
{
  int idx = INVALID_TABLE_IDX;

  COUNT_sub_start("IsSbrSettingAvail");

  MOVE(1); /* counting previous operation */

  ADD(1); BRANCH(1);
  if (sampleRateInput < 32000)
  {
    COUNT_sub_end();
    return 0;
  }

  DIV(1); STORE(1);
  *sampleRateCore = sampleRateInput/2;

  FUNC(3);
  idx = getSbrTuningTableIndex(bitrate,numOutputChannels, *sampleRateCore);

  ADD(1); BRANCH(1); /* counting post-operation */

  COUNT_sub_end();

  return (idx == INVALID_TABLE_IDX) ? 0 : 1;
}

    void print_to_file(const char * userfile, int lineno, T obj, ADDON addon =
                           ADDON()) {

        tagset.insert("notag");
        (*OS) << DIV("notag") << br << BLUE( obj) << NBSP << CALLINFO << NBSP
              << BROWN(addon.getString()) << NBSP << EDIV;
        (*OS).flush();
    }

/**
 * Generates a sequence of nbits random bits
 */
int srslte_binsource_cache_gen(srslte_binsource_t* q, int nbits) {
  if (gen_seq_buff(q,DIV(nbits,32))) {
    return -1;
  }
  q->seq_cache_nbits = nbits;
  q->seq_cache_rp = 0;
  return 0;
}

/**
 * Stores in the bits buffer a sequence of nbits pseudo-random bits.
 * Overwrites the bits generated using srslte_binsource_cache_gen.
 */
int srslte_binsource_generate(srslte_binsource_t* q, uint8_t *bits, int nbits) {

  if (gen_seq_buff(q,DIV(nbits,32))) {
    return -1;
  }
  int_2_bits(q->seq_buff,bits,nbits);
  return 0;
}

/**
 * Stores in the bits buffer a sequence of nbits pseudo-random bits.
 * Overwrites the bits generated using binsource_cache_gen.
 */
int binsource_generate(binsource_t* q, char *bits, int nbits) {

  if (gen_seq_buff(q,DIV(nbits,32))) {
    return -1;
  }
  int_2_bits(q->seq_buff,bits,nbits);
  return 0;
}