home *** CD-ROM | disk | FTP | other *** search
/ Windows 95 Secrets / Secrets2.iso / Audio / WAV / MaplayP / _SETUP.1 / layer3.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1997-07-06  |  50.1 KB  |  1,607 lines
  1. /* layer3.cpp
  2.  
  3.     Implementation of the layer III decoder
  4.  
  5.    01/31/97 : Layer III routines adopted from the ISO MPEG Audio Subgroup
  6.    Software Simulation Group's public c source for its MPEG audio decoder.
  7.    These routines were in the file "decoder.c". Rearrangement of the routines
  8.    as member functions of a layer III decoder object, and optimizations by
  9.    Jeff Tsay (ctsay@pasteur.eecs.berkeley.edu).
  10.  
  11.    04/14/97 : Several performance improvements. Inverse IMDCT moved to
  12.    an external source file. No huffman tables needed, so no need for
  13.    initialization. Put get_side_info() in this source file, and made
  14.    one function inline for better speed and elegance. Also added support
  15.    for mono decoding of stereo streams as well as downmixing. Bug fix
  16.    in dequantize_samples().
  17.  
  18.    06/26/97 : Added MPEG2 LSF capability and made a few minor speedups.
  19.    The optimized reording function must be fixed, so right now the
  20.    one from 1.81 is used. */
  21.  
  22. #include <math.h>
  23.  
  24. #include "all.h"
  25. #include "l3type.h"
  26. #include "ibitstr.h"
  27. #include "obuffer.h"
  28. #include "bit_res.h"
  29. #include "header.h"
  30. #include "synfilt.h"
  31. #include "huffman.h"
  32. #include "layer3.h"
  33. #include "inv_mdct.h"
  34.  
  35. LayerIII_Decoder::LayerIII_Decoder(Ibitstream *stream0,
  36.                                    Header *header0,
  37.                                    SynthesisFilter *filtera,
  38.                                    SynthesisFilter *filterb,
  39.                                            Obuffer *buffer0,
  40.                                    enum e_channels which_ch0)
  41. {
  42.   stream         = stream0;
  43.   header         = header0;
  44.   filter1        = filtera;
  45.   filter2        = filterb;
  46.   buffer         = buffer0;
  47.   which_channels = which_ch0;
  48.  
  49.   frame_start = 0;
  50.   channels    = (header->mode() == single_channel) ? 1 : 2;
  51.   max_gr      = (header->version() == MPEG1) ? 2 : 1;
  52.  
  53.   sfreq       =  header->sample_frequency() +
  54.                  ((header->version() == MPEG1) ? 3 : 0);
  55.  
  56.   if (channels == 2) {
  57.  
  58.         switch (which_channels) {
  59.  
  60.      case left:
  61.      case downmix:
  62.      first_channel = last_channel = 0;
  63.      break;
  64.  
  65.      case right:
  66.      first_channel = last_channel = 1;
  67.      break;
  68.  
  69.      case both:
  70.       default:
  71.      first_channel  = 0;
  72.      last_channel   = 1;
  73.      break;
  74.      }
  75.  
  76.   } else {
  77.  
  78.     first_channel = last_channel = 0;
  79.   }
  80.  
  81.   for(uint32 i=0;i<2;i++)
  82.           for(uint32 j=0;j<SBLIMIT;j++)
  83.               for(uint32 k=0;k<SSLIMIT;k++)
  84.                   prevblck[i][j][k] = 0.0f;
  85.  
  86.   br = new Bit_Reserve();
  87.   si = new III_side_info_t;
  88. }
  89.  
  90. LayerIII_Decoder::~LayerIII_Decoder()
  91. {
  92.    delete br;
  93.    delete si;
  94. }
  95.  
  96. void LayerIII_Decoder::seek_notify()
  97. {
  98.     frame_start = 0;
  99.  
  100.  
  101.       for(uint32 i=0;i<2;i++)
  102.           for(uint32 j=0;j<SBLIMIT;j++)
  103.               for(uint32 k=0;k<SSLIMIT;k++)
  104.                   prevblck[i][j][k]=0.0f;
  105.  
  106.    delete br;
  107.    br = new Bit_Reserve;
  108. }
  109.  
  110.  
  111. bool LayerIII_Decoder::get_side_info()
  112. // Reads the side info from the stream, assuming the entire
  113. // frame has been read already.
  114.  
  115. // Mono   : 136 bits (= 17 bytes)
  116. // Stereo : 256 bits (= 32 bytes)
  117.  
  118. {
  119.     if (header->version() == MPEG1) {
  120.  
  121.         si->main_data_begin = stream->get_bits(9);
  122.         if (channels == 1)
  123.             si->private_bits = stream->get_bits(5);
  124.         else si->private_bits = stream->get_bits(3);
  125.  
  126.         for (uint32 ch=0; ch<channels; ch++) {
  127.             si->ch[ch].scfsi[0] = stream->get_bits(1);
  128.             si->ch[ch].scfsi[1] = stream->get_bits(1);
  129.             si->ch[ch].scfsi[2] = stream->get_bits(1);
  130.             si->ch[ch].scfsi[3] = stream->get_bits(1);
  131.        }
  132.  
  133.         for (uint32 gr=0; gr<2; gr++) {
  134.             for (uint32 ch=0; ch<channels; ch++) {
  135.                 si->ch[ch].gr[gr].part2_3_length = stream->get_bits(12);
  136.                   si->ch[ch].gr[gr].big_values = stream->get_bits(9);
  137.                 si->ch[ch].gr[gr].global_gain = stream->get_bits(8);
  138.                 si->ch[ch].gr[gr].scalefac_compress = stream->get_bits(4);
  139.                 si->ch[ch].gr[gr].window_switching_flag = stream->get_bits(1);
  140.                 if (si->ch[ch].gr[gr].window_switching_flag) {
  141.                     si->ch[ch].gr[gr].block_type       = stream->get_bits(2);
  142.                     si->ch[ch].gr[gr].mixed_block_flag = stream->get_bits(1);
  143.  
  144.                     si->ch[ch].gr[gr].table_select[0]  = stream->get_bits(5);
  145.                     si->ch[ch].gr[gr].table_select[1]  = stream->get_bits(5);
  146.  
  147.                     si->ch[ch].gr[gr].subblock_gain[0] = stream->get_bits(3);
  148.                     si->ch[ch].gr[gr].subblock_gain[1] = stream->get_bits(3);
  149.                     si->ch[ch].gr[gr].subblock_gain[2] = stream->get_bits(3);
  150.  
  151.                     // Set region_count parameters since they are implicit in this case.
  152.  
  153.                     if (si->ch[ch].gr[gr].block_type == 0) {
  154.                         //     Side info bad: block_type == 0 in split block
  155.                         return(FALSE);
  156.                     } else if (si->ch[ch].gr[gr].block_type == 2
  157.                                     && si->ch[ch].gr[gr].mixed_block_flag == 0) {
  158.                         si->ch[ch].gr[gr].region0_count = 8;
  159.                } else {
  160.                    si->ch[ch].gr[gr].region0_count = 7;
  161.                }
  162.                     si->ch[ch].gr[gr].region1_count = 20 -
  163.                             si->ch[ch].gr[gr].region0_count;
  164.                 } else {
  165.                     si->ch[ch].gr[gr].table_select[0] = stream->get_bits(5);
  166.                     si->ch[ch].gr[gr].table_select[1] = stream->get_bits(5);
  167.                     si->ch[ch].gr[gr].table_select[2] = stream->get_bits(5);
  168.                     si->ch[ch].gr[gr].region0_count = stream->get_bits(4);
  169.                     si->ch[ch].gr[gr].region1_count = stream->get_bits(3);
  170.                     si->ch[ch].gr[gr].block_type = 0;
  171.                 }
  172.                 si->ch[ch].gr[gr].preflag = stream->get_bits(1);
  173.                 si->ch[ch].gr[gr].scalefac_scale = stream->get_bits(1);
  174.                 si->ch[ch].gr[gr].count1table_select = stream->get_bits(1);
  175.          }
  176.       }
  177.  
  178.    } else {      // MPEG-2 LSF
  179.  
  180.       si->main_data_begin = stream->get_bits(8);
  181.       if (channels == 1)
  182.           si->private_bits = stream->get_bits(1);
  183.       else si->private_bits = stream->get_bits(2);
  184.  
  185.  
  186.       for (uint32 ch=0; ch<channels; ch++) {
  187.  
  188.           si->ch[ch].gr[0].part2_3_length = stream->get_bits(12);
  189.           si->ch[ch].gr[0].big_values = stream->get_bits(9);
  190.           si->ch[ch].gr[0].global_gain = stream->get_bits(8);
  191.           si->ch[ch].gr[0].scalefac_compress = stream->get_bits(9);
  192.           si->ch[ch].gr[0].window_switching_flag = stream->get_bits(1);
  193.  
  194.           if (si->ch[ch].gr[0].window_switching_flag) {
  195.  
  196.              si->ch[ch].gr[0].block_type = stream->get_bits(2);
  197.              si->ch[ch].gr[0].mixed_block_flag = stream->get_bits(1);
  198.              si->ch[ch].gr[0].table_select[0] = stream->get_bits(5);
  199.              si->ch[ch].gr[0].table_select[1] = stream->get_bits(5);
  200.  
  201.              si->ch[ch].gr[0].subblock_gain[0] = stream->get_bits(3);
  202.              si->ch[ch].gr[0].subblock_gain[1] = stream->get_bits(3);
  203.              si->ch[ch].gr[0].subblock_gain[2] = stream->get_bits(3);
  204.  
  205.             // Set region_count parameters since they are implicit in this case.
  206.  
  207.              if (si->ch[ch].gr[0].block_type == 0) {
  208.                 // Side info bad: block_type == 0 in split block
  209.                 return(FALSE);
  210.              } else if (si->ch[ch].gr[0].block_type == 2
  211.                       && si->ch[ch].gr[0].mixed_block_flag == 0) {
  212.                   si->ch[ch].gr[0].region0_count = 8;
  213.                  } else {
  214.                   si->ch[ch].gr[0].region0_count = 7;
  215.                 si->ch[ch].gr[0].region1_count = 20 -
  216.                                                             si->ch[ch].gr[0].region0_count;
  217.              }
  218.  
  219.           } else {
  220.              si->ch[ch].gr[0].table_select[0] = stream->get_bits(5);
  221.              si->ch[ch].gr[0].table_select[1] = stream->get_bits(5);
  222.              si->ch[ch].gr[0].table_select[2] = stream->get_bits(5);
  223.              si->ch[ch].gr[0].region0_count = stream->get_bits(4);
  224.              si->ch[ch].gr[0].region1_count = stream->get_bits(3);
  225.              si->ch[ch].gr[0].block_type = 0;
  226.           }
  227.  
  228.           si->ch[ch].gr[0].scalefac_scale = stream->get_bits(1);
  229.           si->ch[ch].gr[0].count1table_select = stream->get_bits(1);
  230.       }   // for(ch=0; ch<channels; ch++)
  231.    } // if (header->version() == MPEG1)
  232.     return(TRUE);
  233. }
  234.  
  235. struct {
  236.     int32 l[5];
  237.     int32 s[3];} sfbtable = {{0, 6, 11, 16, 21},
  238.                                     {0, 6, 12}};
  239.  
  240. int32 slen[2][16] = {{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
  241.                      {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}};
  242.  
  243. void LayerIII_Decoder::get_scale_factors(uint32 ch, uint32 gr)
  244. {
  245.     int32 sfb, window;
  246.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  247.    int32 scale_comp   = gr_info->scalefac_compress;
  248.    int32 length0      = slen[0][scale_comp];
  249.    int32 length1      = slen[1][scale_comp];
  250.  
  251.     if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  252.         if (gr_info->mixed_block_flag) { // MIXED
  253.             for (sfb = 0; sfb < 8; sfb++)
  254.                 scalefac[ch].l[sfb] = br->hgetbits(
  255.                       slen[0][gr_info->scalefac_compress]);
  256.             for (sfb = 3; sfb < 6; sfb++)
  257.                 for (window=0; window<3; window++)
  258.                     scalefac[ch].s[window][sfb] = br->hgetbits(
  259.                       slen[0][gr_info->scalefac_compress]);
  260.             for (sfb = 6; sfb < 12; sfb++)
  261.                 for (window=0; window<3; window++)
  262.                     scalefac[ch].s[window][sfb] = br->hgetbits(
  263.                       slen[1][gr_info->scalefac_compress]);
  264.             for (sfb=12,window=0; window<3; window++)
  265.                 scalefac[ch].s[window][sfb] = 0;
  266.  
  267.       } else {  // SHORT
  268.  
  269.          scalefac[ch].s[0][0]  = br->hgetbits(length0);
  270.          scalefac[ch].s[1][0]  = br->hgetbits(length0);
  271.          scalefac[ch].s[2][0]  = br->hgetbits(length0);
  272.          scalefac[ch].s[0][1]  = br->hgetbits(length0);
  273.          scalefac[ch].s[1][1]  = br->hgetbits(length0);
  274.          scalefac[ch].s[2][1]  = br->hgetbits(length0);
  275.          scalefac[ch].s[0][2]  = br->hgetbits(length0);
  276.          scalefac[ch].s[1][2]  = br->hgetbits(length0);
  277.          scalefac[ch].s[2][2]  = br->hgetbits(length0);
  278.          scalefac[ch].s[0][3]  = br->hgetbits(length0);
  279.          scalefac[ch].s[1][3]  = br->hgetbits(length0);
  280.          scalefac[ch].s[2][3]  = br->hgetbits(length0);
  281.          scalefac[ch].s[0][4]  = br->hgetbits(length0);
  282.          scalefac[ch].s[1][4]  = br->hgetbits(length0);
  283.          scalefac[ch].s[2][4]  = br->hgetbits(length0);
  284.          scalefac[ch].s[0][5]  = br->hgetbits(length0);
  285.          scalefac[ch].s[1][5]  = br->hgetbits(length0);
  286.          scalefac[ch].s[2][5]  = br->hgetbits(length0);
  287.          scalefac[ch].s[0][6]  = br->hgetbits(length1);
  288.          scalefac[ch].s[1][6]  = br->hgetbits(length1);
  289.          scalefac[ch].s[2][6]  = br->hgetbits(length1);
  290.          scalefac[ch].s[0][7]  = br->hgetbits(length1);
  291.          scalefac[ch].s[1][7]  = br->hgetbits(length1);
  292.          scalefac[ch].s[2][7]  = br->hgetbits(length1);
  293.          scalefac[ch].s[0][8]  = br->hgetbits(length1);
  294.          scalefac[ch].s[1][8]  = br->hgetbits(length1);
  295.          scalefac[ch].s[2][8]  = br->hgetbits(length1);
  296.          scalefac[ch].s[0][9]  = br->hgetbits(length1);
  297.          scalefac[ch].s[1][9]  = br->hgetbits(length1);
  298.          scalefac[ch].s[2][9]  = br->hgetbits(length1);
  299.          scalefac[ch].s[0][10] = br->hgetbits(length1);
  300.          scalefac[ch].s[1][10] = br->hgetbits(length1);
  301.          scalefac[ch].s[2][10] = br->hgetbits(length1);
  302.          scalefac[ch].s[0][11] = br->hgetbits(length1);
  303.          scalefac[ch].s[1][11] = br->hgetbits(length1);
  304.          scalefac[ch].s[2][11] = br->hgetbits(length1);
  305.          scalefac[ch].s[0][12] = 0;
  306.             scalefac[ch].s[1][12] = 0;
  307.             scalefac[ch].s[2][12] = 0;
  308.         } // SHORT
  309.  
  310.     } else {   // LONG types 0,1,3
  311.  
  312.       if ((si->ch[ch].scfsi[0] == 0) || (gr == 0)) {
  313.            scalefac[ch].l[0]  = br->hgetbits(length0);
  314.            scalefac[ch].l[1]  = br->hgetbits(length0);
  315.            scalefac[ch].l[2]  = br->hgetbits(length0);
  316.            scalefac[ch].l[3]  = br->hgetbits(length0);
  317.            scalefac[ch].l[4]  = br->hgetbits(length0);
  318.            scalefac[ch].l[5]  = br->hgetbits(length0);
  319.         }
  320.       if ((si->ch[ch].scfsi[1] == 0) || (gr == 0)) {
  321.            scalefac[ch].l[6]  = br->hgetbits(length0);
  322.            scalefac[ch].l[7]  = br->hgetbits(length0);
  323.            scalefac[ch].l[8]  = br->hgetbits(length0);
  324.            scalefac[ch].l[9]  = br->hgetbits(length0);
  325.            scalefac[ch].l[10] = br->hgetbits(length0);
  326.         }
  327.       if ((si->ch[ch].scfsi[2] == 0) || (gr == 0)) {
  328.            scalefac[ch].l[11] = br->hgetbits(length1);
  329.            scalefac[ch].l[12] = br->hgetbits(length1);
  330.            scalefac[ch].l[13] = br->hgetbits(length1);
  331.            scalefac[ch].l[14] = br->hgetbits(length1);
  332.            scalefac[ch].l[15] = br->hgetbits(length1);
  333.         }
  334.       if ((si->ch[ch].scfsi[3] == 0) || (gr == 0)) {
  335.            scalefac[ch].l[16] = br->hgetbits(length1);
  336.            scalefac[ch].l[17] = br->hgetbits(length1);
  337.            scalefac[ch].l[18] = br->hgetbits(length1);
  338.            scalefac[ch].l[19] = br->hgetbits(length1);
  339.            scalefac[ch].l[20] = br->hgetbits(length1);
  340.         }
  341.  
  342.       scalefac[ch].l[21] = 0;
  343.         scalefac[ch].l[22] = 0;
  344.     }
  345. }
  346.  
  347. uint32 nr_of_sfb_block[6][3][4] =
  348.     {{{ 6, 5, 5, 5} , { 9, 9, 9, 9} , { 6, 9, 9, 9}},
  349.     {{ 6, 5, 7, 3} , { 9, 9,12, 6} , { 6, 9,12, 6}},
  350.     {{11,10, 0, 0} , {18,18, 0, 0} , {15,18, 0, 0}},
  351.     {{ 7, 7, 7, 0} , {12,12,12, 0} , { 6,15,12, 0}},
  352.     {{ 6, 6, 6, 3} , {12, 9, 9, 6} , { 6,12, 9, 6}},
  353.     {{ 8, 8, 5, 0} , {15,12, 9, 0} , { 6,18, 9, 0}}};
  354.  
  355. uint32 scalefac_buffer[54];
  356.  
  357. void LayerIII_Decoder::get_LSF_scale_data(uint32 ch, uint32 gr)
  358. {
  359.     uint32 new_slen[4];
  360.       uint32 scalefac_comp, int_scalefac_comp;
  361.    uint32 mode_ext = header->mode_extension();
  362.     int32 m;
  363.     int32 blocktypenumber, blocknumber;
  364.  
  365.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  366.  
  367.     scalefac_comp =  gr_info->scalefac_compress;
  368.  
  369.    if (gr_info->block_type == 2) {
  370.        if (gr_info->mixed_block_flag == 0)
  371.           blocktypenumber = 1;
  372.       else if (gr_info->mixed_block_flag == 1)
  373.             blocktypenumber = 2;
  374.       else
  375.           blocktypenumber = 0;
  376.    } else {
  377.        blocktypenumber = 0;
  378.    }
  379.  
  380.    if(!(((mode_ext == 1) || (mode_ext == 3)) && (ch == 1))) {
  381.  
  382.         if(scalefac_comp < 400) {
  383.  
  384.             new_slen[0] = (scalefac_comp >> 4) / 5 ;
  385.             new_slen[1] = (scalefac_comp >> 4) % 5 ;
  386.             new_slen[2] = (scalefac_comp & 0xF) >> 2 ;
  387.             new_slen[3] = (scalefac_comp & 3);
  388.          si->ch[ch].gr[gr].preflag = 0;
  389.  
  390.          blocknumber = 0;
  391.  
  392.       } else if (scalefac_comp  < 500) {
  393.  
  394.             new_slen[0] = ((scalefac_comp - 400) >> 2) / 5 ;
  395.             new_slen[1] = ((scalefac_comp - 400) >> 2) % 5 ;
  396.             new_slen[2] = (scalefac_comp - 400 ) & 3 ;
  397.             new_slen[3] = 0;
  398.          si->ch[ch].gr[gr].preflag = 0;
  399.  
  400.          blocknumber = 1;
  401.  
  402.        } else if (scalefac_comp < 512) {
  403.  
  404.             new_slen[0] = (scalefac_comp - 500 ) / 3 ;
  405.             new_slen[1] = (scalefac_comp - 500)  % 3 ;
  406.             new_slen[2] = 0;
  407.             new_slen[3] = 0;
  408.           si->ch[ch].gr[gr].preflag = 1;
  409.  
  410.           blocknumber = 2;
  411.         }
  412.    }
  413.  
  414.    if((((mode_ext == 1) || (mode_ext == 3)) && (ch == 1)))
  415.    {
  416.       int_scalefac_comp = scalefac_comp >> 1;
  417.  
  418.       if (int_scalefac_comp < 180)
  419.       {
  420.             new_slen[0] = int_scalefac_comp  / 36 ;
  421.             new_slen[1] = (int_scalefac_comp % 36 ) / 6 ;
  422.             new_slen[2] = (int_scalefac_comp % 36) % 6;
  423.             new_slen[3] = 0;
  424.          si->ch[ch].gr[gr].preflag = 0;
  425.          blocknumber = 3;
  426.       } else if (int_scalefac_comp < 244) {
  427.             new_slen[0] = ((int_scalefac_comp - 180 )  & 0x3F) >> 4 ;
  428.             new_slen[1] = ((int_scalefac_comp - 180) & 0xF) >> 2 ;
  429.             new_slen[2] = (int_scalefac_comp - 180 ) & 3 ;
  430.             new_slen[3] = 0;
  431.          si->ch[ch].gr[gr].preflag = 0;
  432.          blocknumber = 4;
  433.       } else if (int_scalefac_comp < 255) {
  434.             new_slen[0] = (int_scalefac_comp - 244 ) / 3 ;
  435.             new_slen[1] = (int_scalefac_comp - 244 )  % 3 ;
  436.             new_slen[2] = 0 ;
  437.             new_slen[3] = 0;
  438.          si->ch[ch].gr[gr].preflag = 0;
  439.          blocknumber = 5;
  440.       }
  441.    }
  442.  
  443.    for (uint32 x=0; x<45; x++) // why 45, not 54?
  444.        scalefac_buffer[x] = 0;
  445.  
  446.    m = 0;
  447.    for (uint32 i=0; i<4;i++) {
  448.          for (uint32 j = 0; j < nr_of_sfb_block[blocknumber][blocktypenumber][i];
  449.            j++)
  450.       {
  451.         scalefac_buffer[m] = (new_slen[i] == 0) ? 0 :
  452.                                       br->hgetbits(new_slen[i]);
  453.         m++;
  454.  
  455.       } // for (unint32 j ...
  456.    } // for (uint32 i ...
  457. }
  458.  
  459. void LayerIII_Decoder::get_LSF_scale_factors(uint32 ch, uint32 gr)
  460. {
  461.     uint32 m = 0;
  462.    uint32 sfb, window;
  463.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  464.  
  465.    get_LSF_scale_data(ch, gr);
  466.  
  467.    if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  468.       if (gr_info->mixed_block_flag) {     // MIXED
  469.          for (sfb = 0; sfb < 8; sfb++)
  470.          {
  471.               scalefac[ch].l[sfb] = scalefac_buffer[m];
  472.               m++;
  473.          }
  474.          for (sfb = 3; sfb < 12; sfb++) {
  475.             for (window=0; window<3; window++)
  476.             {
  477.                scalefac[ch].s[window][sfb] = scalefac_buffer[m];
  478.                m++;
  479.             }
  480.          }
  481.          for (window=0; window<3; window++)
  482.             scalefac[ch].s[window][12] = 0;
  483.  
  484.       } else {  // SHORT
  485.  
  486.            for (sfb = 0; sfb < 12; sfb++) {
  487.                for (window=0; window<3; window++)
  488.                {
  489.                   scalefac[ch].s[window][sfb] = scalefac_buffer[m];
  490.                   m++;
  491.                }
  492.            }
  493.  
  494.            for (window=0; window<3; window++)
  495.                scalefac[ch].s[window][12] = 0;
  496.       }
  497.    } else {   // LONG types 0,1,3
  498.  
  499.       for (sfb = 0; sfb < 21; sfb++) {
  500.           scalefac[ch].l[sfb] = scalefac_buffer[m];
  501.           m++;
  502.       }
  503.       scalefac[ch].l[21] = 0; // Jeff
  504.       scalefac[ch].l[22] = 0;
  505.     }
  506. }
  507.  
  508. struct  {
  509.    int32 l[23];
  510.    int32 s[14];} sfBandIndex[6] =
  511.     {{{0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  512.      {0,4,8,12,18,24,32,42,56,74,100,132,174,192}},
  513.     {{0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},
  514.      {0,4,8,12,18,26,36,48,62,80,104,136,180,192}},
  515.     {{0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576},
  516.      {0,4,8,12,18,26,36,48,62,80,104,134,174,192}},
  517.  
  518.     {{0,4,8,12,16,20,24,30,36,44,52,62,74,90,110,134,162,196,238,288,342,418,576},
  519.      {0,4,8,12,16,22,30,40,52,66,84,106,136,192}},
  520.     {{0,4,8,12,16,20,24,30,36,42,50,60,72,88,106,128,156,190,230,276,330,384,576},
  521.      {0,4,8,12,16,22,28,38,50,64,80,100,126,192}},
  522.     {{0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576},
  523.      {0,4,8,12,16,22,30,42,58,78,104,138,180,192}}};
  524.  
  525. void LayerIII_Decoder::huffman_decode(uint32 ch, uint32 gr)
  526. {
  527.     int32 x, y;
  528.     int32 v, w;
  529.    int32 part2_3_end = part2_start + si->ch[ch].gr[gr].part2_3_length;
  530.    int32 num_bits;
  531.     int32 region1Start;
  532.     int32 region2Start;
  533.    int32 ssindex, sbindex;
  534.      struct huffcodetab *h;
  535.  
  536.     // Find region boundary for short block case
  537.  
  538.     if ( (si->ch[ch].gr[gr].window_switching_flag) &&
  539.           (si->ch[ch].gr[gr].block_type == 2) ) {
  540.  
  541.         // Region2.
  542.  
  543.         region1Start = 36;  // sfb[9/3]*3=36
  544.         region2Start = 576; // No Region2 for short block case
  545.  
  546.     } else {          // Find region boundary for long block case
  547.  
  548.         region1Start = sfBandIndex[sfreq].l[si->ch[ch].gr[gr].region0_count
  549.                                              + 1];
  550.         region2Start = sfBandIndex[sfreq].l[si->ch[ch].gr[gr].region0_count +
  551.                                            si->ch[ch].gr[gr].region1_count + 2]; /* MI */
  552.    }
  553.  
  554.    sbindex = 0; ssindex = 0;
  555.     // Read bigvalues area
  556.     for (uint32 i=0; i<(si->ch[ch].gr[gr].big_values<<1); i+=2) {
  557.         if      (i<region1Start) h = &ht[si->ch[ch].gr[gr].table_select[0]];
  558.         else if (i<region2Start) h = &ht[si->ch[ch].gr[gr].table_select[1]];
  559.               else                h = &ht[si->ch[ch].gr[gr].table_select[2]];
  560.  
  561.         huffman_decoder(h, &x, &y, &v, &w, br);
  562.  
  563.       is[sbindex][ssindex]   = x;
  564.       is[sbindex][ssindex+1] = y;
  565.  
  566.       ssindex += 2;
  567.       if (ssindex >= SSLIMIT) {
  568.           ssindex = 0;
  569.          sbindex++;
  570.       }
  571.     }
  572.  
  573.     // Read count1 area
  574.     h = &ht[si->ch[ch].gr[gr].count1table_select+32];
  575.    num_bits = br->hsstell();
  576.  
  577.     while ((num_bits < part2_3_end) && (sbindex < SBLIMIT)) {
  578.  
  579.         huffman_decoder(h, &x, &y, &v, &w, br);
  580.       is[sbindex][ssindex]   = v;
  581.       is[sbindex][ssindex+1] = w;
  582.  
  583.       ssindex += 2;
  584.       if (ssindex >= SSLIMIT) {
  585.           ssindex = 0;
  586.          sbindex++;
  587.       }
  588.  
  589.         if (sbindex < SBLIMIT) {
  590.             is[sbindex][ssindex]   = x;
  591.             is[sbindex][ssindex+1] = y;
  592.       }
  593.  
  594.       ssindex += 2;
  595.       if (ssindex >= SSLIMIT) {
  596.           ssindex = 0;
  597.          sbindex++;
  598.       }
  599.       num_bits = br->hsstell();
  600.    }
  601.  
  602.     if (num_bits > part2_3_end) {
  603.         br->rewindNbits(num_bits - part2_3_end);
  604.       ssindex -= 4;
  605.       if (ssindex < 0) {
  606.           ssindex += SSLIMIT;
  607.          sbindex--;
  608.       }
  609.     }
  610.  
  611.    num_bits = br->hsstell();
  612.  
  613.     // Dismiss stuffing bits
  614.     if (num_bits < part2_3_end)
  615.        br->hgetbits(part2_3_end - num_bits);
  616.  
  617.     // Zero out rest
  618.  
  619.    for (; ssindex < SSLIMIT; ssindex++)
  620.        is[sbindex][ssindex] = 0;
  621.  
  622.    sbindex++;
  623.  
  624.    for(; sbindex < SBLIMIT; sbindex++) {
  625.        for(ssindex = 0; ssindex < SSLIMIT; ssindex+=3) {
  626.           is[sbindex][ssindex]   = 0;
  627.          is[sbindex][ssindex+1] = 0;
  628.          is[sbindex][ssindex+2] = 0;
  629.       }
  630.    }
  631. }
  632.  
  633. uint32 pretab[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};
  634.  
  635. void LayerIII_Decoder::dequantize_sample(real xr[SBLIMIT][SSLIMIT],
  636.                                                      uint32 ch, uint32 gr)
  637. {
  638.    static real TO_FOUR_THIRDS[POW_TABLE_LIMIT];
  639.     static real two_to_negative_half_pow[64];
  640.    static bool Dequant_init = FALSE;
  641.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  642.     int32  ss, sb, cb=0;
  643.     int32  next_cb_boundary, cb_begin, cb_width;
  644.     int32  index=0, t_index;
  645.    int32 *is1d;
  646.    real   g_gain;
  647.    real  *xr1d;
  648.  
  649.    if (!Dequant_init) {
  650.  
  651.        uint32 i;
  652.  
  653.        for(i=0; i<POW_TABLE_LIMIT; i++)
  654.               TO_FOUR_THIRDS[i] = (real) pow((double) i, 4.0/3.0);
  655.  
  656.       for(i=0; i<64; i++)
  657.           two_to_negative_half_pow[i] = (real) pow(2.0, -0.5 * (double) i);
  658.  
  659.       Dequant_init = TRUE;
  660.    }
  661.  
  662.     // choose correct scalefactor band per block type, initalize boundary
  663.  
  664.     if (gr_info->window_switching_flag && (gr_info->block_type == 2) ) {
  665.         if (gr_info->mixed_block_flag)
  666.             next_cb_boundary=sfBandIndex[sfreq].l[1];  // LONG blocks: 0,1,3
  667.         else {
  668.          cb_width = sfBandIndex[sfreq].s[1];
  669.            next_cb_boundary = (cb_width << 2) - cb_width;
  670.             cb_begin = 0;
  671.         }
  672.     } else {
  673.         next_cb_boundary=sfBandIndex[sfreq].l[1];  // LONG blocks: 0,1,3
  674.    }
  675.  
  676.    // Compute overall (global) scaling.
  677.  
  678.     g_gain = (real) pow(2.0 , (0.25 * (gr_info->global_gain - 210.0)));
  679.  
  680.    for (sb=0; sb < SBLIMIT; sb++) {
  681.  
  682.        is1d = is[sb];        xr1d = xr[sb];
  683.        for(ss=0; ss < SSLIMIT; ss++) {
  684.  
  685.           if (is1d[ss] == 0) {
  686.                 xr1d[ss] = 0.0f;
  687.          } else {
  688.              uint32 abv = abs(is1d[ss]);
  689.             if (abv < POW_TABLE_LIMIT)
  690.                xr1d[ss] = g_gain * TO_FOUR_THIRDS[abv];
  691.             else
  692.                 xr1d[ss] = g_gain * pow((double) abv, 4.0/3.0);
  693.  
  694.             if (is1d[ss] < 0)   xr1d[ss] = -xr1d[ss];
  695.          }
  696.       }
  697.     }
  698.  
  699.     // apply formula per block type
  700.  
  701.     for (sb=0; sb < SBLIMIT; sb++) {
  702.  
  703.         for (ss=0; ss < SSLIMIT; ss++) {
  704.  
  705.             if (index == next_cb_boundary)  { /* Adjust critical band boundary */
  706.                 if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  707.                     if (gr_info->mixed_block_flag)  {
  708.  
  709.                         if (index == sfBandIndex[sfreq].l[8])  {
  710.                      next_cb_boundary = sfBandIndex[sfreq].s[4];
  711.                      next_cb_boundary = (next_cb_boundary << 2) -
  712.                                             next_cb_boundary;
  713.                             cb = 3;
  714.                            cb_width = sfBandIndex[sfreq].s[4] -
  715.                                    sfBandIndex[sfreq].s[3];
  716.  
  717.                           cb_begin = sfBandIndex[sfreq].s[3];
  718.                      cb_begin = (cb_begin << 2) - cb_begin;
  719.                         }
  720.  
  721.                         else if (index < sfBandIndex[sfreq].l[8])
  722.                             next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  723.                         else {
  724.                       next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
  725.                      next_cb_boundary = (next_cb_boundary << 2) -
  726.                                              next_cb_boundary;
  727.  
  728.                      cb_begin = sfBandIndex[sfreq].s[cb];
  729.                             cb_width = sfBandIndex[sfreq].s[cb+1] -
  730.                                 cb_begin;
  731.                      cb_begin = (cb_begin << 2) - cb_begin;
  732.                         }
  733.                     }
  734.                     else  {
  735.                   next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
  736.                   next_cb_boundary = (next_cb_boundary << 2) -
  737.                                       next_cb_boundary;
  738.  
  739.                   cb_begin = sfBandIndex[sfreq].s[cb];
  740.                         cb_width = sfBandIndex[sfreq].s[cb+1] -
  741.                                cb_begin;
  742.                   cb_begin = (cb_begin << 2) - cb_begin;
  743.                     }
  744.                 }
  745.                 else // long blocks
  746.                     next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  747.             }
  748.  
  749.             // Do long/short dependent scaling operations
  750.  
  751.             if (gr_info->window_switching_flag &&
  752.                  (((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 0)) ||
  753.                   ((gr_info->block_type == 2) && gr_info->mixed_block_flag && (sb >= 2)) ))
  754.          {
  755.  
  756.                 t_index = (index - cb_begin) / cb_width;
  757. /*            xr[sb][ss] *= pow(2.0, ((-2.0 * gr_info->subblock_gain[t_index])
  758.                                     -(0.5 * (1.0 + gr_info->scalefac_scale)
  759.                                       * scalefac[ch].s[t_index][cb]))); */
  760.                 uint32 idx = scalefac[ch].s[t_index][cb]
  761.                              << gr_info->scalefac_scale;
  762.             idx += (gr_info->subblock_gain[t_index] << 2);
  763.  
  764.             xr[sb][ss] *= two_to_negative_half_pow[idx];
  765.  
  766.             } else {   // LONG block types 0,1,3 & 1st 2 subbands of switched blocks
  767. /*                xr[sb][ss] *= pow(2.0, -0.5 * (1.0+gr_info->scalefac_scale)
  768.                                                      * (scalefac[ch].l[cb]
  769.                                                      + gr_info->preflag * pretab[cb])); */
  770.                 uint32 idx = scalefac[ch].l[cb];
  771.  
  772.                if (gr_info->preflag)
  773.                    idx += pretab[cb];
  774.  
  775.                idx = idx << gr_info->scalefac_scale;
  776.  
  777.             xr[sb][ss] *= two_to_negative_half_pow[idx];
  778.             }
  779.          index++;
  780.         }
  781.    }
  782. }
  783. /*
  784. This reorder routine is a little more optimized, but it has a bug in it.
  785. It results in a hollow wood knock noise in the output
  786.  
  787. void LayerIII_Decoder::reorder(real xr[SBLIMIT][SSLIMIT], uint32 ch, uint32 gr)
  788. {
  789.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  790.    uint32 freq, freq3;
  791.     int32 sfb, sfb_start, sfb_lines;
  792.  
  793.    int32 sb, ss;
  794.     real *ho;
  795.    real *xr1d;
  796.  
  797.     if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  798.  
  799.         for(sb=0;sb<SBLIMIT;sb++) {
  800.           ho = re_hybridOut[sb];
  801.          ho[0]  = 0.0f;        ho[1]  = 0.0f;        ho[2]  = 0.0f;
  802.          ho[3]  = 0.0f;        ho[4]  = 0.0f;        ho[5]  = 0.0f;
  803.          ho[6]  = 0.0f;        ho[7]  = 0.0f;        ho[8]  = 0.0f;
  804.          ho[9]  = 0.0f;        ho[10] = 0.0f;        ho[11] = 0.0f;
  805.          ho[12] = 0.0f;        ho[13] = 0.0f;        ho[14] = 0.0f;
  806.          ho[15] = 0.0f;        ho[16] = 0.0f;        ho[17] = 0.0f;
  807.         }
  808.  
  809.         if (gr_info->mixed_block_flag) {
  810.             // NO REORDER FOR LOW 2 SUBBANDS
  811.  
  812.                for (ss=0; ss < SSLIMIT; ss+=3) {
  813.                     re_hybridOut[0][ss]   = xr[0][ss];
  814.                re_hybridOut[0][ss+1] = xr[0][ss+1];
  815.                re_hybridOut[0][ss+2] = xr[0][ss+2];
  816.             }
  817.  
  818.             for (ss=0; ss < SSLIMIT; ss+=3) {
  819.                 re_hybridOut[1][ss]   = xr[1][ss];
  820.                re_hybridOut[1][ss+1] = xr[1][ss+1];
  821.                re_hybridOut[1][ss+2] = xr[1][ss+2];
  822.             }
  823.  
  824.             // REORDERING FOR REST SWITCHED SHORT
  825.                 for(sfb=3,
  826.                 sfb_start = sfBandIndex[sfreq].s[3],
  827.                 sfb_lines = sfb_lines=sfBandIndex[sfreq].s[4] - sfb_start;
  828.                        sfb < 13;
  829.                 sfb++, sfb_start = sfBandIndex[sfreq].s[sfb],
  830.                     sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start)
  831.             {
  832.                        int32 sfb_start3 = (sfb_start << 2) - sfb_start;
  833.                   int32 start_line_div = sfb_start3 / SSLIMIT;
  834.                         int32 start_line_mod = sfb_start3 % SSLIMIT;
  835.  
  836.                         for(freq=0, freq3=0; freq<sfb_lines;
  837.                       freq++, freq3+=3) {
  838.  
  839.                      int32 src_line_div = start_line_div;
  840.                      int32 src_line_mod = start_line_mod + freq;
  841.  
  842.                      while (src_line_mod > SSLIMIT) {
  843.                          src_line_mod -= SSLIMIT;
  844.                         src_line_div++;
  845.                      }
  846.  
  847.                             int32 des_line_div = start_line_div;
  848.                      int32 des_line_mod = start_line_mod + freq3;
  849.  
  850.                      while (des_line_mod > SSLIMIT) {
  851.                          des_line_mod -= SSLIMIT;
  852.                         des_line_div++;
  853.                      }
  854.  
  855.                             re_hybridOut[des_line_div][des_line_mod] =
  856.                                                 xr[src_line_div][src_line_mod];
  857.  
  858.                             src_line_mod += sfb_lines;
  859.  
  860.                      while(src_line_mod >= SSLIMIT) {
  861.                          src_line_mod -= SSLIMIT;
  862.                         src_line_div++;
  863.                      }
  864.  
  865.                             des_line_mod++;
  866.  
  867.                      if (des_line_mod >= SSLIMIT) {
  868.                          des_line_mod = 0;
  869.                         des_line_div++;
  870.                      }
  871.  
  872.                             re_hybridOut[des_line_div][des_line_mod] =
  873.                                                 xr[src_line_div][src_line_mod];
  874.  
  875.                             src_line_mod += sfb_lines;
  876.                             des_line_mod++;
  877.  
  878.                      while(src_line_mod >= SSLIMIT) {
  879.                          src_line_mod -= SSLIMIT;
  880.                         src_line_div++;
  881.                      }
  882.  
  883.                      if (des_line_mod >= SSLIMIT) {
  884.                          des_line_mod = 0;
  885.                         des_line_div++;
  886.                      }
  887.  
  888.                             re_hybridOut[des_line_div][des_line_mod] =
  889.                                                 xr[src_line_div][src_line_mod];
  890.  
  891.                        }
  892.             }
  893.         }
  894.         else {  // pure short
  895.             for(sfb = 0, sfb_start = 0, sfb_lines = sfBandIndex[sfreq].s[1];
  896.                  sfb < 13;
  897.              sfb++, sfb_start=sfBandIndex[sfreq].s[sfb],
  898.                         sfb_lines = sfBandIndex[sfreq].s[sfb+1] - sfb_start)
  899.          {
  900.                        int32 sfb_start3 = (sfb_start << 2) - sfb_start;
  901.                   int32 start_line_div = sfb_start3 / SSLIMIT;
  902.                         int32 start_line_mod = sfb_start3 % SSLIMIT;
  903.  
  904.                         for(freq=0, freq3=0; freq<sfb_lines;
  905.                       freq++, freq3+=3) {
  906.  
  907.                      int32 src_line_div = start_line_div;
  908.                      int32 src_line_mod = start_line_mod + freq;
  909.  
  910.                      while (src_line_mod > SSLIMIT) {
  911.                          src_line_mod -= SSLIMIT;
  912.                         src_line_div++;
  913.                      }
  914.  
  915.                             int32 des_line_div = start_line_div;
  916.                      int32 des_line_mod = start_line_mod + freq3;
  917.  
  918.                      while (des_line_mod > SSLIMIT) {
  919.                          des_line_mod -= SSLIMIT;
  920.                         des_line_div++;
  921.                      }
  922.  
  923.                             re_hybridOut[des_line_div][des_line_mod] =
  924.                                                 xr[src_line_div][src_line_mod];
  925.  
  926.                             src_line_mod += sfb_lines;
  927.  
  928.                      while(src_line_mod >= SSLIMIT) {
  929.                          src_line_mod -= SSLIMIT;
  930.                         src_line_div++;
  931.                      }
  932.  
  933.                             des_line_mod++;
  934.  
  935.                      if (des_line_mod >= SSLIMIT) {
  936.                          des_line_mod = 0;
  937.                         des_line_div++;
  938.                      }
  939.  
  940.                             re_hybridOut[des_line_div][des_line_mod] =
  941.                                                 xr[src_line_div][src_line_mod];
  942.  
  943.                             src_line_mod += sfb_lines;
  944.  
  945.                      while (src_line_mod >= SSLIMIT) {
  946.                          src_line_mod -= SSLIMIT;
  947.                         src_line_div++;
  948.                      }
  949.  
  950.                             des_line_mod++;
  951.  
  952.                      if (des_line_mod >= SSLIMIT) {
  953.                          des_line_mod = 0;
  954.                         des_line_div++;
  955.                      }
  956.  
  957.                             re_hybridOut[des_line_div][des_line_mod] =
  958.                                                 xr[src_line_div][src_line_mod];
  959.                        }
  960.          } // for(sfb ..
  961.         } // else pure short
  962.  
  963.     } else {   // long blocks
  964.  
  965.         for (sb=0; sb < SBLIMIT; sb++) {
  966.            ho   = re_hybridOut[sb];  xr1d = xr[sb];
  967.  
  968.          ho[0]  = xr1d[0];         ho[1]  = xr1d[1];
  969.          ho[2]  = xr1d[2];         ho[3]  = xr1d[3];
  970.          ho[4]  = xr1d[4];         ho[5]  = xr1d[5];
  971.          ho[6]  = xr1d[6];         ho[7]  = xr1d[7];
  972.          ho[8]  = xr1d[8];         ho[9]  = xr1d[9];
  973.          ho[10] = xr1d[10];        ho[11] = xr1d[11];
  974.          ho[12] = xr1d[12];        ho[13] = xr1d[13];
  975.          ho[14] = xr1d[14];        ho[15] = xr1d[15];
  976.          ho[16] = xr1d[16];        ho[17] = xr1d[17];
  977.       }
  978.     }
  979. } */
  980.  
  981. void LayerIII_Decoder::reorder (real xr[SBLIMIT][SSLIMIT], uint32 ch, uint32 gr)
  982. {
  983.  
  984.     gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  985.  //    uint32 sfreq = (uint32) header->sample_frequency();
  986.    uint32 freq, freq3;
  987.     int32 sfb, sfb_start, sfb_lines;
  988.    int32 src_line, des_line;
  989.    real *ho, *xr1d;
  990.  
  991.     if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  992.  
  993.         for(uint32 sb=0;sb<SBLIMIT;sb++) {
  994.           ho = re_hybridOut[sb];
  995.          ho[0]  = 0.0f;        ho[1]  = 0.0f;        ho[2]  = 0.0f;
  996.          ho[3]  = 0.0f;        ho[4]  = 0.0f;        ho[5]  = 0.0f;
  997.          ho[6]  = 0.0f;        ho[7]  = 0.0f;        ho[8]  = 0.0f;
  998.          ho[9]  = 0.0f;        ho[10] = 0.0f;        ho[11] = 0.0f;
  999.          ho[12] = 0.0f;        ho[13] = 0.0f;        ho[14] = 0.0f;
  1000.          ho[15] = 0.0f;        ho[16] = 0.0f;        ho[17] = 0.0f;
  1001.         }
  1002.  
  1003.         if (gr_info->mixed_block_flag) {
  1004.             // NO REORDER FOR LOW 2 SUBBANDS
  1005.                for (uint32 ss=0; ss < SSLIMIT; ss+=3) {
  1006.                     re_hybridOut[0][ss]   = xr[0][ss];
  1007.                re_hybridOut[0][ss+1] = xr[0][ss+1];
  1008.                re_hybridOut[0][ss+2] = xr[0][ss+2];
  1009.             }
  1010.  
  1011.             for (uint32 ss=0; ss < SSLIMIT; ss+=3) {
  1012.                 re_hybridOut[1][ss]   = xr[1][ss];
  1013.                re_hybridOut[1][ss+1] = xr[1][ss+1];
  1014.                re_hybridOut[1][ss+2] = xr[1][ss+2];
  1015.             }
  1016.  
  1017.             // REORDERING FOR REST SWITCHED SHORT
  1018.                 for(sfb=3,sfb_start=sfBandIndex[sfreq].s[3],
  1019.                        sfb_lines=sfBandIndex[sfreq].s[4] - sfb_start;
  1020.                        sfb < 13; sfb++,sfb_start = sfBandIndex[sfreq].s[sfb],
  1021.                     (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  1022.             {
  1023.                        int32 sfb_start3 = (sfb_start << 2) - sfb_start;
  1024.  
  1025.                         for(freq=0, freq3=0; freq<sfb_lines;
  1026.                       freq++, freq3+=3) {
  1027.  
  1028.                             src_line = sfb_start3 + freq;
  1029.                             des_line = sfb_start3 + freq3;
  1030.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  1031.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  1032.                             src_line += sfb_lines;
  1033.                             des_line++;
  1034.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  1035.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  1036.                             src_line += sfb_lines;
  1037.                             des_line++;
  1038.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  1039.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  1040.                        }
  1041.             }
  1042.         }
  1043.         else {  // pure short
  1044.             for(sfb=0,sfb_start=0,sfb_lines=sfBandIndex[sfreq].s[1];
  1045.                 sfb < 13; sfb++,sfb_start=sfBandIndex[sfreq].s[sfb],
  1046.                 (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  1047.             {
  1048.                        int32 sfb_start3 = (sfb_start << 2) - sfb_start;
  1049.  
  1050.                         for(freq=0, freq3=0; freq<sfb_lines;
  1051.                       freq++, freq3+=3) {
  1052.  
  1053.                             src_line = sfb_start3 + freq;
  1054.                             des_line = sfb_start3 + freq3;
  1055.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  1056.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  1057.                             src_line += sfb_lines;
  1058.                             des_line++;
  1059.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  1060.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  1061.                             src_line += sfb_lines;
  1062.                             des_line++;
  1063.                             re_hybridOut[des_line/SSLIMIT][des_line%SSLIMIT] =
  1064.                                                 xr[src_line/SSLIMIT][src_line%SSLIMIT];
  1065.                        }
  1066.             }
  1067.         }
  1068.     }
  1069.     else {   // long blocks
  1070.         for (uint32 sb=0; sb < SBLIMIT; sb++) {
  1071.            ho = re_hybridOut[sb];        xr1d = xr[sb];
  1072.          ho[0]  = xr1d[0];         ho[1]  = xr1d[1];
  1073.          ho[2]  = xr1d[2];         ho[3]  = xr1d[3];
  1074.          ho[4]  = xr1d[4];         ho[5]  = xr1d[5];
  1075.          ho[6]  = xr1d[6];         ho[7]  = xr1d[7];
  1076.          ho[8]  = xr1d[8];         ho[9]  = xr1d[9];
  1077.          ho[10] = xr1d[10];        ho[11] = xr1d[11];
  1078.          ho[12] = xr1d[12];        ho[13] = xr1d[13];
  1079.          ho[14] = xr1d[14];        ho[15] = xr1d[15];
  1080.          ho[16] = xr1d[16];        ho[17] = xr1d[17];
  1081.       }
  1082.     }
  1083. }
  1084.  
  1085.  
  1086.  
  1087. real TAN12[16]={0.0, 0.26794919, 0.57735027, 1.0,
  1088.                 1.73205081, 3.73205081, 9.9999999e10 /*unbounded*/, -3.73205081,
  1089.                 -1.73205081, -1.0, -0.57735027, -0.26794919,
  1090.                 0.0, 0.26794919, 0.57735027, 1.0};
  1091.  
  1092. void LayerIII_Decoder::i_stereo_k_values(uint32 is_pos, uint32 io_type,
  1093.                                                      uint32 i)
  1094. {
  1095.     static real io[2][32];
  1096.     static bool k_init = FALSE;
  1097.  
  1098.    if (!k_init) {
  1099.  
  1100.        uint32 j;
  1101.        for (j = 0; j < 32; j++)
  1102.             io[0][j] = (real) pow(0.840896415256, (double) j);
  1103.  
  1104.        for (j = 0; j < 32; j++)
  1105.             io[1][j] = (real) pow(0.707106781188, (double) j);
  1106.  
  1107.       k_init = TRUE;
  1108.    }
  1109.  
  1110.    if (is_pos == 0) {
  1111.       k[0][i] = 1.0f;
  1112.       k[1][i] = 1.0f;
  1113.    } else if (is_pos & 1) {
  1114.         k[0][i] = io[io_type][(is_pos + 1) >> 1];
  1115.       k[1][i] = 1.0f;
  1116.    } else {
  1117.       k[0][i] = 1.0f;
  1118.       k[1][i] = io[io_type][is_pos >> 1];
  1119.    }
  1120. }
  1121.  
  1122. void LayerIII_Decoder::stereo(uint32 gr)
  1123. {
  1124.    int32 sb, ss;
  1125.  
  1126.     if  (channels == 1) { // mono , bypass xr[0][][] to lr[0][][]
  1127.  
  1128.         for(sb=0;sb<SBLIMIT;sb++)
  1129.             for(ss=0;ss<SSLIMIT;ss+=3) {
  1130.                 lr[0][sb][ss]   = ro[0][sb][ss];
  1131.             lr[0][sb][ss+1] = ro[0][sb][ss+1];
  1132.                 lr[0][sb][ss+2] = ro[0][sb][ss+2];
  1133.          }
  1134.  
  1135.    } else {
  1136.  
  1137.     uint32 is_pos[576];
  1138.     real  is_ratio[576];
  1139.     gr_info_s *gr_info = &(si->ch[0].gr[gr]);
  1140.    uint32 mode_ext = header->mode_extension();
  1141.     int32 sfb;
  1142.     int32 i;
  1143.    int32 lines, temp, temp2;
  1144.     bool ms_stereo = (header->mode() == joint_stereo) && (mode_ext & 0x2);
  1145.     bool i_stereo  = (header->mode() == joint_stereo) && (mode_ext & 0x1);
  1146.    bool lsf = (header->version() == MPEG2_LSF);
  1147.  
  1148.     uint32 io_type = (gr_info->scalefac_compress & 1);
  1149.  
  1150.      // initialization
  1151.    for (i=0; i<576; i+=8) {
  1152.       is_pos[i]   = 7; is_pos[i+1] = 7; is_pos[i+2] = 7; is_pos[i+3] = 7;
  1153.       is_pos[i+4] = 7; is_pos[i+5] = 7; is_pos[i+6] = 7; is_pos[i+7] = 7;
  1154.    }
  1155.  
  1156.     if (i_stereo) {
  1157.        if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  1158.           if (gr_info->mixed_block_flag) {
  1159.  
  1160.               int32 max_sfb = 0;
  1161.  
  1162.                  for (uint32 j=0; j<3; j++) {
  1163.                 int32 sfbcnt;
  1164.                     sfbcnt = 2;
  1165.                     for( sfb=12; sfb >=3; sfb-- ) {
  1166.                    i = sfBandIndex[sfreq].s[sfb];
  1167.                         lines = sfBandIndex[sfreq].s[sfb+1] - i;
  1168.                   i = (i << 2) - i + (j+1) * lines - 1;
  1169.  
  1170.                   int32 i_div = i / SSLIMIT;
  1171.                   int32 i_mod = i % SSLIMIT;
  1172.  
  1173.                         while (lines > 0) {
  1174.                       if (ro[1][i_div][i_mod] != 0.0f) {
  1175.                          sfbcnt = sfb;
  1176.                                 sfb = -10;
  1177.                                 lines = -10;
  1178.                             }
  1179.  
  1180.                             lines--;
  1181.                             i_mod--;
  1182.  
  1183.                      if (i_mod < 0) {
  1184.                             i_mod = SSLIMIT-1;
  1185.                         i_div--;
  1186.                      }
  1187.                         } // while (lines > 0)
  1188.                     } // for (sfb=12 ...
  1189.                     sfb = sfbcnt + 1;
  1190.  
  1191.                     if (sfb > max_sfb)
  1192.                         max_sfb = sfb;
  1193.  
  1194.                     while(sfb < 12) {
  1195.                    temp = sfBandIndex[sfreq].s[sfb];
  1196.                    sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
  1197.                   i    = (temp << 2) - temp + j * sb;
  1198.  
  1199.                         for ( ; sb > 0; sb--) {
  1200.                       is_pos[i] = scalefac[1].s[j][sfb];
  1201.                             if (is_pos[i] != 7)
  1202.                          if (lsf)
  1203.                            i_stereo_k_values(is_pos[i], io_type, i);
  1204.                         else
  1205.                             is_ratio[i] = TAN12[is_pos[i]];
  1206.  
  1207.                             i++;
  1208.                         } // for (; sb>0...
  1209.                         sfb++;
  1210.                     } // while (sfb < 12)
  1211.                     sfb = sfBandIndex[sfreq].s[10];
  1212.                sb  = sfBandIndex[sfreq].s[11] - sfb;
  1213.                sfb = (sfb << 2) - sfb + j * sb;
  1214.                temp  = sfBandIndex[sfreq].s[11];
  1215.                sb = sfBandIndex[sfreq].s[12] - temp;
  1216.                i = (temp << 2) - temp + j * sb;
  1217.  
  1218.                     for (; sb > 0; sb--) {
  1219.                    is_pos[i] = is_pos[sfb];
  1220.  
  1221.                     if (lsf) {
  1222.                        k[0][i] = k[0][sfb];
  1223.                          k[1][i] = k[1][sfb];
  1224.                     } else {
  1225.                              is_ratio[i] = is_ratio[sfb];
  1226.                   }
  1227.                         i++;
  1228.                     } // for (; sb > 0 ...
  1229.                  }
  1230.                  if (max_sfb <= 3) {
  1231.                 i = 2;
  1232.                      ss = 17;
  1233.                      sb = -1;
  1234.                      while (i >= 0) {
  1235.                     if (ro[1][i][ss] != 0.0f) {
  1236.                         sb = (i<<4) + (i<<1) + ss;
  1237.                              i = -1;
  1238.                         } else {
  1239.                       ss--;
  1240.                              if (ss < 0) {
  1241.                          i--;
  1242.                                  ss = 17;
  1243.                              }
  1244.                         } // if (ro ...
  1245.                      } // while (i>=0)
  1246.                      i = 0;
  1247.                      while (sfBandIndex[sfreq].l[i] <= sb)
  1248.                          i++;
  1249.                      sfb = i;
  1250.                      i = sfBandIndex[sfreq].l[i];
  1251.                      for (; sfb<8; sfb++) {
  1252.                    sb = sfBandIndex[sfreq].l[sfb+1]-sfBandIndex[sfreq].l[sfb];
  1253.                          for (; sb>0; sb--) {
  1254.                       is_pos[i] = scalefac[1].l[sfb];
  1255.                         if (is_pos[i] != 7)
  1256.                           if (lsf)
  1257.                            i_stereo_k_values(is_pos[i], io_type, i);
  1258.                          else
  1259.                             is_ratio[i] = TAN12[is_pos[i]];
  1260.                              i++;
  1261.                          } // for (; sb>0 ...
  1262.                      } // for (; sfb<8 ...
  1263.                  } // for (j=0 ...
  1264.             } else { // if (gr_info->mixed_block_flag)
  1265.              for (uint32 j=0; j<3; j++) {
  1266.                 int32 sfbcnt;
  1267.                     sfbcnt = -1;
  1268.                     for( sfb=12; sfb >=0; sfb-- )
  1269.                     {
  1270.                         temp = sfBandIndex[sfreq].s[sfb];
  1271.                   lines = sfBandIndex[sfreq].s[sfb+1] - temp;
  1272.                   i = (temp << 2) - temp + (j+1) * lines - 1;
  1273.  
  1274.                   int32 i_div = i / SSLIMIT;
  1275.                   int32 i_mod = i % SSLIMIT;
  1276.  
  1277.                         while (lines > 0) {
  1278.                             if (ro[1][i_div][i_mod] != 0.0f) {
  1279.                          sfbcnt = sfb;
  1280.                                 sfb = -10;
  1281.                                 lines = -10;
  1282.                             }
  1283.                             lines--;
  1284.                             i_mod--;
  1285.  
  1286.                      if (i_mod < 0) {
  1287.                          i_mod = SSLIMIT-1;
  1288.                         i_div--;
  1289.                      }
  1290.                         } // while (lines > 0)
  1291.                     } // for (sfb=12 ...
  1292.                     sfb = sfbcnt + 1;
  1293.                     while(sfb<12) {
  1294.                         temp = sfBandIndex[sfreq].s[sfb];
  1295.                   sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
  1296.                   i    = (temp << 2) - temp + j * sb;
  1297.                         for ( ; sb > 0; sb--) {
  1298.                       is_pos[i] = scalefac[1].s[j][sfb];
  1299.                             if (is_pos[i] != 7)
  1300.                           if (lsf)
  1301.                            i_stereo_k_values(is_pos[i], io_type, i);
  1302.                          else
  1303.                             is_ratio[i] = TAN12[is_pos[i]];
  1304.                             i++;
  1305.                         } // for (; sb>0 ...
  1306.                         sfb++;
  1307.                     } // while (sfb<12)
  1308.  
  1309.                     temp = sfBandIndex[sfreq].s[10];
  1310.                temp2= sfBandIndex[sfreq].s[11];
  1311.                sb   = temp2 - temp;
  1312.                sfb  = (temp << 2) - temp + j * sb;
  1313.                sb   = sfBandIndex[sfreq].s[12] - temp2;
  1314.                i    = (temp2 << 2) - temp2 + j * sb;
  1315.  
  1316.                     for (; sb>0; sb--) {
  1317.                    is_pos[i] = is_pos[sfb];
  1318.  
  1319.                     if (lsf) {
  1320.                        k[0][i] = k[0][sfb];
  1321.                          k[1][i] = k[1][sfb];
  1322.                     } else {
  1323.                        is_ratio[i] = is_ratio[sfb];
  1324.                   }
  1325.                         i++;
  1326.                     } // for (; sb>0 ...
  1327.                 } // for (sfb=12
  1328.             } // for (j=0 ...
  1329.         } else { // if (gr_info->window_switching_flag ...
  1330.           i = 31;
  1331.             ss = 17;
  1332.             sb = 0;
  1333.             while (i >= 0) {
  1334.              if (ro[1][i][ss] != 0.0f) {
  1335.                 sb = (i<<4) + (i<<1) + ss;
  1336.                     i = -1;
  1337.                 } else {
  1338.                 ss--;
  1339.                     if (ss < 0) {
  1340.                    i--;
  1341.                         ss = 17;
  1342.                     }
  1343.                 }
  1344.             }
  1345.             i = 0;
  1346.             while (sfBandIndex[sfreq].l[i] <= sb)
  1347.                 i++;
  1348.  
  1349.             sfb = i;
  1350.             i = sfBandIndex[sfreq].l[i];
  1351.             for (; sfb<21; sfb++) {
  1352.              sb = sfBandIndex[sfreq].l[sfb+1] - sfBandIndex[sfreq].l[sfb];
  1353.              for (; sb > 0; sb--) {
  1354.                 is_pos[i] = scalefac[1].l[sfb];
  1355.                     if (is_pos[i] != 7)
  1356.                   if (lsf)
  1357.                      i_stereo_k_values(is_pos[i], io_type, i);
  1358.                   else
  1359.                        is_ratio[i] = TAN12[is_pos[i]];
  1360.                     i++;
  1361.                 }
  1362.             }
  1363.             sfb = sfBandIndex[sfreq].l[20];
  1364.             for (sb = 576 - sfBandIndex[sfreq].l[21]; (sb > 0) && (i<576); sb--)
  1365.             {
  1366.              is_pos[i] = is_pos[sfb]; // error here : i >=576
  1367.  
  1368.             if (lsf) {
  1369.                k[0][i] = k[0][sfb];
  1370.                  k[1][i] = k[1][sfb];
  1371.             } else {
  1372.                       is_ratio[i] = is_ratio[sfb];
  1373.             }
  1374.                 i++;
  1375.             } // if (gr_info->mixed_block_flag)
  1376.         } // if (gr_info->window_switching_flag ...
  1377.     } // if (i_stereo)
  1378.  
  1379.        i = 0;
  1380.         for(sb=0;sb<SBLIMIT;sb++)
  1381.             for(ss=0;ss<SSLIMIT;ss++) {
  1382.                 if (is_pos[i] == 7) {
  1383.                     if (ms_stereo) {
  1384.                         lr[0][sb][ss] = (ro[0][sb][ss]+ro[1][sb][ss]) * 0.707106781f;
  1385.                         lr[1][sb][ss] = (ro[0][sb][ss]-ro[1][sb][ss]) * 0.707106781f;
  1386.                     } else {
  1387.                         lr[0][sb][ss] = ro[0][sb][ss];
  1388.                         lr[1][sb][ss] = ro[1][sb][ss];
  1389.                     }
  1390.                 }
  1391.                 else if (i_stereo) {
  1392.  
  1393.                 if (lsf) {
  1394.                   lr[0][sb][ss] = ro[0][sb][ss] * k[0][i];
  1395.                   lr[1][sb][ss] = ro[0][sb][ss] * k[1][i];
  1396.                } else {
  1397.                    lr[1][sb][ss] = ro[0][sb][ss] / (real) (1 + is_ratio[i]);
  1398.                          lr[0][sb][ss] = lr[1][sb][ss] * is_ratio[i];
  1399.                }
  1400.                 }
  1401. /*                else {
  1402.                     printf("Error in stereo processing\n");
  1403.                 } */
  1404.             i++;
  1405.             }
  1406.  
  1407.     } // channels == 2
  1408. }
  1409.  
  1410. real Ci[8]={-0.6f,-0.535f,-0.33f,-0.185f,-0.095f,-0.041f,-0.0142f,-0.0037f};
  1411.  
  1412. void LayerIII_Decoder::antialias(uint32 ch, uint32 gr)
  1413. {
  1414.      static real   ca[8],cs[8];
  1415.      static bool   antialias_init = FALSE;
  1416.    uint32 ss, sb, sblim;
  1417.    gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  1418.    real *hi, *hi1;
  1419.  
  1420.     if (!antialias_init) {
  1421.         for (int32 i=0;i<8;i++) {
  1422.             real sq = sqrt(1.0f + Ci[i]*Ci[i]);
  1423.             cs[i] = 1.0f/sq;
  1424.          ca[i] = Ci[i] * cs[i];
  1425.         }
  1426.         antialias_init = TRUE;
  1427.     }
  1428.  
  1429.     // 31 alias-reduction operations between each pair of sub-bands
  1430.     // with 8 butterflies between each pair
  1431.  
  1432.     if  (gr_info->window_switching_flag && (gr_info->block_type == 2) &&
  1433.          !gr_info->mixed_block_flag )
  1434.        return;
  1435.  
  1436.     if (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  1437.         (gr_info->block_type == 2)) {
  1438.       sblim = 1;
  1439.     } else {
  1440.         sblim = SBLIMIT - 1 ;
  1441.    }
  1442.  
  1443.     for(sb=0; sb < sblim; sb++) {
  1444.          hi  = re_hybridOut[sb];
  1445.        hi1 = re_hybridOut[sb+1];
  1446.        for(ss=0;ss<8;ss++) {
  1447.           real bu = hi[17-ss];
  1448.             real bd = hi1[ss];
  1449.             hi[17-ss] = (bu * cs[ss]) - (bd * ca[ss]);
  1450.             hi1[ss]   = (bd * cs[ss]) + (bu * ca[ss]);
  1451.       }
  1452.    }
  1453. }
  1454.  
  1455. void LayerIII_Decoder::hybrid(uint32 ch, uint32 gr)
  1456. {
  1457.     real rawout[36];
  1458.    uint32 bt;
  1459.    gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  1460.    real *tsOut;
  1461.    real *prvblk;
  1462.  
  1463.    for(uint32 sb=0;sb<SBLIMIT;sb++) {
  1464.  
  1465.         bt = (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  1466.                  (sb < 2)) ? 0 : gr_info->block_type;
  1467.  
  1468.         inv_mdct(re_hybridOut[sb], rawout, bt);
  1469.  
  1470.         // overlap addition
  1471.        tsOut  = re_hybridOut[sb];
  1472.        prvblk = prevblck[ch][sb];
  1473.  
  1474.        tsOut[0]   = rawout[0]  + prvblk[0];
  1475.        prvblk[0]  = rawout[18];
  1476.        tsOut[1]   = rawout[1]  + prvblk[1];
  1477.        prvblk[1]  = rawout[19];
  1478.        tsOut[2]   = rawout[2]  + prvblk[2];
  1479.        prvblk[2]  = rawout[20];
  1480.        tsOut[3]   = rawout[3]  + prvblk[3];
  1481.        prvblk[3]  = rawout[21];
  1482.        tsOut[4]   = rawout[4]  + prvblk[4];
  1483.        prvblk[4]  = rawout[22];
  1484.        tsOut[5]   = rawout[5]  + prvblk[5];
  1485.        prvblk[5]  = rawout[23];
  1486.        tsOut[6]   = rawout[6]  + prvblk[6];
  1487.        prvblk[6]  = rawout[24];
  1488.        tsOut[7]   = rawout[7]  + prvblk[7];
  1489.        prvblk[7]  = rawout[25];
  1490.        tsOut[8]   = rawout[8]  + prvblk[8];
  1491.        prvblk[8]  = rawout[26];
  1492.        tsOut[9]   = rawout[9]  + prvblk[9];
  1493.        prvblk[9]  = rawout[27];
  1494.        tsOut[10]  = rawout[10] + prvblk[10];
  1495.        prvblk[10] = rawout[28];
  1496.        tsOut[11]  = rawout[11] + prvblk[11];
  1497.       prvblk[11] = rawout[29];
  1498.        tsOut[12]  = rawout[12] + prvblk[12];
  1499.        prvblk[12] = rawout[30];
  1500.        tsOut[13]  = rawout[13] + prvblk[13];
  1501.        prvblk[13] = rawout[31];
  1502.        tsOut[14]  = rawout[14] + prvblk[14];
  1503.        prvblk[14] = rawout[32];
  1504.        tsOut[15]  = rawout[15] + prvblk[15];
  1505.        prvblk[15] = rawout[33];
  1506.        tsOut[16]  = rawout[16] + prvblk[16];
  1507.        prvblk[16] = rawout[34];
  1508.        tsOut[17]  = rawout[17] + prvblk[17];
  1509.        prvblk[17] = rawout[35];
  1510.    }
  1511. }
  1512.  
  1513. void LayerIII_Decoder::do_downmix()
  1514. {
  1515.     for (uint32 sb=0; sb<SSLIMIT; sb++)
  1516.        for (uint32 ss=0; ss<SSLIMIT; ss+=3) {
  1517.           lr[0][sb][ss]   = (lr[0][sb][ss]   + lr[1][sb][ss])   * 0.5f;
  1518.           lr[0][sb][ss+1] = (lr[0][sb][ss+1] + lr[1][sb][ss+1]) * 0.5f;
  1519.           lr[0][sb][ss+2] = (lr[0][sb][ss+2] + lr[1][sb][ss+2]) * 0.5f;
  1520.       }
  1521. }
  1522.  
  1523. void LayerIII_Decoder::decode()
  1524. {
  1525.      uint32 nSlots = header->slots();
  1526.     uint32 ch, ss, sb;
  1527.     int32 main_data_end;
  1528.      int32 bytes_to_discard;
  1529.  
  1530.      get_side_info();
  1531.  
  1532.     for (uint32 i=0; i<nSlots; i++)
  1533.         br->hputbuf(stream->get_bits(8));
  1534.  
  1535.     main_data_end = br->hsstell() >> 3; // of previous frame
  1536.  
  1537.     if (uint32 flush_main = (br->hsstell() & 7)) {
  1538.          br->hgetbits(8 - flush_main);
  1539.             main_data_end++;
  1540.      }
  1541.  
  1542.      bytes_to_discard = frame_start - main_data_end
  1543.                               - si->main_data_begin;
  1544.  
  1545.      frame_start += nSlots;
  1546.  
  1547.     if (bytes_to_discard < 0)
  1548.             return;
  1549.  
  1550.      if (main_data_end > 4096) {
  1551.             frame_start -= 4096;
  1552.             br->rewindNbytes(4096);
  1553.      }
  1554.  
  1555.      for (; bytes_to_discard > 0; bytes_to_discard--)
  1556.             br->hgetbits(8);
  1557.  
  1558.      for (uint32 gr=0;gr<max_gr;gr++) {
  1559.  
  1560.             for (ch=0; ch<channels; ch++) {
  1561.            part2_start = br->hsstell();
  1562.  
  1563.            if (header->version() == MPEG1)
  1564.                   get_scale_factors(ch, gr);
  1565.            else  // MPEG-2 LSF
  1566.               get_LSF_scale_factors(ch, gr);
  1567.  
  1568.               huffman_decode(ch, gr);
  1569.               dequantize_sample(ro[ch], ch, gr);
  1570.             }
  1571.  
  1572.             stereo(gr);
  1573.  
  1574.          if ((which_channels == downmix) && (channels > 1))
  1575.             do_downmix();
  1576.  
  1577.             for (ch=first_channel; ch<=last_channel; ch++) {
  1578.  
  1579.                     reorder(lr[ch], ch, gr);
  1580.                     antialias(ch, gr);
  1581.                hybrid(ch, gr);
  1582.  
  1583.                for (sb=1;sb<SBLIMIT;sb+=2)    // Frequency inversion
  1584.                    for (ss=1;ss<SSLIMIT;ss+=2)
  1585.                             re_hybridOut[sb][ss] = -re_hybridOut[sb][ss];
  1586.  
  1587.                     if ((ch == 0) || (which_channels == right)) {
  1588.                       for (ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
  1589.                      for (sb=0;sb<SBLIMIT;sb++)
  1590.                                   filter1->input_sample(re_hybridOut[sb][ss], sb);
  1591.  
  1592.                         filter1->calculate_pcm_samples(buffer);
  1593.                       }
  1594.                     } else {
  1595.                       for (ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
  1596.                             for (sb=0;sb<SBLIMIT;sb++)
  1597.                                 filter2->input_sample(re_hybridOut[sb][ss], sb);
  1598.  
  1599.                             filter2->calculate_pcm_samples(buffer);
  1600.                       }
  1601.                }
  1602.             }    // channels
  1603.      }    // granule
  1604.        buffer->write_buffer(1);
  1605. }
  1606.  
  1607.