开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
layer3.cpp
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：38k
源码类别：

VC书籍

开发平台：

Visual C++

layer3.cpp：源码内容
  1. /* layer3.cpp
  3. Implementation of the layer III decoder
  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).
  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().
  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. */
  22. #include <math.h>
  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 "l3table.h"
  34. #include "inv_mdct.h"
  36. LayerIII_Decoder::LayerIII_Decoder(Ibitstream *stream0,
  37.                                    Header *header0,
  38.                                    SynthesisFilter *filtera,
  39.                                    SynthesisFilter *filterb,
  40.                     Obuffer *buffer0,
  41.                                    enum e_channels which_ch0)
  42. {
  43.   stream         = stream0;
  44.   header         = header0;
  45.   filter1        = filtera;
  46.   filter2        = filterb;
  47.   buffer         = buffer0;
  48.   which_channels = which_ch0;
  50.   frame_start = 0;
  51.   channels    = (header->mode() == single_channel) ? 1 : 2;
  52.   max_gr      = (header->version() == MPEG1) ? 2 : 1;
  54.   sfreq       =  header->sample_frequency() +
  55.                  ((header->version() == MPEG1) ? 3 : 0);
  57.   if (channels == 2) {
  59.      switch (which_channels) {
  61.      case left:
  62.      case downmix:
  63.      first_channel = last_channel = 0;
  64.      break;
  66.      case right:
  67.      first_channel = last_channel = 1;
  68.      break;
  70.      case both:
  71.   default:
  72.      first_channel  = 0;
  73.      last_channel   = 1;
  74.      break;
  75.      }
  77.   } else {
  79.     first_channel = last_channel = 0;
  80.   }
  82.   for(int32 ch=0;ch<2;ch++)
  83.      for (int32 j=0; j<576; j++)
  84.     prevblck[ch][j] = 0.0f;
  86.   nonzero[0] = nonzero[1] = 576;
  88.   br = new Bit_Reserve();
  89.   si = new III_side_info_t;
  90. }
  92. LayerIII_Decoder::~LayerIII_Decoder()
  93. {
  94.    delete br;
  95.    delete si;
  96. }
  98. void LayerIII_Decoder::seek_notify()
  99. {
  100. frame_start = 0;
  103.   for(int32 ch=0;ch<2;ch++)
  104.   for (int32 j=0; j<576; j++)
  105.        prevblck[ch][j] = 0.0f;
  107.    delete br;
  108.    br = new Bit_Reserve;
  109. }
  112. bool LayerIII_Decoder::get_side_info()
  113. // Reads the side info from the stream, assuming the entire
  114. // frame has been read already.
  116. // Mono   : 136 bits (= 17 bytes)
  117. // Stereo : 256 bits (= 32 bytes)
  119. {
  120. uint32 ch;
  121. int32 gr;
  123. if (header->version() == MPEG1) {
  125. si->main_data_begin = stream->get_bits(9);
  126. if (channels == 1)
  127. si->private_bits = stream->get_bits(5);
  128. else si->private_bits = stream->get_bits(3);
  130. for (ch=0; ch<channels; ch++) {
  131. si->ch[ch].scfsi[0] = stream->get_bits(1);
  132. si->ch[ch].scfsi[1] = stream->get_bits(1);
  133. si->ch[ch].scfsi[2] = stream->get_bits(1);
  134. si->ch[ch].scfsi[3] = stream->get_bits(1);
  135.    }
  137. for (gr=0; gr<2; gr++) {
  138. for (ch=0; ch<channels; ch++) {
  139. si->ch[ch].gr[gr].part2_3_length = stream->get_bits(12);
  140.    si->ch[ch].gr[gr].big_values = stream->get_bits(9);
  141. si->ch[ch].gr[gr].global_gain = stream->get_bits(8);
  142. si->ch[ch].gr[gr].scalefac_compress = stream->get_bits(4);
  143. si->ch[ch].gr[gr].window_switching_flag = stream->get_bits(1);
  144. if (si->ch[ch].gr[gr].window_switching_flag) {
  145. si->ch[ch].gr[gr].block_type       = stream->get_bits(2);
  146. si->ch[ch].gr[gr].mixed_block_flag = stream->get_bits(1);
  148. si->ch[ch].gr[gr].table_select[0]  = stream->get_bits(5);
  149. si->ch[ch].gr[gr].table_select[1]  = stream->get_bits(5);
  151. si->ch[ch].gr[gr].subblock_gain[0] = stream->get_bits(3);
  152. si->ch[ch].gr[gr].subblock_gain[1] = stream->get_bits(3);
  153. si->ch[ch].gr[gr].subblock_gain[2] = stream->get_bits(3);
  155. // Set region_count parameters since they are implicit in this case.
  157. if (si->ch[ch].gr[gr].block_type == 0) {
  158. //  Side info bad: block_type == 0 in split block
  159. return false;
  160. } else if (si->ch[ch].gr[gr].block_type == 2
  161.      && si->ch[ch].gr[gr].mixed_block_flag == 0) {
  162. si->ch[ch].gr[gr].region0_count = 8;
  163.                } else {
  164.                si->ch[ch].gr[gr].region0_count = 7;
  165.                }
  166. si->ch[ch].gr[gr].region1_count = 20 -
  167. si->ch[ch].gr[gr].region0_count;
  168. } else {
  169. si->ch[ch].gr[gr].table_select[0] = stream->get_bits(5);
  170. si->ch[ch].gr[gr].table_select[1] = stream->get_bits(5);
  171. si->ch[ch].gr[gr].table_select[2] = stream->get_bits(5);
  172. si->ch[ch].gr[gr].region0_count = stream->get_bits(4);
  173. si->ch[ch].gr[gr].region1_count = stream->get_bits(3);
  174. si->ch[ch].gr[gr].block_type = 0;
  175. }
  176. si->ch[ch].gr[gr].preflag = stream->get_bits(1);
  177. si->ch[ch].gr[gr].scalefac_scale = stream->get_bits(1);
  178. si->ch[ch].gr[gr].count1table_select = stream->get_bits(1);
  179.          }
  180.       }
  182.    } else {   // MPEG-2 LSF
  184.       si->main_data_begin = stream->get_bits(8);
  185.       if (channels == 1)
  186.        si->private_bits = stream->get_bits(1);
  187.       else si->private_bits = stream->get_bits(2);
  189.       for (ch=0; ch<channels; ch++) {
  191.           si->ch[ch].gr[0].part2_3_length = stream->get_bits(12);
  192.           si->ch[ch].gr[0].big_values = stream->get_bits(9);
  193.           si->ch[ch].gr[0].global_gain = stream->get_bits(8);
  194.           si->ch[ch].gr[0].scalefac_compress = stream->get_bits(9);
  195.           si->ch[ch].gr[0].window_switching_flag = stream->get_bits(1);
  197.           if (si->ch[ch].gr[0].window_switching_flag) {
  199.              si->ch[ch].gr[0].block_type = stream->get_bits(2);
  200.              si->ch[ch].gr[0].mixed_block_flag = stream->get_bits(1);
  201.              si->ch[ch].gr[0].table_select[0] = stream->get_bits(5);
  202.              si->ch[ch].gr[0].table_select[1] = stream->get_bits(5);
  204.              si->ch[ch].gr[0].subblock_gain[0] = stream->get_bits(3);
  205.              si->ch[ch].gr[0].subblock_gain[1] = stream->get_bits(3);
  206.              si->ch[ch].gr[0].subblock_gain[2] = stream->get_bits(3);
  208.             // Set region_count parameters since they are implicit in this case.
  210.              if (si->ch[ch].gr[0].block_type == 0) {
  211.                 // Side info bad: block_type == 0 in split block
  212.                 return false;
  213.              } else if (si->ch[ch].gr[0].block_type == 2
  214.                       && si->ch[ch].gr[0].mixed_block_flag == 0) {
  215.                si->ch[ch].gr[0].region0_count = 8;
  216.  } else {
  217.                si->ch[ch].gr[0].region0_count = 7;
  218.                 si->ch[ch].gr[0].region1_count = 20 -
  219.                  si->ch[ch].gr[0].region0_count;
  220.              }
  222.           } else {
  223.              si->ch[ch].gr[0].table_select[0] = stream->get_bits(5);
  224.              si->ch[ch].gr[0].table_select[1] = stream->get_bits(5);
  225.              si->ch[ch].gr[0].table_select[2] = stream->get_bits(5);
  226.              si->ch[ch].gr[0].region0_count = stream->get_bits(4);
  227.              si->ch[ch].gr[0].region1_count = stream->get_bits(3);
  228.              si->ch[ch].gr[0].block_type = 0;
  229.           }
  231.           si->ch[ch].gr[0].scalefac_scale = stream->get_bits(1);
  232.           si->ch[ch].gr[0].count1table_select = stream->get_bits(1);
  233.       }   // for(ch=0; ch<channels; ch++)
  234.    } // if (header->version() == MPEG1)
  235. return true;
  236. }
  238. struct {
  239. int32 l[5];
  240. int32 s[3];} sfbtable = {{0, 6, 11, 16, 21},
  241.     {0, 6, 12}};
  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];
  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;
  267.       } else {  // SHORT
  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
  310. } else {   // LONG types 0,1,3
  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. }
  342.       scalefac[ch].l[21] = 0;
  343. scalefac[ch].l[22] = 0;
  344. }
  345. }
  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}}};
  355. uint32 scalefac_buffer[54];
  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;
  365. gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  367. scalefac_comp =  gr_info->scalefac_compress;
  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.    }
  380.    if(!(((mode_ext == 1) || (mode_ext == 3)) && (ch == 1))) {
  382. if(scalefac_comp < 400) {
  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;
  390.          blocknumber = 0;
  392.       } else if (scalefac_comp  < 500) {
  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;
  400.          blocknumber = 1;
  402.    } else if (scalefac_comp < 512) {
  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;
  410.       blocknumber = 2;
  411.      }
  412.    }
  414.    if((((mode_ext == 1) || (mode_ext == 3)) && (ch == 1)))
  415.    {
  416.       int_scalefac_comp = scalefac_comp >> 1;
  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.    }
  443.    for (uint32 x=0; x<45; x++) // why 45, not 54?
  444.     scalefac_buffer[x] = 0;
  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++;
  455.       } // for (unint32 j ...
  456.    } // for (uint32 i ...
  457. }
  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]);
  465.    get_LSF_scale_data(ch, gr);
  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;
  484.       } else {  // SHORT
  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.            }
  494.            for (window=0; window<3; window++)
  495.                scalefac[ch].s[window][12] = 0;
  496.       }
  497.    } else {   // LONG types 0,1,3
  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. }
  508. void LayerIII_Decoder::huffman_decode(uint32 ch, uint32 gr)
  509. {
  510. int32 x, y;
  511. int32 v, w;
  512.    int32 part2_3_end = part2_start + si->ch[ch].gr[gr].part2_3_length;
  513.    int32 num_bits;
  514. int32 region1Start;
  515. int32 region2Start;
  516.    int32 index;
  517.   struct huffcodetab *h;
  519. // Find region boundary for short block case
  521. if ( (si->ch[ch].gr[gr].window_switching_flag) &&
  522.   (si->ch[ch].gr[gr].block_type == 2) ) {
  524. // Region2.
  526. region1Start = 36;  // sfb[9/3]*3=36
  527. region2Start = 576; // No Region2 for short block case
  529. } else {          // Find region boundary for long block case
  531. region1Start = sfBandIndex[sfreq].l[si->ch[ch].gr[gr].region0_count
  532.                                              + 1];
  533. region2Start = sfBandIndex[sfreq].l[si->ch[ch].gr[gr].region0_count +
  534.    si->ch[ch].gr[gr].region1_count + 2]; /* MI */
  535.    }
  537.    index = 0;
  538. // Read bigvalues area
  539. for (uint32 i=0; i<(si->ch[ch].gr[gr].big_values<<1); i+=2) {
  540. if      (i<region1Start) h = &ht[si->ch[ch].gr[gr].table_select[0]];
  541. else if (i<region2Start) h = &ht[si->ch[ch].gr[gr].table_select[1]];
  542.   else                h = &ht[si->ch[ch].gr[gr].table_select[2]];
  544. huffman_decoder(h, &x, &y, &v, &w, br);
  546.       is_1d[index++] = x;
  547.       is_1d[index++] = y;
  548. }
  550. // Read count1 area
  551. h = &ht[si->ch[ch].gr[gr].count1table_select+32];
  552.    num_bits = br->hsstell();
  554. while ((num_bits < part2_3_end) && (index < 576)) {
  556. huffman_decoder(h, &x, &y, &v, &w, br);
  558.       is_1d[index++] = v;
  559.       is_1d[index++] = w;
  560.       is_1d[index++] = x;
  561.       is_1d[index++] = y;
  562.       num_bits = br->hsstell();
  563.    }
  565. if (num_bits > part2_3_end) {
  566. br->rewindNbits(num_bits - part2_3_end);
  567.       index-=4;
  568.    }
  570.    num_bits = br->hsstell();
  572. // Dismiss stuffing bits
  573. if (num_bits < part2_3_end)
  574.     br->hgetbits(part2_3_end - num_bits);
  576. // Zero out rest
  578.    if (index < 576)
  579.    nonzero[ch] = index;
  580.    else
  581.     nonzero[ch] = 576;
  583.    // may not be necessary
  584.    for (; index<576; index++)
  585.     is_1d[index] = 0;
  586. }
  588. void LayerIII_Decoder::dequantize_sample(real xr[SBLIMIT][SSLIMIT],
  589.      uint32 ch, uint32 gr)
  590. {
  591. gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  592. int32  cb=0;
  593. int32  next_cb_boundary, cb_begin, cb_width;
  594. int32  index=0, t_index, j;
  595.    real   g_gain;
  596.    real  *xr_1d = &xr[0][0];
  598. // choose correct scalefactor band per block type, initalize boundary
  600. if (gr_info->window_switching_flag && (gr_info->block_type == 2) ) {
  601. if (gr_info->mixed_block_flag)
  602. next_cb_boundary=sfBandIndex[sfreq].l[1];  // LONG blocks: 0,1,3
  603. else {
  604.          cb_width = sfBandIndex[sfreq].s[1];
  605.    next_cb_boundary = (cb_width << 2) - cb_width;
  606.      cb_begin = 0;
  607. }
  608. } else {
  609. next_cb_boundary=sfBandIndex[sfreq].l[1];  // LONG blocks: 0,1,3
  610.    }
  612.    // Compute overall (global) scaling.
  614. g_gain = (real) pow(2.0 , (0.25 * (gr_info->global_gain - 210.0)));
  616.    for (j=0; j<nonzero[ch]; j++) {
  617.      if (is_1d[j] == 0) {
  618. xr_1d[j] = 0.0f;
  619.       } else {
  620.          int32 abv = is_1d[j];
  621.          if (is_1d[j] > 0)
  622.       xr_1d[j] = g_gain * t_43[abv];
  623.          else
  624.           xr_1d[j] = -g_gain * t_43[-abv];
  625.       }
  626.    }
  628. // apply formula per block type
  630.    for (j=0; j<nonzero[ch]; j++) {
  632. if (index == next_cb_boundary)  { /* Adjust critical band boundary */
  633.        if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  634.           if (gr_info->mixed_block_flag)  {
  636.              if (index == sfBandIndex[sfreq].l[8])  {
  637.                   next_cb_boundary = sfBandIndex[sfreq].s[4];
  638.                   next_cb_boundary = (next_cb_boundary << 2) -
  639.                                 next_cb_boundary;
  640.                   cb = 3;
  641.                   cb_width = sfBandIndex[sfreq].s[4] -
  642.                        sfBandIndex[sfreq].s[3];
  644.                   cb_begin = sfBandIndex[sfreq].s[3];
  645.                   cb_begin = (cb_begin << 2) - cb_begin;
  647.                } else if (index < sfBandIndex[sfreq].l[8]) {
  649.                 next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  651.                } else {
  653.                 next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
  654.                   next_cb_boundary = (next_cb_boundary << 2) -
  655.                              next_cb_boundary;
  657.                   cb_begin = sfBandIndex[sfreq].s[cb];
  658. cb_width = sfBandIndex[sfreq].s[cb+1] -
  659.                              cb_begin;
  660.                   cb_begin = (cb_begin << 2) - cb_begin;
  661.                }
  663.             } else  {
  665.                next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
  666.                next_cb_boundary = (next_cb_boundary << 2) -
  667.                                   next_cb_boundary;
  669.                cb_begin = sfBandIndex[sfreq].s[cb];
  670. cb_width = sfBandIndex[sfreq].s[cb+1] -
  671.                           cb_begin;
  672.                cb_begin = (cb_begin << 2) - cb_begin;
  673.             }
  675.          } else  { // long blocks
  677. next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
  679.          }
  680.       }
  682. // Do long/short dependent scaling operations
  684. if (gr_info->window_switching_flag &&
  685.  (((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 0)) ||
  686.   ((gr_info->block_type == 2) && gr_info->mixed_block_flag && (j >= 36)) ))
  687.       {
  689. t_index = (index - cb_begin) / cb_width;
  690. /*            xr[sb][ss] *= pow(2.0, ((-2.0 * gr_info->subblock_gain[t_index])
  691.                                     -(0.5 * (1.0 + gr_info->scalefac_scale)
  692.                                       * scalefac[ch].s[t_index][cb]))); */
  693. uint32 idx = scalefac[ch].s[t_index][cb]
  694.              << gr_info->scalefac_scale;
  695.          idx += (gr_info->subblock_gain[t_index] << 2);
  697. xr_1d[j] *= two_to_negative_half_pow[idx];
  699. } else {   // LONG block types 0,1,3 & 1st 2 subbands of switched blocks
  700. /* xr[sb][ss] *= pow(2.0, -0.5 * (1.0+gr_info->scalefac_scale)
  701.  * (scalefac[ch].l[cb]
  702.  + gr_info->preflag * pretab[cb])); */
  703. uint32 idx = scalefac[ch].l[cb];
  705.     if (gr_info->preflag)
  706.     idx += pretab[cb];
  708.    idx = idx << gr_info->scalefac_scale;
  709.          xr_1d[j] *= two_to_negative_half_pow[idx];
  710. }
  711.       index++;
  712. }
  714.    for (j=nonzero[ch]; j<576; j++)
  715.       xr_1d[j] = 0.0f;
  717.    return;
  718. }
  720. void LayerIII_Decoder::reorder(real xr[SBLIMIT][SSLIMIT], uint32 ch, uint32 gr)
  721. {
  723. gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  724.    uint32 freq, freq3;
  725.    int32 index;
  726. int32 sfb, sfb_start, sfb_lines;
  727.    int32 src_line, des_line;
  729.    real *xr_1d = &xr[0][0];
  731. if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  733.       for(index=0; index<576; index++)
  734.          out_1d[index] = 0.0f;
  736. if (gr_info->mixed_block_flag) {
  737. // NO REORDER FOR LOW 2 SUBBANDS
  738.             for (index = 0; index < 36; index++)
  739.                out_1d[index] = xr_1d[index];
  741. // REORDERING FOR REST SWITCHED SHORT
  742. for(sfb=3,sfb_start=sfBandIndex[sfreq].s[3],
  743.     sfb_lines=sfBandIndex[sfreq].s[4] - sfb_start;
  744.     sfb < 13; sfb++,sfb_start = sfBandIndex[sfreq].s[sfb],
  745.     (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
  746.             {
  747.    int32 sfb_start3 = (sfb_start << 2) - sfb_start;
  749. for(freq=0, freq3=0; freq<sfb_lines;
  750.                       freq++, freq3+=3) {
  752. src_line = sfb_start3 + freq;
  753. des_line = sfb_start3 + freq3;
  754. out_1d[des_line] = xr_1d[src_line];
  755. src_line += sfb_lines;
  756. des_line++;
  757. out_1d[des_line] = xr_1d[src_line];
  758. src_line += sfb_lines;
  759. des_line++;
  760. out_1d[des_line] = xr_1d[src_line];
  761.    }
  762.             }
  764. } else {  // pure short
  765.        for(index=0;index<576;index++)
  766.             out_1d[index] = xr_1d[reorder_table[sfreq][index]];
  767. }
  768. }
  769. else {   // long blocks
  770.       for(index=0; index<576; index++)
  771.        out_1d[index] = xr_1d[index];
  772. }
  773. }
  775. void LayerIII_Decoder::i_stereo_k_values(uint32 is_pos, uint32 io_type,
  776.      uint32 i)
  777. {
  778.    if (is_pos == 0) {
  779.       k[0][i] = 1.0f;
  780.       k[1][i] = 1.0f;
  781.    } else if (is_pos & 1) {
  782. k[0][i] = io[io_type][(is_pos + 1) >> 1];
  783.       k[1][i] = 1.0f;
  784.    } else {
  785.       k[0][i] = 1.0f;
  786.       k[1][i] = io[io_type][is_pos >> 1];
  787.    }
  788. }
  790. void LayerIII_Decoder::stereo(uint32 gr)
  791. {
  792.    int32 sb, ss;
  794. if  (channels == 1) { // mono , bypass xr[0][][] to lr[0][][]
  796. for(sb=0;sb<SBLIMIT;sb++)
  797. for(ss=0;ss<SSLIMIT;ss+=3) {
  798. lr[0][sb][ss]   = ro[0][sb][ss];
  799.             lr[0][sb][ss+1] = ro[0][sb][ss+1];
  800. lr[0][sb][ss+2] = ro[0][sb][ss+2];
  801.          }
  803.    } else {
  805. uint32 is_pos[576];
  806. real  is_ratio[576];
  807. gr_info_s *gr_info = &(si->ch[0].gr[gr]);
  808.    uint32 mode_ext = header->mode_extension();
  809. int32 sfb;
  810. int32 i;
  811.    int32 lines, temp, temp2;
  812. bool ms_stereo = (header->mode() == joint_stereo) && (mode_ext & 0x2);
  813. bool i_stereo  = (header->mode() == joint_stereo) && (mode_ext & 0x1);
  814.    bool lsf = (header->version() == MPEG2_LSF);
  816. uint32 io_type = (gr_info->scalefac_compress & 1);
  818.   // initialization
  820.    for (i=0; i<576; i++)
  821.     is_pos[i] = 7;
  823. if (i_stereo) {
  824.     if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
  825.        if (gr_info->mixed_block_flag) {
  827.            int32 max_sfb = 0;
  829.  for (uint32 j=0; j<3; j++) {
  830.              int32 sfbcnt;
  831. sfbcnt = 2;
  832. for( sfb=12; sfb >=3; sfb-- ) {
  833.                 i = sfBandIndex[sfreq].s[sfb];
  834. lines = sfBandIndex[sfreq].s[sfb+1] - i;
  835.                   i = (i << 2) - i + (j+1) * lines - 1;
  837. while (lines > 0) {
  838.                    if (ro[1][ss_div[i]][ss_mod[i]] != 0.0f) {
  839.                       sfbcnt = sfb;
  840. sfb = -10;
  841. lines = -10;
  842. }
  844. lines--;
  845. i--;
  847. } // while (lines > 0)
  849. } // for (sfb=12 ...
  850. sfb = sfbcnt + 1;
  852. if (sfb > max_sfb)
  853. max_sfb = sfb;
  855. while(sfb < 12) {
  856.                 temp = sfBandIndex[sfreq].s[sfb];
  857.                 sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
  858.                   i    = (temp << 2) - temp + j * sb;
  860. for ( ; sb > 0; sb--) {
  861.                    is_pos[i] = scalefac[1].s[j][sfb];
  862. if (is_pos[i] != 7)
  863.                       if (lsf)
  864.                            i_stereo_k_values(is_pos[i], io_type, i);
  865.                         else
  866.                          is_ratio[i] = TAN12[is_pos[i]];
  868. i++;
  869. } // for (; sb>0...
  870. sfb++;
  871. } // while (sfb < 12)
  872. sfb = sfBandIndex[sfreq].s[10];
  873.                sb  = sfBandIndex[sfreq].s[11] - sfb;
  874.                sfb = (sfb << 2) - sfb + j * sb;
  875.                temp  = sfBandIndex[sfreq].s[11];
  876.                sb = sfBandIndex[sfreq].s[12] - temp;
  877.                i = (temp << 2) - temp + j * sb;
  879. for (; sb > 0; sb--) {
  880.                 is_pos[i] = is_pos[sfb];
  882.             if (lsf) {
  883.                k[0][i] = k[0][sfb];
  884.          k[1][i] = k[1][sfb];
  885.             } else {
  886.       is_ratio[i] = is_ratio[sfb];
  887.                   }
  888. i++;
  889. } // for (; sb > 0 ...
  890.  }
  891.  if (max_sfb <= 3) {
  892.                 i = 2;
  893.  ss = 17;
  894.  sb = -1;
  895.  while (i >= 0) {
  896.                  if (ro[1][i][ss] != 0.0f) {
  897.                      sb = (i<<4) + (i<<1) + ss;
  898.  i = -1;
  899. } else {
  900.                       ss--;
  901.  if (ss < 0) {
  902.                          i--;
  903.  ss = 17;
  904.  }
  905. } // if (ro ...
  906.  } // while (i>=0)
  907.  i = 0;
  908.  while (sfBandIndex[sfreq].l[i] <= sb)
  909.  i++;
  910.  sfb = i;
  911.  i = sfBandIndex[sfreq].l[i];
  912.  for (; sfb<8; sfb++) {
  913.                    sb = sfBandIndex[sfreq].l[sfb+1]-sfBandIndex[sfreq].l[sfb];
  914.  for (; sb>0; sb--) {
  915.                       is_pos[i] = scalefac[1].l[sfb];
  916.                      if (is_pos[i] != 7)
  917.                       if (lsf)
  918.                            i_stereo_k_values(is_pos[i], io_type, i);
  919.                          else
  920.                          is_ratio[i] = TAN12[is_pos[i]];
  921.  i++;
  922.  } // for (; sb>0 ...
  923.  } // for (; sfb<8 ...
  924.  } // for (j=0 ...
  925. } else { // if (gr_info->mixed_block_flag)
  926.           for (uint32 j=0; j<3; j++) {
  927.              int32 sfbcnt;
  928. sfbcnt = -1;
  929. for( sfb=12; sfb >=0; sfb-- )
  930. {
  931. temp = sfBandIndex[sfreq].s[sfb];
  932.                   lines = sfBandIndex[sfreq].s[sfb+1] - temp;
  933.                   i = (temp << 2) - temp + (j+1) * lines - 1;
  935. while (lines > 0) {
  936. if (ro[1][ss_div[i]][ss_mod[i]] != 0.0f) {
  937.                       sfbcnt = sfb;
  938. sfb = -10;
  939. lines = -10;
  940. }
  941. lines--;
  942. i--;
  943. } // while (lines > 0) */
  945. } // for (sfb=12 ...
  946. sfb = sfbcnt + 1;
  947. while(sfb<12) {
  948. temp = sfBandIndex[sfreq].s[sfb];
  949.                   sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
  950.                   i    = (temp << 2) - temp + j * sb;
  951. for ( ; sb > 0; sb--) {
  952.                    is_pos[i] = scalefac[1].s[j][sfb];
  953. if (is_pos[i] != 7)
  954.                       if (lsf)
  955.                            i_stereo_k_values(is_pos[i], io_type, i);
  956.                          else
  957.                          is_ratio[i] = TAN12[is_pos[i]];
  958. i++;
  959. } // for (; sb>0 ...
  960. sfb++;
  961. } // while (sfb<12)
  963. temp = sfBandIndex[sfreq].s[10];
  964.                temp2= sfBandIndex[sfreq].s[11];
  965.                sb   = temp2 - temp;
  966.                sfb  = (temp << 2) - temp + j * sb;
  967.                sb   = sfBandIndex[sfreq].s[12] - temp2;
  968.                i    = (temp2 << 2) - temp2 + j * sb;
  970. for (; sb>0; sb--) {
  971.                 is_pos[i] = is_pos[sfb];
  973.             if (lsf) {
  974.                k[0][i] = k[0][sfb];
  975.          k[1][i] = k[1][sfb];
  976.              } else {
  977.                 is_ratio[i] = is_ratio[sfb];
  978.                   }
  979. i++;
  980. } // for (; sb>0 ...
  981. } // for (sfb=12
  982. } // for (j=0 ...
  983. } else { // if (gr_info->window_switching_flag ...
  984.        i = 31;
  985. ss = 17;
  986. sb = 0;
  987. while (i >= 0) {
  988.           if (ro[1][i][ss] != 0.0f) {
  989.              sb = (i<<4) + (i<<1) + ss;
  990. i = -1;
  991. } else {
  992.              ss--;
  993. if (ss < 0) {
  994.                 i--;
  995. ss = 17;
  996. }
  997. }
  998. }
  999. i = 0;
  1000. while (sfBandIndex[sfreq].l[i] <= sb)
  1001. i++;
  1003. sfb = i;
  1004. i = sfBandIndex[sfreq].l[i];
  1005. for (; sfb<21; sfb++) {
  1006.           sb = sfBandIndex[sfreq].l[sfb+1] - sfBandIndex[sfreq].l[sfb];
  1007.           for (; sb > 0; sb--) {
  1008.              is_pos[i] = scalefac[1].l[sfb];
  1009. if (is_pos[i] != 7)
  1010.                   if (lsf)
  1011.                      i_stereo_k_values(is_pos[i], io_type, i);
  1012.                   else
  1013.                     is_ratio[i] = TAN12[is_pos[i]];
  1014. i++;
  1015. }
  1016. }
  1017. sfb = sfBandIndex[sfreq].l[20];
  1018. for (sb = 576 - sfBandIndex[sfreq].l[21]; (sb > 0) && (i<576); sb--)
  1019. {
  1020.           is_pos[i] = is_pos[sfb]; // error here : i >=576
  1022.             if (lsf) {
  1023.                k[0][i] = k[0][sfb];
  1024.          k[1][i] = k[1][sfb];
  1025.             } else {
  1026.    is_ratio[i] = is_ratio[sfb];
  1027.             }
  1028. i++;
  1029. } // if (gr_info->mixed_block_flag)
  1030. } // if (gr_info->window_switching_flag ...
  1031. } // if (i_stereo)
  1033.     i = 0;
  1034. for(sb=0;sb<SBLIMIT;sb++)
  1035. for(ss=0;ss<SSLIMIT;ss++) {
  1036. if (is_pos[i] == 7) {
  1037. if (ms_stereo) {
  1038. lr[0][sb][ss] = (ro[0][sb][ss]+ro[1][sb][ss]) * 0.707106781f;
  1039. lr[1][sb][ss] = (ro[0][sb][ss]-ro[1][sb][ss]) * 0.707106781f;
  1040. } else {
  1041. lr[0][sb][ss] = ro[0][sb][ss];
  1042. lr[1][sb][ss] = ro[1][sb][ss];
  1043. }
  1044. }
  1045. else if (i_stereo) {
  1047.              if (lsf) {
  1048.                   lr[0][sb][ss] = ro[0][sb][ss] * k[0][i];
  1049.                   lr[1][sb][ss] = ro[0][sb][ss] * k[1][i];
  1050.                } else {
  1051.                 lr[1][sb][ss] = ro[0][sb][ss] / (real) (1 + is_ratio[i]);
  1052.       lr[0][sb][ss] = lr[1][sb][ss] * is_ratio[i];
  1053.                }
  1054. }
  1055. /* else {
  1056. printf("Error in stereo processingn");
  1057. } */
  1058.             i++;
  1059. }
  1061.     } // channels == 2
  1062. }
  1064. void LayerIII_Decoder::antialias(uint32 ch, uint32 gr)
  1065. {
  1066. int32 sb18, ss, sb18lim;
  1067.    gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  1069. // 31 alias-reduction operations between each pair of sub-bands
  1070. // with 8 butterflies between each pair
  1072. if  (gr_info->window_switching_flag && (gr_info->block_type == 2) &&
  1073.  !gr_info->mixed_block_flag )
  1074.        return;
  1076. if (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  1077.     (gr_info->block_type == 2)) {
  1078.       sb18lim = 18;
  1079. } else {
  1080. sb18lim = 558;
  1081.    }
  1083.    for (sb18=0; sb18 < sb18lim; sb18+=18) {
  1084.       for (ss=0;ss<8;ss++) {
  1085.        int32 src_idx1 = sb18 + 17 - ss;
  1086.          int32 src_idx2 = sb18 + 18 + ss;
  1087.        real bu = out_1d[src_idx1];
  1088. real bd = out_1d[src_idx2];
  1089. out_1d[src_idx1] = (bu * cs[ss]) - (bd * ca[ss]);
  1090. out_1d[src_idx2] = (bd * cs[ss]) + (bu * ca[ss]);
  1091.       }
  1092.    }
  1093. }
  1095. void LayerIII_Decoder::hybrid(uint32 ch, uint32 gr)
  1096. {
  1097. real rawout[36];
  1098.    uint32 bt;
  1099.    int32 sb18;
  1100.    gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
  1101.    real *tsOut;
  1102.    real *prvblk;
  1104.    for(sb18=0;sb18<576;sb18+=18) {
  1106. bt = (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
  1107.  (sb18 < 36)) ? 0 : gr_info->block_type;
  1109. tsOut = out_1d + sb18;
  1111. inv_mdct(tsOut, rawout, bt);
  1113. // overlap addition
  1114. prvblk = &prevblck[ch][sb18];
  1116.    tsOut[0]   = rawout[0]  + prvblk[0];
  1117.    prvblk[0]  = rawout[18];
  1118.    tsOut[1]   = rawout[1]  + prvblk[1];
  1119.    prvblk[1]  = rawout[19];
  1120.    tsOut[2]   = rawout[2]  + prvblk[2];
  1121.    prvblk[2]  = rawout[20];
  1122.    tsOut[3]   = rawout[3]  + prvblk[3];
  1123.    prvblk[3]  = rawout[21];
  1124.    tsOut[4]   = rawout[4]  + prvblk[4];
  1125.    prvblk[4]  = rawout[22];
  1126.    tsOut[5]   = rawout[5]  + prvblk[5];
  1127.    prvblk[5]  = rawout[23];
  1128.    tsOut[6]   = rawout[6]  + prvblk[6];
  1129.    prvblk[6]  = rawout[24];
  1130.    tsOut[7]   = rawout[7]  + prvblk[7];
  1131.    prvblk[7]  = rawout[25];
  1132.    tsOut[8]   = rawout[8]  + prvblk[8];
  1133.    prvblk[8]  = rawout[26];
  1134.    tsOut[9]   = rawout[9]  + prvblk[9];
  1135.    prvblk[9]  = rawout[27];
  1136.     tsOut[10]  = rawout[10] + prvblk[10];
  1137.     prvblk[10] = rawout[28];
  1138.     tsOut[11]  = rawout[11] + prvblk[11];
  1139.       prvblk[11] = rawout[29];
  1140.     tsOut[12]  = rawout[12] + prvblk[12];
  1141.     prvblk[12] = rawout[30];
  1142.     tsOut[13]  = rawout[13] + prvblk[13];
  1143.     prvblk[13] = rawout[31];
  1144.     tsOut[14]  = rawout[14] + prvblk[14];
  1145.     prvblk[14] = rawout[32];
  1146.     tsOut[15]  = rawout[15] + prvblk[15];
  1147.     prvblk[15] = rawout[33];
  1148.     tsOut[16]  = rawout[16] + prvblk[16];
  1149.     prvblk[16] = rawout[34];
  1150.     tsOut[17]  = rawout[17] + prvblk[17];
  1151.     prvblk[17] = rawout[35];
  1152.    }
  1153. }
  1155. void LayerIII_Decoder::do_downmix()
  1156. {
  1157. for (uint32 sb=0; sb<SSLIMIT; sb++) {
  1158.     for (uint32 ss=0; ss<SSLIMIT; ss+=3) {
  1159.        lr[0][sb][ss]   = (lr[0][sb][ss]   + lr[1][sb][ss])   * 0.5f;
  1160.        lr[0][sb][ss+1] = (lr[0][sb][ss+1] + lr[1][sb][ss+1]) * 0.5f;
  1161.        lr[0][sb][ss+2] = (lr[0][sb][ss+2] + lr[1][sb][ss+2]) * 0.5f;
  1162.       }
  1163.    }
  1164. }
  1166. void LayerIII_Decoder::decode()
  1167. {
  1168.  uint32 nSlots = header->slots();
  1169.     uint32 flush_main;
  1170.     uint32 gr, ch, ss, sb, sb18;
  1171.     int32 main_data_end;
  1172.  int32 bytes_to_discard;
  1173.     uint32 i;
  1175.  get_side_info();
  1177.     for (i=0; i<nSlots; i++)
  1178.      br->hputbuf(stream->get_bits(8));
  1180.     main_data_end = br->hsstell() >> 3; // of previous frame
  1182.     if (flush_main = (br->hsstell() & 7)) {
  1183.          br->hgetbits(8 - flush_main);
  1184. main_data_end++;
  1185.  }
  1187.  bytes_to_discard = frame_start - main_data_end
  1188.   - si->main_data_begin;
  1190.  frame_start += nSlots;
  1192.     if (bytes_to_discard < 0)
  1193. return;
  1195.  if (main_data_end > 4096) {
  1196. frame_start -= 4096;
  1197. br->rewindNbytes(4096);
  1198.  }
  1200.  for (; bytes_to_discard > 0; bytes_to_discard--)
  1201.      br->hgetbits(8);
  1203.  for (gr=0;gr<max_gr;gr++) {
  1205. for (ch=0; ch<channels; ch++) {
  1206.            part2_start = br->hsstell();
  1208.            if (header->version() == MPEG1)
  1209.   get_scale_factors(ch, gr);
  1210.            else  // MPEG-2 LSF
  1211.               get_LSF_scale_factors(ch, gr);
  1213.   huffman_decode(ch, gr);
  1214.   dequantize_sample(ro[ch], ch, gr);
  1215. }
  1217.          stereo(gr);
  1219.          if ((which_channels == downmix) && (channels > 1))
  1220.           do_downmix();
  1222.          for (ch=first_channel; ch<=last_channel; ch++) {
  1224.           reorder(lr[ch], ch, gr);
  1225. antialias(ch, gr);
  1226.                hybrid(ch, gr);
  1228. for (sb18=18;sb18<576;sb18+=36) // Frequency inversion
  1229.                    for (ss=1;ss<SSLIMIT;ss+=2)
  1230.                      out_1d[sb18 + ss] = -out_1d[sb18 + ss];
  1232. if ((ch == 0) || (which_channels == right)) {
  1233.   for (ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
  1234.                    sb = 0;
  1235.                   for (sb18=0; sb18<576; sb18+=18) {
  1236.  filter1->input_sample(out_1d[sb18+ss], sb);
  1237.                          sb++;
  1238.                      }
  1239.                      filter1->calculate_pcm_samples(buffer);
  1240.   }
  1241. } else {
  1242.   for (ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
  1243.                    sb = 0;
  1244.                   for (sb18=0; sb18<576; sb18+=18) {
  1245.  filter2->input_sample(out_1d[sb18+ss], sb);
  1246.                          sb++;
  1247.                      }
  1248.                      filter2->calculate_pcm_samples(buffer);
  1249.   }
  1251.                }
  1252. } // channels
  1253.  } // granule
  1255.     buffer->write_buffer(1);
  1256. }