home *** CD-ROM | disk | FTP | other *** search
/ PC Shareware 1997 June / PC_Shareware-1997-06.iso / manga / mp2win95 / _setup.1 / LAYER3.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-31  |  43.9 KB  |  1,477 lines
  1. /*
  2. Layer III routines adopted from the ISO MPEG Audio Subgroup Software Simulation
  3. Group's public c source for its MPEG audio decoder. These routines were in the
  4. file "decoder.c". Rearrangement of the routines as member functions of a
  5. layer III decoder object, and optimizations by Jeff Tsay
  6. (ctsay@pasteur.eecs.berkeley.edu).
  7.  
  8. If you want to help, figure out how to implement a 9 point IDCT
  9. in n log n time, and e-mail me.
  10.  
  11. Last modified : 01/31/97 */
  12.  
  13. #define STRICT
  14. #define WIN32_LEAN_AND_MEAN
  15. #define NOMCX
  16. #define NOIME
  17. #define NOGDI
  18. #define NOUSER
  19. #define NOSOUND
  20. #define NOCOMM
  21. #define NODRIVERS
  22. #define OEMRESOURCE
  23. #define NONLS
  24. #define NOSERVICE
  25. #define NOKANJI
  26. #define NOMINMAX
  27. #define NOLOGERROR
  28. #define NOPROFILER
  29. #define NOMEMMGR
  30. #define NOLFILEIO
  31. #define NOOPENFILE
  32. #define NORESOURCE
  33. #define NOATOM
  34. #define NOLANGUAGE
  35. #define NOLSTRING
  36. #define NODBCS
  37. #define NOKEYBOARDINFO
  38. #define NOGDICAPMASKS
  39. #define NOCOLOR
  40. #define NOGDIOBJ
  41. #define NODRAWTEXT
  42. #define NOTEXTMETRIC
  43. #define NOSCALABLEFONT
  44. #define NOBITMAP
  45. #define NORASTEROPS
  46. #define NOMETAFILE
  47. #define NOSYSMETRICS
  48. #define NOSYSTEMPARAMSINFO
  49. #define NOMSG
  50. #define NOWINSTYLES
  51. #define NOWINOFFSETS
  52. #define NOSHOWWINDOW
  53. #define NODEFERWINDOWPOS
  54. #define NOVIRTUALKEYCODES
  55. #define NOKEYSTATES
  56. #define NOWH
  57. #define NOMENUS
  58. #define NOSCROLL
  59. #define NOCLIPBOARD
  60. #define NOICONS
  61. #define NOMB
  62. #define NOSYSCOMMANDS
  63. #define NOMDI
  64. #define NOCTLMGR
  65. #define NOWINMESSAGES
  66. #define NOHELP
  67. #define _WINUSER_
  68. #include <windows.h>
  69. #include <math.h>
  70.  
  71. #include "all.h"
  72. #include "l3type.h"
  73. #include "ibitstr.h"
  74. #include "obuffer.h"
  75. #include "bit_res.h"
  76. #include "header.h"
  77. #include "synfilt.h"
  78. #include "huffman.h"
  79. #include "layer3.h"
  80.  
  81. LayerIII_Decoder::LayerIII_Decoder(char *huffdec_path0,
  82.                                              Ibitstream *stream0,
  83.                                    Header *header0,
  84.                                    SynthesisFilter *filtera,
  85.                                    SynthesisFilter *filterb,
  86.                                            Obuffer *buffer0)
  87. {
  88.   huffdec_path = huffdec_path0;
  89.   stream = stream0;
  90.   header = header0;
  91.   filter1 = filtera;
  92.   filter2 = filterb;
  93.   buffer = buffer0;
  94.  
  95.   frame_start = 0;
  96.   channels = (header->mode() == single_channel) ? 1 : 2;
  97.  
  98.   int32 i,j,k;
  99.  
  100.   for(i=0;i<2;i++)
  101.           for(j=0;j<SBLIMIT;j++)
  102.               for(k=0;k<SSLIMIT;k++)
  103.                   prevblck[i][j][k]=0.0f;
  104.  
  105.   br = new Bit_Reserve();
  106.   si = new III_side_info_t;
  107. }
  108.  
  109. LayerIII_Decoder::~LayerIII_Decoder()
  110. {
  111.    delete br;
  112.    delete si;
  113. }
  114.  
  115. void LayerIII_Decoder::seek_notify()
  116. {
  117.     frame_start = 0;
  118.  
  119.    int32 i,j,k;
  120.  
  121.       for(i=0;i<2;i++)
  122.           for(j=0;j<SBLIMIT;j++)
  123.               for(k=0;k<SSLIMIT;k++)
  124.                   prevblck[i][j][k]=0.0f;
  125.  
  126.    delete br;
  127.    br = new Bit_Reserve;
  128. }
  129.  
  130.  
  131. struct {
  132.     int32 l[5];
  133.     int32 s[3];} sfbtable = {{0, 6, 11, 16, 21},
  134.                                     {0, 6, 12}};
  135.  
  136. int32 slen[2][16] = {{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
  137.                      {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}};
  138.  
  139. void LayerIII_Decoder::get_scale_factors(int32 ch, int32 gr)
  140. {
  141.     int32 sfb, window;
  142.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  143.    int32 scale_comp = gr_info->scalefac_compress;
  144.    int32 length0 = slen[0][scale_comp];
  145.    int32 length1 = slen[1][scale_comp];
  146.  
  147.      if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  148.         if (gr_info->mixed_block_flag) { /* MIXED */ /* NEW - ag 11/25 */
  149.             for (sfb = 0; sfb < 8; sfb++)
  150.                 scalefac[ch].l[sfb] = br->hgetbits(
  151.                       slen[0][gr_info->scalefac_compress]);
  152.             for (sfb = 3; sfb < 6; sfb++)
  153.                 for (window=0; window<3; window++)
  154.                     scalefac[ch].s[window][sfb] = br->hgetbits(
  155.                       slen[0][gr_info->scalefac_compress]);
  156.             for (sfb = 6; sfb < 12; sfb++)
  157.                 for (window=0; window<3; window++)
  158.                     scalefac[ch].s[window][sfb] = br->hgetbits(
  159.                       slen[1][gr_info->scalefac_compress]);
  160.             for (sfb=12,window=0; window<3; window++)
  161.                 scalefac[ch].s[window][sfb] = 0;
  162.         }
  163.         else {  /* SHORT*/
  164.  
  165.          scalefac[ch].s[0][0] = br->hgetbits(length0);
  166.          scalefac[ch].s[1][0] = br->hgetbits(length0);
  167.          scalefac[ch].s[2][0] = br->hgetbits(length0);
  168.          scalefac[ch].s[0][1] = br->hgetbits(length0);
  169.          scalefac[ch].s[1][1] = br->hgetbits(length0);
  170.          scalefac[ch].s[2][1] = br->hgetbits(length0);
  171.          scalefac[ch].s[0][2] = br->hgetbits(length0);
  172.          scalefac[ch].s[1][2] = br->hgetbits(length0);
  173.          scalefac[ch].s[2][2] = br->hgetbits(length0);
  174.          scalefac[ch].s[0][3] = br->hgetbits(length0);
  175.          scalefac[ch].s[1][3] = br->hgetbits(length0);
  176.          scalefac[ch].s[2][3] = br->hgetbits(length0);
  177.          scalefac[ch].s[0][4] = br->hgetbits(length0);
  178.          scalefac[ch].s[1][4] = br->hgetbits(length0);
  179.          scalefac[ch].s[2][4] = br->hgetbits(length0);
  180.          scalefac[ch].s[0][5] = br->hgetbits(length0);
  181.          scalefac[ch].s[1][5] = br->hgetbits(length0);
  182.          scalefac[ch].s[2][5] = br->hgetbits(length0);
  183.          scalefac[ch].s[0][6] = br->hgetbits(length1);
  184.          scalefac[ch].s[1][6] = br->hgetbits(length1);
  185.          scalefac[ch].s[2][6] = br->hgetbits(length1);
  186.          scalefac[ch].s[0][7] = br->hgetbits(length1);
  187.          scalefac[ch].s[1][7] = br->hgetbits(length1);
  188.          scalefac[ch].s[2][7] = br->hgetbits(length1);
  189.          scalefac[ch].s[0][8] = br->hgetbits(length1);
  190.          scalefac[ch].s[1][8] = br->hgetbits(length1);
  191.          scalefac[ch].s[2][8] = br->hgetbits(length1);
  192.          scalefac[ch].s[0][9] = br->hgetbits(length1);
  193.          scalefac[ch].s[1][9] = br->hgetbits(length1);
  194.          scalefac[ch].s[2][9] = br->hgetbits(length1);
  195.          scalefac[ch].s[0][10] = br->hgetbits(length1);
  196.          scalefac[ch].s[1][10] = br->hgetbits(length1);
  197.          scalefac[ch].s[2][10] = br->hgetbits(length1);
  198.          scalefac[ch].s[0][11] = br->hgetbits(length1);
  199.          scalefac[ch].s[1][11] = br->hgetbits(length1);
  200.          scalefac[ch].s[2][11] = br->hgetbits(length1);
  201.          scalefac[ch].s[0][12] = 0;
  202.             scalefac[ch].s[1][12] = 0;
  203.             scalefac[ch].s[2][12] = 0;
  204.  
  205.         }
  206.      }
  207.      else {   /* LONG types 0,1,3 */
  208.  
  209.         if ((si->ch[ch].scfsi[0] == 0) || (gr == 0)) {
  210.            scalefac[ch].l[0] = br->hgetbits(length0);
  211.            scalefac[ch].l[1] = br->hgetbits(length0);
  212.            scalefac[ch].l[2] = br->hgetbits(length0);
  213.            scalefac[ch].l[3] = br->hgetbits(length0);
  214.            scalefac[ch].l[4] = br->hgetbits(length0);
  215.            scalefac[ch].l[5] = br->hgetbits(length0);
  216.           }
  217.         if ((si->ch[ch].scfsi[1] == 0) || (gr == 0)) {
  218.            scalefac[ch].l[6] = br->hgetbits(length0);
  219.            scalefac[ch].l[7] = br->hgetbits(length0);
  220.            scalefac[ch].l[8] = br->hgetbits(length0);
  221.            scalefac[ch].l[9] = br->hgetbits(length0);
  222.            scalefac[ch].l[10] = br->hgetbits(length0);
  223.           }
  224.         if ((si->ch[ch].scfsi[2] == 0) || (gr == 0)) {
  225.            scalefac[ch].l[11] = br->hgetbits(length1);
  226.            scalefac[ch].l[12] = br->hgetbits(length1);
  227.            scalefac[ch].l[13] = br->hgetbits(length1);
  228.            scalefac[ch].l[14] = br->hgetbits(length1);
  229.            scalefac[ch].l[15] = br->hgetbits(length1);
  230.           }
  231.         if ((si->ch[ch].scfsi[3] == 0) || (gr == 0)) {
  232.            scalefac[ch].l[16] = br->hgetbits(length1);
  233.            scalefac[ch].l[17] = br->hgetbits(length1);
  234.            scalefac[ch].l[18] = br->hgetbits(length1);
  235.            scalefac[ch].l[19] = br->hgetbits(length1);
  236.            scalefac[ch].l[20] = br->hgetbits(length1);
  237.           }
  238.  
  239.         scalefac[ch].l[21] = 0;
  240.           scalefac[ch].l[22] = 0;
  241.      }
  242. }
  243.  
  244. struct  {
  245.     int32 l[23];
  246.     int32 s[14];} sfBandIndex[3] =
  247.     {{{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
  248.       {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
  249.      {{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
  250.       {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
  251.      {{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
  252.       {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}};
  253.  
  254. void LayerIII_Decoder::hufman_decode(int32 ch, int32 gr)
  255. {
  256.     int32 i, x, y;
  257.     int32 v, w;
  258.    int32 part2_3_end = part2_start + si->ch[ch].gr[gr].part2_3_length;
  259.    int32 num_bits;
  260.     int32 region1Start;
  261.     int32 region2Start;
  262.    int32 sf_index;
  263.    int32 ssindex, sbindex;
  264.      struct huffcodetab *h;
  265.  
  266.    static BOOL huffman_init = FALSE;
  267.  
  268.    if (!huffman_init) {
  269.         if (read_decoder_table(huffdec_path))
  270.           huffman_init = TRUE;
  271.       else
  272.           ExitThread(1L);
  273.    }
  274.  
  275.    /* Initialize output */
  276.    /* Eliminates need to zero out the rest */
  277.  
  278.    for (x=0;x<SBLIMIT;x++){
  279.        is[x][0]  = 0; is[x][1]  = 0; is[x][2]  = 0;
  280.          is[x][3]  = 0; is[x][4]  = 0; is[x][5]  = 0;
  281.        is[x][6]  = 0; is[x][7]  = 0; is[x][8]  = 0;
  282.        is[x][9]  = 0; is[x][10] = 0; is[x][11] = 0;
  283.        is[x][12] = 0; is[x][13] = 0; is[x][14] = 0;
  284.         is[x][15] = 0; is[x][16] = 0; is[x][17] = 0;
  285.    }
  286.  
  287.     /* Find region boundary for short block case. */
  288.  
  289.     if ( (si->ch[ch].gr[gr].window_switching_flag) &&
  290.           (si->ch[ch].gr[gr].block_type == 2) ) {
  291.  
  292.         /* Region2. */
  293.  
  294.         region1Start = 36;  /* sfb[9/3]*3=36 */
  295.         region2Start = 576; /* No Region2 for short block case. */
  296.     }
  297.  
  298.     else {          /* Find region boundary for long block case. */
  299.  
  300.        sf_index = header->sample_frequency();
  301.  
  302.         region1Start = sfBandIndex[sf_index].l[si->ch[ch].gr[gr].region0_count
  303.                                              + 1]; /* MI */
  304.         region2Start = sfBandIndex[sf_index].l[si->ch[ch].gr[gr].region0_count +
  305.                                            si->ch[ch].gr[gr].region1_count + 2]; /* MI */
  306.         }
  307.  
  308.    sbindex = 0; ssindex = 0;
  309.     /* Read bigvalues area. */
  310.     for (i=0; i<(si->ch[ch].gr[gr].big_values<<1); i+=2) {
  311.         if      (i<region1Start) h = &ht[si->ch[ch].gr[gr].table_select[0]];
  312.         else if (i<region2Start) h = &ht[si->ch[ch].gr[gr].table_select[1]];
  313.               else                h = &ht[si->ch[ch].gr[gr].table_select[2]];
  314.  
  315.         huffman_decoder(h, &x, &y, &v, &w, br);
  316.  
  317.       is[sbindex][ssindex]   = x;
  318.       is[sbindex][ssindex+1] = y;
  319.  
  320.       ssindex += 2;
  321.       if (ssindex >= SSLIMIT) {
  322.           ssindex = 0;
  323.          sbindex++;
  324.       }
  325.     }
  326.  
  327.     /* Read count1 area. */
  328.     h = &ht[(*si).ch[ch].gr[gr].count1table_select+32];
  329.    num_bits = br->hsstell();
  330.  
  331.     while ((num_bits < part2_3_end) && (sbindex < SBLIMIT)) {
  332.  
  333.         huffman_decoder(h, &x, &y, &v, &w, br);
  334.       is[sbindex][ssindex] = v;
  335.       is[sbindex][ssindex + 1] = w;
  336.  
  337.       ssindex += 2;
  338.       if (ssindex >= SSLIMIT) {
  339.           ssindex = 0;
  340.          sbindex++;
  341.       }
  342.  
  343.         if (sbindex < SBLIMIT) {
  344.             is[sbindex][ssindex]   = x;
  345.             is[sbindex][ssindex+1] = y;
  346.       }
  347.  
  348.       ssindex += 2;
  349.       if (ssindex >= SSLIMIT) {
  350.           ssindex = 0;
  351.          sbindex++;
  352.       }
  353.       num_bits = br->hsstell();
  354.    }
  355.  
  356.     if (num_bits > part2_3_end)
  357.         br->rewindNbits(num_bits - part2_3_end);
  358.  
  359.    num_bits = br->hsstell();
  360.  
  361.     /* Dismiss stuffing Bits */
  362.     if (num_bits < part2_3_end)
  363.        br->hgetbits(part2_3_end - num_bits);
  364.  
  365.     /* Zero out rest. */
  366. /*    for (; i<SSLIMIT*SBLIMIT; i++)
  367.         is[i/SSLIMIT][i%SSLIMIT] = 0; */
  368. }
  369.  
  370. int pretab[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};
  371.  
  372. real LayerIII_Decoder::two_pow2(int32 scale, int32 preflag,
  373.                                 int32 pretab_offset, int32 l)
  374. {
  375.     int32 index;
  376.     static real two_to_negative_half_pow[40];
  377.    static BOOL two_pow2_init = FALSE;
  378.  
  379.    if (!two_pow2_init) {
  380.        int32 i;
  381.  
  382.       for (i=0;i<40;i++)
  383.           two_to_negative_half_pow[i] = (real) pow(2.0, -0.5 * (double) i);
  384.  
  385.       two_pow2_init = TRUE;
  386.    }
  387.  
  388.    index = l;
  389.  
  390.    if (preflag)
  391.        index += pretab_offset;
  392.  
  393.    index = index << scale;
  394.  
  395.    return(two_to_negative_half_pow[index]);
  396. }
  397.  
  398. void LayerIII_Decoder::dequantize_sample(real xr[SBLIMIT][SSLIMIT],
  399.                                                      int32 ch, int32 gr)
  400. {
  401.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  402.  
  403.     int32 ss, sb, cb=0, sfreq=header->sample_frequency();
  404.     int32 next_cb_boundary, cb_begin, cb_width;
  405.    real temp;
  406.     int32 index=0, t_index;
  407.    int32 i;
  408.    static BOOL Dequant_init=FALSE;
  409.    static real TO_FOUR_THIRDS[1024];
  410.  
  411.    if (!Dequant_init) {
  412.  
  413.        for(i = 0; i<1024; i++)
  414.               TO_FOUR_THIRDS[i] = (real) pow( (double) i, 4.0/3.0);
  415.  
  416.       Dequant_init = TRUE;
  417.    }
  418.  
  419.     /* choose correct scalefactor band per block type, initalize boundary */
  420.  
  421.     if (gr_info->window_switching_flag && (gr_info->block_type == 2) )
  422.         if (gr_info->mixed_block_flag)
  423.             next_cb_boundary=sfBandIndex[sfreq].l[1];  /* LONG blocks: 0,1,3 */
  424.         else {
  425.          cb_width = sfBandIndex[sfreq].s[1];
  426.            next_cb_boundary= (cb_width << 2) - cb_width;
  427.             cb_begin = 0;
  428.         }
  429.     else
  430.         next_cb_boundary=sfBandIndex[sfreq].l[1];  /* LONG blocks: 0,1,3 */
  431.  
  432.    /* Compute overall (global) scaling. */
  433.  
  434.     temp = (real) pow( 2.0 , (0.25 * (gr_info->global_gain - 210.0)));
  435.  
  436.    for (sb=0; sb < SBLIMIT; sb++)
  437.        for(ss=0; ss < SSLIMIT; ss+=2) {
  438.             xr[sb][ss]   =  temp * TO_FOUR_THIRDS[abs(is[sb][ss])];
  439.          xr[sb][ss+1] =  temp * TO_FOUR_THIRDS[abs(is[sb][ss+1])];
  440.             if (is[sb][ss]<0)   xr[sb][ss]   = -xr[sb][ss];
  441.          if (is[sb][ss+1]<0) xr[sb][ss+1] = -xr[sb][ss+1];
  442.       }
  443.  
  444.     /* apply formula per block type */
  445.  
  446.     for (sb=0 ; sb < SBLIMIT ; sb++) {
  447.  
  448.         for (ss=0 ; ss < SSLIMIT ; ss++) {
  449.  
  450.             if (index == next_cb_boundary)  { /* Adjust critical band boundary */
  451.                 if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  452.                     if (gr_info->mixed_block_flag)  {
  453.  
  454.                         if (index == sfBandIndex[sfreq].l[8])  {
  455.                      next_cb_boundary = sfBandIndex[sfreq].s[4];
  456.                      next_cb_boundary = (next_cb_boundary << 2) -
  457.                                             next_cb_boundary;
  458.                             cb = 3;
  459.                            cb_width = sfBandIndex[sfreq].s[4] -
  460.                                    sfBandIndex[sfreq].s[3];
  461.  
  462.                           cb_begin = sfBandIndex[sfreq].s[3];
  463.                      cb_begin = (cb_begin << 2) - cb_begin;
  464.                         }
  465.  
  466.                         else if (index < sfBandIndex[sfreq].l[8])
  467.                             next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  468.                         else {
  469.                       next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
  470.                      next_cb_boundary = (next_cb_boundary << 2) -
  471.                                              next_cb_boundary;
  472.  
  473.                      cb_begin = sfBandIndex[sfreq].s[cb];
  474.                             cb_width = sfBandIndex[sfreq].s[cb+1] -
  475.                                 cb_begin;
  476.                      cb_begin = (cb_begin << 2) - cb_begin;
  477.                         }
  478.                     }
  479.                     else  {
  480.                   next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
  481.                   next_cb_boundary = (next_cb_boundary << 2) -
  482.                                       next_cb_boundary;
  483.  
  484.                   cb_begin = sfBandIndex[sfreq].s[cb];
  485.                         cb_width = sfBandIndex[sfreq].s[cb+1] -
  486.                                cb_begin;
  487.                   cb_begin = (cb_begin << 2) - cb_begin;
  488.                     }
  489.                 }
  490.                 else /* long blocks */
  491.                     next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  492.             }
  493.  
  494.             /* Do long/short dependent scaling operations. */
  495.  
  496.             if (gr_info->window_switching_flag &&
  497.                  (((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 0)) ||
  498.                   ((gr_info->block_type == 2) && gr_info->mixed_block_flag && (sb >= 2)) ))
  499.          {
  500.  
  501.                 t_index = (index - cb_begin) / cb_width;
  502.             xr[sb][ss] *= pow(2.0, ((-2.0 * gr_info->subblock_gain[t_index])
  503.                                     -(0.5 * (1.0 + gr_info->scalefac_scale)
  504.                                       * scalefac[ch].s[t_index][cb])));
  505.             }
  506.             else {   /* LONG block types 0,1,3 & 1st 2 subbands of switched blocks */
  507. /*                xr[sb][ss] *= pow(2.0, -0.5 * (1.0+gr_info->scalefac_scale)
  508.                                                      * (scalefac[ch].l[cb]
  509.                                                      + gr_info->preflag * pretab[cb])); */
  510.                 xr[sb][ss] *= two_pow2(gr_info->scalefac_scale, gr_info->preflag,
  511.                                    pretab[cb], scalefac[ch].l[cb]);
  512.             }
  513.          index++;
  514.         }
  515.    }
  516.  
  517. }
  518.  
  519. void LayerIII_Decoder::reorder (real xr[SBLIMIT][SSLIMIT], int32 ch, int32 gr)
  520. {
  521.  
  522.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  523.     int32 sfreq=header->sample_frequency();
  524.     int32 sfb, sfb_start, sfb_lines;
  525.     int32 sb, ss, freq, src_line, des_line;
  526.  
  527.     if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  528.  
  529.         for(sb=0;sb<SBLIMIT;sb++)
  530.           re_hybridOut[sb][0]  = re_hybridOut[sb][1]  = re_hybridOut[sb][2]  =
  531.          re_hybridOut[sb][3]  = re_hybridOut[sb][4]  = re_hybridOut[sb][5]  =
  532.          re_hybridOut[sb][6]  = re_hybridOut[sb][7]  = re_hybridOut[sb][8]  =
  533.          re_hybridOut[sb][9]  = re_hybridOut[sb][10] = re_hybridOut[sb][11] =
  534.            re_hybridOut[sb][12] = re_hybridOut[sb][13] = re_hybridOut[sb][14] =
  535.          re_hybridOut[sb][15] = re_hybridOut[sb][16] = re_hybridOut[sb][17] =
  536.          0.0f;
  537.  
  538.         if (gr_info->mixed_block_flag) {
  539.             /* NO REORDER FOR LOW 2 SUBBANDS */
  540.                for (ss=0 ; ss < SSLIMIT ; ss+=3) {
  541.                     re_hybridOut[0][ss]   = xr[0][ss];
  542.                re_hybridOut[0][ss+1] = xr[0][ss+1];
  543.                re_hybridOut[0][ss+2] = xr[0][ss+2];
  544.             }
  545.  
  546.             for (ss=0; ss < SSLIMIT ; ss+=3) {
  547.                 re_hybridOut[1][ss]   = xr[1][ss];
  548.                re_hybridOut[1][ss+1] = xr[1][ss+1];
  549.                re_hybridOut[1][ss+2] = xr[1][ss+2];
  550.             }
  551.  
  552.             /* REORDERING FOR REST SWITCHED SHORT */
  553.                 for(sfb=3,sfb_start=sfBandIndex[sfreq].s[3],
  554.                        sfb_lines=sfBandIndex[sfreq].s[4] - sfb_start;
  555.                        sfb < 13; sfb++,sfb_start=sfBandIndex[sfreq].s[sfb],
  556.                     (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  557.             {
  558.                        int32 sfb_start3 = (sfb_start << 2) - sfb_start;
  559.  
  560.                         for(freq=0;freq<sfb_lines;freq++) {
  561.                      int32 freq3 = (freq << 2) - freq;
  562.  
  563.                             src_line = sfb_start3 + freq;
  564.                             des_line = sfb_start3 + freq3;
  565.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  566.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  567.                             src_line += sfb_lines;
  568.                             des_line++;
  569.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  570.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  571.                             src_line += sfb_lines;
  572.                             des_line++;
  573.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  574.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  575.                        }
  576.             }
  577.         }
  578.         else {  /* pure short */
  579.             for(sfb=0,sfb_start=0,sfb_lines=sfBandIndex[sfreq].s[1];
  580.                 sfb < 13; sfb++,sfb_start=sfBandIndex[sfreq].s[sfb],
  581.                 (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  582.             {
  583.                        int32 sfb_start3 = (sfb_start << 2) - sfb_start;
  584.  
  585.                         for(freq=0;freq<sfb_lines;freq++) {
  586.                      int32 freq3 = (freq << 2) - freq;
  587.  
  588.                             src_line = sfb_start3 + freq;
  589.                             des_line = sfb_start3 + freq3;
  590.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  591.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  592.                             src_line += sfb_lines;
  593.                             des_line++;
  594.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  595.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  596.                             src_line += sfb_lines;
  597.                             des_line++;
  598.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  599.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  600.                        }
  601.             }
  602.         }
  603.     }
  604.     else {   /*long blocks */
  605.         for (sb=0 ; sb < SBLIMIT ; sb++)
  606.          for (ss = 0; ss < SSLIMIT; ss+=3) {
  607.              re_hybridOut[sb][ss]   = xr[sb][ss];
  608.             re_hybridOut[sb][ss+1] = xr[sb][ss+1];
  609.             re_hybridOut[sb][ss+2] = xr[sb][ss+2];
  610.          }
  611.     }
  612. }
  613.  
  614. #define PI   3.141593
  615. #define PI12 0.2617994
  616. #define PI18 0.17453293
  617. #define PI24 0.1308997
  618. #define PI36 0.08726646
  619. #define PI72 0.04363323
  620.  
  621. real TAN12[16]={0.0, 0.26794919, 0.57735027, 1.0,
  622.                 1.73205081, 3.73205081, 9.9999999e10 /*unbounded*/, -3.73205081,
  623.                 -1.73205081, -1.0, -0.57735027, -0.26794919,
  624.                 0.0, 0.26794919, 0.57735027, 1.0};
  625.  
  626. void LayerIII_Decoder::stereo(int32 gr)
  627. {
  628.     gr_info_s *gr_info = &(si->ch[0].gr[gr]);
  629.     int32 sfreq = header->sample_frequency();
  630.    int32 mode_ext = header->mode_extension();
  631.  
  632.     int32 ms_stereo = (header->mode() == joint_stereo) && (mode_ext & 0x2);
  633.     int32 i_stereo  = (header->mode() == joint_stereo) && (mode_ext & 0x1);
  634.     int32 sfb;
  635.     int32 i,j,sb,ss,is_pos[576];
  636.    int32 lines, temp, temp2;
  637.     real is_ratio[576];
  638.  
  639.     if  (channels == 1) { /* mono , bypass xr[0][][] to lr[0][][]*/
  640.  
  641.         for(sb=0;sb<SBLIMIT;sb++)
  642.             for(ss=0;ss<SSLIMIT;ss+=3) {
  643.                 lr[0][sb][ss]   = ro[0][sb][ss];
  644.             lr[0][sb][ss+1] = ro[0][sb][ss+1];
  645.                 lr[0][sb][ss+2] = ro[0][sb][ss+2];
  646.          }
  647.  
  648.    } else {
  649.  
  650.      /* initialization */
  651.    for (i=0; i<576; i+=8)
  652.       is_pos[i] = is_pos[i+1] = is_pos[i+2] = is_pos[i+3] =
  653.       is_pos[i+4] = is_pos[i+5] = is_pos[i+6] = is_pos[i+7] = 7;
  654.  
  655.     if (i_stereo)
  656.     {  if (gr_info->window_switching_flag && (gr_info->block_type == 2))
  657.         {  if( gr_info->mixed_block_flag )
  658.             {  int32 max_sfb = 0;
  659.  
  660.                 for (j=0; j<3; j++)
  661.                 {  int32 sfbcnt;
  662.                     sfbcnt = 2;
  663.                     for( sfb=12; sfb >=3; sfb-- )
  664.                     {
  665.                    i = sfBandIndex[sfreq].s[sfb];
  666.                         lines = sfBandIndex[sfreq].s[sfb+1] - i;
  667.                   i = (i << 2) - i + (j+1) * lines - 1;
  668.                         while ( lines > 0 )
  669.                         {  if ( ro[1][i/SSLIMIT][i%SSLIMIT] != 0.0f )
  670.                             {  sfbcnt = sfb;
  671.                                 sfb = -10;
  672.                                 lines = -10;
  673.                             }
  674.                             lines--;
  675.                             i--;
  676.                         }
  677.                     }
  678.                     sfb = sfbcnt + 1;
  679.  
  680.                     if (sfb > max_sfb)
  681.                         max_sfb = sfb;
  682.  
  683.                     while(sfb < 12)
  684.                     {    temp = sfBandIndex[sfreq].s[sfb];
  685.                    sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
  686.                   i    = (temp << 2) - temp + j * sb;
  687.  
  688.                         for ( ; sb > 0; sb--)
  689.                         {  is_pos[i] = scalefac[1].s[j][sfb];
  690.                             if (is_pos[i] != 7)
  691.                         is_ratio[i] = TAN12[is_pos[i]];
  692.  
  693.                             i++;
  694.                         }
  695.                         sfb++;
  696.                     }
  697.                     sfb = sfBandIndex[sfreq].s[10];
  698.                sb  = sfBandIndex[sfreq].s[11] - sfb;
  699.                sfb = (sfb << 2) - sfb + j * sb;
  700.                temp  = sfBandIndex[sfreq].s[11];
  701.                sb = sfBandIndex[sfreq].s[12] - temp;
  702.                i = (temp << 2) - temp + j * sb;
  703.  
  704.                     for ( ; sb > 0; sb-- )
  705.                     {  is_pos[i] = is_pos[sfb];
  706.                         is_ratio[i] = is_ratio[sfb];
  707.                         i++;
  708.                     }
  709.                  }
  710.                  if (max_sfb <= 3)
  711.                  {  i = 2;
  712.                      ss = 17;
  713.                      sb = -1;
  714.                      while (i >= 0)
  715.                      {  if (ro[1][i][ss] != 0.0f)
  716.                          {
  717.                         sb = (i<<4) + (i<<1) + ss;
  718.                              i = -1;
  719.                          } else
  720.                          {  ss--;
  721.                              if (ss < 0)
  722.                              {  i--;
  723.                                  ss = 17;
  724.                              }
  725.                          }
  726.                      }
  727.                      i = 0;
  728.                      while ( sfBandIndex[sfreq].l[i] <= sb )
  729.                          i++;
  730.                      sfb = i;
  731.                      i = sfBandIndex[sfreq].l[i];
  732.                      for (; sfb<8; sfb++)
  733.                      {  sb = sfBandIndex[sfreq].l[sfb+1]-sfBandIndex[sfreq].l[sfb];
  734.                          for (; sb>0; sb--)
  735.                          {  is_pos[i] = scalefac[1].l[sfb];
  736.                              if (is_pos[i] != 7)
  737.                            is_ratio[i] = TAN12[is_pos[i]];
  738.  
  739.                              i++;
  740.                          }
  741.                      }
  742.                 }
  743.             } else
  744.             {  for (j=0; j<3; j++)
  745.                 {  int32 sfbcnt;
  746.                     sfbcnt = -1;
  747.                     for( sfb=12; sfb >=0; sfb-- )
  748.                     {
  749.                         temp = sfBandIndex[sfreq].s[sfb];
  750.                   lines = sfBandIndex[sfreq].s[sfb+1] - temp;
  751.                   i = (temp << 2) - temp + (j+1) * lines - 1;
  752.  
  753.                         while ( lines > 0 )
  754.                         {  if (ro[1][i/SSLIMIT][i%SSLIMIT] != 0.0f)
  755.                             {  sfbcnt = sfb;
  756.                                 sfb = -10;
  757.                                 lines = -10;
  758.                             }
  759.                             lines--;
  760.                             i--;
  761.                         }
  762.                     }
  763.                     sfb = sfbcnt + 1;
  764.                     while( sfb<12 )
  765.                     {
  766.                         temp = sfBandIndex[sfreq].s[sfb];
  767.                   sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
  768.                   i    = (temp << 2) - temp + j * sb;
  769.                         for ( ; sb > 0; sb--)
  770.                         {  is_pos[i] = scalefac[1].s[j][sfb];
  771.                             if (is_pos[i] != 7)
  772.                               is_ratio[i] = TAN12[is_pos[i]];
  773.  
  774.                             i++;
  775.                         }
  776.                         sfb++;
  777.                     }
  778.  
  779.                     temp = sfBandIndex[sfreq].s[10];
  780.                temp2= sfBandIndex[sfreq].s[11];
  781.                sb   = temp2 - temp;
  782.                sfb  = (temp << 2) - temp + j * sb;
  783.                sb   = sfBandIndex[sfreq].s[12] - temp2;
  784.                i    = (temp2 << 2) - temp2 + j * sb;
  785.  
  786.                     for (; sb>0; sb--)
  787.                     {  is_pos[i] = is_pos[sfb];
  788.                         is_ratio[i] = is_ratio[sfb];
  789.                         i++;
  790.                     }
  791.                 }
  792.             }
  793.         } else // ms-stereo
  794.         {  i = 31;
  795.             ss = 17;
  796.             sb = 0;
  797.             while (i >= 0)
  798.             {  if (ro[1][i][ss] != 0.0f)
  799.                 {
  800.                 sb = (i<<4) + (i<<1) + ss;
  801.                     i = -1;
  802.                 } else
  803.                 {  ss--;
  804.                     if ( ss < 0 )
  805.                     {  i--;
  806.                         ss = 17;
  807.                     }
  808.                 }
  809.             }
  810.             i = 0;
  811.             while ( sfBandIndex[sfreq].l[i] <= sb )
  812.                 i++;
  813.             sfb = i;
  814.             i = sfBandIndex[sfreq].l[i];
  815.             for ( ; sfb<21; sfb++ )
  816.             {  sb = sfBandIndex[sfreq].l[sfb+1] - sfBandIndex[sfreq].l[sfb];
  817.                 for ( ; sb > 0; sb--)
  818.                 {  is_pos[i] = scalefac[1].l[sfb];
  819.                     if ( is_pos[i] != 7 )
  820.                    is_ratio[i] = TAN12[is_pos[i]];
  821.  
  822.                     i++;
  823.                 }
  824.             }
  825.             sfb = sfBandIndex[sfreq].l[20];
  826.             for ( sb = 576 - sfBandIndex[sfreq].l[21]; sb > 0; sb-- )
  827.             {  is_pos[i] = is_pos[sfb];
  828.                 is_ratio[i] = is_ratio[sfb];
  829.                 i++;
  830.             }
  831.         }
  832.     }
  833.  
  834.        i = 0;
  835.         for(sb=0;sb<SBLIMIT;sb++)
  836.             for(ss=0;ss<SSLIMIT;ss++) {
  837.                 if ( is_pos[i] == 7 ) {
  838.                     if (ms_stereo) {
  839.                         lr[0][sb][ss] = (ro[0][sb][ss]+ro[1][sb][ss])* 0.7071068f;
  840.                         lr[1][sb][ss] = (ro[0][sb][ss]-ro[1][sb][ss])* 0.7071068f;
  841.                     }
  842.                     else {
  843.                         lr[0][sb][ss] = ro[0][sb][ss];
  844.                         lr[1][sb][ss] = ro[1][sb][ss];
  845.                     }
  846.                 }
  847.                 else if (i_stereo ) {
  848.                lr[1][sb][ss] = ro[0][sb][ss] / (real) (1 + is_ratio[i]);
  849.                      lr[0][sb][ss] = lr[1][sb][ss] * is_ratio[i];
  850.                 }
  851. /*                else {
  852.                     printf("Error in stereo processing\n");
  853.                 } */
  854.             i++;
  855.             }
  856.  
  857.     } // channels == 2
  858. }
  859.  
  860. real Ci[8]={-0.6f,-0.535f,-0.33f,-0.185f,-0.095f,-0.041f,-0.0142f,-0.0037f};
  861.  
  862. void LayerIII_Decoder::antialias(int32 ch, int32 gr)
  863. {
  864.    gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  865.  
  866.     real          bu,bd;  /* upper and lower butterfly inputs */
  867.     int32         ss,sb;
  868.      static real   ca[8],cs[8];
  869.      static BOOL   antialias_init = FALSE;
  870.  
  871.     if (!antialias_init) {
  872.         int32 i;
  873.         real    sq;
  874.         for (i=0;i<8;i++) {
  875.             sq=sqrt(1.0f+Ci[i]*Ci[i]);
  876.             cs[i] = 1.0f/sq;
  877.          ca[i] = Ci[i] * cs[i];
  878.         }
  879.         antialias_init = TRUE;
  880.     }
  881.  
  882.     /* 31 alias-reduction operations between each pair of sub-bands */
  883.     /* with 8 butterflies between each pair                         */
  884.  
  885.     if  (gr_info->window_switching_flag && (gr_info->block_type == 2) &&
  886.          !gr_info->mixed_block_flag ) {
  887.  
  888.        for(sb=0;sb<SBLIMIT;sb++) {
  889.             hybridIn[sb][0] = re_hybridOut[sb][0];
  890.             hybridIn[sb][1] = re_hybridOut[sb][1];
  891.             hybridIn[sb][2] = re_hybridOut[sb][2];
  892.             hybridIn[sb][3] = re_hybridOut[sb][3];
  893.             hybridIn[sb][4] = re_hybridOut[sb][4];
  894.             hybridIn[sb][5] = re_hybridOut[sb][5];
  895.             hybridIn[sb][6] = re_hybridOut[sb][6];
  896.             hybridIn[sb][7] = re_hybridOut[sb][7];
  897.             hybridIn[sb][8] = re_hybridOut[sb][8];
  898.             hybridIn[sb][9] = re_hybridOut[sb][9];
  899.             hybridIn[sb][10]= re_hybridOut[sb][10];
  900.             hybridIn[sb][11]= re_hybridOut[sb][11];
  901.             hybridIn[sb][12]= re_hybridOut[sb][12];
  902.             hybridIn[sb][13]= re_hybridOut[sb][13];
  903.             hybridIn[sb][14]= re_hybridOut[sb][14];
  904.             hybridIn[sb][15]= re_hybridOut[sb][15];
  905.            hybridIn[sb][16]= re_hybridOut[sb][16];
  906.             hybridIn[sb][17]= re_hybridOut[sb][17];
  907.       }
  908.  
  909.     } else if (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  910.       (gr_info->block_type == 2)) {
  911.  
  912.         hybridIn[0][0] = re_hybridOut[0][0];
  913.         hybridIn[0][1] = re_hybridOut[0][1];
  914.         hybridIn[0][2] = re_hybridOut[0][2];
  915.         hybridIn[0][3] = re_hybridOut[0][3];
  916.       hybridIn[0][4] = re_hybridOut[0][4];
  917.         hybridIn[0][5] = re_hybridOut[0][5];
  918.         hybridIn[0][6] = re_hybridOut[0][6];
  919.         hybridIn[0][7] = re_hybridOut[0][7];
  920.         hybridIn[0][8] = re_hybridOut[0][8];
  921.         hybridIn[0][9] = re_hybridOut[0][9];
  922.  
  923.       for(ss=0;ss<8;ss++) {
  924.             bu = re_hybridOut[0][17-ss];
  925.             bd = re_hybridOut[1][ss];
  926.             hybridIn[0][17-ss] = (bu * cs[ss]) - (bd * ca[ss]);
  927.             hybridIn[1][ss]    = (bd * cs[ss]) + (bu * ca[ss]);
  928.       }
  929.  
  930.       hybridIn[1][8]  = re_hybridOut[1][8];
  931.       hybridIn[1][9]  = re_hybridOut[1][9];
  932.       hybridIn[1][10] = re_hybridOut[1][10];
  933.       hybridIn[1][11] = re_hybridOut[1][11];
  934.       hybridIn[1][12] = re_hybridOut[1][12];
  935.       hybridIn[1][13] = re_hybridOut[1][13];
  936.       hybridIn[1][14] = re_hybridOut[1][14];
  937.       hybridIn[1][15] = re_hybridOut[1][15];
  938.       hybridIn[1][16] = re_hybridOut[1][16];
  939.       hybridIn[1][17] = re_hybridOut[1][17];
  940.  
  941.         for(sb=2;sb<SBLIMIT;sb++) {
  942.  
  943.             hybridIn[sb][0] = re_hybridOut[sb][0];
  944.             hybridIn[sb][1] = re_hybridOut[sb][1];
  945.             hybridIn[sb][2] = re_hybridOut[sb][2];
  946.             hybridIn[sb][3] = re_hybridOut[sb][3];
  947.             hybridIn[sb][4] = re_hybridOut[sb][4];
  948.             hybridIn[sb][5] = re_hybridOut[sb][5];
  949.             hybridIn[sb][6] = re_hybridOut[sb][6];
  950.             hybridIn[sb][7] = re_hybridOut[sb][7];
  951.             hybridIn[sb][8] = re_hybridOut[sb][8];
  952.             hybridIn[sb][9] = re_hybridOut[sb][9];
  953.             hybridIn[sb][10]= re_hybridOut[sb][10];
  954.             hybridIn[sb][11]= re_hybridOut[sb][11];
  955.             hybridIn[sb][12]= re_hybridOut[sb][12];
  956.             hybridIn[sb][13]= re_hybridOut[sb][13];
  957.             hybridIn[sb][14]= re_hybridOut[sb][14];
  958.             hybridIn[sb][15]= re_hybridOut[sb][15];
  959.             hybridIn[sb][16]= re_hybridOut[sb][16];
  960.             hybridIn[sb][17]= re_hybridOut[sb][17];
  961.       }
  962.  
  963.     } else {
  964.  
  965.       hybridIn[0][0] = re_hybridOut[0][0];
  966.       hybridIn[0][1] = re_hybridOut[0][1];
  967.       hybridIn[0][2] = re_hybridOut[0][2];
  968.       hybridIn[0][3] = re_hybridOut[0][3];
  969.       hybridIn[0][4] = re_hybridOut[0][4];
  970.       hybridIn[0][5] = re_hybridOut[0][5];
  971.       hybridIn[0][6] = re_hybridOut[0][6];
  972.       hybridIn[0][7] = re_hybridOut[0][7];
  973.  
  974.         for(sb=0;sb<31;sb++) {
  975.             for(ss=0;ss<8;ss++) {
  976.                 bu = re_hybridOut[sb][17-ss];
  977.                 bd = re_hybridOut[sb+1][ss];
  978.                 hybridIn[sb][17-ss]   = (bu * cs[ss]) - (bd * ca[ss]);
  979.                 hybridIn[sb+1][ss]    = (bd * cs[ss]) + (bu * ca[ss]);
  980.             }
  981.  
  982.          hybridIn[sb][8]   = re_hybridOut[sb][8];
  983.          hybridIn[sb][9]   = re_hybridOut[sb][9];
  984.       }
  985.       hybridIn[31][8]  = re_hybridOut[31][8];
  986.       hybridIn[31][9]  = re_hybridOut[31][9];
  987.       hybridIn[31][10] = re_hybridOut[31][10];
  988.       hybridIn[31][11] = re_hybridOut[31][11];
  989.       hybridIn[31][12] = re_hybridOut[31][12];
  990.       hybridIn[31][13] = re_hybridOut[31][13];
  991.       hybridIn[31][14] = re_hybridOut[31][14];
  992.       hybridIn[31][15] = re_hybridOut[31][15];
  993.       hybridIn[31][16] = re_hybridOut[31][16];
  994.       hybridIn[31][17] = re_hybridOut[31][17];
  995.    }
  996. }
  997.  
  998. void LayerIII_Decoder::inv_mdct(real *in, real *out, int32 block_type)
  999. {
  1000. /*
  1001. This uses Byeong Gi Lee's Fast Cosine Transform algorithm, but the
  1002. 9 point IDCT needs to be reduced further. Unfortunately, I don't
  1003. know how to do that, because 9 is not an even number. - Jeff.*/
  1004.  
  1005. /*------------------------------------------------------------------*/
  1006. /*                                                                  */
  1007. /*    Function: Calculation of the inverse MDCT                     */
  1008. /*    In the case of short blocks the 3 output vectors are already  */
  1009. /*    overlapped and added in this modul.                           */
  1010. /*                                                                  */
  1011. /*    New layer3                                                    */
  1012. /*                                                                  */
  1013. /*------------------------------------------------------------------*/
  1014.  
  1015. int32   i, six_i, p;
  1016. int32   odd_i, two_odd_i, four_odd_i, eight_odd_i;
  1017. real    tmp[18], save, sum;
  1018. real       pp1, pp2;
  1019. static  BOOL MDCT_init = FALSE;
  1020. static  real  win[4][36];
  1021. static  real COS18[138];
  1022.  
  1023.      if(!MDCT_init){
  1024.  
  1025.      /* type 0 */
  1026.         for(i=0;i<36;i++)
  1027.             win[0][i] = (real) sin( PI36 *(i+0.5) );
  1028.  
  1029.      /* type 1*/
  1030.         for(i=0;i<18;i++)
  1031.             win[1][i] = (real) sin( PI36 *(i+0.5) );
  1032.         for(i=18;i<24;i++)
  1033.             win[1][i] = 1.0f;
  1034.         for(i=24;i<30;i++)
  1035.             win[1][i] = (real) sin( PI12 *(i+0.5-18) );
  1036.         for(i=30;i<36;i++)
  1037.             win[1][i] = 0.0f;
  1038.  
  1039.      /* type 2 (not needed anymore) */
  1040. /*        for(i=0;i<12;i++)
  1041.             win[2][i] = (real) sin( PI12*(i+0.5) ) ;
  1042.         for(i=12;i<36;i++)
  1043.             win[2][i] = 0.0f; */
  1044.  
  1045.      /* type 3*/
  1046.         for(i=0;i<6;i++)
  1047.             win[3][i] = 0.0f;
  1048.         for(i=6;i<12;i++)
  1049.             win[3][i] = (real) sin(PI12 * (i+ 0.5 - 6.0));
  1050.         for(i=12;i<18;i++)
  1051.             win[3][i] =1.0f;
  1052.         for(i=18;i<36;i++)
  1053.             win[3][i] = (real) sin(PI36 * (i + 0.5));
  1054.  
  1055.        for(i=0;i<138;i++)
  1056.           COS18[i] = (real) cos(PI18 * i);
  1057.  
  1058.         MDCT_init = TRUE;
  1059.      }
  1060.  
  1061.      if(block_type == 2){
  1062.  
  1063.        for(p=0;p<36;p+=9) {
  1064.            out[p]   = out[p+1] = out[p+2] = out[p+3] =
  1065.           out[p+4] = out[p+5] = out[p+6] = out[p+7] =
  1066.           out[p+8] = 0.0f;
  1067.        }
  1068.  
  1069.        six_i = 0;
  1070.        for(i=0;i<3;i++)
  1071.        {
  1072.  
  1073.       // 12 point IMDCT
  1074.  
  1075.       // Begin 12 point IDCT
  1076.  
  1077.        // Input aliasing for 12 pt IDCT
  1078.        in[15+i] += in[12+i]; in[12+i] += in[9+i]; in[9+i]  +=  in[6+i];
  1079.        in[6+i]  += in[3+i];  in[3+i]  += in[0+i];
  1080.  
  1081.        // Input aliasing on odd indices (for 6 point IDCT)
  1082.        in[15+i] += in[9+i];  in[9+i]  += in[3+i];
  1083.  
  1084.        // 3 point IDCT on even indices
  1085.  
  1086.         pp2 = in[12+i] * 0.500000000f;
  1087.        pp1 = in[ 6+i] * 0.866025403f;
  1088.        sum = in[0+i] + pp2;
  1089.        tmp[1] = in[0+i] - in[12+i];
  1090.        tmp[0] = sum + pp1;
  1091.        tmp[2] = sum - pp1;
  1092.  
  1093.       // End 3 point IDCT on even indices
  1094.  
  1095.        // 3 point IDCT on odd indices (for 6 point IDCT)
  1096.  
  1097.         pp2 = in[15+i] * 0.500000000f;
  1098.        pp1 = in[9+i]  * 0.866025403f;
  1099.        sum = in[3+i] + pp2;
  1100.        tmp[4] = in[3+i] - in[15+i];
  1101.        tmp[5] = sum + pp1;
  1102.        tmp[3] = sum - pp1;
  1103.  
  1104.       // End 3 point IDCT on odd indices
  1105.  
  1106.        // Twiddle factors on odd indices (for 6 point IDCT)
  1107.  
  1108.        tmp[3] *= 1.931851653f;
  1109.        tmp[4] *= 0.707106781f;
  1110.        tmp[5] *= 0.517638090f;
  1111.  
  1112.        // Output butterflies on 2 3 point IDCT's (for 6 point IDCT)
  1113.  
  1114.        save = tmp[0];
  1115.        tmp[0] += tmp[5];
  1116.        tmp[5] = save - tmp[5];
  1117.        save = tmp[1];
  1118.        tmp[1] += tmp[4];
  1119.        tmp[4] = save - tmp[4];
  1120.        save = tmp[2];
  1121.        tmp[2] += tmp[3];
  1122.        tmp[3] = save - tmp[3];
  1123.  
  1124.        // End 6 point IDCT
  1125.  
  1126.        // Twiddle factors on indices (for 12 point IDCT)
  1127.  
  1128.        tmp[0]  *=  0.504314480f;
  1129.        tmp[1]  *=  0.541196100f;
  1130.        tmp[2]  *=  0.630236207f;
  1131.        tmp[3]  *=  0.821339815f;
  1132.        tmp[4]  *=  1.306562965f;
  1133.        tmp[5]  *=  3.830648788f;
  1134.  
  1135.       // End 12 point IDCT
  1136.  
  1137.        // Shift to 12 point modified IDCT, multiply by window type 2
  1138.        tmp[8]  = -tmp[0] * 0.793353340f;
  1139.        tmp[9]  = -tmp[0] * 0.608761429f;
  1140.        tmp[7]  = -tmp[1] * 0.923879532f;
  1141.        tmp[10] = -tmp[1] * 0.382683432f;
  1142.        tmp[6]  = -tmp[2] * 0.991444861f;
  1143.        tmp[11] = -tmp[2] * 0.130526192f;
  1144.  
  1145.        tmp[0]  =  tmp[3];
  1146.        tmp[1]  =  tmp[4] * 0.382683432f;
  1147.        tmp[2]  =  tmp[5] * 0.608761429f;
  1148.  
  1149.        tmp[3]  = -tmp[5] * 0.793353340f;
  1150.        tmp[4]  = -tmp[4] * 0.923879532f;
  1151.        tmp[5]  = -tmp[0] * 0.991444861f;
  1152.  
  1153.        tmp[0] *= 0.130526192f;
  1154.  
  1155.        out[six_i + 6]  += tmp[0];
  1156.         out[six_i + 7]  += tmp[1];
  1157.        out[six_i + 8]  += tmp[2];
  1158.         out[six_i + 9]  += tmp[3];
  1159.        out[six_i + 10] += tmp[4];
  1160.         out[six_i + 11] += tmp[5];
  1161.        out[six_i + 12] += tmp[6];
  1162.         out[six_i + 13] += tmp[7];
  1163.        out[six_i + 14] += tmp[8];
  1164.         out[six_i + 15] += tmp[9];
  1165.        out[six_i + 16] += tmp[10];
  1166.         out[six_i + 17] += tmp[11];
  1167.  
  1168.        six_i += 6;
  1169.        }
  1170.  
  1171.      } else {
  1172.  
  1173.    // 36 point IDCT
  1174.  
  1175.    // input aliasing for 36 point IDCT
  1176.    in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14]; in[14]+=in[13];
  1177.    in[13]+=in[12]; in[12]+=in[11]; in[11]+=in[10]; in[10]+=in[9];
  1178.    in[9] +=in[8];  in[8] +=in[7];  in[7] +=in[6];  in[6] +=in[5];
  1179.    in[5] +=in[4];  in[4] +=in[3];  in[3] +=in[2];  in[2] +=in[1];
  1180.    in[1] +=in[0];
  1181.  
  1182.    // 18 point IDCT for odd indices
  1183.  
  1184.    // input aliasing for 18 point IDCT
  1185.    in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9];
  1186.    in[9] +=in[7];  in[7] +=in[5];  in[5] +=in[3];  in[3] +=in[1];
  1187.  
  1188.    // 9 point IDCT on even indices
  1189. /*   for(i=0; i<9; i++) {
  1190.        sum = 0.0;
  1191.  
  1192.       for(j=0;j<18;j+=2)
  1193.           sum += in[j] * cos(PI36 * (2*i + 1) * j);
  1194.  
  1195.       tmp[i] = sum;
  1196.    } */
  1197.  
  1198.    for(i=0; i<9; i++) {
  1199.  
  1200.        odd_i = (i << 1) + 1;
  1201.  
  1202.       sum = in[0];
  1203.  
  1204.       two_odd_i = odd_i << 1;
  1205.       four_odd_i = odd_i << 2;
  1206.  
  1207.       sum += in[2]  * COS18[odd_i];
  1208.       sum += in[4]  * COS18[two_odd_i];
  1209.  
  1210.       eight_odd_i = two_odd_i << 2;
  1211.  
  1212.       sum += in[6]  * COS18[four_odd_i - odd_i];
  1213.       sum += in[8]  * COS18[four_odd_i];
  1214.       sum += in[10] * COS18[four_odd_i + odd_i];
  1215.       sum += in[12] * COS18[four_odd_i + two_odd_i];
  1216.       sum += in[14] * COS18[eight_odd_i - odd_i];
  1217.       sum += in[16] * COS18[eight_odd_i];
  1218.  
  1219.       tmp[i] = sum;
  1220.    }
  1221.  
  1222.    // End 9 point IDCT on even indices
  1223.  
  1224.    // 9 point IDCT on odd indices
  1225. /*   for(i=0; i<9; i++) {
  1226.        sum = 0.0;
  1227.  
  1228.       for(j=0;j<18;j+=2)
  1229.           sum += in[j+1] * cos(PI36 * (2*i + 1) * j);
  1230.  
  1231.       tmp[17-i] = sum;
  1232.    } */
  1233.  
  1234.    for(i=0; i<9; i++) {
  1235.  
  1236.        odd_i = (i << 1) + 1;
  1237.  
  1238.       sum = in[1];
  1239.  
  1240.       two_odd_i = odd_i << 1;
  1241.       four_odd_i = odd_i << 2;
  1242.  
  1243.       sum += in[3]  * COS18[odd_i];
  1244.       sum += in[5]  * COS18[two_odd_i];
  1245.  
  1246.       eight_odd_i = two_odd_i << 2;
  1247.  
  1248.       sum += in[7]  * COS18[four_odd_i - odd_i];
  1249.       sum += in[9]  * COS18[four_odd_i];
  1250.       sum += in[11] * COS18[four_odd_i + odd_i];
  1251.       sum += in[13] * COS18[four_odd_i + two_odd_i];
  1252.       sum += in[15] * COS18[eight_odd_i - odd_i];
  1253.       sum += in[17] * COS18[eight_odd_i];
  1254.  
  1255.       tmp[17-i] = sum;
  1256.    }
  1257.  
  1258.    // End 9 point IDCT on odd indices
  1259.  
  1260.    // Twiddle factors on odd indices
  1261.  
  1262.    tmp[9]  *= 5.736856623f;
  1263.    tmp[10] *= 1.931851653f;
  1264.    tmp[11] *= 1.183100792f;
  1265.    tmp[12] *= 0.871723397f;
  1266.    tmp[13] *= 0.707106781f;
  1267.    tmp[14] *= 0.610387294f;
  1268.    tmp[15] *= 0.551688959f;
  1269.    tmp[16] *= 0.517638090f;
  1270.    tmp[17] *= 0.501909918f;
  1271.  
  1272.    // Butterflies on 9 point IDCT's
  1273.    for (i=0;i<9;i++) {
  1274.        save = tmp[i];
  1275.       tmp[i] += tmp[17-i];
  1276.       tmp[17-i] = save - tmp[17-i];
  1277.    }
  1278.    // end 18 point IDCT
  1279.  
  1280.    // twiddle factors for 36 point IDCT
  1281.  
  1282.    tmp[0] *=  -0.500476342f;
  1283.    tmp[1] *=  -0.504314480f;
  1284.    tmp[2] *=  -0.512139757f;
  1285.    tmp[3] *=  -0.524264562f;
  1286.    tmp[4] *=  -0.541196100f;
  1287.    tmp[5] *=  -0.563690973f;
  1288.     tmp[6] *=  -0.592844523f;
  1289.    tmp[7] *=  -0.630236207f;
  1290.    tmp[8] *=  -0.678170852f;
  1291.    tmp[9] *=  -0.740093616f;
  1292.    tmp[10]*=  -0.821339815f;
  1293.    tmp[11]*=  -0.930579498f;
  1294.    tmp[12]*=  -1.082840285f;
  1295.    tmp[13]*=  -1.306562965f;
  1296.    tmp[14]*=  -1.662754762f;
  1297.    tmp[15]*=  -2.310113158f;
  1298.    tmp[16]*=  -3.830648788f;
  1299.    tmp[17]*= -11.46279281f;
  1300.  
  1301.    // end 36 point IDCT
  1302.  
  1303.    // shift to modified IDCT
  1304.  
  1305.    out[0] =-tmp[9]  * win[block_type][0];
  1306.    out[1] =-tmp[10] * win[block_type][1];
  1307.    out[2] =-tmp[11] * win[block_type][2];
  1308.    out[3] =-tmp[12] * win[block_type][3];
  1309.    out[4] =-tmp[13] * win[block_type][4];
  1310.    out[5] =-tmp[14] * win[block_type][5];
  1311.    out[6] =-tmp[15] * win[block_type][6];
  1312.    out[7] =-tmp[16] * win[block_type][7];
  1313.    out[8] =-tmp[17] * win[block_type][8];
  1314.  
  1315.    out[9] = tmp[17] * win[block_type][9];
  1316.    out[10]= tmp[16] * win[block_type][10];
  1317.    out[11]= tmp[15] * win[block_type][11];
  1318.    out[12]= tmp[14] * win[block_type][12];
  1319.    out[13]= tmp[13] * win[block_type][13];
  1320.    out[14]= tmp[12] * win[block_type][14];
  1321.    out[15]= tmp[11] * win[block_type][15];
  1322.    out[16]= tmp[10] * win[block_type][16];
  1323.    out[17]= tmp[9]  * win[block_type][17];
  1324.    out[18]= tmp[8]  * win[block_type][18];
  1325.    out[19]= tmp[7]  * win[block_type][19];
  1326.    out[20]= tmp[6]  * win[block_type][20];
  1327.    out[21]= tmp[5]  * win[block_type][21];
  1328.    out[22]= tmp[4]  * win[block_type][22];
  1329.    out[23]= tmp[3]  * win[block_type][23];
  1330.    out[24]= tmp[2]  * win[block_type][24];
  1331.    out[25]= tmp[1]  * win[block_type][25];
  1332.    out[26]= tmp[0]  * win[block_type][26];
  1333.  
  1334.    out[27]= tmp[0]  * win[block_type][27];
  1335.    out[28]= tmp[1]  * win[block_type][28];
  1336.    out[29]= tmp[2]  * win[block_type][29];
  1337.    out[30]= tmp[3]  * win[block_type][30];
  1338.    out[31]= tmp[4]  * win[block_type][31];
  1339.    out[32]= tmp[5]  * win[block_type][32];
  1340.    out[33]= tmp[6]  * win[block_type][33];
  1341.    out[34]= tmp[7]  * win[block_type][34];
  1342.    out[35]= tmp[8]  * win[block_type][35];
  1343.  
  1344.    }
  1345. }
  1346.  
  1347. void LayerIII_Decoder::hybrid(int32 ch, int32 gr, int32 sb)
  1348. {
  1349.  
  1350.     real *fsIn  = hybridIn[sb];
  1351.    real *tsOut = re_hybridOut[sb];
  1352.    gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  1353.  
  1354.     real rawout[36];
  1355.     int32 bt;
  1356.  
  1357.     bt = (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  1358.              (sb < 2)) ? 0 : gr_info->block_type;
  1359.  
  1360.     inv_mdct(fsIn, rawout, bt);
  1361.  
  1362.     /* overlap addition */
  1363.    tsOut[0]             = rawout[0]  + prevblck[ch][sb][0];
  1364.    prevblck[ch][sb][0]  = rawout[18];
  1365.    tsOut[1]             = rawout[1]  + prevblck[ch][sb][1];
  1366.    prevblck[ch][sb][1]  = rawout[19];
  1367.    tsOut[2]             = rawout[2]  + prevblck[ch][sb][2];
  1368.    prevblck[ch][sb][2]  = rawout[20];
  1369.    tsOut[3]             = rawout[3]  + prevblck[ch][sb][3];
  1370.    prevblck[ch][sb][3]  = rawout[21];
  1371.    tsOut[4]             = rawout[4]  + prevblck[ch][sb][4];
  1372.    prevblck[ch][sb][4]  = rawout[22];
  1373.    tsOut[5]             = rawout[5]  + prevblck[ch][sb][5];
  1374.    prevblck[ch][sb][5]  = rawout[23];
  1375.    tsOut[6]             = rawout[6]  + prevblck[ch][sb][6];
  1376.    prevblck[ch][sb][6]  = rawout[24];
  1377.    tsOut[7]             = rawout[7]  + prevblck[ch][sb][7];
  1378.    prevblck[ch][sb][7]  = rawout[25];
  1379.    tsOut[8]             = rawout[8]  + prevblck[ch][sb][8];
  1380.    prevblck[ch][sb][8]  = rawout[26];
  1381.    tsOut[9]             = rawout[9]  + prevblck[ch][sb][9];
  1382.    prevblck[ch][sb][9]  = rawout[27];
  1383.    tsOut[10]            = rawout[10] + prevblck[ch][sb][10];
  1384.    prevblck[ch][sb][10] = rawout[28];
  1385.    tsOut[11]            = rawout[11] + prevblck[ch][sb][11];
  1386.    prevblck[ch][sb][11] = rawout[29];
  1387.    tsOut[12]            = rawout[12] + prevblck[ch][sb][12];
  1388.    prevblck[ch][sb][12] = rawout[30];
  1389.    tsOut[13]            = rawout[13] + prevblck[ch][sb][13];
  1390.    prevblck[ch][sb][13] = rawout[31];
  1391.    tsOut[14]            = rawout[14] + prevblck[ch][sb][14];
  1392.    prevblck[ch][sb][14] = rawout[32];
  1393.    tsOut[15]            = rawout[15] + prevblck[ch][sb][15];
  1394.    prevblck[ch][sb][15] = rawout[33];
  1395.    tsOut[16]            = rawout[16] + prevblck[ch][sb][16];
  1396.    prevblck[ch][sb][16] = rawout[34];
  1397.    tsOut[17]            = rawout[17] + prevblck[ch][sb][17];
  1398.    prevblck[ch][sb][17] = rawout[35];
  1399.  
  1400. }
  1401.  
  1402. void LayerIII_Decoder::decode()
  1403. {
  1404.      int32 nSlots = header->slots();
  1405.      int32 gr, ch, ss, sb, main_data_end, flush_main;
  1406.      int32 bytes_to_discard;
  1407.  
  1408.      stream->get_side_info(channels, si);
  1409.  
  1410.      for (; nSlots > 0; nSlots--)  // read main data.
  1411.          br->hputbuf((uint32) stream->get_bits(8));
  1412.  
  1413.     main_data_end = br->hsstell() >> 3; // of previous frame
  1414.  
  1415.     if (flush_main=(br->hsstell() & 0x7)) {
  1416.          br->hgetbits(8 - flush_main);
  1417.             main_data_end++;
  1418.      }
  1419.  
  1420.      bytes_to_discard = frame_start - main_data_end
  1421.                               - si->main_data_begin;
  1422.      if(main_data_end > 4096) {
  1423.             frame_start -= 4096;
  1424.             br->rewindNbytes(4096);
  1425.      }
  1426.  
  1427.      frame_start += header->slots();
  1428.  
  1429.     if (bytes_to_discard < 0)
  1430.             return;
  1431.  
  1432.      for (; bytes_to_discard > 0; bytes_to_discard--) br->hgetbits(8);
  1433.  
  1434.      for (gr=0;gr<2;gr++) {
  1435.  
  1436.             for (ch=0; ch<channels; ch++) {
  1437.            part2_start= br->hsstell();
  1438.               get_scale_factors(ch, gr);
  1439.               hufman_decode(ch, gr);
  1440.               dequantize_sample(ro[ch], ch, gr);
  1441.             }
  1442.  
  1443.             stereo(gr);
  1444.  
  1445.             for (ch=0; ch<channels; ch++) {
  1446.  
  1447.                     reorder (lr[ch], ch, gr);
  1448.                     antialias(ch, gr);
  1449.  
  1450.                     for (sb=0;sb<SBLIMIT;sb++) { // Hybrid synthesis.
  1451.                          hybrid(ch, gr, sb);
  1452.                     }
  1453.  
  1454.                     for (ss=1;ss<SSLIMIT;ss+=2) // Frequency inversion for polyphase.
  1455.                           for (sb=1;sb<SBLIMIT;sb+=2)
  1456.                                   re_hybridOut[sb][ss] = -re_hybridOut[sb][ss];
  1457.  
  1458.                     if (ch == 0)
  1459.                       for (ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
  1460.                             for (sb=0;sb<SBLIMIT;sb++)
  1461.                                 filter1->input_sample(re_hybridOut[sb][ss], sb);
  1462.  
  1463.                             filter1->calculate_pcm_samples(buffer);
  1464.                       }
  1465.                     else
  1466.                       for (ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
  1467.                             for (sb=0;sb<SBLIMIT;sb++)
  1468.                                 filter2->input_sample(re_hybridOut[sb][ss], sb);
  1469.  
  1470.                             filter2->calculate_pcm_samples(buffer);
  1471.                       }
  1472.             }    // channels
  1473.      }    // granule
  1474.        buffer->write_buffer (1);        // write to stdout
  1475. }
  1476.  
  1477.