mpegauddct.c

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

//#ifndef USE_CE_ASM_FUNCTION
#if 1
void imdct12(int *out, int *in)
{
  #ifdef BLOCKSCALE_DCT
    block_scale(in, 12, 5);
  #endif

  #ifdef USE_INT_MULTC
  {
    register int tmp1, tmp2;
    INT_MULTC6P(out[0], in[0], C7, in[1], -C3, in[2], -C11, in[3], C1, in[4], -C9, in[5], -C5);
    out[5] = -out[0];
    tmp1 = in[0] - in[3];
    tmp2 = in[2] + in[5];
    INT_MULTC4P(out[1], tmp1, C9, in[1], -C3, tmp2, C3, in[4], -C9);
    out[4] = -out[1];
    INT_MULTC6P(out[2], in[0], C11, in[1], -C9, in[2], C7, in[3], -C5, in[4], C3, in[5], -C1);
    out[3] = -out[2];
    INT_MULTC6P(out[6], in[0], -C5, in[1], C9, in[2], C1, in[3], C11, in[4], -C3, in[5], -C7);
    out[11] = out[6];
    tmp1 = -in[0] + in[3];
    tmp2 = in[2] + in[5];
    INT_MULTC4P(out[7], tmp1, C3, in[1], -C9, tmp2, C9, in[4], C3);
    out[10] = out[7];
    INT_MULTC6P(out[8], in[0], -C1, in[1], -C3, in[2], -C5, in[3], -C7, in[4], -C9, in[5], -C11);
    out[9] = out[8];
  }
  #else
  {
    int tmp;
    int64_t in1_3, in1_9, in4_3, in4_9;

    in1_3 = MUL64(in[1], C3);
    in1_9 = MUL64(in[1], C9);
    in4_3 = MUL64(in[4], C3);
    in4_9 = MUL64(in[4], C9);
    
    tmp = FRAC_RND(MUL64(in[0], C7) - in1_3 - MUL64(in[2], C11) + MUL64(in[3], C1) - in4_9 - MUL64(in[5], C5));
    out[0] = tmp;
    out[5] = -tmp;
    tmp = FRAC_RND(MUL64(in[0] - in[3], C9) - in1_3 + MUL64(in[2] + in[5], C3) - in4_9);
    out[1] = tmp;
    out[4] = -tmp;
    tmp = FRAC_RND(MUL64(in[0], C11) - in1_9 + MUL64(in[2], C7) - MUL64(in[3], C5) + in4_3 - MUL64(in[5], C1));
    out[2] = tmp;
    out[3] = -tmp;
    tmp = FRAC_RND(MUL64(-in[0], C5) + in1_9 + MUL64(in[2], C1) + MUL64(in[3], C11) - in4_3 - MUL64(in[5], C7));
    out[6] = tmp;
    out[11] = tmp;
    tmp = FRAC_RND(MUL64(-in[0] + in[3], C3) - in1_9 + MUL64(in[2] + in[5], C9) + in4_3);
    out[7] = tmp;
    out[10] = tmp;
    tmp = FRAC_RND(-MUL64(in[0], C1) - in1_3 - MUL64(in[2], C5) - MUL64(in[3], C7) - in4_9 - MUL64(in[5], C11));
    out[8] = tmp;
    out[9] = tmp;
  }
  #endif
  #ifdef BLOCKSCALE_DCT
    un_block_scale(out, 12, 5);
  #endif
}
#endif

#undef C1
#undef C3
#undef C5
#undef C7
#undef C9
#undef C11

/* c o s(pi*i/18) */
#define C1 FIXR(0.98480775301220805936)
#define C2 FIXR(0.93969262078590838405)
#define C3 FIXR(0.86602540378443864676)
#define C4 FIXR(0.76604444311897803520)
#define C5 FIXR(0.64278760968653932632)
#define C6 FIXR(0.5)
#define C7 FIXR(0.34202014332566873304)
#define C8 FIXR(0.17364817766693034885)

/* 0.5 / c o s(pi*(2*i+1)/36) */
const int icos36[9] = 
{
    FIXR(0.50190991877167369479),
    FIXR(0.51763809020504152469),
    FIXR(0.55168895948124587824),
    FIXR(0.61038729438072803416),
    FIXR(0.70710678118654752439),
    FIXR(0.87172339781054900991),
    FIXR(1.18310079157624925896),
    FIXR(1.93185165257813657349),
    FIXR(5.73685662283492756461),
};

