Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. #include <math.h>
  2.  
  3. static float coef32[31];        /* 32 pt dct coefs */
  4.  
  5. void fdct_init()                /* gen coef for N=32 (31 coefs) */
  6. {
  7.         int p, n, i, k;
  8.         double t, pi;
  9.  
  10.         pi = 4.0 * atan(1.0);
  11.         n = 16;
  12.         k = 0;
  13.         for (i = 0; i < 5; i++, n = n / 2) {
  14.                 for (p = 0; p < n; p++, k++) {
  15.                         t = (pi / (4 * n)) * (2 * p + 1);
  16.                         coef32[k] = (float) (0.50 / cos(t));
  17.                 }
  18.         }
  19. }
  20.  
  21. static void forward_bf(int m, int n, float x[], float f[], float coef[])
  22. {
  23.         int i, j, n2;
  24.         int p, q, p0, k;
  25.  
  26.         p0 = 0;
  27.         n2 = n >> 1;
  28.         for (i = 0; i < m; i++, p0 += n) {
  29.                 k = 0;
  30.                 p = p0;
  31.                 q = p + n - 1;
  32.                 for (j = 0; j < n2; j++, p++, q--, k++) {
  33.                         f[p] = x[p] + x[q];
  34.                         f[n2 + p] = coef[k] * (x[p] - x[q]);
  35.                 }
  36.         }
  37. }
  38. /*------------------------------------------------------------*/
  39. static void back_bf(int m, int n, float x[], float f[])
  40. {
  41.         int i, j, n2, n21;
  42.         int p, q, p0;
  43.  
  44.         p0 = 0;
  45.         n2 = n >> 1;
  46.         n21 = n2 - 1;
  47.         for (i = 0; i < m; i++, p0 += n) {
  48.                 p = p0;
  49.                 q = p0;
  50.                 for (j = 0; j < n2; j++, p += 2, q++)
  51.                         f[p] = x[q];
  52.                 p = p0 + 1;
  53.                 for (j = 0; j < n21; j++, p += 2, q++)
  54.                         f[p] = x[q] + x[q + 1];
  55.                 f[p] = x[q];
  56.         }
  57. }
  58. /*------------------------------------------------------------*/
  59. extern int m_enableEQ;
  60. extern float m_equalizer[32];
  61.  
  62. void fdct32(float x[], float c[])
  63. {
  64.         float a[32];                    /* ping pong buffers */
  65.         float b[32];
  66.         int p, q;
  67.  
  68.         if (m_enableEQ) {
  69.                 for (p = 0; p < 32; p++) x[p] *= m_equalizer[p];
  70.         }
  71. /* special first stage */
  72.         for (p = 0, q = 31; p < 16; p++, q--) {
  73.                 a[p] = x[p] + x[q];
  74.                 a[16 + p] = coef32[p] * (x[p] - x[q]);
  75.         }
  76.  
  77.         forward_bf(2, 16, a, b, coef32 + 16);
  78.         forward_bf(4, 8, b, a, coef32 + 16 + 8);
  79.         forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
  80.         forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
  81.         back_bf(8, 4, a, b);
  82.         back_bf(4, 8, b, a);
  83.         back_bf(2, 16, a, b);
  84.         back_bf(1, 32, b, c);
  85. }
  86. /*------------------------------------------------------------*/
  87. void fdct32_dual(float x[], float c[])
  88. {
  89.    float a[32];                 /* ping pong buffers */
  90.    float b[32];
  91.    int p, pp, qq;
  92.  
  93.         if (m_enableEQ) {
  94.                 for (p = 0; p < 32; p++) x[p] *= m_equalizer[p];
  95.         }
  96.  
  97.    /* special first stage for dual chan (interleaved x) */
  98.    pp = 0;
  99.    qq = 2 * 31;
  100.    for (p = 0; p < 16; p++, pp += 2, qq -= 2)
  101.    {
  102.       a[p] = x[pp] + x[qq];
  103.       a[16 + p] = coef32[p] * (x[pp] - x[qq]);
  104.    }
  105.    forward_bf(2, 16, a, b, coef32 + 16);
  106.    forward_bf(4, 8, b, a, coef32 + 16 + 8);
  107.    forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
  108.    forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
  109.    back_bf(8, 4, a, b);
  110.    back_bf(4, 8, b, a);
  111.    back_bf(2, 16, a, b);
  112.    back_bf(1, 32, b, c);
  113. }
  114. /*---------------convert dual to mono------------------------------*/
  115. void fdct32_dual_mono(float x[], float c[])
  116. {
  117.    float a[32];                 /* ping pong buffers */
  118.    float b[32];
  119.    float t1, t2;
  120.    int p, pp, qq;
  121.  
  122. /* special first stage  */
  123.    pp = 0;
  124.    qq = 2 * 31;
  125.    for (p = 0; p < 16; p++, pp += 2, qq -= 2)
  126.    {
  127.       t1 = 0.5F * (x[pp] + x[pp + 1]);
  128.       t2 = 0.5F * (x[qq] + x[qq + 1]);
  129.       a[p] = t1 + t2;
  130.       a[16 + p] = coef32[p] * (t1 - t2);
  131.    }
  132.    forward_bf(2, 16, a, b, coef32 + 16);
  133.    forward_bf(4, 8, b, a, coef32 + 16 + 8);
  134.    forward_bf(8, 4, a, b, coef32 + 16 + 8 + 4);
  135.    forward_bf(16, 2, b, a, coef32 + 16 + 8 + 4 + 2);
  136.    back_bf(8, 4, a, b);
  137.    back_bf(4, 8, b, a);
  138.    back_bf(2, 16, a, b);
  139.    back_bf(1, 32, b, c);
  140. }
  141. /*------------------------------------------------------------*/
  142. /*---------------- 16 pt fdct -------------------------------*/
  143. void fdct16(float x[], float c[])
  144. {
  145.    float a[16];                 /* ping pong buffers */
  146.    float b[16];
  147.    int p, q;
  148.  
  149. /* special first stage (drop highest sb) */
  150.    a[0] = x[0];
  151.    a[8] = coef32[16] * x[0];
  152.    for (p = 1, q = 14; p < 8; p++, q--)
  153.    {
  154.       a[p] = x[p] + x[q];
  155.       a[8 + p] = coef32[16 + p] * (x[p] - x[q]);
  156.    }
  157.    forward_bf(2, 8, a, b, coef32 + 16 + 8);
  158.    forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
  159.    forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
  160.    back_bf(4, 4, b, a);
  161.    back_bf(2, 8, a, b);
  162.    back_bf(1, 16, b, c);
  163. }
  164. /*------------------------------------------------------------*/
  165. /*---------------- 16 pt fdct dual chan---------------------*/
  166. void fdct16_dual(float x[], float c[])
  167. {
  168.    float a[16];                 /* ping pong buffers */
  169.    float b[16];
  170.    int p, pp, qq;
  171.  
  172. /* special first stage for interleaved input */
  173.    a[0] = x[0];
  174.    a[8] = coef32[16] * x[0];
  175.    pp = 2;
  176.    qq = 2 * 14;
  177.    for (p = 1; p < 8; p++, pp += 2, qq -= 2)
  178.    {
  179.       a[p] = x[pp] + x[qq];
  180.       a[8 + p] = coef32[16 + p] * (x[pp] - x[qq]);
  181.    }
  182.    forward_bf(2, 8, a, b, coef32 + 16 + 8);
  183.    forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
  184.    forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
  185.    back_bf(4, 4, b, a);
  186.    back_bf(2, 8, a, b);
  187.    back_bf(1, 16, b, c);
  188. }
  189. /*------------------------------------------------------------*/
  190. /*---------------- 16 pt fdct dual to mono-------------------*/
  191. void fdct16_dual_mono(float x[], float c[])
  192. {
  193.    float a[16];                 /* ping pong buffers */
  194.    float b[16];
  195.    float t1, t2;
  196.    int p, pp, qq;
  197.  
  198. /* special first stage  */
  199.    a[0] = 0.5F * (x[0] + x[1]);
  200.    a[8] = coef32[16] * a[0];
  201.    pp = 2;
  202.    qq = 2 * 14;
  203.    for (p = 1; p < 8; p++, pp += 2, qq -= 2)
  204.    {
  205.       t1 = 0.5F * (x[pp] + x[pp + 1]);
  206.       t2 = 0.5F * (x[qq] + x[qq + 1]);
  207.       a[p] = t1 + t2;
  208.       a[8 + p] = coef32[16 + p] * (t1 - t2);
  209.    }
  210.    forward_bf(2, 8, a, b, coef32 + 16 + 8);
  211.    forward_bf(4, 4, b, a, coef32 + 16 + 8 + 4);
  212.    forward_bf(8, 2, a, b, coef32 + 16 + 8 + 4 + 2);
  213.    back_bf(4, 4, b, a);
  214.    back_bf(2, 8, a, b);
  215.    back_bf(1, 16, b, c);
  216. }
  217. /*------------------------------------------------------------*/
  218. /*---------------- 8 pt fdct -------------------------------*/
  219. void fdct8(float x[], float c[])
  220. {
  221.    float a[8];                  /* ping pong buffers */
  222.    float b[8];
  223.    int p, q;
  224.  
  225. /* special first stage  */
  226.  
  227.    b[0] = x[0] + x[7];
  228.    b[4] = coef32[16 + 8] * (x[0] - x[7]);
  229.    for (p = 1, q = 6; p < 4; p++, q--)
  230.    {
  231.       b[p] = x[p] + x[q];
  232.       b[4 + p] = coef32[16 + 8 + p] * (x[p] - x[q]);
  233.    }
  234.  
  235.    forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
  236.    forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
  237.    back_bf(2, 4, b, a);
  238.    back_bf(1, 8, a, c);
  239. }
  240.  
  241. /*---------------- 8 pt fdct dual chan---------------------*/
  242. void fdct8_dual(float x[], float c[])
  243. {
  244.    float a[8];                  /* ping pong buffers */
  245.    float b[8];
  246.    int p, pp, qq;
  247.  
  248. /* special first stage for interleaved input */
  249.    b[0] = x[0] + x[14];
  250.    b[4] = coef32[16 + 8] * (x[0] - x[14]);
  251.    pp = 2;
  252.    qq = 2 * 6;
  253.    for (p = 1; p < 4; p++, pp += 2, qq -= 2)
  254.    {
  255.       b[p] = x[pp] + x[qq];
  256.       b[4 + p] = coef32[16 + 8 + p] * (x[pp] - x[qq]);
  257.    }
  258.    forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
  259.    forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
  260.    back_bf(2, 4, b, a);
  261.    back_bf(1, 8, a, c);
  262. }
  263.  
  264. /*---------------- 8 pt fdct dual to mono---------------------*/
  265. void fdct8_dual_mono(float x[], float c[])
  266. {
  267.    float a[8];                  /* ping pong buffers */
  268.    float b[8];
  269.    float t1, t2;
  270.    int p, pp, qq;
  271.  
  272. /* special first stage  */
  273.    t1 = 0.5F * (x[0] + x[1]);
  274.    t2 = 0.5F * (x[14] + x[15]);
  275.    b[0] = t1 + t2;
  276.    b[4] = coef32[16 + 8] * (t1 - t2);
  277.    pp = 2;
  278.    qq = 2 * 6;
  279.    for (p = 1; p < 4; p++, pp += 2, qq -= 2)
  280.    {
  281.       t1 = 0.5F * (x[pp] + x[pp + 1]);
  282.       t2 = 0.5F * (x[qq] + x[qq + 1]);
  283.       b[p] = t1 + t2;
  284.       b[4 + p] = coef32[16 + 8 + p] * (t1 - t2);
  285.    }
  286.    forward_bf(2, 4, b, a, coef32 + 16 + 8 + 4);
  287.    forward_bf(4, 2, a, b, coef32 + 16 + 8 + 4 + 2);
  288.    back_bf(2, 4, b, a);
  289.    back_bf(1, 8, a, c);
  290. }
  291.