ic_predict.c

au1200 linux2.6.11 硬件解码mae驱动和maiplayer播放器源码

    (0.00000000000000000000000000000019721522630525295000),
    (0.00000000000000000000000000000009860761315262647600),
    (0.00000000000000000000000000000004930380657631323800),
    (0.00000000000000000000000000000002465190328815661900),
    (0.00000000000000000000000000000001232595164407830900),
    (0.00000000000000000000000000000000616297582203915470),
    (0.00000000000000000000000000000000308148791101957740),
    (0.00000000000000000000000000000000154074395550978870),
    (0.00000000000000000000000000000000077037197775489434),
    (0.00000000000000000000000000000000038518598887744717),
    (0.00000000000000000000000000000000019259299443872359),
    (0.00000000000000000000000000000000009629649721936179),
    (0.00000000000000000000000000000000004814824860968090),
    (0.00000000000000000000000000000000002407412430484045),
    (0.00000000000000000000000000000000001203706215242022),
    (0.00000000000000000000000000000000000601853107621011),
    (0.00000000000000000000000000000000000300926553810506),
    (0.00000000000000000000000000000000000150463276905253),
    (0.00000000000000000000000000000000000075231638452626),
    (0.00000000000000000000000000000000000037615819226313),
    (0.00000000000000000000000000000000000018807909613157),
    (0.00000000000000000000000000000000000009403954806578),
    (0.00000000000000000000000000000000000004701977403289),
    (0.00000000000000000000000000000000000002350988701645),
    (0.00000000000000000000000000000000000001175494350822),
    (0.0 /* 0000000000000000000000000000000000000587747175411 "floating point underflow" */),
    (0.0)
};
#endif

#ifdef FIXED_POINT /* [ */

#define i_ALPHA    REAL_CONST(0.90625)
#define i_A        REAL_CONST(0.953125)

#if 0
int32_t ilog2(int64_t ii)
{ 
  /* returns x, where x = log2(2^x) = log2(2^(x+1)-1) */
  uint32_t xx, iu;

  if (ii < 1)
    return 0;

  if (ii <= 0x7fffffffL)
  {
    xx = 0;
    iu = (uint32_t)ii;

    while ((iu >> xx) > 1)
      xx++;
    return xx;
  }
  else
  {
    iu = (uint32_t)(ii >> 31);
    xx = 0;
    while ((iu >> xx) > 1)
      xx++;
  
    xx += 31; 
    return xx;
  }
}
#else


#endif

#if 0
static void pfloat(float32_t ff, int16_t qq)
{
  uint32_t *tmp = (uint32_t *)&ff;
  int32_t q = *tmp;
  int64_t out;
  int64_t ii = (q & 0x7fffff) | 0x800000;
  int64_t gg = (q & 0x7fffff);
  int32_t ex = ((int32_t)((q >> 23) & 0xff)) - 127 - 23;
  int32_t sign = (q & 0x80000000) ? 1 : 0;

  if (ex < -64)
    out = 0;
  else if (ex > 63)
    out = (int64_t)0x7fffffffffffffffll;
  else
    out = ((ex < 0) ? (ii >> -ex) : (ii << ex));
  if (sign)
    out = -out;

  printf("float %f ::: %x, ex %d, implied %llx, %lld %llx sign %d\n", ff, qq, ex, gg, out, out, sign);
/*
   19  << 4    5253c0, 0000d253c
   20  << 3    2f9000, 00015f200
   21  << 2    7e5b64, 0003f96d9
   22  << 1    35177a, 0005a8bbd
   23  << 0    5d673d, 000dd673d
   24  >> 1    7f900c, 001ff2018
   25  >> 2    738199, 003ce0664 
   26  >> 3    641631, 00720b188
   27  >> 4    5edd5d, 00dedd5d0
   28  >> 5    012dfe, 01025bfc0 
   29  >> 6    07b8f4, 021ee3d00
   30  >> 7    1b76b1, 04dbb5880
   31  >> 8    03b3b5, 083b3b500
   32  >> 9    1fd437, 13fa86e00
*/
}
#endif