const int icos72[18] = 
{
    /* 0.5 / c o s(pi*(2*i+19)/72) */
    FIXR(0.74009361646113053152),
    FIXR(0.82133981585229078570),
    FIXR(0.93057949835178895673),
    FIXR(1.08284028510010010928),
    FIXR(1.30656296487637652785),
    FIXR(1.66275476171152078719),
    FIXR(2.31011315767264929558),
    FIXR(3.83064878777019433457),
    FIXR(11.46279281302667383546),

    /* 0.5 / c o s(pi*(2*(i + 18) +19)/72) */
    FIXR(-0.67817085245462840086),
    FIXR(-0.63023620700513223342),
    FIXR(-0.59284452371708034528),
    FIXR(-0.56369097343317117734),
    FIXR(-0.54119610014619698439),
    FIXR(-0.52426456257040533932),
    FIXR(-0.51213975715725461845),
    FIXR(-0.50431448029007636036),
    FIXR(-0.50047634258165998492),
};

/* using Lee-like decomposition followed by hand coded 9 points DCT */
#ifndef USE_CE_ASM_FUNCTION
void imdct36(int *out, int *in)
{
  int i, j, t0, t1, t2, t3, s0, s1, s2, s3;
  int tmp[18], *tmp1, *in1;

  #ifdef BLOCKSCALE_DCT
    block_scale(in, 18, 5);
  #endif

  for (i = 17; i >= 1; i--)
    in[i] += in[i-1];
  for (i = 17; i >= 3; i-=2)
    in[i] += in[i-2];

  for (j = 0; j < 2; j++) 
  {
    tmp1 = tmp + j;
    in1 = in + j;

    #ifdef USE_INT_MULTC
      INT_MULTC4P(tmp1[0], in1[2*1], C1, in1[2*3], C3, in1[2*5], C5, in1[2*7], C7);
      INT_MULTC4P(tmp1[2], in1[2*2], C2, in1[2*4], C4, in1[2*6], C6, in1[2*8], C8);
      tmp1[2] += in1[2*0];
      MULDCT(tmp1[4], in1[2*1] - in1[2*5] - in1[2*7], C3);
      MULDCT(tmp1[6], in1[2*2] - in1[2*4] - in1[2*8], C6);
      tmp1[6] +=  -in1[2*6] + in1[2*0];
      INT_MULTC4P(tmp1[8], in1[2*1], C5, in1[2*3], -C3, in1[2*5], -C7, in1[2*7], C1);
      INT_MULTC4P(tmp1[10], in1[2*2], -C8, in1[2*4], -C2, in1[2*6], C6, in1[2*8], C4);
      tmp1[10] += in1[2*0];
      INT_MULTC4P(tmp1[12], in1[2*1], C7, in1[2*3], -C3, in1[2*5], C1, in1[2*7], -C5);
      INT_MULTC4P(tmp1[14], in1[2*2], -C4, in1[2*4], C8, in1[2*6], C6, in1[2*8], -C2);
      tmp1[14] += in1[2*0];
      tmp1[16] = in1[2*0] - in1[2*2] + in1[2*4] - in1[2*6] + in1[2*8];
    #else
    {
      int64_t in3_3, in6_6;
      in3_3 = MUL64(in1[2*3], C3);
      in6_6 = MUL64(in1[2*6], C6);
    
      tmp1[0] = FRAC_RND(MUL64(in1[2*1], C1) + in3_3 + MUL64(in1[2*5], C5) + MUL64(in1[2*7], C7));
      tmp1[2] = in1[2*0] + FRAC_RND(MUL64(in1[2*2], C2) + MUL64(in1[2*4], C4) + in6_6 + MUL64(in1[2*8], C8));
      tmp1[4] = FRAC_RND(MUL64(in1[2*1] - in1[2*5] - in1[2*7], C3));
      tmp1[6] = FRAC_RND(MUL64(in1[2*2] - in1[2*4] - in1[2*8], C6)) - in1[2*6] + in1[2*0];
      tmp1[8] = FRAC_RND(MUL64(in1[2*1], C5) - in3_3 - MUL64(in1[2*5], C7) + MUL64(in1[2*7], C1));
      tmp1[10] = in1[2*0] + FRAC_RND(MUL64(-in1[2*2], C8) - MUL64(in1[2*4], C2) + in6_6 + MUL64(in1[2*8], C4));
      tmp1[12] = FRAC_RND(MUL64(in1[2*1], C7) - in3_3 + MUL64(in1[2*5], C1) - MUL64(in1[2*7], C5));
      tmp1[14] = in1[2*0] + FRAC_RND(MUL64(-in1[2*2], C4) + MUL64(in1[2*4], C8) + in6_6 - MUL64(in1[2*8], C2));
      tmp1[16] = in1[2*0] - in1[2*2] + in1[2*4] - in1[2*6] + in1[2*8];
    }
    #endif
  }

  i = 0;
  for (j = 0; j < 4; j++) 
  {
    t0 = tmp[i];
    t1 = tmp[i + 2];
    s0 = t1 + t0;
    s2 = t1 - t0;

    t2 = tmp[i + 1];
    t3 = tmp[i + 3];
    MULDCT(s1, t3 + t2, icos36[j]);
    MULDCT(s3, t3 - t2, icos36[8 - j]);
    
    MULDCT(t0, s0 + s1, icos72[9 + 8 - j]);
    MULDCT(t1, s0 - s1, icos72[8 - j]);
    out[18 + 9 + j] = t0;
    out[18 + 8 - j] = t0;
    out[9 + j] = -t1;
    out[8 - j] = t1;
    
    MULDCT(t0, s2 + s3, icos72[9+j]);
    MULDCT(t1, s2 - s3, icos72[j]);
    out[18 + 9 + (8 - j)] = t0;
    out[18 + j] = t0;
    out[9 + (8 - j)] = -t1;
    out[j] = t1;
    i += 4;
  }

  s0 = tmp[16];
  MULDCT(s1, tmp[17], icos36[4]);
  MULDCT(t0, s0 + s1, icos72[9 + 4]);
  MULDCT(t1, s0 - s1, icos72[4]);
  out[18 + 9 + 4] = t0;
  out[18 + 8 - 4] = t0;
  out[9 + 4] = -t1;
  out[8 - 4] = t1;
  #ifdef BLOCKSCALE_DCT
    un_block_scale(out, 36, 5);
  #endif
}
#endif


