mpegauddct.c

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

/*
 * MPEG Audio decoder
 * Copyright (c) 2001, 2002 Fabrice Bellard.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 */

/**
 * @file mpegaudiodec.c
 * MPEG Audio decoder.
 * from FFMPEG_VERSION  "0.4.8"
 */ 

//#define DEBUG
#include <stdio.h>
#include "mpegaudiodec.h"

/* layer 1 unscaling */
/* n = number of bits of the mantissa minus 1 */
int l1_unscale(int n, int mant, int scale_factor)
{
  int shift, mod;
  int64_t val, one = 1;

  shift = scale_factor_modshift[scale_factor];
  mod = shift & 3;
  shift >>= 2;
  shift += n;
  /* NOTE: at this point, 1 <= shift >= 21 + 15 */
  val = MUL64(mant + (-1 << n) + 1, scale_factor_mult[n-1][mod]);
  mod = (int)((val + (one << (shift - 1))) >> shift);
  return mod;
}

int l2_unscale_group(int steps, int mant, int scale_factor)
{
  int shift, mod, val;

  shift = scale_factor_modshift[scale_factor];
  mod = shift & 3;
  shift >>= 2;

  val = (mant - (steps >> 1)) * scale_factor_mult2[steps >> 2][mod];
  /* NOTE: at this point, 0 <= shift <= 21 */
  if (shift > 0)
      val = (val + (1 << (shift - 1))) >> shift;
  return val;
}

/* compute value^(4/3) * 2^(exponent/4). It normalized to FRAC_BITS */
int l3_unscale(int value, int exponent)
{
#if FRAC_BITS <= 15    
    unsigned int m;
#else
    uint64_t m, one = 1;
    unsigned int im;
#endif
    int e, eo = 0;

    e = table_4_3_exp[value];
    e += (exponent >> 2);
    e = FRAC_BITS - e;
#if FRAC_BITS <= 15    
    if (e > 31)
        e = 31;
#endif
    im = table_4_3_value[value];
#if FRAC_BITS <= 15    
    m = (m * scale_factor_mult3[exponent & 3]);
    m = (m + (1 << (e-1))) >> e;
    return m;
#else
    m = MUL64(im, scale_factor_mult3[exponent & 3]);
    if (e > 31)
    {
      eo = e - 31;
      m = m >> 31;
      m = m >> eo;
    }
    else
      m = (m + (one << (e-1))) >> e;
    return (int)m;
#endif
}



/* tab[i][j] = 1.0 / (2.0 * c o s(pi*(2*k+1) / 2^(6 - j))) */
/* c o s(i*pi/64) */
#define COS0_0  FIXR(0.50060299823519630134)
#define COS0_1  FIXR(0.50547095989754365998)
#define COS0_2  FIXR(0.51544730992262454697)
#define COS0_3  FIXR(0.53104259108978417447)
#define COS0_4  FIXR(0.55310389603444452782)
#define COS0_5  FIXR(0.58293496820613387367)
#define COS0_6  FIXR(0.62250412303566481615)
#define COS0_7  FIXR(0.67480834145500574602)
#define COS0_8  FIXR(0.74453627100229844977)
#define COS0_9  FIXR(0.83934964541552703873)
#define COS0_10 FIXR(0.97256823786196069369)
#define COS0_11 FIXR(1.16943993343288495515)
#define COS0_12 FIXR(1.48416461631416627724)
#define COS0_13 FIXR(2.05778100995341155085)
#define COS0_14 FIXR(3.40760841846871878570)
#define COS0_15 FIXR(10.19000812354805681150)

#define COS1_0 FIXR(0.50241928618815570551)
#define COS1_1 FIXR(0.52249861493968888062)
#define COS1_2 FIXR(0.56694403481635770368)
#define COS1_3 FIXR(0.64682178335999012954)
#define COS1_4 FIXR(0.78815462345125022473)
#define COS1_5 FIXR(1.06067768599034747134)
#define COS1_6 FIXR(1.72244709823833392782)
#define COS1_7 FIXR(5.10114861868916385802)

#define COS2_0 FIXR(0.50979557910415916894)
#define COS2_1 FIXR(0.60134488693504528054)
#define COS2_2 FIXR(0.89997622313641570463)
#define COS2_3 FIXR(2.56291544774150617881)

#define COS3_0 FIXR(0.54119610014619698439)
#define COS3_1 FIXR(1.30656296487637652785)

#define COS4_0 FIXR(0.70710678118654752439)


/* butterfly operator */
#define BF(a, b, c)\
{\
    tmp0 = tab[a] + tab[b];\
    tmp1 = tab[a] - tab[b];\
    tab[a] = tmp0;\
    MULDCT(tab[b], tmp1, c);\
}

#define BF1(a, b, c, d)\
{\
    BF(a, b, COS4_0);\
    BF(c, d, -COS4_0);\
    tab[c] += tab[d];\
}

#define BF2(a, b, c, d)\
{\
    BF(a, b, COS4_0);\
    BF(c, d, -COS4_0);\
    tab[c] += tab[d];\
    tab[a] += tab[c];\
    tab[c] += tab[b];\
    tab[b] += tab[d];\
}

#define ADD(a, b) tab[a] += tab[b]

#define block_scale(ITEM, LENGTH, SHIFT) { int ii; for (ii = 0; ii < LENGTH; ii++) ITEM[ii] <<= SHIFT; }
#define un_block_scale(ITEM, LENGTH, SHIFT) { int ii; for (ii = 0; ii < LENGTH; ii++) ITEM[ii] >>= SHIFT; }