static int32_t i_quant_pred(int64_t ii)
{
//    float32_t x = (float32_t)ii;
//    int16_t q;
//    uint32_t *tmp = (uint32_t *)&x;
    int32_t ex, normex;
    uint32_t sign = 0, mant, out;

//    q = (int16_t)(*tmp>>16);
//    pfloat(x, q);

    if (ii == 0) /* special case */
      return 0;
    else if (ii < 0)
    {
      sign = 0x80000000;
      ii = -ii;
    }
    {
      // ex = ilog2(ii);
      uint32_t xx, iu;

      if (ii < 1)
        ex = 0;
      else if (ii <= 0x7fffffff)
      {
        xx = 0;
        iu = (uint32_t)ii;
    
        while ((iu >> xx) > 1)
          xx++;
        ex = xx;
      }
      else
      {
        iu = (uint32_t)(ii >> 31);
        xx = 0;
        while ((iu >> xx) > 1)
          xx++;
      
        xx += 31; 
        ex = xx;
      }
    }
    /* normalize mantissa */
    if (ex <= 23)
      mant = (int32_t)(ii << (23 - ex));
    else
      mant = (int32_t)(ii >> (ex - 23));
    mant &= 0x7fffff;

    /* normalize exponent */
    normex = ex + 127;
    out = sign | (normex << 23) | mant;

//DPF(("i_quant_pred %d normex %x,  %x %x, sign %x %llx %x\n", ex, normex<<23, out, out>>16, sign, ii, q));

//    return q;
    return (int32_t)(out>>16);
}
#if 0
static int16_t quant_pred(float32_t x)
{
  return i_quant_pred((int64_t)x);
}
#endif

static int64_t ii_inv_quant_pred(int32_t q)
{
    int64_t out, ii = (q & 0x7f) | 0x80;
    int32_t ex = ((int32_t)((q >> 7) & 0xff)) - 134; /* -127 - 7 */
    int32_t sign = (q & 0x8000);

    if (ex < -64)
      out = 0;
    else if (ex > 63)
    #ifdef _MSC_VER
      out = (int64_t)0x7fffffffffffffff;
    #else
      out = (int64_t)0x7fffffffffffffffll;
    #endif
    else
      out = ((ex < 0) ? (ii >> -ex) : (ii << ex));

//if (out > 0x7fffffff)
//  ODPF(("count %d, BIG!!!  %lld, ", debug_count, out));
    if (sign)
      out = -out;
//DPF(("i_inv_quant_pred %llx %d %lld %llx sign %d\n", ii, ex, out, out, sign));

    return out;
}

static int64_t i_inv_quant_pred(int32_t q)
{
    int64_t iiout = ii_inv_quant_pred(q);
    return iiout;
#if 0
    int32_t out, ii = (q & 0x7f) | 0x80;
    int32_t ex = ((int32_t)((q >> 7) & 0xff)) - 134; /* -127 - 7 */
    int32_t sign = (q & 0x8000);

    ex -= 17; // We are going to limit this to 32 bits total
    if (ex < -31)
      out = 0;
    else if (ex > 31)
      out = 0x7fffffff;
    else
    {
      out = ((ex < 0) ? (ii >> -ex) : (ii << ex));
    }

//if (out > 0x7fffffff)
//  ODPF(("count %d, BIG!!!  %lld, ", debug_count, out));
    if (sign)
      out = -out;
//DPF(("i_inv_quant_pred %llx %d %lld %llx sign %d\n", ii, ex, out, out, sign));

//if ((iiout& 0xfffffffffffe0000ll) != ((((int64_t)out)<<17)& 0xfffffffffffe0000ll))
//  ODPF(("%d: %llx %llx\n", debug_count, iiout, ((int64_t)out)<<17));
    return ((int64_t)out)<<17;
#endif
}
#if 0
static int64_t inv_quant_pred(int16_t q)
{
  i_inv_quant_pred(q);
}
#endif

