Subversion Repositories Kolibri OS

Rev

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

  1. #include "layer3.h"
  2. #include <string.h>
  3. #include <math.h>
  4.  
  5. #ifndef min
  6.         #define max(a,b)    (((a) > (b)) ? (a) : (b))
  7.         #define min(a,b)    (((a) < (b)) ? (a) : (b))
  8. #endif
  9.  
  10. extern int              m_frame_size, m_pcm_size;
  11.  
  12. // shared
  13. SAMPLE                  m_sample[2][2][576];//- sample union of int/float  sample[ch][gr][576]
  14. int                             m_nsb_limit;
  15. SBT_PROC                m_sbt_proc;
  16.  
  17. XFORM_PROC              m_xform_proc;
  18. int                             m_channels;                     //(mode == 3) ? 1 : 2
  19. int                             m_ms_mode, m_is_mode;
  20. int                             m_sfBandIndex[2][22];// [long/short][cb]
  21. int                             m_nBand[2][22];
  22. int                             m_band_limit;
  23. int                             m_band_limit21;         // limit for sf band 21
  24. int                             m_band_limit12;         // limit for sf band 12 short
  25. int                             m_band_limit_nsb;
  26. int                             m_ncbl_mixed;
  27.  
  28. SIDE_INFO               m_side_info;
  29. SCALE_FACTOR    m_scale_fac[2][2];      // [gr][ch]
  30. CB_INFO                 m_cb_info[2][2];        // [gr][ch]
  31. IS_SF_INFO              m_is_sf_info;
  32.  
  33. #define NBUF (8*1024)
  34. #define BUF_TRIGGER (NBUF-1500)
  35.  
  36. int                             m_gr;
  37. int                             m_main_pos_bit;
  38. byte                    m_buf[NBUF];
  39. int                             m_buf_ptr0, m_buf_ptr1;
  40. int                             m_nsamp[2][2];          // must start = 0, for m_nsamp[igr_prev]
  41. float                   m_yout[576];            // hybrid out, sbt in
  42.  
  43. //extern "l3side.c"
  44. int L3get_side_info1();
  45. int L3get_side_info2(int gr);
  46.  
  47. //extern "l3sf.c"
  48. void L3get_scale_factor1(int gr, int ch);
  49. void L3get_scale_factor2(int gr, int ch);
  50.  
  51. void huffman(void *xy, int n, int ntable);
  52. int huffman_quad(void *vwxy, int n, int nbits, int ntable);
  53. void dequant(SAMPLE sample[], int gr, int ch);
  54. void antialias(void *x, int n);
  55. void ms_process(void *x, int n);
  56. void is_process1(void *x, SCALE_FACTOR* sf,
  57.                 CB_INFO cb_info[2], int nsamp);
  58. void is_process2(void *x, SCALE_FACTOR * sf,
  59.                 CB_INFO cb_info[2], int nsamp);
  60.  
  61. //extern "l3hybrid.c"
  62. int hybrid(void *xin, void *xprev, float *y,
  63.                 int btype, int nlong, int ntot, int nprev);
  64. int hybrid_sum(void *xin, void *xin_left, float *y,
  65.                 int btype, int nlong, int ntot);
  66. void sum_f_bands(void *a, void *b, int n);
  67. void freq_invert(float *y, int n); /* xform, */
  68.  
  69. void L3decode_main(MPEG_HEADER* h, byte *pcm, int gr);
  70.  
  71. void L3decode_reset()
  72. {
  73.         m_buf_ptr0 = m_buf_ptr1 = 0;
  74. }
  75.  
  76. void L3decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm)
  77. {
  78.         int crc_size, side_size;
  79.         int copy_size;
  80.  
  81.         if (h->mode == 1) {
  82.                 m_ms_mode = h->mode_ext >> 1;
  83.                 m_is_mode = h->mode_ext & 1;
  84.         }
  85.         else {
  86.                 m_ms_mode = 0;
  87.                 m_is_mode = 0;
  88.         }
  89.  
  90.         crc_size = (h->error_prot) ? 2 : 0;
  91.         bitget_init(mpeg + 4 + crc_size);
  92.         if (h->version == 1)
  93.                 side_size = L3get_side_info1();
  94.         else
  95.                 side_size = L3get_side_info2(m_gr);
  96.  
  97.         m_buf_ptr0 = m_buf_ptr1 - m_side_info.main_data_begin;/* decode start point */
  98.         if (m_buf_ptr1 > BUF_TRIGGER) { /* shift buffer */
  99.                 memmove(m_buf, m_buf + m_buf_ptr0, m_side_info.main_data_begin);
  100.                 m_buf_ptr0 = 0;
  101.                 m_buf_ptr1 = m_side_info.main_data_begin;
  102.         }
  103.         copy_size = m_frame_size - (4 + crc_size + side_size);
  104.         //24/02/02 X-MaD
  105.         if (copy_size < 0) { copy_size = copy_size * -1; }
  106.         //if (copy_size < 0) { copy_size = 0; }
  107.         //__try {
  108.                 memmove(m_buf + m_buf_ptr1, mpeg + (4 + crc_size + side_size), copy_size);
  109.         //}    __except(0){
  110.         //      m_buf_ptr1 = 0;        
  111.         //}
  112.         m_buf_ptr1 += copy_size;
  113.         //24/02/02 X-MaD
  114.  
  115.         if (m_buf_ptr0 >= 0) {
  116.                 m_main_pos_bit = m_buf_ptr0 << 3;
  117.                 if (h->version == 1) {
  118.                         L3decode_main(h, pcm, 0);
  119.                         L3decode_main(h, pcm + (m_pcm_size / 2), 1);
  120.                 }
  121.                 else {
  122.                         L3decode_main(h, pcm, m_gr);
  123.                         m_gr = m_gr ^ 1;
  124.                 }
  125.         }
  126. }
  127.  
  128. void L3decode_main(MPEG_HEADER* h, byte *pcm, int gr)
  129. {
  130.         int ch;
  131.         int n1, n2, n3, n4, nn2, nn3, nn4;
  132.         int bit0, qbits, m0;
  133.  
  134.         for (ch = 0; ch < m_channels; ch ++) {
  135.                 bitget_init(m_buf + (m_main_pos_bit >> 3));
  136.                 bit0 = (m_main_pos_bit & 7);
  137.                 if (bit0) bitget(bit0);
  138.                 m_main_pos_bit += m_side_info.gr[gr][ch].part2_3_length;
  139.                 bitget_init_end(m_buf + ((m_main_pos_bit + 39) >> 3));
  140. // scale factors
  141.                 if (h->version == 1)
  142.                         L3get_scale_factor1(gr, ch);
  143.                 else
  144.                         L3get_scale_factor2(gr, ch);
  145. // huff data
  146.                 n1 = m_sfBandIndex[0][m_side_info.gr[gr][ch].region0_count];
  147.                 n2 = m_sfBandIndex[0][m_side_info.gr[gr][ch].region0_count
  148.                                 + m_side_info.gr[gr][ch].region1_count + 1];
  149.                 n3 = m_side_info.gr[gr][ch].big_values;
  150.                 n3 = n3 + n3;
  151.  
  152.                 if (n3 > m_band_limit) n3 = m_band_limit;
  153.                 if (n2 > n3) n2 = n3;
  154.                 if (n1 > n3) n1 = n3;
  155.                 nn3 = n3 - n2;
  156.                 nn2 = n2 - n1;
  157.                 huffman(m_sample[ch][gr], n1, m_side_info.gr[gr][ch].table_select[0]);
  158.                 huffman(m_sample[ch][gr] + n1, nn2, m_side_info.gr[gr][ch].table_select[1]);
  159.                 huffman(m_sample[ch][gr] + n2, nn3, m_side_info.gr[gr][ch].table_select[2]);
  160.                 qbits = m_side_info.gr[gr][ch].part2_3_length - (bitget_bits_used() - bit0);
  161.                 nn4 = huffman_quad(m_sample[ch][gr] + n3, m_band_limit - n3, qbits,
  162.                                 m_side_info.gr[gr][ch].count1table_select);
  163.                 n4 = n3 + nn4;
  164.                 m_nsamp[gr][ch] = n4;
  165.                 // limit n4 or allow deqaunt to sf band 22
  166.                 if (m_side_info.gr[gr][ch].block_type == 2)
  167.                         n4 = min(n4, m_band_limit12);
  168.                 else
  169.                         n4 = min(n4, m_band_limit21);
  170.                 if (n4 < 576)
  171.                         memset(m_sample[ch][gr] + n4, 0, sizeof(SAMPLE) * (576 - n4));
  172.                 if (bitget_overrun())
  173.                         memset(m_sample[ch][gr], 0, sizeof(SAMPLE) * (576));
  174.         }
  175. // dequant
  176.         for (ch = 0; ch < m_channels; ch++) {
  177.                 dequant(m_sample[ch][gr], gr, ch);
  178.         }
  179. // ms stereo processing
  180.         if (m_ms_mode) {
  181.                 if (m_is_mode == 0) {
  182.                         m0 = m_nsamp[gr][0];    // process to longer of left/right
  183.                         if (m0 < m_nsamp[gr][1])
  184.                                 m0 = m_nsamp[gr][1];
  185.                 }
  186.                 else {// process to last cb in right
  187.                         m0 = m_sfBandIndex[m_cb_info[gr][1].cbtype][m_cb_info[gr][1].cbmax];
  188.                 }
  189.                 ms_process(m_sample[0][gr], m0);
  190.         }
  191. // is stereo processing
  192.         if (m_is_mode) {
  193.                 if (h->version == 1)
  194.                         is_process1(m_sample[0][gr], &m_scale_fac[gr][1],
  195.                                         m_cb_info[gr], m_nsamp[gr][0]);
  196.                 else
  197.                         is_process2(m_sample[0][gr], &m_scale_fac[gr][1],
  198.                                         m_cb_info[gr], m_nsamp[gr][0]);
  199.         }
  200. // adjust ms and is modes to max of left/right
  201.         if (m_ms_mode || m_is_mode) {
  202.                 if (m_nsamp[gr][0] < m_nsamp[gr][1])
  203.                         m_nsamp[gr][0] = m_nsamp[gr][1];
  204.                 else
  205.                         m_nsamp[gr][1] = m_nsamp[gr][0];
  206.         }
  207.  
  208. // antialias
  209.         for (ch = 0; ch < m_channels; ch ++) {
  210.                 if (m_cb_info[gr][ch].ncbl == 0)
  211.                         continue;               // have no long blocks
  212.                 if (m_side_info.gr[gr][ch].mixed_block_flag)
  213.                         n1 = 1;         // 1 -> 36 samples
  214.                 else
  215.                         n1 = (m_nsamp[gr][ch] + 7) / 18;
  216.                 if (n1 > 31)
  217.                         n1 = 31;
  218.                 antialias(m_sample[ch][gr], n1);
  219.                 n1 = 18 * n1 + 8;               // update number of samples
  220.                 if (n1 > m_nsamp[gr][ch])
  221.                         m_nsamp[gr][ch] = n1;
  222.         }
  223. // hybrid + sbt
  224.         m_xform_proc(pcm, gr);
  225. }
  226.  
  227. void xform_mono(void *pcm, int igr)
  228. {
  229.         int igr_prev, n1, n2;
  230.  
  231. // hybrid + sbt
  232.         n1 = n2 = m_nsamp[igr][0];      // total number bands
  233.         if (m_side_info.gr[igr][0].block_type == 2) {   // long bands
  234.                 if (m_side_info.gr[igr][0].mixed_block_flag)
  235.                         n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
  236.                 else
  237.                         n1 = 0;
  238.         }
  239.         if (n1 > m_band_limit)
  240.                 n1 = m_band_limit;
  241.         if (n2 > m_band_limit)
  242.                 n2 = m_band_limit;
  243.         igr_prev = igr ^ 1;
  244.  
  245.         m_nsamp[igr][0] = hybrid(m_sample[0][igr], m_sample[0][igr_prev],
  246.                         m_yout, m_side_info.gr[igr][0].block_type, n1, n2, m_nsamp[igr_prev][0]);
  247.         freq_invert(m_yout, m_nsamp[igr][0]);
  248.         m_sbt_proc(m_yout, pcm, 0);
  249. }
  250.  
  251. void xform_dual_right(void *pcm, int igr)
  252. {
  253.         int igr_prev, n1, n2;
  254.  
  255. // hybrid + sbt
  256.         n1 = n2 = m_nsamp[igr][1];      // total number bands
  257.         if (m_side_info.gr[igr][1].block_type == 2) {   // long bands
  258.                 if (m_side_info.gr[igr][1].mixed_block_flag)
  259.                         n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
  260.                 else
  261.                         n1 = 0;
  262.         }
  263.         if (n1 > m_band_limit)
  264.                 n1 = m_band_limit;
  265.         if (n2 > m_band_limit)
  266.                 n2 = m_band_limit;
  267.         igr_prev = igr ^ 1;
  268.         m_nsamp[igr][1] = hybrid(m_sample[1][igr], m_sample[1][igr_prev],
  269.                         m_yout, m_side_info.gr[igr][1].block_type, n1, n2, m_nsamp[igr_prev][1]);
  270.         freq_invert(m_yout, m_nsamp[igr][1]);
  271.         m_sbt_proc(m_yout, pcm, 0);
  272. }
  273.  
  274. void xform_dual(void *pcm, int igr)
  275. {
  276.         int ch;
  277.         int igr_prev, n1, n2;
  278.  
  279. // hybrid + sbt
  280.         igr_prev = igr ^ 1;
  281.         for (ch = 0; ch < m_channels; ch++) {
  282.                 n1 = n2 = m_nsamp[igr][ch];     // total number bands
  283.                 if (m_side_info.gr[igr][ch].block_type == 2) { // long bands
  284.                         if (m_side_info.gr[igr][ch].mixed_block_flag)
  285.                                 n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
  286.                         else
  287.                                 n1 = 0;
  288.                 }
  289.                 if (n1 > m_band_limit)
  290.                         n1 = m_band_limit;
  291.                 if (n2 > m_band_limit)
  292.                         n2 = m_band_limit;
  293.                 m_nsamp[igr][ch] = hybrid(m_sample[ch][igr], m_sample[ch][igr_prev],
  294.                                 m_yout, m_side_info.gr[igr][ch].block_type, n1, n2, m_nsamp[igr_prev][ch]);
  295.                 freq_invert(m_yout, m_nsamp[igr][ch]);
  296.                 m_sbt_proc(m_yout, pcm, ch);
  297.         }
  298. }
  299.  
  300. void xform_dual_mono(void *pcm, int igr)
  301. {
  302.         int igr_prev, n1, n2, n3;
  303.  
  304. // hybrid + sbt
  305.         igr_prev = igr ^ 1;
  306.         if ((m_side_info.gr[igr][0].block_type == m_side_info.gr[igr][1].block_type)
  307.                         && (m_side_info.gr[igr][0].mixed_block_flag == 0)
  308.                         && (m_side_info.gr[igr][1].mixed_block_flag == 0)) {
  309.                 n2 = m_nsamp[igr][0];   // total number bands max of L R
  310.                 if (n2 < m_nsamp[igr][1])
  311.                         n2 = m_nsamp[igr][1];
  312.                 if (n2 > m_band_limit)
  313.                         n2 = m_band_limit;
  314.                 if (m_side_info.gr[igr][0].block_type == 2)
  315.                         n1 = 0;
  316.                 else
  317.                         n1 = n2;                // n1 = number long bands
  318.                 sum_f_bands(m_sample[0][igr], m_sample[1][igr], n2);
  319.                 n3 = m_nsamp[igr][0] = hybrid(m_sample[0][igr], m_sample[0][igr_prev],
  320.                                 m_yout, m_side_info.gr[igr][0].block_type, n1, n2, m_nsamp[igr_prev][0]);
  321.         }
  322.         else {  // transform and then sum (not tested - never happens in test)
  323. // left chan
  324.                 n1 = n2 = m_nsamp[igr][0];      // total number bands
  325.                 if (m_side_info.gr[igr][0].block_type == 2) {   // long bands
  326.                         if (m_side_info.gr[igr][0].mixed_block_flag)
  327.                                 n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
  328.                         else
  329.                                 n1 = 0;
  330.                 }
  331.                 n3 = m_nsamp[igr][0] = hybrid(m_sample[0][igr], m_sample[0][igr_prev],
  332.                                 m_yout, m_side_info.gr[igr][0].block_type, n1, n2, m_nsamp[igr_prev][0]);
  333. // right chan
  334.                 n1 = n2 = m_nsamp[igr][1];      // total number bands
  335.                 if (m_side_info.gr[igr][1].block_type == 2) {   // long bands
  336.                         if (m_side_info.gr[igr][1].mixed_block_flag)
  337.                                 n1 = m_sfBandIndex[0][m_ncbl_mixed - 1];
  338.                         else
  339.                                 n1 = 0;
  340.                 }
  341.                 m_nsamp[igr][1] = hybrid_sum(m_sample[1][igr], m_sample[0][igr],
  342.                                 m_yout, m_side_info.gr[igr][1].block_type, n1, n2);
  343.                 if (n3 < m_nsamp[igr][1])
  344.                         n1 = m_nsamp[igr][1];
  345.         }
  346.  
  347.         freq_invert(m_yout, n3);
  348.         m_sbt_proc(m_yout, pcm, 0);
  349. }
  350.  
  351.