#ifndef USE_CE_ASM_FUNCTION
/* DCT32 without 1/s q r t(2) coef zero scaling. */
void dct32(int32_t *out, int32_t *tab)
{
  int tmp0, tmp1;

  #ifdef BLOCKSCALE_DCT
    block_scale(tab, 32, 5);
  #endif

  /* pass 1 */
  BF(0, 31, COS0_0);
  BF(1, 30, COS0_1);
  BF(2, 29, COS0_2);
  BF(3, 28, COS0_3);
  BF(4, 27, COS0_4);
  BF(5, 26, COS0_5);
  BF(6, 25, COS0_6);
  BF(7, 24, COS0_7);
  BF(8, 23, COS0_8);
  BF(9, 22, COS0_9);
  BF(10, 21, COS0_10);
  BF(11, 20, COS0_11);
  BF(12, 19, COS0_12);
  BF(13, 18, COS0_13);
  BF(14, 17, COS0_14);
  BF(15, 16, COS0_15);

  /* pass 2 */
  BF(0, 15, COS1_0);
  BF(1, 14, COS1_1);
  BF(2, 13, COS1_2);
  BF(3, 12, COS1_3);
  BF(4, 11, COS1_4);
  BF(5, 10, COS1_5);
  BF(6,  9, COS1_6);
  BF(7,  8, COS1_7);
  
  BF(16, 31, -COS1_0);
  BF(17, 30, -COS1_1);
  BF(18, 29, -COS1_2);
  BF(19, 28, -COS1_3);
  BF(20, 27, -COS1_4);
  BF(21, 26, -COS1_5);
  BF(22, 25, -COS1_6);
  BF(23, 24, -COS1_7);
  
  /* pass 3 */
  BF(0, 7, COS2_0);
  BF(1, 6, COS2_1);
  BF(2, 5, COS2_2);
  BF(3, 4, COS2_3);
  
  BF(8, 15, -COS2_0);
  BF(9, 14, -COS2_1);
  BF(10, 13, -COS2_2);
  BF(11, 12, -COS2_3);
  
  BF(16, 23, COS2_0);
  BF(17, 22, COS2_1);
  BF(18, 21, COS2_2);
  BF(19, 20, COS2_3);
  
  BF(24, 31, -COS2_0);
  BF(25, 30, -COS2_1);
  BF(26, 29, -COS2_2);
  BF(27, 28, -COS2_3);

  /* pass 4 */
  BF(0, 3, COS3_0);
  BF(1, 2, COS3_1);
  
  BF(4, 7, -COS3_0);
  BF(5, 6, -COS3_1);
  
  BF(8, 11, COS3_0);
  BF(9, 10, COS3_1);
  
  BF(12, 15, -COS3_0);
  BF(13, 14, -COS3_1);
  
  BF(16, 19, COS3_0);
  BF(17, 18, COS3_1);
  
  BF(20, 23, -COS3_0);
  BF(21, 22, -COS3_1);
  
  BF(24, 27, COS3_0);
  BF(25, 26, COS3_1);
  
  BF(28, 31, -COS3_0);
  BF(29, 30, -COS3_1);
  
  /* pass 5 */
  BF1(0, 1, 2, 3);
  BF2(4, 5, 6, 7);
  BF1(8, 9, 10, 11);
  BF2(12, 13, 14, 15);
  BF1(16, 17, 18, 19);
  BF2(20, 21, 22, 23);
  BF1(24, 25, 26, 27);
  BF2(28, 29, 30, 31);
  
  /* pass 6 */
  
  ADD( 8, 12);
  ADD(12, 10);
  ADD(10, 14);
  ADD(14,  9);
  ADD( 9, 13);
  ADD(13, 11);
  ADD(11, 15);

  out[ 0] = tab[0];
  out[16] = tab[1];
  out[ 8] = tab[2];
  out[24] = tab[3];
  out[ 4] = tab[4];
  out[20] = tab[5];
  out[12] = tab[6];
  out[28] = tab[7];
  out[ 2] = tab[8];
  out[18] = tab[9];
  out[10] = tab[10];
  out[26] = tab[11];
  out[ 6] = tab[12];
  out[22] = tab[13];
  out[14] = tab[14];
  out[30] = tab[15];
  
  ADD(24, 28);
  ADD(28, 26);
  ADD(26, 30);
  ADD(30, 25);
  ADD(25, 29);
  ADD(29, 27);
  ADD(27, 31);

  out[ 1] = tab[16] + tab[24];
  out[17] = tab[17] + tab[25];
  out[ 9] = tab[18] + tab[26];
  out[25] = tab[19] + tab[27];
  out[ 5] = tab[20] + tab[28];
  out[21] = tab[21] + tab[29];
  out[13] = tab[22] + tab[30];
  out[29] = tab[23] + tab[31];
  out[ 3] = tab[24] + tab[20];
  out[19] = tab[25] + tab[21];
  out[11] = tab[26] + tab[22];
  out[27] = tab[27] + tab[23];
  out[ 7] = tab[28] + tab[18];
  out[23] = tab[29] + tab[19];
  out[15] = tab[30] + tab[17];
  out[31] = tab[31];
  #ifdef BLOCKSCALE_DCT
    un_block_scale(out, 32, 5);
  #endif
}
#endif

/* c o s(pi*i/24) */
#define C1  FIXR(0.99144486137381041114)
#define C3  FIXR(0.92387953251128675612)
#define C5  FIXR(0.79335334029123516458)
#define C7  FIXR(0.60876142900872063941)
#define C9  FIXR(0.38268343236508977173)
#define C11 FIXR(0.13052619222005159154)

/* 12 points IMDCT. We compute it "by hand" by factorizing obvious cases. */