void compute_imdct(MPADecodeContext *s,
                          GranuleDef *g, 
                          int32_t *sb_samples,
                          int32_t *mdct_buf)
{
  int32_t *ptr, *win, *win1, *buf, *buf2, *out_ptr, *ptr1;
  int32_t in[6];               
  int32_t out[36];
  int32_t out2[12];
  int i, j, k, mdct_long_end, v, sblimit;

  /* find last non zero block */
  ptr = g->sb_hybrid + 576;
  ptr1 = g->sb_hybrid + 2 * 18;
  while (ptr >= ptr1) 
  {
    ptr -= 6;
    v = ptr[0] | ptr[1] | ptr[2] | ptr[3] | ptr[4] | ptr[5];
    if (v != 0)
      break;
  }
  sblimit = ((ptr - g->sb_hybrid) / 18) + 1;

  if (g->block_type == 2) 
  {
    /* XXX: check for 8000 Hz */
    if (g->switch_point)
      mdct_long_end = 2;
    else
      mdct_long_end = 0;
  } 
  else 
  {
    mdct_long_end = sblimit;
  }

  buf = mdct_buf;
  ptr = g->sb_hybrid;
  for (j=0;j<mdct_long_end;j++) 
  {
    imdct36(out, ptr);
    /* apply window & overlap with previous buffer */
    out_ptr = sb_samples + j;
    /* select window */
    if (g->switch_point && j < 2)
      win1 = mdct_win[0];
    else
      win1 = mdct_win[g->block_type];
    /* select frequency inversion */
    win = win1 + ((4 * 36) & -(j & 1));
    for (i=0;i<18;i++) 
    {
      MULT7(*out_ptr, out[i], win[i]);
      *out_ptr += buf[i];
      MULT7(buf[i], out[i + 18], win[i + 18]);
      out_ptr += SBLIMIT;
    }
    ptr += 18;
    buf += 18;
  }
  for (j=mdct_long_end;j<sblimit;j++) 
  {
    for (i=0;i<6;i++) 
    {
      out[i] = 0;
      out[6 + i] = 0;
      out[30+i] = 0;
    }
    /* select frequency inversion */
    win = mdct_win[2] + ((4 * 36) & -(j & 1));
    buf2 = out + 6;
    for (k=0;k<3;k++) 
    {
      /* reorder input for short mdct */
      ptr1 = ptr + k;
      for (i=0;i<6;i++) 
      {
        in[i] = *ptr1;
        ptr1 += 3;
      }
      imdct12(out2, in);
      /* apply 12 point window and do small overlap */
      for (i=0;i<6;i++) 
      {
        int temp = buf2[i];  
        MULT7(buf2[i], out2[i], win[i]);
        buf2[i] += temp;
        MULT7(buf2[i + 6], out2[i + 6], win[i + 6]);
      }
      buf2 += 6;
    }
    /* overlap */
    out_ptr = sb_samples + j;
    for (i=0;i<18;i++) 
    {
      *out_ptr = out[i] + buf[i];
      buf[i] = out[i + 18];
      out_ptr += SBLIMIT;
    }
    ptr += 18;
    buf += 18;
  }
  /* zero bands */
  for (j=sblimit;j<SBLIMIT;j++) 
  {
    /* overlap */
    out_ptr = sb_samples + j;
    for (i=0;i<18;i++) 
    {
      *out_ptr = buf[i];
      buf[i] = 0;
      out_ptr += SBLIMIT;
    }
    buf += 18;
  }
}