Subversion Repositories Kolibri OS

Rev

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

  1. #include <math.h>
  2.  
  3. /* "fdct.c" */
  4. void fdct32(float *, float *);
  5. void fdct32_dual(float *, float *);
  6. void fdct32_dual_mono(float *, float *);
  7. void fdct16(float *, float *);
  8. void fdct16_dual(float *, float *);
  9. void fdct16_dual_mono(float *, float *);
  10. void fdct8(float *, float *);
  11. void fdct8_dual(float *, float *);
  12. void fdct8_dual_mono(float *, float *);
  13.  
  14. /* "windowb.c" */
  15. void windowB(float *vbuf, int vb_ptr, unsigned char *pcm);
  16. void windowB_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
  17. void windowB16(float *vbuf, int vb_ptr, unsigned char *pcm);
  18. void windowB16_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
  19. void windowB8(float *vbuf, int vb_ptr, unsigned char *pcm);
  20. void windowB8_dual(float *vbuf, int vb_ptr, unsigned char *pcm);
  21.  
  22. extern int vb_ptr;
  23. extern int vb2_ptr;
  24. extern float vbuf[512];
  25. extern float vbuf2[512];
  26.  
  27. void sbtB_mono(float *sample, unsigned char *pcm, int n)
  28. {
  29.    int i;
  30.  
  31.    for (i = 0; i < n; i++)
  32.    {
  33.       fdct32(sample, vbuf + vb_ptr);
  34.       windowB(vbuf, vb_ptr, pcm);
  35.       sample += 64;
  36.       vb_ptr = (vb_ptr - 32) & 511;
  37.       pcm += 32;
  38.    }
  39.  
  40. }
  41.  
  42. void sbtB_dual(float *sample, unsigned char *pcm, int n)
  43. {
  44.    int i;
  45.  
  46.    for (i = 0; i < n; i++)
  47.    {
  48.       fdct32_dual(sample, vbuf + vb_ptr);
  49.       fdct32_dual(sample + 1, vbuf2 + vb_ptr);
  50.       windowB_dual(vbuf, vb_ptr, pcm);
  51.       windowB_dual(vbuf2, vb_ptr, pcm + 1);
  52.       sample += 64;
  53.       vb_ptr = (vb_ptr - 32) & 511;
  54.       pcm += 64;
  55.    }
  56.  
  57.  
  58. }
  59.  
  60. void sbtB_dual_mono(float *sample, unsigned char *pcm, int n)
  61. {
  62.    int i;
  63.  
  64.    for (i = 0; i < n; i++)
  65.    {
  66.       fdct32_dual_mono(sample, vbuf + vb_ptr);
  67.       windowB(vbuf, vb_ptr, pcm);
  68.       sample += 64;
  69.       vb_ptr = (vb_ptr - 32) & 511;
  70.       pcm += 32;
  71.    }
  72.  
  73. }
  74.  
  75. void sbtB_dual_left(float *sample, unsigned char *pcm, int n)
  76. {
  77.    int i;
  78.  
  79.    for (i = 0; i < n; i++)
  80.    {
  81.       fdct32_dual(sample, vbuf + vb_ptr);
  82.       windowB(vbuf, vb_ptr, pcm);
  83.       sample += 64;
  84.       vb_ptr = (vb_ptr - 32) & 511;
  85.       pcm += 32;
  86.    }
  87. }
  88.  
  89. void sbtB_dual_right(float *sample, unsigned char *pcm, int n)
  90. {
  91.    int i;
  92.  
  93.    sample++;                    /* point to right chan */
  94.    for (i = 0; i < n; i++)
  95.    {
  96.       fdct32_dual(sample, vbuf + vb_ptr);
  97.       windowB(vbuf, vb_ptr, pcm);
  98.       sample += 64;
  99.       vb_ptr = (vb_ptr - 32) & 511;
  100.       pcm += 32;
  101.    }
  102. }
  103.  
  104. void sbtB16_mono(float *sample, unsigned char *pcm, int n)
  105. {
  106.    int i;
  107.  
  108.    for (i = 0; i < n; i++)
  109.    {
  110.       fdct16(sample, vbuf + vb_ptr);
  111.       windowB16(vbuf, vb_ptr, pcm);
  112.       sample += 64;
  113.       vb_ptr = (vb_ptr - 16) & 255;
  114.       pcm += 16;
  115.    }
  116.  
  117.  
  118. }
  119.  
  120. void sbtB16_dual(float *sample, unsigned char *pcm, int n)
  121. {
  122.    int i;
  123.  
  124.    for (i = 0; i < n; i++)
  125.    {
  126.       fdct16_dual(sample, vbuf + vb_ptr);
  127.       fdct16_dual(sample + 1, vbuf2 + vb_ptr);
  128.       windowB16_dual(vbuf, vb_ptr, pcm);
  129.       windowB16_dual(vbuf2, vb_ptr, pcm + 1);
  130.       sample += 64;
  131.       vb_ptr = (vb_ptr - 16) & 255;
  132.       pcm += 32;
  133.    }
  134. }
  135.  
  136. void sbtB16_dual_mono(float *sample, unsigned char *pcm, int n)
  137. {
  138.    int i;
  139.  
  140.    for (i = 0; i < n; i++)
  141.    {
  142.       fdct16_dual_mono(sample, vbuf + vb_ptr);
  143.       windowB16(vbuf, vb_ptr, pcm);
  144.       sample += 64;
  145.       vb_ptr = (vb_ptr - 16) & 255;
  146.       pcm += 16;
  147.    }
  148. }
  149.  
  150. void sbtB16_dual_left(float *sample, unsigned char *pcm, int n)
  151. {
  152.    int i;
  153.  
  154.    for (i = 0; i < n; i++)
  155.    {
  156.       fdct16_dual(sample, vbuf + vb_ptr);
  157.       windowB16(vbuf, vb_ptr, pcm);
  158.       sample += 64;
  159.       vb_ptr = (vb_ptr - 16) & 255;
  160.       pcm += 16;
  161.    }
  162. }
  163.  
  164. void sbtB16_dual_right(float *sample, unsigned char *pcm, int n)
  165. {
  166.    int i;
  167.  
  168.    sample++;
  169.    for (i = 0; i < n; i++)
  170.    {
  171.       fdct16_dual(sample, vbuf + vb_ptr);
  172.       windowB16(vbuf, vb_ptr, pcm);
  173.       sample += 64;
  174.       vb_ptr = (vb_ptr - 16) & 255;
  175.       pcm += 16;
  176.    }
  177. }
  178.  
  179. void sbtB8_mono(float *sample, unsigned char *pcm, int n)
  180. {
  181.    int i;
  182.  
  183.    for (i = 0; i < n; i++)
  184.    {
  185.       fdct8(sample, vbuf + vb_ptr);
  186.       windowB8(vbuf, vb_ptr, pcm);
  187.       sample += 64;
  188.       vb_ptr = (vb_ptr - 8) & 127;
  189.       pcm += 8;
  190.    }
  191.  
  192. }
  193.  
  194. void sbtB8_dual(float *sample, unsigned char *pcm, int n)
  195. {
  196.    int i;
  197.  
  198.    for (i = 0; i < n; i++)
  199.    {
  200.       fdct8_dual(sample, vbuf + vb_ptr);
  201.       fdct8_dual(sample + 1, vbuf2 + vb_ptr);
  202.       windowB8_dual(vbuf, vb_ptr, pcm);
  203.       windowB8_dual(vbuf2, vb_ptr, pcm + 1);
  204.       sample += 64;
  205.       vb_ptr = (vb_ptr - 8) & 127;
  206.       pcm += 16;
  207.    }
  208. }
  209.  
  210. void sbtB8_dual_mono(float *sample, unsigned char *pcm, int n)
  211. {
  212.    int i;
  213.  
  214.    for (i = 0; i < n; i++)
  215.    {
  216.       fdct8_dual_mono(sample, vbuf + vb_ptr);
  217.       windowB8(vbuf, vb_ptr, pcm);
  218.       sample += 64;
  219.       vb_ptr = (vb_ptr - 8) & 127;
  220.       pcm += 8;
  221.    }
  222. }
  223.  
  224. void sbtB8_dual_left(float *sample, unsigned char *pcm, int n)
  225. {
  226.    int i;
  227.  
  228.    for (i = 0; i < n; i++)
  229.    {
  230.       fdct8_dual(sample, vbuf + vb_ptr);
  231.       windowB8(vbuf, vb_ptr, pcm);
  232.       sample += 64;
  233.       vb_ptr = (vb_ptr - 8) & 127;
  234.       pcm += 8;
  235.    }
  236. }
  237.  
  238. void sbtB8_dual_right(float *sample, unsigned char *pcm, int n)
  239. {
  240.    int i;
  241.  
  242.    sample++;
  243.    for (i = 0; i < n; i++)
  244.    {
  245.       fdct8_dual(sample, vbuf + vb_ptr);
  246.       windowB8(vbuf, vb_ptr, pcm);
  247.       sample += 64;
  248.       vb_ptr = (vb_ptr - 8) & 127;
  249.       pcm += 8;
  250.    }
  251. }
  252.  
  253. void sbtB_mono_L3(float *sample, unsigned char *pcm, int ch)
  254. {
  255.    int i;
  256.  
  257.    ch = 0;
  258.    for (i = 0; i < 18; i++)
  259.    {
  260.       fdct32(sample, vbuf + vb_ptr);
  261.       windowB(vbuf, vb_ptr, pcm);
  262.       sample += 32;
  263.       vb_ptr = (vb_ptr - 32) & 511;
  264.       pcm += 32;
  265.    }
  266.  
  267. }
  268.  
  269. void sbtB_dual_L3(float *sample, unsigned char *pcm, int ch)
  270. {
  271.    int i;
  272.  
  273.    if (ch == 0)
  274.       for (i = 0; i < 18; i++)
  275.       {
  276.          fdct32(sample, vbuf + vb_ptr);
  277.          windowB_dual(vbuf, vb_ptr, pcm);
  278.          sample += 32;
  279.          vb_ptr = (vb_ptr - 32) & 511;
  280.          pcm += 64;
  281.       }
  282.    else
  283.       for (i = 0; i < 18; i++)
  284.       {
  285.          fdct32(sample, vbuf2 + vb2_ptr);
  286.          windowB_dual(vbuf2, vb2_ptr, pcm + 1);
  287.          sample += 32;
  288.          vb2_ptr = (vb2_ptr - 32) & 511;
  289.          pcm += 64;
  290.       }
  291.  
  292. }
  293.  
  294. void sbtB16_mono_L3(float *sample, unsigned char *pcm, int ch)
  295. {
  296.    int i;
  297.  
  298.    ch = 0;
  299.    for (i = 0; i < 18; i++)
  300.    {
  301.       fdct16(sample, vbuf + vb_ptr);
  302.       windowB16(vbuf, vb_ptr, pcm);
  303.       sample += 32;
  304.       vb_ptr = (vb_ptr - 16) & 255;
  305.       pcm += 16;
  306.    }
  307.  
  308.  
  309. }
  310.  
  311. void sbtB16_dual_L3(float *sample, unsigned char *pcm, int ch)
  312. {
  313.    int i;
  314.  
  315.    if (ch == 0)
  316.    {
  317.       for (i = 0; i < 18; i++)
  318.       {
  319.          fdct16(sample, vbuf + vb_ptr);
  320.          windowB16_dual(vbuf, vb_ptr, pcm);
  321.          sample += 32;
  322.          vb_ptr = (vb_ptr - 16) & 255;
  323.          pcm += 32;
  324.       }
  325.    }
  326.    else
  327.    {
  328.       for (i = 0; i < 18; i++)
  329.       {
  330.          fdct16(sample, vbuf2 + vb2_ptr);
  331.          windowB16_dual(vbuf2, vb2_ptr, pcm + 1);
  332.          sample += 32;
  333.          vb2_ptr = (vb2_ptr - 16) & 255;
  334.          pcm += 32;
  335.       }
  336.    }
  337.  
  338. }
  339.  
  340. void sbtB8_mono_L3(float *sample, unsigned char *pcm, int ch)
  341. {
  342.    int i;
  343.  
  344.    ch = 0;
  345.    for (i = 0; i < 18; i++)
  346.    {
  347.       fdct8(sample, vbuf + vb_ptr);
  348.       windowB8(vbuf, vb_ptr, pcm);
  349.       sample += 32;
  350.       vb_ptr = (vb_ptr - 8) & 127;
  351.       pcm += 8;
  352.    }
  353.  
  354. }
  355.  
  356. void sbtB8_dual_L3(float *sample, unsigned char *pcm, int ch)
  357. {
  358.    int i;
  359.  
  360.    if (ch == 0)
  361.    {
  362.       for (i = 0; i < 18; i++)
  363.       {
  364.          fdct8(sample, vbuf + vb_ptr);
  365.          windowB8_dual(vbuf, vb_ptr, pcm);
  366.          sample += 32;
  367.          vb_ptr = (vb_ptr - 8) & 127;
  368.          pcm += 16;
  369.       }
  370.    }
  371.    else
  372.    {
  373.       for (i = 0; i < 18; i++)
  374.       {
  375.          fdct8(sample, vbuf2 + vb2_ptr);
  376.          windowB8_dual(vbuf2, vb2_ptr, pcm + 1);
  377.          sample += 32;
  378.          vb2_ptr = (vb2_ptr - 8) & 127;
  379.          pcm += 16;
  380.       }
  381.    }
  382. }
  383.