Beispiel #1
0
/* 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();
}
Beispiel #2
0
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;
}
Beispiel #3
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);

}
Beispiel #4
0
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;
}
Beispiel #5
0
    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();
    }
Beispiel #6
0
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);
}
Beispiel #7
0
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();
}
Beispiel #8
0
	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();
	}
Beispiel #9
0
// skipped some of the special handling in here - if we get crashes, let the interpreter handle this
// op
void JitILBase::divwux(UGeckoInstruction inst)
{
	// FIXME
	FALLBACK_IF(true);

#if 0
	int a = inst.RA, b = inst.RB, d = inst.RD;
	gpr.FlushLockX(RSCRATCH1);
	gpr.Lock(a, b, d);

	if (d != a && d != b)
	{
		gpr.LoadToX64(d, false, true);
	}
	else
	{
		gpr.LoadToX64(d, true, true);
	}

	MOV(32, R(RSCRATCH), gpr.R(a));
	XOR(32, R(RSCRATCH2), R(RSCRATCH));
	gpr.KillImmediate(b);
	DIV(32, gpr.R(b));
	MOV(32, gpr.R(d), R(RSCRATCH));
	gpr.UnlockAll();
	gpr.UnlockAllX();

	if (inst.Rc)
	{
		CALL((u8*)asm_routines.computeRc);
	}
#endif
}
Beispiel #10
0
/*
  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();
}
Beispiel #11
0
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;
}
Beispiel #12
0
/*!

  \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;
}
Beispiel #13
0
    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();
    }
Beispiel #14
0
/**
 * 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;
}
Beispiel #15
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;
}
Beispiel #16
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;
}
Beispiel #17
0
int is_abs_walkable(Entity** entities, int x, int y) {
    int walkable = is_walkable(entities[DIV(x)][DIV(y)]);
    if(MOD(x) != 0 && MOD(y) != 0)
        walkable = walkable && is_walkable(entities[DIV(x) + 1][DIV(y) + 1]);
    if(MOD(x) != 0)
        walkable = walkable && is_walkable(entities[DIV(x) + 1][DIV(y)]);
    if(MOD(y) != 0)
        walkable = walkable && is_walkable(entities[DIV(x)][DIV(y) + 1]);
    return walkable;
}
Beispiel #18
0
struct LongNumber DEGREE(struct LongNumber a, struct LongNumber b, struct LongNumber c)
{ 
	struct LongNumber res;
	if(a.size < c.size)
		res.size = c.size + c.size;
	else
		res.size = a.size + a.size;

	res = allocate(res, res.size);
    res = zero(res, res.size); 
	res.pointer[0] = 1;

	struct LongNumber com;
	com.size = 1;
	com = allocate(com, com.size);
	com.pointer[0] = 0;

	struct LongNumber value;
	value.size = res.size;
	value = allocate(value, value.size);
    value = zero(value, value.size);

	memcpy(value.pointer, a.pointer, a.size * sizeof(unsigned int));

	struct LongNumber pow = copy(b);

	while((compare(pow,com)) > 0)
	{
		if((pow.pointer[0] & 1)==1)
		{
			res = MUL(res, value);
			res = DIV(res, c, 2);
		}

		value = MUL(value, value);
		value = DIV(value, c, 2);
		pow = SmallDIV(pow, 2);
	}

	com = clear(com);
	pow = clear(pow);
	value = clear(value);

	return res;
}
Beispiel #19
0
    void print_to_default_file(const char * userfile, int lineno, S tag,
                               unsigned int obj, ADDON addon = ADDON()) {

        tagset.insert(tag);
        (*OS) << DIV(tag) << BOLD("<br>Tag : ") << RED(tag) << NBSP << CALLINFO
              << NBSP << BROWN(addon.getString()) << NBSP
              << BOLD(" Data : <br>") << obj << EDIV;
        (*OS).flush();
    }
Beispiel #20
0
    void print_to_file(const char * userfile, int lineno, const char* tag,
                       const char* objS) {

//llvm::errs()<<"I am called in line no"<<__LINE__;
        tagset.insert(tag);
        (*OS) << DIV(tag) << BOLD("<br>Tag : ") << RED(tag) << NBSP << CALLINFO
              << NBSP << BOLD(" Data : <br>") << objS << EDIV;
        (*OS).flush();
    }
Beispiel #21
0
/*****************************************************************************

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

}
Beispiel #22
0
int main(void)
{

	printf("ADDITION:\t %f + %f = %f\n", WERT1, WERT2, ADD(WERT1,WERT2));
	printf("SUBTRAKTION:\t %f - %f = %f\n", WERT1, WERT2, SUB(WERT1,WERT2));
	printf("MULTIPLIKATION:\t %f * %f = %f\n", WERT1, WERT2, MUL(WERT1,WERT2));
	printf("DIVISION:\t %f / %f = %f\n", WERT1, WERT2, DIV(WERT1,WERT2));

	return 0;
}
Beispiel #23
0
int main()
{
 printf("%d",p);
 int num1, num2, mod;
 printf("\nEnter two integers\n");
 scanf("%d%d",&num1,&num2);
 printf("\nThe result of division is %d\n", DIV(num1,num2));
 mod = MOD(num1,num2);
 printf("\nThe result of modulus is %d\n", mod);
 
}
Beispiel #24
0
int moduloExprCodegen(c_tree tree, int *registerNo, int topLevel,
		int getAddress, const char *breakLabel, const char *continueLabel)
{
	c_tree op2 = TREE_EXPR_OPERAND(tree,1);

	c_tree op1 = TREE_EXPR_OPERAND(tree,0);

	if (!topLevel)
	{
		int op1Register = c_codegen_recurse(op1,
				registerNo, topLevel, getAddress, breakLabel, continueLabel);

		if (TREE_CODE(op2) == TREE_INTEGER_CST)
		{
			int divReg = (*registerNo)++;
			int mulReg = (*registerNo)++;
			int resReg = (*registerNo)++;

			int immiValue = INTEGER_CST(op2)->val;
			DIVi(divReg, op1Register, immiValue, "modulo", NULL);
			MULi(mulReg, divReg, immiValue, "modulo", NULL);
			SUB(resReg, op1Register, mulReg, "modulo", NULL);

			return resReg;
		}
		else
		{
			int op2Register = c_codegen_recurse(op2, registerNo, topLevel,
					getAddress, breakLabel, continueLabel);

			int divReg = (*registerNo)++;
			int mulReg = (*registerNo)++;
			int resReg = (*registerNo)++;

			DIV(divReg, op1Register, op2Register, "modulo", NULL);
			MUL(mulReg, divReg, op2Register, "modulo", NULL);
			SUB(resReg, op1Register, mulReg, "modulo", NULL);

			return resReg;
		}
	}
	else
	{
		c_codegen_recurse(op1, registerNo, topLevel, getAddress, breakLabel,
						continueLabel);

		c_codegen_recurse(op2, registerNo, topLevel, getAddress, breakLabel,
				continueLabel);

		return *registerNo;
	}
}
Beispiel #25
0
static void test_div_basic(void)
{
	TB_INFO("   Testing basic cases");

	DEF_BIGINT(n, 2048);
	DEF_BIGINT(d, 2048);
	DEF_BIGINT(q, 2048);
	DEF_BIGINT(r, 2048);
	DEF_BIGINT(v, 2048);

	SELF_VERIFY_DIV("8111_1110_0000_0001_12345678", "8000000012345678");

	DIV("0", "1", "0");
	DIV("1", "1", "1");
	DIV("b7fb", "5", "24CB");
	DIV("124378912734891273894712890347102358129034789120374",
	    "1984086C15FA011154C86FA68", "B73D14EC7205D3311F6E78411D");
	SELF_VERIFY_DIV("124378912734891273894712890347102358129034789120374",
			"1984086C15FA011154C86FA68");
	SELF_VERIFY_DIV("-124378912734891273894712890347102358129034789120374",
			"1984086C15FA011154C86FA68");
	SELF_VERIFY_DIV("124378912734891273894712890347102358129034789120374",
			"-1984086C15FA011154C86FA68");
	SELF_VERIFY_DIV("-124378912734891273894712890347102358129034789120374",
			"-1984086C15FA011154C86FA68");
	SELF_VERIFY_DIV("12345678", "10");
	SELF_VERIFY_DIV("-12345678", "10");
	SELF_VERIFY_DIV("12345678", "-10");
	SELF_VERIFY_DIV("-12345678", "-10");
	SELF_VERIFY_DIV("12345678901234567890123456789012345678901", "10");
	SELF_VERIFY_DIV("1234567890123456789012345678901234567890", "10");
	SELF_VERIFY_DIV("123456789012345678901234567890123456789", "10");

	DEL_BIGINT(n);
	DEL_BIGINT(d);
	DEL_BIGINT(q);
	DEL_BIGINT(r);
	DEL_BIGINT(v);
}
Beispiel #26
0
	Byte Processor::execInstruction() {
#ifdef R_UM_OPT_ENABLE_LOGGING
#ifdef R_UM_OPT_PRC_DEBUG
		ic_ ++;
#endif
#endif
		Word instr = (*mm_)(0, pc_ ++);
		switch (decodeInstruction(instr)) {
			case IC_CNDMOV:
				return CNDMOV(decodeAreg(instr), decodeBreg(instr),
						decodeCreg(instr));
			case IC_ARRIDX:
				return ARRIDX(decodeAreg(instr), decodeBreg(instr),
						decodeCreg(instr));
			case IC_ARRAMD:
				return ARRAMD(decodeAreg(instr), decodeBreg(instr),
						decodeCreg(instr));
			case IC_ADD:
				return ADD(decodeAreg(instr), decodeBreg(instr),
						decodeCreg(instr));
			case IC_MUL:
				return MUL(decodeAreg(instr), decodeBreg(instr),
						decodeCreg(instr));
			case IC_DIV:
				return DIV(decodeAreg(instr), decodeBreg(instr),
						decodeCreg(instr));
			case IC_NOTAND:
				return NOTAND(decodeAreg(instr), decodeBreg(instr),
						decodeCreg(instr));

			case IC_HLT:
				return HLT();
			case IC_ALLOC:
				return ALLOC(decodeBreg(instr), decodeCreg(instr));
			case IC_ABAND:
				return ABAND(decodeCreg(instr));
			case IC_OUTP:
				return OUTP(decodeCreg(instr));
			case IC_INP:
				return INP(decodeCreg(instr));
			case IC_LDPRG:
				return LDPRG(decodeBreg(instr), decodeCreg(instr));

			case IC_ORTHO:
				return ORTHO(decodeOreg(instr), decodeVal(instr));

			default:
				assert(false);
				return HLT();
		}
	}
Beispiel #27
0
int main (void)
{
	double *x, *f;
	int i;
	x = aCy (n, -1., 1. );

	SV (n, x);
	f = DIV (n);
	for (i = 0; i < n; i++)
		f[i] = fun (x[i]);
	difdiv (n, x, f); /* generat el polinomi */
	writeFile (n, 0.001, -1, 1, x, f);
	return 0;
}
Beispiel #28
0
int timer_init(void)
{
	/* We are using timer34 in unchained 32-bit mode, full speed */
	timer->tcr = 0x0;
	timer->tgcr = 0x0;
	timer->tgcr = 0x06;
	timer->tim34 = 0x0;
	timer->prd34 = DIV(TIMER_LOAD_VAL);
	lastinc = 0;
	timer->tcr = 0x80 << 16;
	timestamp = 0;

	return(0);
}
Beispiel #29
0
int
dynBitCount(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);
}
Beispiel #30
0
    void print_to_file(const char * userfile, int lineno, const char* tag,
                       T &obj) {
        std::string msg;
//llvm::errs()<<"I am called in line no"<<__LINE__;

        llvm::raw_string_ostream Msg(msg);
        Msg << obj;
        std::string objS = Msg.str();

        replaceAll(objS, "\n", mendl);
        tagset.insert(tag);
        (*OS) << DIV(tag) << BOLD("<br>Tag : ") << RED(tag) << NBSP << CALLINFO
              << NBSP << BOLD(" Data : <br>") << objS << EDIV;
        (*OS).flush();
    }