Subversion Repositories Kolibri OS

Rev

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

  1. #include "layer3.h"
  2.  
  3. extern MPEG_DECODE_OPTION m_option;
  4. extern SAMPLE           m_sample[2][2][576];
  5. extern int                      m_frequency;
  6.  
  7. extern SBT_PROC         m_sbt_proc;
  8. extern XFORM_PROC       m_xform_proc;
  9. extern int                      m_channels;
  10. extern int                      m_sfBandIndex[2][22];// [long/short][cb]
  11. extern int                      m_nBand[2][22];
  12. extern int                      m_band_limit;
  13. extern int                      m_band_limit21;         // limit for sf band 21
  14. extern int                      m_band_limit12;         // limit for sf band 12 short
  15. extern int                      m_band_limit_nsb;
  16. extern int                      m_ncbl_mixed;
  17. extern int                      m_nsb_limit;
  18.  
  19. extern int                      m_gr;
  20. extern int                      m_buf_ptr0, m_buf_ptr1;
  21. extern float            m_yout[576];
  22.  
  23. //extern "l3sbt.c"
  24. void sbt_mono_L3(float *sample, signed short *pcm, int ch);
  25. void sbt_dual_L3(float *sample, signed short *pcm, int ch);
  26. void sbt16_mono_L3(float *sample, signed short *pcm, int ch);
  27. void sbt16_dual_L3(float *sample, signed short *pcm, int ch);
  28. void sbt8_mono_L3(float *sample, signed short *pcm, int ch);
  29. void sbt8_dual_L3(float *sample, signed short *pcm, int ch);
  30. void sbtB_mono_L3(float *sample, unsigned char *pcm, int ch);
  31. void sbtB_dual_L3(float *sample, unsigned char *pcm, int ch);
  32. void sbtB16_mono_L3(float *sample, unsigned char *pcm, int ch);
  33. void sbtB16_dual_L3(float *sample, unsigned char *pcm, int ch);
  34. void sbtB8_mono_L3(float *sample, unsigned char *pcm, int ch);
  35. void sbtB8_dual_L3(float *sample, unsigned char *pcm, int ch);
  36.  
  37. //extern "l3dec.c"
  38. void xform_mono(void *pcm, int igr);
  39. void xform_dual(void *pcm, int igr);
  40. void xform_dual_mono(void *pcm, int igr);
  41. void xform_dual_right(void *pcm, int igr);
  42.  
  43. static const SBT_PROC sbt_table[2][3][2] =
  44. {
  45.         sbt_mono_L3,
  46.         sbt_dual_L3,
  47.         sbt16_mono_L3,
  48.         sbt16_dual_L3,
  49.         sbt8_mono_L3,
  50.         sbt8_dual_L3,
  51. // 8 bit output
  52.         sbtB_mono_L3,
  53.         sbtB_dual_L3,
  54.         sbtB16_mono_L3,
  55.         sbtB16_dual_L3,
  56.         sbtB8_mono_L3,
  57.         sbtB8_dual_L3,
  58. };
  59.  
  60. static const XFORM_PROC xform_table[5] =
  61. {
  62.         xform_mono,
  63.         xform_dual,
  64.         xform_dual_mono,
  65.         xform_mono,                     /* left */
  66.         xform_dual_right,
  67. };
  68.  
  69. static const struct {
  70.    int l[23];
  71.    int s[14];
  72. } sfBandTable[3][3] = {
  73. // MPEG-1
  74.         {{
  75.                 {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162, 196, 238, 288, 342, 418, 576},
  76.                 {0, 4, 8, 12, 16, 22, 30, 40, 52, 66, 84, 106, 136, 192}
  77.         },{
  78.                 {0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156, 190, 230, 276, 330, 384, 576},
  79.                 {0, 4, 8, 12, 16, 22, 28, 38, 50, 64, 80, 100, 126, 192}
  80.         },{
  81.                 {0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194, 240, 296, 364, 448, 550, 576},
  82.                 {0, 4, 8, 12, 16, 22, 30, 42, 58, 78, 104, 138, 180, 192}
  83.         }},
  84. // MPEG-2
  85.         {{
  86.                 {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
  87.                 {0, 4, 8, 12, 18, 24, 32, 42, 56, 74, 100, 132, 174, 192}
  88.         },{
  89.                 {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194, 232, 278, 332, 394, 464, 540, 576},
  90.                 {0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 136, 180, 192}
  91.         },{
  92.                 {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
  93.                 {0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}
  94.         }},
  95. // MPEG-2.5, 11 & 12 KHz seem ok, 8 ok
  96.         {{
  97.                 {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
  98.                 {0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}
  99.         },{
  100.                 {0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200, 238, 284, 336, 396, 464, 522, 576},
  101.                 {0, 4, 8, 12, 18, 26, 36, 48, 62, 80, 104, 134, 174, 192}
  102.         },{
  103. // this 8khz table, and only 8khz, from mpeg123)
  104.                 {0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336, 400, 476, 566, 568, 570, 572, 574, 576},
  105.                 {0, 8, 16, 24, 36, 52, 72, 96, 124, 160, 162, 164, 166, 192}
  106.         }},
  107. };
  108.  
  109. void quant_init();
  110. void alias_init();
  111. void msis_init();
  112. void fdct_init();
  113. void imdct_init();
  114. void hwin_init();
  115.  
  116. void L3table_init()
  117. {
  118.         quant_init();
  119.         alias_init();
  120.         msis_init();
  121.         fdct_init();
  122.         imdct_init();
  123.         hwin_init();
  124. }
  125.  
  126. int L3decode_start(MPEG_HEADER* h)
  127. {
  128.         int i, j, k, v;
  129.         int channels, limit;
  130.         int bit_code;
  131.  
  132.         m_buf_ptr0 = 0;
  133.         m_buf_ptr1 = 0;
  134.         m_gr = 0;
  135.         v = h->version - 1;
  136.         if (h->version == 1) //MPEG-1
  137.                 m_ncbl_mixed = 8;
  138.         else //MPEG-2, MPEG-2.5
  139.                 m_ncbl_mixed = 6;
  140.  
  141. // compute nsb_limit
  142.         m_nsb_limit = (m_option.freqLimit * 64L + m_frequency / 2) / m_frequency;
  143. // caller limit
  144.         limit = (32 >> m_option.reduction);
  145.         if (limit > 8)
  146.                 limit--;
  147.         if (m_nsb_limit > limit)
  148.                 m_nsb_limit = limit;
  149.         limit = 18 * m_nsb_limit;
  150.  
  151.         if (h->version == 1) {
  152.                 //MPEG-1
  153.                 m_band_limit12 = 3 * sfBandTable[v][h->fr_index].s[13];
  154.                 m_band_limit = m_band_limit21 = sfBandTable[v][h->fr_index].l[22];
  155.         }
  156.         else {
  157.                 //MPEG-2, MPEG-2.5
  158.                 m_band_limit12 = 3 * sfBandTable[v][h->fr_index].s[12];
  159.                 m_band_limit = m_band_limit21 = sfBandTable[v][h->fr_index].l[21];
  160.         }
  161.         m_band_limit += 8;      // allow for antialias
  162.         if (m_band_limit > limit)
  163.                 m_band_limit = limit;
  164.         if (m_band_limit21 > m_band_limit)
  165.                 m_band_limit21 = m_band_limit;
  166.         if (m_band_limit12 > m_band_limit)
  167.                 m_band_limit12 = m_band_limit;
  168.         m_band_limit_nsb = (m_band_limit + 17) / 18;    // limit nsb's rounded up
  169. /*
  170.         gain_adjust = 0;        // adjust gain e.g. cvt to mono sum channel
  171.         if ((h->mode != 3) && (m_option.convert == 1))
  172.                 gain_adjust = -4;
  173. */
  174.         m_channels = (h->mode == 3) ? 1 : 2;
  175.         if (m_option.convert) channels = 1;
  176.         else channels = m_channels;
  177.  
  178.         bit_code = (m_option.convert & 8) ? 1 : 0;
  179.         m_sbt_proc = sbt_table[bit_code][m_option.reduction][channels - 1];//[2][3][2]
  180.         k = (h->mode != 3) ? (1 + m_option.convert) : 0;
  181.         m_xform_proc = xform_table[k];//[5]
  182. /*
  183.         if (bit_code)
  184.                 zero_level_pcm = 128;// 8 bit output
  185.         else
  186.                 zero_level_pcm = 0;
  187. */
  188. // init band tables
  189.         for (i = 0; i < 22; i ++)
  190.                 m_sfBandIndex[0][i] = sfBandTable[v][h->fr_index].l[i + 1];
  191.         for (i = 0; i < 13; i ++)
  192.                 m_sfBandIndex[1][i] = 3 * sfBandTable[v][h->fr_index].s[i + 1];
  193.         for (i = 0; i < 22; i ++)
  194.                 m_nBand[0][i] = sfBandTable[v][h->fr_index].l[i + 1]
  195.                                 - sfBandTable[v][h->fr_index].l[i];
  196.         for (i = 0; i < 13; i ++)
  197.                 m_nBand[1][i] = sfBandTable[v][h->fr_index].s[i + 1]
  198.                                 - sfBandTable[v][h->fr_index].s[i];
  199.  
  200. // clear buffers
  201.         for (i = 0; i < 576; i++)
  202.                 m_yout[i] = 0.0f;
  203.         for (i = 0; i < 2; i ++)
  204.     {   for (j = 0; j < 2; j ++)
  205.         {       for (k = 0; k < 576; k++)
  206.            {    m_sample[i][j][k].x = 0.0f;
  207.                                 m_sample[i][j][k].s = 0;
  208.                         }
  209.                 }
  210.         }
  211.         return 1;
  212. }
  213.