static void ic_predict(pred_state *state, real_t input, real_t *output, uint8_t pred)
{
    uint32_t tmp;
    int32_t i, j;
    int32_t i_predictedvalue;
    FLCOMP2(float32_t, dr1)
    FLCOMP2(float32_t, e0)
    FLCOMP2(float32_t, k1)
    FLCOMP2(float32_t, e1)
    FLCOMP2(float32_t, k2)
    FLCOMP2(float32_t, r[2])
    FLCOMP2(float32_t, COR[2])
    FLCOMP2(float32_t, VAR[2])

    int i_dr1;
    int i_e0, i_e1;
    int i_k1, i_k2;
    int i_r[2];
    int64_t i_COR[2];
    int64_t i_VAR[2];

DPF(("count %d, r[0] before inv_quant_pred %d \n", debug_count, state->r[0]));
    i_r[0] = (int32_t)i_inv_quant_pred(state->r[0]);
    FLCOMP((r[0] = inv_quant_pred(state->r[0])))
DPF(("r[0] after inv_quant_pred %f %d\n", r[0], i_r[0]));
DPF(("r[1] before inv_quant_pred %d \n", state->r[1]));
    FLCOMP((r[1] = inv_quant_pred(state->r[1])))
    i_r[1] = (int32_t)i_inv_quant_pred(state->r[1]);
DPF(("r[1] after inv_quant_pred %f %d \n", r[1], i_r[1]));
    FLCOMP((COR[0] = inv_quant_pred(state->COR[0])))
    i_COR[0] = i_inv_quant_pred(state->COR[0]);
    FLCOMP((COR[1] = inv_quant_pred(state->COR[1])))
    i_COR[1] = i_inv_quant_pred(state->COR[1]);
    FLCOMP((VAR[0] = inv_quant_pred(state->VAR[0])))
    i_VAR[0] = i_inv_quant_pred(state->VAR[0]);
    FLCOMP((VAR[1] = inv_quant_pred(state->VAR[1])))
    i_VAR[1] = i_inv_quant_pred(state->VAR[1]);

//DPF(("%f %f %f %f %f %f\n", r[0], r[1], COR[0], COR[1], VAR[0], VAR[1]));
DPF(("F %d %d %lld %lld %lld %lld\n", (int32_t)r[0], (int32_t)r[1], (int64_t)COR[0], (int64_t)COR[1], (int64_t)VAR[0], (int64_t)VAR[1]));
DPF(("I %d %d %lld %lld %lld %lld\n", i_r[0], i_r[1], i_COR[0], i_COR[1], i_VAR[0], i_VAR[1]));

    tmp = state->VAR[0];
    j = (tmp >> 7);
    i = tmp & 0x7f;
DPF(("state->VAR[0] %d COR[0] %f %lld %llx\n", state->VAR[0], COR[0], i_COR[0], i_COR[0]));
    if (j >= 128)
    {
        j -= 128;
DPF(("j %d, i %d  mt %d %x %f\n", j, i, mnt_table[i], mnt_table[i], (float)mnt_table[i]/(float)COEF_PRECISION));
        if (j < 15)
          i_k1 = (int32_t)(MUL_L(i_COR[0] >> 16, mnt_table[i]) << (15 - j));
        else
          i_k1 = (int32_t)(MUL_L(i_COR[0] >> 16, mnt_table[i]) >> (j - 15));
        FLCOMP((k1 = COR[0] * f_exp_table[j] * ((float)mnt_table[i]/(float)COEF_PRECISION)))
    } else {
        FLCOMP((k1 = 0))
        i_k1 = COEF_CONST(0);
    }

DPF(("k1 %f %x %f\n", k1, i_k1, (float)i_k1/(float)COEF_PRECISION));
DPF(("do pred %d\n", pred));
    if (pred)
    {
        tmp = state->VAR[1];
        j = (tmp >> 7);
        i = tmp & 0x7f;
        if (j >= 128)
        {
            j -= 128;
DPF(("j %d, i %d  mt %d %f\n", j, i, mnt_table[i], (float)mnt_table[i]/(float)COEF_PRECISION));

          if (j < 15)
            i_k2 = (int)(MUL_L(i_COR[1] >> 16, mnt_table[i]) << (15 - j));
          else
            i_k2 = (int)(MUL_L(i_COR[1] >> 16, mnt_table[i]) >> (j - 15));
          FLCOMP((k2 = COR[1] * f_exp_table[j] * ((float)mnt_table[i]/(float)COEF_PRECISION)))
        } else {
          FLCOMP((k2 = 0))
          i_k2 = COEF_CONST(0);
        }

        /* k1 and k2 are COEF */
DPF(("k2 %f %x %f, r[0] %f %d r[1] %f %d\n", k2, i_k2, (float)i_k2/(float)COEF_PRECISION, r[0], i_r[0], r[1], i_r[1]));
        i_predictedvalue = (int32_t)((MUL_L(i_k1, i_r[0]) + MUL_L(i_k2, i_r[1])) >> (COEF_BITS-4));
        FLCOMP((predictedvalue = (int32_t)((k1*r[0] + k2*r[1]) * 16.0)))
ODPF(("count %d, ", debug_count));
ODPF(("predictedvalue %d %d ", predictedvalue, i_predictedvalue));
ODPF(("input %f, ", input/16.0));
        *output = input + i_predictedvalue;
ODPF(("output %f\n", *output/16.0));
    }

    /* k1 and k2 are COEF */
    /* calculate new state data */
    FLCOMP((e0 = *output / 16.0))
    i_e0 = *output;
DPF(("e0 %f %f, ", e0, i_e0/16.0));
    FLCOMP((e1 = e0 - k1*r[0]))
    i_e1 = i_e0 - (int32_t)(MUL_L(i_k1, i_r[0]) >> (COEF_BITS-4));
DPF(("e1 %f %f, ", e1, i_e1/16.0));
    FLCOMP((dr1 = k1*e0))
    i_dr1 = MUL_C(i_k1, i_e0);
DPF(("dr1 %f %f\n", dr1, i_dr1/16.0));

    /* range VAR[0] always positive 1 to fa0000000000 */
    /* range VAR[1] always positive 1 to e20000000000 */
//if (mf < VAR[1]) { mf = VAR[1]; printf("\nMAX %f %llx\n", mf, (int64_t)mf); }
//if (nf > VAR[1]) { nf = VAR[1]; printf("\nMIN %f %llx\n", nf, (int64_t)nf); }
    FLCOMP((VAR[0] = ALPHA*VAR[0] + 0.5f * (r[0]*r[0] + e0*e0)))
    i_VAR[0] = (MUL_L(i_ALPHA, i_VAR[0])>>REAL_BITS) + ((MUL_L(i_r[0],i_r[0]) + (MUL_L(i_e0, i_e0)>>8) ) >>1);
DPF(("VAR[0] %f %lld, ", VAR[0], i_VAR[0]));
    FLCOMP((COR[0] = ALPHA*COR[0] + r[0]*e0))
    i_COR[0] = (MUL_L(i_ALPHA, i_COR[0])>>REAL_BITS) + (MUL_L(i_r[0],i_e0)>>4);
DPF(("COR[0] %f %lld, ", COR[0], i_COR[0]));
    FLCOMP((VAR[1] = ALPHA*VAR[1] + 0.5f * (r[1]*r[1] + e1*e1)))
    i_VAR[1] = (MUL_L(i_ALPHA, i_VAR[1])>>REAL_BITS) + ((MUL_L(i_r[1],i_r[1]) + (MUL_L(i_e1, i_e1) >>8) ) >>1);