PageRenderTime 753ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 0ms

/cdex1/branches/cdex_130/cdexos/MP3Dec/layer3.cpp

#
C++ | 1256 lines | 994 code | 208 blank | 54 comment | 304 complexity | 91516c2c1d281181ab4dffbf8f49ecc8 MD5 | raw file
Possible License(s): LGPL-2.1, GPL-2.0, LGPL-2.0, BSD-3-Clause, AGPL-1.0, CC-BY-SA-3.0, GPL-3.0 
    

  1. /* layer3.cpp
    2. 

    3. 

  3. 	Implementation of the layer III decoder
    4. 

    5. 

  5.    01/31/97 : Layer III routines adopted from the ISO MPEG Audio Subgroup
    6. 

  6.    Software Simulation Group's public c source for its MPEG audio decoder.
    7. 

  7.    These routines were in the file "decoder.c". Rearrangement of the routines
    8. 

  8.    as member functions of a layer III decoder object, and optimizations by
    9. 

  9.    Jeff Tsay (ctsay@pasteur.eecs.berkeley.edu).
    10. 

    11. 

  11.    04/14/97 : Several performance improvements. Inverse IMDCT moved to
    12. 

  12.    an external source file. No huffman tables needed, so no need for
    13. 

  13.    initialization. Put get_side_info() in this source file, and made
    14. 

  14.    one function inline for better speed and elegance. Also added support
    15. 

  15.    for mono decoding of stereo streams as well as downmixing. Bug fix
    16. 

  16.    in dequantize_samples().
    17. 

    18. 

  18.    06/26/97 : Added MPEG2 LSF capability and made a few minor speedups.
    19. 

  19.    The optimized reording function must be fixed, so right now the
    20. 

  20.    one from 1.81 is used. */
    21. 

  21. 

  22. #include <math.h>
    23. 

  23. 

  24. #include "all.h"
    25. 

  25. #include "l3type.h"
    26. 

  26. #include "ibitstr.h"
    27. 

  27. #include "obuffer.h"
    28. 

  28. #include "bit_res.h"
    29. 

  29. #include "header.h"
    30. 

  30. #include "synfilt.h"
    31. 

  31. #include "huffman.h"
    32. 

  32. #include "layer3.h"
    33. 

  33. #include "l3table.h"
    34. 

  34. #include "inv_mdct.h"
    35. 

  35. 

  36. LayerIII_Decoder::LayerIII_Decoder(Ibitstream *stream0,
    37. 

  37.                                    Header *header0,
    38. 

  38.                                    SynthesisFilter *filtera,
    39. 

  39.                                    SynthesisFilter *filterb,
    40. 

  40.                  						  Obuffer *buffer0,
    41. 

  41.                                    enum e_channels which_ch0)
    42. 

  42. {
    43. 

  43.   stream         = stream0;
    44. 

  44.   header         = header0;
    45. 

  45.   filter1        = filtera;
    46. 

  46.   filter2        = filterb;
    47. 

  47.   buffer         = buffer0;
    48. 

  48.   which_channels = which_ch0;
    49. 

  49. 

  50.   frame_start = 0;
    51. 

  51.   channels    = (header->mode() == single_channel) ? 1 : 2;
    52. 

  52.   max_gr      = (header->version() == MPEG1) ? 2 : 1;
    53. 

  53. 

  54.   sfreq       =  header->sample_frequency() +
    55. 

  55.                  ((header->version() == MPEG1) ? 3 : 0);
    56. 

  56. 

  57.   if (channels == 2) {
    58. 

  58. 

  59.   	  switch (which_channels) {
    60. 

  60. 

  61.      case left:
    62. 

  62.      case downmix:
    63. 

  63.      first_channel = last_channel = 0;
    64. 

  64.      break;
    65. 

  65. 

  66.      case right:
    67. 

  67.      first_channel = last_channel = 1;
    68. 

  68.      break;
    69. 

  69. 

  70.      case both:
    71. 

  71. 	  default:
    72. 

  72.      first_channel  = 0;
    73. 

  73.      last_channel   = 1;
    74. 

  74.      break;
    75. 

  75.      }
    76. 

  76. 

  77.   } else {
    78. 

  78. 

  79.     first_channel = last_channel = 0;
    80. 

  80.   }
    81. 

  81. 

  82.   for(int32 ch=0;ch<2;ch++)
    83. 

  83.      for (int32 j=0; j<576; j++)
    84. 

  84.    		prevblck[ch][j] = 0.0f;
    85. 

  85. 

  86.   nonzero[0] = nonzero[1] = 576;
    87. 

  87. 

  88.   br = new Bit_Reserve();
    89. 

  89.   si = new III_side_info_t;
    90. 

  90. 

  91. }
    92. 

  92. 

  93. LayerIII_Decoder::~LayerIII_Decoder()
    94. 

  94. {
    95. 

  95.    delete br;
    96. 

  96.    delete si;
    97. 

  97. }
    98. 

  98. 

  99. void LayerIII_Decoder::seek_notify()
    100. 

  100. {
    101. 

  101. 	frame_start = 0;
    102. 

  102. 

  103. 

  104.   for(int32 ch=0;ch<2;ch++)
    105. 

  105. 	  for (int32 j=0; j<576; j++)
    106. 

  106.    	   prevblck[ch][j] = 0.0f;
    107. 

  107. 

  108.    delete br;
    109. 

  109.    br = new Bit_Reserve;
    110. 

  110. }
    111. 

  111. 

  112. 

  113. bool LayerIII_Decoder::get_side_info()
    114. 

  114. // Reads the side info from the stream, assuming the entire
    115. 

  115. // frame has been read already.
    116. 

  116. 

  117. // Mono   : 136 bits (= 17 bytes)
    118. 

  118. // Stereo : 256 bits (= 32 bytes)
    119. 

  119. 

  120. {
    121. 

  121. 	int32 ch, gr;
    122. 

  122. 

  123. 	if (header->version() == MPEG1) {
    124. 

  124. 

  125. 		si->main_data_begin = stream->get_bits(9);
    126. 

  126. 		if (channels == 1)
    127. 

  127. 			si->private_bits = stream->get_bits(5);
    128. 

  128. 		else si->private_bits = stream->get_bits(3);
    129. 

  129. 

  130. 		for (ch=0; ch<(int32)channels; ch++) {
    131. 

  131. 			si->ch[ch].scfsi[0] = stream->get_bits(1);
    132. 

  132. 			si->ch[ch].scfsi[1] = stream->get_bits(1);
    133. 

  133. 			si->ch[ch].scfsi[2] = stream->get_bits(1);
    134. 

  134. 			si->ch[ch].scfsi[3] = stream->get_bits(1);
    135. 

  135. 	   }
    136. 

  136. 

  137. 		for (gr=0; gr<2; gr++) {
    138. 

  138. 			for (ch=0; ch<(int32)channels; ch++) {
    139. 

  139. 				si->ch[ch].gr[gr].part2_3_length = stream->get_bits(12);
    140. 

  140.   				si->ch[ch].gr[gr].big_values = stream->get_bits(9);
    141. 

  141. 				si->ch[ch].gr[gr].global_gain = stream->get_bits(8);
    142. 

  142. 				si->ch[ch].gr[gr].scalefac_compress = stream->get_bits(4);
    143. 

  143. 				si->ch[ch].gr[gr].window_switching_flag = stream->get_bits(1);
    144. 

  144. 				if (si->ch[ch].gr[gr].window_switching_flag) {
    145. 

  145. 					si->ch[ch].gr[gr].block_type       = stream->get_bits(2);
    146. 

  146. 					si->ch[ch].gr[gr].mixed_block_flag = stream->get_bits(1);
    147. 

  147. 

  148. 					si->ch[ch].gr[gr].table_select[0]  = stream->get_bits(5);
    149. 

  149. 					si->ch[ch].gr[gr].table_select[1]  = stream->get_bits(5);
    150. 

  150. 

  151. 					si->ch[ch].gr[gr].subblock_gain[0] = stream->get_bits(3);
    152. 

  152. 					si->ch[ch].gr[gr].subblock_gain[1] = stream->get_bits(3);
    153. 

  153. 					si->ch[ch].gr[gr].subblock_gain[2] = stream->get_bits(3);
    154. 

  154. 

  155. 					// Set region_count parameters since they are implicit in this case.
    156. 

  156. 

  157. 					if (si->ch[ch].gr[gr].block_type == 0) {
    158. 

  158. 						//	 Side info bad: block_type == 0 in split block
    159. 

  159. 						return false;
    160. 

  160. 					} else if (si->ch[ch].gr[gr].block_type == 2
    161. 

  161. 	  							  && si->ch[ch].gr[gr].mixed_block_flag == 0) {
    162. 

  162. 						si->ch[ch].gr[gr].region0_count = 8;
    163. 

  163.                } else {
    164. 

  164. 	               si->ch[ch].gr[gr].region0_count = 7;
    165. 

  165.                }
    166. 

  166. 					si->ch[ch].gr[gr].region1_count = 20 -
    167. 

  167. 							si->ch[ch].gr[gr].region0_count;
    168. 

  168. 				} else {
    169. 

  169. 					si->ch[ch].gr[gr].table_select[0] = stream->get_bits(5);
    170. 

  170. 					si->ch[ch].gr[gr].table_select[1] = stream->get_bits(5);
    171. 

  171. 					si->ch[ch].gr[gr].table_select[2] = stream->get_bits(5);
    172. 

  172. 					si->ch[ch].gr[gr].region0_count = stream->get_bits(4);
    173. 

  173. 					si->ch[ch].gr[gr].region1_count = stream->get_bits(3);
    174. 

  174. 					si->ch[ch].gr[gr].block_type = 0;
    175. 

  175. 				}
    176. 

  176. 				si->ch[ch].gr[gr].preflag = stream->get_bits(1);
    177. 

  177. 				si->ch[ch].gr[gr].scalefac_scale = stream->get_bits(1);
    178. 

  178. 				si->ch[ch].gr[gr].count1table_select = stream->get_bits(1);
    179. 

  179.          }
    180. 

  180.       }
    181. 

  181. 

  182.    } else {  	// MPEG-2 LSF
    183. 

  183. 

  184.       si->main_data_begin = stream->get_bits(8);
    185. 

  185.       if (channels == 1)
    186. 

  186.       	si->private_bits = stream->get_bits(1);
    187. 

  187.       else si->private_bits = stream->get_bits(2);
    188. 

  188. 

  189.       for (ch=0; ch<(int32)channels; ch++) {
    190. 

  190. 

  191.           si->ch[ch].gr[0].part2_3_length = stream->get_bits(12);
    192. 

  192.           si->ch[ch].gr[0].big_values = stream->get_bits(9);
    193. 

  193.           si->ch[ch].gr[0].global_gain = stream->get_bits(8);
    194. 

  194.           si->ch[ch].gr[0].scalefac_compress = stream->get_bits(9);
    195. 

  195.           si->ch[ch].gr[0].window_switching_flag = stream->get_bits(1);
    196. 

  196. 

  197.           if (si->ch[ch].gr[0].window_switching_flag) {
    198. 

  198. 

  199.              si->ch[ch].gr[0].block_type = stream->get_bits(2);
    200. 

  200.              si->ch[ch].gr[0].mixed_block_flag = stream->get_bits(1);
    201. 

  201.              si->ch[ch].gr[0].table_select[0] = stream->get_bits(5);
    202. 

  202.              si->ch[ch].gr[0].table_select[1] = stream->get_bits(5);
    203. 

  203. 

  204.              si->ch[ch].gr[0].subblock_gain[0] = stream->get_bits(3);
    205. 

  205.              si->ch[ch].gr[0].subblock_gain[1] = stream->get_bits(3);
    206. 

  206.              si->ch[ch].gr[0].subblock_gain[2] = stream->get_bits(3);
    207. 

  207. 

  208.             // Set region_count parameters since they are implicit in this case.
    209. 

  209. 

  210.              if (si->ch[ch].gr[0].block_type == 0) {
    211. 

  211.                 // Side info bad: block_type == 0 in split block
    212. 

  212.                 return false;
    213. 

  213.              } else if (si->ch[ch].gr[0].block_type == 2
    214. 

  214.                       && si->ch[ch].gr[0].mixed_block_flag == 0) {
    215. 

  215.              	 si->ch[ch].gr[0].region0_count = 8;
    216. 

  216. 				 } else {
    217. 

  217.              	 si->ch[ch].gr[0].region0_count = 7;
    218. 

  218.                 si->ch[ch].gr[0].region1_count = 20 -
    219. 

  219.                 											si->ch[ch].gr[0].region0_count;
    220. 

  220.              }
    221. 

  221. 

  222.           } else {
    223. 

  223.              si->ch[ch].gr[0].table_select[0] = stream->get_bits(5);
    224. 

  224.              si->ch[ch].gr[0].table_select[1] = stream->get_bits(5);
    225. 

  225.              si->ch[ch].gr[0].table_select[2] = stream->get_bits(5);
    226. 

  226.              si->ch[ch].gr[0].region0_count = stream->get_bits(4);
    227. 

  227.              si->ch[ch].gr[0].region1_count = stream->get_bits(3);
    228. 

  228.              si->ch[ch].gr[0].block_type = 0;
    229. 

  229.           }
    230. 

  230. 

  231.           si->ch[ch].gr[0].scalefac_scale = stream->get_bits(1);
    232. 

  232.           si->ch[ch].gr[0].count1table_select = stream->get_bits(1);
    233. 

  233.       }   // for(ch=0; ch<channels; ch++)
    234. 

  234.    } // if (header->version() == MPEG1)
    235. 

  235. 	return true;
    236. 

  236. }
    237. 

  237. 

  238. struct {
    239. 

  239. 	int32 l[5];
    240. 

  240. 	int32 s[3];} sfbtable = {{0, 6, 11, 16, 21},
    241. 

  241. 								    {0, 6, 12}};
    242. 

  242. 

  243. void LayerIII_Decoder::get_scale_factors(uint32 ch, uint32 gr)
    244. 

  244. {
    245. 

  245. 	int32 sfb, window;
    246. 

  246. 	gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
    247. 

  247.    int32 scale_comp   = gr_info->scalefac_compress;
    248. 

  248.    int32 length0      = slen[0][scale_comp];
    249. 

  249.    int32 length1      = slen[1][scale_comp];
    250. 

  250. 

  251. 	if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
    252. 

  252. 		if (gr_info->mixed_block_flag) { // MIXED
    253. 

  253. 			for (sfb = 0; sfb < 8; sfb++)
    254. 

  254. 				scalefac[ch].l[sfb] = br->hgetbits(
    255. 

  255. 					  slen[0][gr_info->scalefac_compress]);
    256. 

  256. 			for (sfb = 3; sfb < 6; sfb++)
    257. 

  257. 				for (window=0; window<3; window++)
    258. 

  258. 					scalefac[ch].s[window][sfb] = br->hgetbits(
    259. 

  259. 					  slen[0][gr_info->scalefac_compress]);
    260. 

  260. 			for (sfb = 6; sfb < 12; sfb++)
    261. 

  261. 				for (window=0; window<3; window++)
    262. 

  262. 					scalefac[ch].s[window][sfb] = br->hgetbits(
    263. 

  263. 					  slen[1][gr_info->scalefac_compress]);
    264. 

  264. 			for (sfb=12,window=0; window<3; window++)
    265. 

  265. 				scalefac[ch].s[window][sfb] = 0;
    266. 

  266. 

  267.       } else {  // SHORT
    268. 

  268. 

  269.          scalefac[ch].s[0][0]  = br->hgetbits(length0);
    270. 

  270.          scalefac[ch].s[1][0]  = br->hgetbits(length0);
    271. 

  271.          scalefac[ch].s[2][0]  = br->hgetbits(length0);
    272. 

  272.          scalefac[ch].s[0][1]  = br->hgetbits(length0);
    273. 

  273.          scalefac[ch].s[1][1]  = br->hgetbits(length0);
    274. 

  274.          scalefac[ch].s[2][1]  = br->hgetbits(length0);
    275. 

  275.          scalefac[ch].s[0][2]  = br->hgetbits(length0);
    276. 

  276.          scalefac[ch].s[1][2]  = br->hgetbits(length0);
    277. 

  277.          scalefac[ch].s[2][2]  = br->hgetbits(length0);
    278. 

  278.          scalefac[ch].s[0][3]  = br->hgetbits(length0);
    279. 

  279.          scalefac[ch].s[1][3]  = br->hgetbits(length0);
    280. 

  280.          scalefac[ch].s[2][3]  = br->hgetbits(length0);
    281. 

  281.          scalefac[ch].s[0][4]  = br->hgetbits(length0);
    282. 

  282.          scalefac[ch].s[1][4]  = br->hgetbits(length0);
    283. 

  283.          scalefac[ch].s[2][4]  = br->hgetbits(length0);
    284. 

  284.          scalefac[ch].s[0][5]  = br->hgetbits(length0);
    285. 

  285.          scalefac[ch].s[1][5]  = br->hgetbits(length0);
    286. 

  286.          scalefac[ch].s[2][5]  = br->hgetbits(length0);
    287. 

  287.          scalefac[ch].s[0][6]  = br->hgetbits(length1);
    288. 

  288.          scalefac[ch].s[1][6]  = br->hgetbits(length1);
    289. 

  289.          scalefac[ch].s[2][6]  = br->hgetbits(length1);
    290. 

  290.          scalefac[ch].s[0][7]  = br->hgetbits(length1);
    291. 

  291.          scalefac[ch].s[1][7]  = br->hgetbits(length1);
    292. 

  292.          scalefac[ch].s[2][7]  = br->hgetbits(length1);
    293. 

  293.          scalefac[ch].s[0][8]  = br->hgetbits(length1);
    294. 

  294.          scalefac[ch].s[1][8]  = br->hgetbits(length1);
    295. 

  295.          scalefac[ch].s[2][8]  = br->hgetbits(length1);
    296. 

  296.          scalefac[ch].s[0][9]  = br->hgetbits(length1);
    297. 

  297.          scalefac[ch].s[1][9]  = br->hgetbits(length1);
    298. 

  298.          scalefac[ch].s[2][9]  = br->hgetbits(length1);
    299. 

  299.          scalefac[ch].s[0][10] = br->hgetbits(length1);
    300. 

  300.          scalefac[ch].s[1][10] = br->hgetbits(length1);
    301. 

  301.          scalefac[ch].s[2][10] = br->hgetbits(length1);
    302. 

  302.          scalefac[ch].s[0][11] = br->hgetbits(length1);
    303. 

  303.          scalefac[ch].s[1][11] = br->hgetbits(length1);
    304. 

  304.          scalefac[ch].s[2][11] = br->hgetbits(length1);
    305. 

  305.          scalefac[ch].s[0][12] = 0;
    306. 

  306. 			scalefac[ch].s[1][12] = 0;
    307. 

  307. 			scalefac[ch].s[2][12] = 0;
    308. 

  308. 		} // SHORT
    309. 

  309. 

  310. 	} else {   // LONG types 0,1,3
    311. 

  311. 

  312.       if ((si->ch[ch].scfsi[0] == 0) || (gr == 0)) {
    313. 

  313.            scalefac[ch].l[0]  = br->hgetbits(length0);
    314. 

  314.            scalefac[ch].l[1]  = br->hgetbits(length0);
    315. 

  315.            scalefac[ch].l[2]  = br->hgetbits(length0);
    316. 

  316.            scalefac[ch].l[3]  = br->hgetbits(length0);
    317. 

  317.            scalefac[ch].l[4]  = br->hgetbits(length0);
    318. 

  318.            scalefac[ch].l[5]  = br->hgetbits(length0);
    319. 

  319. 		}
    320. 

  320.       if ((si->ch[ch].scfsi[1] == 0) || (gr == 0)) {
    321. 

  321.            scalefac[ch].l[6]  = br->hgetbits(length0);
    322. 

  322.            scalefac[ch].l[7]  = br->hgetbits(length0);
    323. 

  323.            scalefac[ch].l[8]  = br->hgetbits(length0);
    324. 

  324.            scalefac[ch].l[9]  = br->hgetbits(length0);
    325. 

  325.            scalefac[ch].l[10] = br->hgetbits(length0);
    326. 

  326. 		}
    327. 

  327.       if ((si->ch[ch].scfsi[2] == 0) || (gr == 0)) {
    328. 

  328.            scalefac[ch].l[11] = br->hgetbits(length1);
    329. 

  329.            scalefac[ch].l[12] = br->hgetbits(length1);
    330. 

  330.            scalefac[ch].l[13] = br->hgetbits(length1);
    331. 

  331.            scalefac[ch].l[14] = br->hgetbits(length1);
    332. 

  332.            scalefac[ch].l[15] = br->hgetbits(length1);
    333. 

  333. 		}
    334. 

  334.       if ((si->ch[ch].scfsi[3] == 0) || (gr == 0)) {
    335. 

  335.            scalefac[ch].l[16] = br->hgetbits(length1);
    336. 

  336.            scalefac[ch].l[17] = br->hgetbits(length1);
    337. 

  337.            scalefac[ch].l[18] = br->hgetbits(length1);
    338. 

  338.            scalefac[ch].l[19] = br->hgetbits(length1);
    339. 

  339.            scalefac[ch].l[20] = br->hgetbits(length1);
    340. 

  340. 		}
    341. 

  341. 

  342.       scalefac[ch].l[21] = 0;
    343. 

  343. 		scalefac[ch].l[22] = 0;
    344. 

  344. 	}
    345. 

  345. }
    346. 

  346. 

  347. uint32 nr_of_sfb_block[6][3][4] =
    348. 

  348. 	{{{ 6, 5, 5, 5} , { 9, 9, 9, 9} , { 6, 9, 9, 9}},
    349. 

  349.     {{ 6, 5, 7, 3} , { 9, 9,12, 6} , { 6, 9,12, 6}},
    350. 

  350.     {{11,10, 0, 0} , {18,18, 0, 0} , {15,18, 0, 0}},
    351. 

  351.     {{ 7, 7, 7, 0} , {12,12,12, 0} , { 6,15,12, 0}},
    352. 

  352.     {{ 6, 6, 6, 3} , {12, 9, 9, 6} , { 6,12, 9, 6}},
    353. 

  353.     {{ 8, 8, 5, 0} , {15,12, 9, 0} , { 6,18, 9, 0}}};
    354. 

  354. 

  355. uint32 scalefac_buffer[54];
    356. 

  356. 

  357. void LayerIII_Decoder::get_LSF_scale_data(uint32 ch, uint32 gr)
    358. 

  358. {
    359. 

  359. 	uint32 new_slen[4];
    360. 

  360.   	uint32 scalefac_comp, int_scalefac_comp;
    361. 

  361.    uint32 mode_ext = header->mode_extension();
    362. 

  362. 	int32 m;
    363. 

  363. 	int32 blocktypenumber, blocknumber;
    364. 

  364. 

  365. 	gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
    366. 

  366. 

  367. 	scalefac_comp =  gr_info->scalefac_compress;
    368. 

  368. 

  369.    if (gr_info->block_type == 2) {
    370. 

  370.    	if (gr_info->mixed_block_flag == 0)
    371. 

  371.       	blocktypenumber = 1;
    372. 

  372.       else if (gr_info->mixed_block_flag == 1)
    373. 

  373. 			blocktypenumber = 2;
    374. 

  374.       else
    375. 

  375.       	blocktypenumber = 0;
    376. 

  376.    } else {
    377. 

  377.    	blocktypenumber = 0;
    378. 

  378.    }
    379. 

  379. 

  380.    if(!(((mode_ext == 1) || (mode_ext == 3)) && (ch == 1))) {
    381. 

  381. 

  382. 		if(scalefac_comp < 400) {
    383. 

  383. 

  384. 			new_slen[0] = (scalefac_comp >> 4) / 5 ;
    385. 

  385. 			new_slen[1] = (scalefac_comp >> 4) % 5 ;
    386. 

  386. 			new_slen[2] = (scalefac_comp & 0xF) >> 2 ;
    387. 

  387. 			new_slen[3] = (scalefac_comp & 3);
    388. 

  388.          si->ch[ch].gr[gr].preflag = 0;
    389. 

  389. 

  390.          blocknumber = 0;
    391. 

  391. 

  392.       } else if (scalefac_comp  < 500) {
    393. 

  393. 

  394. 			new_slen[0] = ((scalefac_comp - 400) >> 2) / 5 ;
    395. 

  395. 			new_slen[1] = ((scalefac_comp - 400) >> 2) % 5 ;
    396. 

  396. 			new_slen[2] = (scalefac_comp - 400 ) & 3 ;
    397. 

  397. 			new_slen[3] = 0;
    398. 

  398.          si->ch[ch].gr[gr].preflag = 0;
    399. 

  399. 

  400.          blocknumber = 1;
    401. 

  401. 

  402. 	   } else if (scalefac_comp < 512) {
    403. 

  403. 

  404. 			new_slen[0] = (scalefac_comp - 500 ) / 3 ;
    405. 

  405. 			new_slen[1] = (scalefac_comp - 500)  % 3 ;
    406. 

  406. 			new_slen[2] = 0;
    407. 

  407. 			new_slen[3] = 0;
    408. 

  408.       	si->ch[ch].gr[gr].preflag = 1;
    409. 

  409. 

  410. 	      blocknumber = 2;
    411. 

  411.  	   }
    412. 

  412.    }
    413. 

  413. 

  414.    if((((mode_ext == 1) || (mode_ext == 3)) && (ch == 1)))
    415. 

  415.    {
    416. 

  416.       int_scalefac_comp = scalefac_comp >> 1;
    417. 

  417. 

  418.       if (int_scalefac_comp < 180)
    419. 

  419.       {
    420. 

  420. 			new_slen[0] = int_scalefac_comp  / 36 ;
    421. 

  421. 			new_slen[1] = (int_scalefac_comp % 36 ) / 6 ;
    422. 

  422. 			new_slen[2] = (int_scalefac_comp % 36) % 6;
    423. 

  423. 			new_slen[3] = 0;
    424. 

  424.          si->ch[ch].gr[gr].preflag = 0;
    425. 

  425.          blocknumber = 3;
    426. 

  426.       } else if (int_scalefac_comp < 244) {
    427. 

  427. 			new_slen[0] = ((int_scalefac_comp - 180 )  & 0x3F) >> 4 ;
    428. 

  428. 			new_slen[1] = ((int_scalefac_comp - 180) & 0xF) >> 2 ;
    429. 

  429. 			new_slen[2] = (int_scalefac_comp - 180 ) & 3 ;
    430. 

  430. 			new_slen[3] = 0;
    431. 

  431.          si->ch[ch].gr[gr].preflag = 0;
    432. 

  432.          blocknumber = 4;
    433. 

  433.       } else if (int_scalefac_comp < 255) {
    434. 

  434. 			new_slen[0] = (int_scalefac_comp - 244 ) / 3 ;
    435. 

  435. 			new_slen[1] = (int_scalefac_comp - 244 )  % 3 ;
    436. 

  436. 			new_slen[2] = 0 ;
    437. 

  437. 			new_slen[3] = 0;
    438. 

  438.          si->ch[ch].gr[gr].preflag = 0;
    439. 

  439.          blocknumber = 5;
    440. 

  440.       }
    441. 

  441.    }
    442. 

  442. 

  443.    for (uint32 x=0; x<45; x++) // why 45, not 54?
    444. 

  444.    	scalefac_buffer[x] = 0;
    445. 

  445. 

  446.    m = 0;
    447. 

  447.    for (uint32 i=0; i<4;i++) {
    448. 

  448.      	for (uint32 j = 0; j < nr_of_sfb_block[blocknumber][blocktypenumber][i];
    449. 

  449.       	 j++)
    450. 

  450.       {
    451. 

  451.         scalefac_buffer[m] = (new_slen[i] == 0) ? 0 :
    452. 

  452.         							  br->hgetbits(new_slen[i]);
    453. 

  453.         m++;
    454. 

  454. 

  455.       } // for (unint32 j ...
    456. 

  456.    } // for (uint32 i ...
    457. 

  457. }
    458. 

  458. 

  459. void LayerIII_Decoder::get_LSF_scale_factors(uint32 ch, uint32 gr)
    460. 

  460. {
    461. 

  461. 	uint32 m = 0;
    462. 

  462.    uint32 sfb, window;
    463. 

  463. 	gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
    464. 

  464. 

  465.    get_LSF_scale_data(ch, gr);
    466. 

  466. 

  467.    if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
    468. 

  468.       if (gr_info->mixed_block_flag) { 	// MIXED
    469. 

  469.          for (sfb = 0; sfb < 8; sfb++)
    470. 

  470.          {
    471. 

  471.               scalefac[ch].l[sfb] = scalefac_buffer[m];
    472. 

  472.               m++;
    473. 

  473.          }
    474. 

  474.          for (sfb = 3; sfb < 12; sfb++) {
    475. 

  475.             for (window=0; window<3; window++)
    476. 

  476.             {
    477. 

  477.                scalefac[ch].s[window][sfb] = scalefac_buffer[m];
    478. 

  478.                m++;
    479. 

  479.             }
    480. 

  480.          }
    481. 

  481.          for (window=0; window<3; window++)
    482. 

  482.             scalefac[ch].s[window][12] = 0;
    483. 

  483. 

  484.       } else {  // SHORT
    485. 

  485. 

  486.            for (sfb = 0; sfb < 12; sfb++) {
    487. 

  487.                for (window=0; window<3; window++)
    488. 

  488.                {
    489. 

  489.                   scalefac[ch].s[window][sfb] = scalefac_buffer[m];
    490. 

  490.                   m++;
    491. 

  491.                }
    492. 

  492.            }
    493. 

  493. 

  494.            for (window=0; window<3; window++)
    495. 

  495.                scalefac[ch].s[window][12] = 0;
    496. 

  496.       }
    497. 

  497.    } else {   // LONG types 0,1,3
    498. 

  498. 

  499.       for (sfb = 0; sfb < 21; sfb++) {
    500. 

  500.           scalefac[ch].l[sfb] = scalefac_buffer[m];
    501. 

  501.           m++;
    502. 

  502.       }
    503. 

  503.       scalefac[ch].l[21] = 0; // Jeff
    504. 

  504.       scalefac[ch].l[22] = 0;
    505. 

  505. 	}
    506. 

  506. }
    507. 

  507. 

  508. void LayerIII_Decoder::huffman_decode(uint32 ch, uint32 gr)
    509. 

  509. {
    510. 

  510. 	int32 x, y;
    511. 

  511. 	int32 v, w;
    512. 

  512.    int32 part2_3_end = part2_start + si->ch[ch].gr[gr].part2_3_length;
    513. 

  513.    int32 num_bits;
    514. 

  514. 	int32 region1Start;
    515. 

  515. 	int32 region2Start;
    516. 

  516.    int32 index;
    517. 

  517.  	struct huffcodetab *h;
    518. 

  518. 

  519. 	// Find region boundary for short block case
    520. 

  520. 

  521. 	if ( (si->ch[ch].gr[gr].window_switching_flag) &&
    522. 

  522. 		  (si->ch[ch].gr[gr].block_type == 2) ) {
    523. 

  523. 

  524. 		// Region2.
    525. 

  525. 

  526. 		region1Start = 36;  // sfb[9/3]*3=36
    527. 

  527. 		region2Start = 576; // No Region2 for short block case
    528. 

  528. 

  529. 	} else {          // Find region boundary for long block case
    530. 

  530. 

  531. 		region1Start = sfBandIndex[sfreq].l[si->ch[ch].gr[gr].region0_count
    532. 

  532.                                              + 1];
    533. 

  533. 		region2Start = sfBandIndex[sfreq].l[si->ch[ch].gr[gr].region0_count +
    534. 

  534. 										   si->ch[ch].gr[gr].region1_count + 2]; /* MI */
    535. 

  535.    }
    536. 

  536. 

  537.    index = 0;
    538. 

  538. 	// Read bigvalues area
    539. 

  539. 	for (uint32 i=0; i<(si->ch[ch].gr[gr].big_values<<1); i+=2) {
    540. 

  540. 		if      (i<(uint32)region1Start) h = &ht[si->ch[ch].gr[gr].table_select[0]];
    541. 

  541. 		else if (i<(uint32)region2Start) h = &ht[si->ch[ch].gr[gr].table_select[1]];
    542. 

  542. 			  else                h = &ht[si->ch[ch].gr[gr].table_select[2]];
    543. 

  543. 

  544. 		huffman_decoder(h, &x, &y, &v, &w, br);
    545. 

  545. 

  546.       is_1d[index++] = x;
    547. 

  547.       is_1d[index++] = y;
    548. 

  548. 	}
    549. 

  549. 

  550. 	// Read count1 area
    551. 

  551. 	h = &ht[si->ch[ch].gr[gr].count1table_select+32];
    552. 

  552.    num_bits = br->hsstell();
    553. 

  553. 

  554. 	while ((num_bits < part2_3_end) && (index < 576)) {
    555. 

  555. 

  556. 		huffman_decoder(h, &x, &y, &v, &w, br);
    557. 

  557. 

  558.       is_1d[index++] = v;
    559. 

  559.       is_1d[index++] = w;
    560. 

  560.       is_1d[index++] = x;
    561. 

  561.       is_1d[index++] = y;
    562. 

  562.       num_bits = br->hsstell();
    563. 

  563.    }
    564. 

  564. 

  565. 	if (num_bits > part2_3_end) {
    566. 

  566. 		br->rewindNbits(num_bits - part2_3_end);
    567. 

  567.       index-=4;
    568. 

  568.    }
    569. 

  569. 

  570.    num_bits = br->hsstell();
    571. 

  571. 

  572. 	// Dismiss stuffing bits
    573. 

  573. 	if (num_bits < part2_3_end)
    574. 

  574.    	br->hgetbits(part2_3_end - num_bits);
    575. 

  575. 

  576. 	// Zero out rest
    577. 

  577. 

  578.    if (index < 576)
    579. 

  579. 	   nonzero[ch] = index;
    580. 

  580.    else
    581. 

  581.    	nonzero[ch] = 576;
    582. 

  582. 

  583.    // may not be necessary
    584. 

  584.    for (; index<576; index++)
    585. 

  585.    	is_1d[index] = 0;
    586. 

  586. }
    587. 

  587. 

  588. void LayerIII_Decoder::dequantize_sample(real xr[SBLIMIT][SSLIMIT],
    589. 

  589. 												     uint32 ch, uint32 gr)
    590. 

  590. {
    591. 

  591. 	gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
    592. 

  592. 	int32  cb=0;
    593. 

  593. 	int32  next_cb_boundary, cb_begin, cb_width;
    594. 

  594. 	int32  index=0, t_index, j;
    595. 

  595.    real   g_gain;
    596. 

  596.    real  *xr_1d = &xr[0][0];
    597. 

  597. 

  598. 	// choose correct scalefactor band per block type, initalize boundary
    599. 

  599. 

  600. 	if (gr_info->window_switching_flag && (gr_info->block_type == 2) ) {
    601. 

  601. 		if (gr_info->mixed_block_flag)
    602. 

  602. 			next_cb_boundary=sfBandIndex[sfreq].l[1];  // LONG blocks: 0,1,3
    603. 

  603. 		else {
    604. 

  604.          cb_width = sfBandIndex[sfreq].s[1];
    605. 

  605. 		   next_cb_boundary = (cb_width << 2) - cb_width;
    606. 

  606. 	 	   cb_begin = 0;
    607. 

  607. 		}
    608. 

  608. 	} else {
    609. 

  609. 		next_cb_boundary=sfBandIndex[sfreq].l[1];  // LONG blocks: 0,1,3
    610. 

  610.    }
    611. 

  611. 

  612.    // Compute overall (global) scaling.
    613. 

  613. 

  614. 	g_gain = (real) pow(2.0 , (0.25 * (gr_info->global_gain - 210.0)));
    615. 

  615. 

  616.   	for (j=0; j<nonzero[ch]; j++) {
    617. 

  617.     	if (is_1d[j] == 0) {
    618. 

  618. 			xr_1d[j] = 0.0f;
    619. 

  619.       } else {
    620. 

  620.          int32 abv = is_1d[j];
    621. 

  621.          if (is_1d[j] > 0)
    622. 

  622. 	  		   xr_1d[j] = g_gain * t_43[abv];
    623. 

  623.          else
    624. 

  624.          	xr_1d[j] = -g_gain * t_43[-abv];
    625. 

  625.       }
    626. 

  626.    }
    627. 

  627. 

  628. 	// apply formula per block type
    629. 

  629. 

  630.    for (j=0; j<nonzero[ch]; j++) {
    631. 

  631. 

  632. 		if (index == next_cb_boundary)  { /* Adjust critical band boundary */
    633. 

  633.       	if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
    634. 

  634.          	if (gr_info->mixed_block_flag)  {
    635. 

  635. 

  636.             	if (index == sfBandIndex[sfreq].l[8])  {
    637. 

  637.                   next_cb_boundary = sfBandIndex[sfreq].s[4];
    638. 

  638.                   next_cb_boundary = (next_cb_boundary << 2) -
    639. 

  639.                     			           next_cb_boundary;
    640. 

  640.                   cb = 3;
    641. 

  641.                   cb_width = sfBandIndex[sfreq].s[4] -
    642. 

  642.                     			  sfBandIndex[sfreq].s[3];
    643. 

  643. 

  644.                   cb_begin = sfBandIndex[sfreq].s[3];
    645. 

  645.                   cb_begin = (cb_begin << 2) - cb_begin;
    646. 

  646. 

  647.                } else if (index < sfBandIndex[sfreq].l[8]) {
    648. 

  648. 

  649.                	next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
    650. 

  650. 

  651.                } else {
    652. 

  652. 

  653.                	next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
    654. 

  654.                   next_cb_boundary = (next_cb_boundary << 2) -
    655. 

  655.                     				        next_cb_boundary;
    656. 

  656. 

  657.                   cb_begin = sfBandIndex[sfreq].s[cb];
    658. 

  658. 						cb_width = sfBandIndex[sfreq].s[cb+1] -
    659. 

  659.                              cb_begin;
    660. 

  660.                   cb_begin = (cb_begin << 2) - cb_begin;
    661. 

  661.                }
    662. 

  662. 

  663.             } else  {
    664. 

  664. 

  665.                next_cb_boundary = sfBandIndex[sfreq].s[(++cb)+1];
    666. 

  666.                next_cb_boundary = (next_cb_boundary << 2) -
    667. 

  667.                                   next_cb_boundary;
    668. 

  668. 

  669.                cb_begin = sfBandIndex[sfreq].s[cb];
    670. 

  670. 					cb_width = sfBandIndex[sfreq].s[cb+1] -
    671. 

  671.                           cb_begin;
    672. 

  672.                cb_begin = (cb_begin << 2) - cb_begin;
    673. 

  673.             }
    674. 

  674. 

  675.          } else  { // long blocks
    676. 

  676. 

  677. 					next_cb_boundary = sfBandIndex[sfreq].l[(++cb)+1];
    678. 

  678. 

  679.          }
    680. 

  680.       }
    681. 

  681. 

  682. 		// Do long/short dependent scaling operations
    683. 

  683. 

  684. 		if (gr_info->window_switching_flag &&
    685. 

  685. 			 (((gr_info->block_type == 2) && (gr_info->mixed_block_flag == 0)) ||
    686. 

  686. 			  ((gr_info->block_type == 2) && gr_info->mixed_block_flag && (j >= 36)) ))
    687. 

  687.       {
    688. 

  688. 

  689. 			t_index = (index - cb_begin) / cb_width;
    690. 

  690. /*            xr[sb][ss] *= pow(2.0, ((-2.0 * gr_info->subblock_gain[t_index])
    691. 

  691.                                     -(0.5 * (1.0 + gr_info->scalefac_scale)
    692. 

  692.                                       * scalefac[ch].s[t_index][cb]))); */
    693. 

  693. 			uint32 idx = scalefac[ch].s[t_index][cb]
    694. 

  694.            				 << gr_info->scalefac_scale;
    695. 

  695.          idx += (gr_info->subblock_gain[t_index] << 2);
    696. 

  696. 

  697. 			xr_1d[j] *= two_to_negative_half_pow[idx];
    698. 

  698. 

  699. 		} else {   // LONG block types 0,1,3 & 1st 2 subbands of switched blocks
    700. 

  700. /*				xr[sb][ss] *= pow(2.0, -0.5 * (1.0+gr_info->scalefac_scale)
    701. 

  701. 													 * (scalefac[ch].l[cb]
    702. 

  702. 													 + gr_info->preflag * pretab[cb])); */
    703. 

  703. 			uint32 idx = scalefac[ch].l[cb];
    704. 

  704. 

  705.    		if (gr_info->preflag)
    706. 

  706. 		   	idx += pretab[cb];
    707. 

  707. 

  708. 		   idx = idx << gr_info->scalefac_scale;
    709. 

  709.          xr_1d[j] *= two_to_negative_half_pow[idx];
    710. 

  710. 		}
    711. 

  711.       index++;
    712. 

  712. 	}
    713. 

  713. 

  714.    for (j=nonzero[ch]; j<576; j++)
    715. 

  715.      	xr_1d[j] = 0.0f;
    716. 

  716. 

  717.    return;
    718. 

  718. }
    719. 

  719. 

  720. void LayerIII_Decoder::reorder(real xr[SBLIMIT][SSLIMIT], uint32 ch, uint32 gr)
    721. 

  721. {
    722. 

  722. 

  723. 	gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
    724. 

  724.    uint32 freq, freq3;
    725. 

  725.    int32 index;
    726. 

  726. 	int32 sfb, sfb_start, sfb_lines;
    727. 

  727.    int32 src_line, des_line;
    728. 

  728. 

  729.    real *xr_1d = &xr[0][0];
    730. 

  730. 

  731. 	if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
    732. 

  732. 

  733.       for(index=0; index<576; index++)
    734. 

  734.          out_1d[index] = 0.0f;
    735. 

  735. 

  736. 		if (gr_info->mixed_block_flag) {
    737. 

  737. 			// NO REORDER FOR LOW 2 SUBBANDS
    738. 

  738.             for (index = 0; index < 36; index++)
    739. 

  739.                out_1d[index] = xr_1d[index];
    740. 

  740. 

  741. 			// REORDERING FOR REST SWITCHED SHORT
    742. 

  742. 				for(sfb=3,sfb_start=sfBandIndex[sfreq].s[3],
    743. 

  743. 	  				 sfb_lines=sfBandIndex[sfreq].s[4] - sfb_start;
    744. 

  744. 	  				 sfb < 13; sfb++,sfb_start = sfBandIndex[sfreq].s[sfb],
    745. 

  745. 				    (sfb_lines=sfBandIndex[sfreq].s[sfb+1] - sfb_start))
    746. 

  746.             {
    747. 

  747. 					   int32 sfb_start3 = (sfb_start << 2) - sfb_start;
    748. 

  748. 

  749. 						for(freq=0, freq3=0; freq<(uint32)sfb_lines;
    750. 

  750.                       freq++, freq3+=3) {
    751. 

  751. 

  752. 							src_line = sfb_start3 + freq;
    753. 

  753. 							des_line = sfb_start3 + freq3;
    754. 

  754. 							out_1d[des_line] = xr_1d[src_line];
    755. 

  755. 							src_line += sfb_lines;
    756. 

  756. 							des_line++;
    757. 

  757. 							out_1d[des_line] = xr_1d[src_line];
    758. 

  758. 							src_line += sfb_lines;
    759. 

  759. 							des_line++;
    760. 

  760. 							out_1d[des_line] = xr_1d[src_line];
    761. 

  761. 					   }
    762. 

  762.             }
    763. 

  763. 

  764. 		} else {  // pure short
    765. 

  765.       	for(index=0;index<576;index++)
    766. 

  766.             out_1d[index] = xr_1d[reorder_table[sfreq][index]];
    767. 

  767. 		}
    768. 

  768. 	}
    769. 

  769. 	else {   // long blocks
    770. 

  770.       for(index=0; index<576; index++)
    771. 

  771.       	out_1d[index] = xr_1d[index];
    772. 

  772. 	}
    773. 

  773. }
    774. 

  774. 

  775. void LayerIII_Decoder::i_stereo_k_values(uint32 is_pos, uint32 io_type,
    776. 

  776. 												     uint32 i)
    777. 

  777. {
    778. 

  778.    if (is_pos == 0) {
    779. 

  779.       k[0][i] = 1.0f;
    780. 

  780.       k[1][i] = 1.0f;
    781. 

  781.    } else if (is_pos & 1) {
    782. 

  782. 		k[0][i] = io[io_type][(is_pos + 1) >> 1];
    783. 

  783.       k[1][i] = 1.0f;
    784. 

  784.    } else {
    785. 

  785.       k[0][i] = 1.0f;
    786. 

  786.       k[1][i] = io[io_type][is_pos >> 1];
    787. 

  787.    }
    788. 

  788. }
    789. 

  789. 

  790. void LayerIII_Decoder::stereo(uint32 gr)
    791. 

  791. {
    792. 

  792.    int32 sb, ss;
    793. 

  793. 

  794. 	if  (channels == 1) { // mono , bypass xr[0][][] to lr[0][][]
    795. 

  795. 

  796. 		for(sb=0;sb<SBLIMIT;sb++)
    797. 

  797. 			for(ss=0;ss<SSLIMIT;ss+=3) {
    798. 

  798. 				lr[0][sb][ss]   = ro[0][sb][ss];
    799. 

  799.             lr[0][sb][ss+1] = ro[0][sb][ss+1];
    800. 

  800. 				lr[0][sb][ss+2] = ro[0][sb][ss+2];
    801. 

  801.          }
    802. 

  802. 

  803.    } else {
    804. 

  804. 

  805. 	uint32 is_pos[576];
    806. 

  806. 	real  is_ratio[576];
    807. 

  807. 	gr_info_s *gr_info = &(si->ch[0].gr[gr]);
    808. 

  808.    uint32 mode_ext = header->mode_extension();
    809. 

  809. 	int32 sfb;
    810. 

  810. 	int32 i;
    811. 

  811.    int32 lines, temp, temp2;
    812. 

  812. 	bool ms_stereo = (header->mode() == joint_stereo) && (mode_ext & 0x2);
    813. 

  813. 	bool i_stereo  = (header->mode() == joint_stereo) && (mode_ext & 0x1);
    814. 

  814.    bool lsf = (header->version() == MPEG2_LSF);
    815. 

  815. 

  816. 	uint32 io_type = (gr_info->scalefac_compress & 1);
    817. 

  817. 

  818.  	// initialization
    819. 

  819. 

  820.    for (i=0; i<576; i++)
    821. 

  821.    	is_pos[i] = 7;
    822. 

  822. 

  823. 	if (i_stereo) {
    824. 

  824.    	if (gr_info->window_switching_flag && (gr_info->block_type == 2)) {
    825. 

  825.       	if (gr_info->mixed_block_flag) {
    826. 

  826. 

  827.          	 int32 max_sfb = 0;
    828. 

  828. 

  829. 				 for (uint32 j=0; j<3; j++) {
    830. 

  830.             	int32 sfbcnt;
    831. 

  831. 					sfbcnt = 2;
    832. 

  832. 					for( sfb=12; sfb >=3; sfb-- ) {
    833. 

  833.                	i = sfBandIndex[sfreq].s[sfb];
    834. 

  834. 						lines = sfBandIndex[sfreq].s[sfb+1] - i;
    835. 

  835.                   i = (i << 2) - i + (j+1) * lines - 1;
    836. 

  836. 

  837. 						while (lines > 0) {
    838. 

  838.                   	if (ro[1][ss_div[i]][ss_mod[i]] != 0.0f) {
    839. 

  839.                      	sfbcnt = sfb;
    840. 

  840. 								sfb = -10;
    841. 

  841. 								lines = -10;
    842. 

  842. 							}
    843. 

  843. 

  844. 							lines--;
    845. 

  845. 							i--;
    846. 

  846. 

  847. 						} // while (lines > 0)
    848. 

  848. 

  849. 					} // for (sfb=12 ...
    850. 

  850. 					sfb = sfbcnt + 1;
    851. 

  851. 

  852. 					if (sfb > max_sfb)
    853. 

  853. 						max_sfb = sfb;
    854. 

  854. 

  855. 					while(sfb < 12) {
    856. 

  856.                	temp = sfBandIndex[sfreq].s[sfb];
    857. 

  857.                	sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
    858. 

  858.                   i    = (temp << 2) - temp + j * sb;
    859. 

  859. 

  860. 						for ( ; sb > 0; sb--) {
    861. 

  861.                   	is_pos[i] = scalefac[1].s[j][sfb];
    862. 

  862. 							if (is_pos[i] != 7)
    863. 

  863.                      	if (lsf)
    864. 

  864.                            i_stereo_k_values(is_pos[i], io_type, i);
    865. 

  865.                         else
    866. 

  866.                         	is_ratio[i] = TAN12[is_pos[i]];
    867. 

  867. 

  868. 							i++;
    869. 

  869. 						} // for (; sb>0...
    870. 

  870. 						sfb++;
    871. 

  871. 					} // while (sfb < 12)
    872. 

  872. 					sfb = sfBandIndex[sfreq].s[10];
    873. 

  873.                sb  = sfBandIndex[sfreq].s[11] - sfb;
    874. 

  874.                sfb = (sfb << 2) - sfb + j * sb;
    875. 

  875.                temp  = sfBandIndex[sfreq].s[11];
    876. 

  876.                sb = sfBandIndex[sfreq].s[12] - temp;
    877. 

  877.                i = (temp << 2) - temp + j * sb;
    878. 

  878. 

  879. 					for (; sb > 0; sb--) {
    880. 

  880.                	is_pos[i] = is_pos[sfb];
    881. 

  881. 

  882. 		            if (lsf) {
    883. 

  883. 		               k[0][i] = k[0][sfb];
    884. 

  884. 				         k[1][i] = k[1][sfb];
    885. 

  885. 		            } else {
    886. 

  886.      						is_ratio[i] = is_ratio[sfb];
    887. 

  887.                   }
    888. 

  888. 						i++;
    889. 

  889. 					} // for (; sb > 0 ...
    890. 

  890. 				 }
    891. 

  891. 				 if (max_sfb <= 3) {
    892. 

  892.                 i = 2;
    893. 

  893. 					 ss = 17;
    894. 

  894. 					 sb = -1;
    895. 

  895. 					 while (i >= 0) {
    896. 

  896.                 	if (ro[1][i][ss] != 0.0f) {
    897. 

  897.                    	 sb = (i<<4) + (i<<1) + ss;
    898. 

  898. 							 i = -1;
    899. 

  899. 						} else {
    900. 

  900.                       ss--;
    901. 

  901. 							 if (ss < 0) {
    902. 

  902.                          i--;
    903. 

  903. 								 ss = 17;
    904. 

  904. 							 }
    905. 

  905. 						} // if (ro ...
    906. 

  906. 					 } // while (i>=0)
    907. 

  907. 					 i = 0;
    908. 

  908. 					 while (sfBandIndex[sfreq].l[i] <= sb)
    909. 

  909. 						 i++;
    910. 

  910. 					 sfb = i;
    911. 

  911. 					 i = sfBandIndex[sfreq].l[i];
    912. 

  912. 					 for (; sfb<8; sfb++) {
    913. 

  913.                    sb = sfBandIndex[sfreq].l[sfb+1]-sfBandIndex[sfreq].l[sfb];
    914. 

  914. 						 for (; sb>0; sb--) {
    915. 

  915.                       is_pos[i] = scalefac[1].l[sfb];
    916. 

  916.                    	 if (is_pos[i] != 7)
    917. 

  917. 	                      if (lsf)
    918. 

  918.                            i_stereo_k_values(is_pos[i], io_type, i);
    919. 

  919.                          else
    920. 

  920.                         	is_ratio[i] = TAN12[is_pos[i]];
    921. 

  921. 							 i++;
    922. 

  922. 						 } // for (; sb>0 ...
    923. 

  923. 					 } // for (; sfb<8 ...
    924. 

  924. 				 } // for (j=0 ...
    925. 

  925. 			} else { // if (gr_info->mixed_block_flag)
    926. 

  926.          	for (uint32 j=0; j<3; j++) {
    927. 

  927.             	int32 sfbcnt;
    928. 

  928. 					sfbcnt = -1;
    929. 

  929. 					for( sfb=12; sfb >=0; sfb-- )
    930. 

  930. 					{
    931. 

  931. 						temp = sfBandIndex[sfreq].s[sfb];
    932. 

  932.                   lines = sfBandIndex[sfreq].s[sfb+1] - temp;
    933. 

  933.                   i = (temp << 2) - temp + (j+1) * lines - 1;
    934. 

  934. 

  935. 						while (lines > 0) {
    936. 

  936. 							if (ro[1][ss_div[i]][ss_mod[i]] != 0.0f) {
    937. 

  937.                      	sfbcnt = sfb;
    938. 

  938. 								sfb = -10;
    939. 

  939. 								lines = -10;
    940. 

  940. 							}
    941. 

  941. 							lines--;
    942. 

  942. 							i--;
    943. 

  943. 						} // while (lines > 0) */
    944. 

  944. 

  945. 					} // for (sfb=12 ...
    946. 

  946. 					sfb = sfbcnt + 1;
    947. 

  947. 					while(sfb<12) {
    948. 

  948. 						temp = sfBandIndex[sfreq].s[sfb];
    949. 

  949.                   sb   = sfBandIndex[sfreq].s[sfb+1] - temp;
    950. 

  950.                   i    = (temp << 2) - temp + j * sb;
    951. 

  951. 						for ( ; sb > 0; sb--) {
    952. 

  952.                   	is_pos[i] = scalefac[1].s[j][sfb];
    953. 

  953. 							if (is_pos[i] != 7)
    954. 

  954. 	                      if (lsf)
    955. 

  955.                            i_stereo_k_values(is_pos[i], io_type, i);
    956. 

  956.                          else
    957. 

  957.                         	is_ratio[i] = TAN12[is_pos[i]];
    958. 

  958. 							i++;
    959. 

  959. 						} // for (; sb>0 ...
    960. 

  960. 						sfb++;
    961. 

  961. 					} // while (sfb<12)
    962. 

  962. 

  963. 					temp = sfBandIndex[sfreq].s[10];
    964. 

  964.                temp2= sfBandIndex[sfreq].s[11];
    965. 

  965.                sb   = temp2 - temp;
    966. 

  966.                sfb  = (temp << 2) - temp + j * sb;
    967. 

  967.                sb   = sfBandIndex[sfreq].s[12] - temp2;
    968. 

  968.                i    = (temp2 << 2) - temp2 + j * sb;
    969. 

  969. 

  970. 					for (; sb>0; sb--) {
    971. 

  971.                	is_pos[i] = is_pos[sfb];
    972. 

  972. 

  973. 		            if (lsf) {
    974. 

  974. 		               k[0][i] = k[0][sfb];
    975. 

  975. 				         k[1][i] = k[1][sfb];
    976. 

  976.       		      } else {
    977. 

  977.                		is_ratio[i] = is_ratio[sfb];
    978. 

  978.                   }
    979. 

  979. 						i++;
    980. 

  980. 					} // for (; sb>0 ...
    981. 

  981. 				} // for (sfb=12
    982. 

  982. 			} // for (j=0 ...
    983. 

  983. 		} else { // if (gr_info->window_switching_flag ...
    984. 

  984.       	i = 31;
    985. 

  985. 			ss = 17;
    986. 

  986. 			sb = 0;
    987. 

  987. 			while (i >= 0) {
    988. 

  988.          	if (ro[1][i][ss] != 0.0f) {
    989. 

  989.             	sb = (i<<4) + (i<<1) + ss;
    990. 

  990. 					i = -1;
    991. 

  991. 				} else {
    992. 

  992.             	ss--;
    993. 

  993. 					if (ss < 0) {
    994. 

  994.                	i--;
    995. 

  995. 						ss = 17;
    996. 

  996. 					}
    997. 

  997. 				}
    998. 

  998. 			}
    999. 

  999. 			i = 0;
    1000. 

  1000. 			while (sfBandIndex[sfreq].l[i] <= sb)
    1001. 

  1001. 				i++;
    1002. 

  1002. 

  1003. 			sfb = i;
    1004. 

  1004. 			i = sfBandIndex[sfreq].l[i];
    1005. 

  1005. 			for (; sfb<21; sfb++) {
    1006. 

  1006.          	sb = sfBandIndex[sfreq].l[sfb+1] - sfBandIndex[sfreq].l[sfb];
    1007. 

  1007.          	for (; sb > 0; sb--) {
    1008. 

  1008.             	is_pos[i] = scalefac[1].l[sfb];
    1009. 

  1009. 					if (is_pos[i] != 7)
    1010. 

  1010.                   if (lsf)
    1011. 

  1011.                      i_stereo_k_values(is_pos[i], io_type, i);
    1012. 

  1012.                   else
    1013. 

  1013.                    	is_ratio[i] = TAN12[is_pos[i]];
    1014. 

  1014. 					i++;
    1015. 

  1015. 				}
    1016. 

  1016. 			}
    1017. 

  1017. 			sfb = sfBandIndex[sfreq].l[20];
    1018. 

  1018. 			for (sb = 576 - sfBandIndex[sfreq].l[21]; (sb > 0) && (i<576); sb--)
    1019. 

  1019. 			{
    1020. 

  1020.          	is_pos[i] = is_pos[sfb]; // error here : i >=576
    1021. 

  1021. 

  1022.             if (lsf) {
    1023. 

  1023.                k[0][i] = k[0][sfb];
    1024. 

  1024. 		         k[1][i] = k[1][sfb];
    1025. 

  1025.             } else {
    1026. 

  1026.   					is_ratio[i] = is_ratio[sfb];
    1027. 

  1027.             }
    1028. 

  1028. 				i++;
    1029. 

  1029. 			} // if (gr_info->mixed_block_flag)
    1030. 

  1030. 		} // if (gr_info->window_switching_flag ...
    1031. 

  1031. 	} // if (i_stereo)
    1032. 

  1032. 

  1033.    	i = 0;
    1034. 

  1034. 		for(sb=0;sb<SBLIMIT;sb++)
    1035. 

  1035. 			for(ss=0;ss<SSLIMIT;ss++) {
    1036. 

  1036. 				if (is_pos[i] == 7) {
    1037. 

  1037. 					if (ms_stereo) {
    1038. 

  1038. 						lr[0][sb][ss] = (ro[0][sb][ss]+ro[1][sb][ss]) * 0.707106781f;
    1039. 

  1039. 						lr[1][sb][ss] = (ro[0][sb][ss]-ro[1][sb][ss]) * 0.707106781f;
    1040. 

  1040. 					} else {
    1041. 

  1041. 						lr[0][sb][ss] = ro[0][sb][ss];
    1042. 

  1042. 						lr[1][sb][ss] = ro[1][sb][ss];
    1043. 

  1043. 					}
    1044. 

  1044. 				}
    1045. 

  1045. 				else if (i_stereo) {
    1046. 

  1046. 

  1047.             	if (lsf) {
    1048. 

  1048.                   lr[0][sb][ss] = ro[0][sb][ss] * k[0][i];
    1049. 

  1049.                   lr[1][sb][ss] = ro[0][sb][ss] * k[1][i];
    1050. 

  1050.                } else {
    1051. 

  1051.                	lr[1][sb][ss] = ro[0][sb][ss] / (real) (1 + is_ratio[i]);
    1052. 

  1052. 	  				   lr[0][sb][ss] = lr[1][sb][ss] * is_ratio[i];
    1053. 

  1053.                }
    1054. 

  1054. 				}
    1055. 

  1055. /*				else {
    1056. 

  1056. 					printf("Error in stereo processing\n");
    1057. 

  1057. 				} */
    1058. 

  1058.             i++;
    1059. 

  1059. 			}
    1060. 

  1060. 

  1061.     } // channels == 2
    1062. 

  1062. }
    1063. 

  1063. 

  1064. void LayerIII_Decoder::antialias(uint32 ch, uint32 gr)
    1065. 

  1065. {
    1066. 

  1066. 	int32 sb18, ss, sb18lim;
    1067. 

  1067.    gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
    1068. 

  1068. 

  1069. 	// 31 alias-reduction operations between each pair of sub-bands
    1070. 

  1070. 	// with 8 butterflies between each pair
    1071. 

  1071. 

  1072. 	if  (gr_info->window_switching_flag && (gr_info->block_type == 2) &&
    1073. 

  1073. 		 !gr_info->mixed_block_flag )
    1074. 

  1074.        return;
    1075. 

  1075. 

  1076. 	if (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
    1077. 

  1077. 	    (gr_info->block_type == 2)) {
    1078. 

  1078.       sb18lim = 18;
    1079. 

  1079. 	} else {
    1080. 

  1080. 		sb18lim = 558;
    1081. 

  1081.    }
    1082. 

  1082. 

  1083.    for (sb18=0; sb18 < sb18lim; sb18+=18) {
    1084. 

  1084.       for (ss=0;ss<8;ss++) {
    1085. 

  1085.       	int32 src_idx1 = sb18 + 17 - ss;
    1086. 

  1086.          int32 src_idx2 = sb18 + 18 + ss;
    1087. 

  1087.       	real bu = out_1d[src_idx1];
    1088. 

  1088. 			real bd = out_1d[src_idx2];
    1089. 

  1089. 			out_1d[src_idx1] = (bu * cs[ss]) - (bd * ca[ss]);
    1090. 

  1090. 			out_1d[src_idx2] = (bd * cs[ss]) + (bu * ca[ss]);
    1091. 

  1091.       }
    1092. 

  1092.    }
    1093. 

  1093. }
    1094. 

  1094. 

  1095. void LayerIII_Decoder::hybrid(uint32 ch, uint32 gr)
    1096. 

  1096. {
    1097. 

  1097. 	real rawout[36];
    1098. 

  1098.    uint32 bt;
    1099. 

  1099.    int32 sb18;
    1100. 

  1100.    gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
    1101. 

  1101.    real *tsOut;
    1102. 

  1102.    real *prvblk;
    1103. 

  1103. 

  1104.    for(sb18=0;sb18<576;sb18+=18) {
    1105. 

  1105. 

  1106. 		bt = (gr_info->window_switching_flag && gr_info->mixed_block_flag &&
    1107. 

  1107. 				 (sb18 < 36)) ? 0 : gr_info->block_type;
    1108. 

  1108. 

  1109. 		tsOut = out_1d + sb18;
    1110. 

  1110. 

  1111. 		inv_mdct(tsOut, rawout, bt);
    1112. 

  1112. 

  1113. 		// overlap addition
    1114. 

  1114. 		prvblk = &prevblck[ch][sb18];
    1115. 

  1115. 

  1116. 	   tsOut[0]   = rawout[0]  + prvblk[0];
    1117. 

  1117. 	   prvblk[0]  = rawout[18];
    1118. 

  1118. 	   tsOut[1]   = rawout[1]  + prvblk[1];
    1119. 

  1119. 	   prvblk[1]  = rawout[19];
    1120. 

  1120. 	   tsOut[2]   = rawout[2]  + prvblk[2];
    1121. 

  1121. 	   prvblk[2]  = rawout[20];
    1122. 

  1122. 	   tsOut[3]   = rawout[3]  + prvblk[3];
    1123. 

  1123. 	   prvblk[3]  = rawout[21];
    1124. 

  1124. 	   tsOut[4]   = rawout[4]  + prvblk[4];
    1125. 

  1125. 	   prvblk[4]  = rawout[22];
    1126. 

  1126. 	   tsOut[5]   = rawout[5]  + prvblk[5];
    1127. 

  1127. 	   prvblk[5]  = rawout[23];
    1128. 

  1128. 	   tsOut[6]   = rawout[6]  + prvblk[6];
    1129. 

  1129. 	   prvblk[6]  = rawout[24];
    1130. 

  1130. 	   tsOut[7]   = rawout[7]  + prvblk[7];
    1131. 

  1131. 	   prvblk[7]  = rawout[25];
    1132. 

  1132. 	   tsOut[8]   = rawout[8]  + prvblk[8];
    1133. 

  1133. 	   prvblk[8]  = rawout[26];
    1134. 

  1134. 	   tsOut[9]   = rawout[9]  + prvblk[9];
    1135. 

  1135. 	   prvblk[9]  = rawout[27];
    1136. 

  1136.    	tsOut[10]  = rawout[10] + prvblk[10];
    1137. 

  1137.    	prvblk[10] = rawout[28];
    1138. 

  1138.    	tsOut[11]  = rawout[11] + prvblk[11];
    1139. 

  1139.       prvblk[11] = rawout[29];
    1140. 

  1140.    	tsOut[12]  = rawout[12] + prvblk[12];
    1141. 

  1141.    	prvblk[12] = rawout[30];
    1142. 

  1142.    	tsOut[13]  = rawout[13] + prvblk[13];
    1143. 

  1143.    	prvblk[13] = rawout[31];
    1144. 

  1144.    	tsOut[14]  = rawout[14] + prvblk[14];
    1145. 

  1145.    	prvblk[14] = rawout[32];
    1146. 

  1146.    	tsOut[15]  = rawout[15] + prvblk[15];
    1147. 

  1147.    	prvblk[15] = rawout[33];
    1148. 

  1148.    	tsOut[16]  = rawout[16] + prvblk[16];
    1149. 

  1149.    	prvblk[16] = rawout[34];
    1150. 

  1150.    	tsOut[17]  = rawout[17] + prvblk[17];
    1151. 

  1151.    	prvblk[17] = rawout[35];
    1152. 

  1152.    }
    1153. 

  1153. }
    1154. 

  1154. 

  1155. void LayerIII_Decoder::do_downmix()
    1156. 

  1156. {
    1157. 

  1157. 	for (uint32 sb=0; sb<SSLIMIT; sb++) {
    1158. 

  1158.    	for (uint32 ss=0; ss<SSLIMIT; ss+=3) {
    1159. 

  1159.       	lr[0][sb][ss]   = (lr[0][sb][ss]   + lr[1][sb][ss])   * 0.5f;
    1160. 

  1160.       	lr[0][sb][ss+1] = (lr[0][sb][ss+1] + lr[1][sb][ss+1]) * 0.5f;
    1161. 

  1161.       	lr[0][sb][ss+2] = (lr[0][sb][ss+2] + lr[1][sb][ss+2]) * 0.5f;
    1162. 

  1162.       }
    1163. 

  1163.    }
    1164. 

  1164. }
    1165. 

  1165. 

  1166. void LayerIII_Decoder::decode()
    1167. 

  1167. {
    1168. 

  1168. 	 uint32 nSlots = header->slots();
    1169. 

  1169.     uint32 flush_main;
    1170. 

  1170.     uint32 gr, ch, ss, sb, sb18;
    1171. 

  1171.     int32 main_data_end;
    1172. 

  1172. 	 int32 bytes_to_discard;
    1173. 

  1173.     int32 i;
    1174. 

  1174. 

  1175. 	 get_side_info();
    1176. 

  1176. 

  1177.     for (i=0; i<(int32)nSlots; i++)
    1178. 

  1178.     	br->hputbuf(stream->get_bits(8));
    1179. 

  1179. 

  1180.     main_data_end = br->hsstell() >> 3; // of previous frame
    1181. 

  1181. 

  1182.     if (flush_main = (br->hsstell() & 7)) {
    1183. 

  1183.          br->hgetbits(8 - flush_main);
    1184. 

  1184. 			main_data_end++;
    1185. 

  1185. 	 }
    1186. 

  1186. 

  1187. 	 bytes_to_discard = frame_start - main_data_end
    1188. 

  1188. 							  - si->main_data_begin;
    1189. 

  1189. 

  1190. 	 frame_start += nSlots;
    1191. 

  1191. 

  1192.     if (bytes_to_discard < 0)
    1193. 

  1193. 			return;
    1194. 

  1194. 

  1195. 	 if (main_data_end > 4096) {
    1196. 

  1196. 			frame_start -= 4096;
    1197. 

  1197. 			br->rewindNbytes(4096);
    1198. 

  1198. 	 }
    1199. 

  1199. 

  1200. 	 for (; bytes_to_discard > 0; bytes_to_discard--)
    1201. 

  1201.     		br->hgetbits(8);
    1202. 

  1202. 

  1203. 	 for (gr=0;gr<max_gr;gr++) {
    1204. 

  1204. 

  1205. 			for (ch=0; ch<channels; ch++) {
    1206. 

  1206.            part2_start = br->hsstell();
    1207. 

  1207. 

  1208.            if (header->version() == MPEG1)
    1209. 

  1209. 				  get_scale_factors(ch, gr);
    1210. 

  1210.            else  // MPEG-2 LSF
    1211. 

  1211.               get_LSF_scale_factors(ch, gr);
    1212. 

  1212. 

  1213. 			  huffman_decode(ch, gr);
    1214. 

  1214. 			  dequantize_sample(ro[ch], ch, gr);
    1215. 

  1215. 			}
    1216. 

  1216. 

  1217.          stereo(gr);
    1218. 

  1218. 

  1219.          if ((which_channels == downmix) && (channels > 1))
    1220. 

  1220.          	do_downmix();
    1221. 

  1221. 

  1222.          for (ch=first_channel; ch<=last_channel; ch++) {
    1223. 

  1223. 

  1224.          		reorder(lr[ch], ch, gr);
    1225. 

  1225. 					antialias(ch, gr);
    1226. 

  1226.                hybrid(ch, gr);
    1227. 

  1227. 

  1228. 					for (sb18=18;sb18<576;sb18+=36) // Frequency inversion
    1229. 

  1229.                    for (ss=1;ss<SSLIMIT;ss+=2)
    1230. 

  1230.                   	  out_1d[sb18 + ss] = -out_1d[sb18 + ss];
    1231. 

  1231. 

  1232. 					if ((ch == 0) || (which_channels == right)) {
    1233. 

  1233. 					  for (ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
    1234. 

  1234.                   	sb = 0;
    1235. 

  1235.                  		for (sb18=0; sb18<576; sb18+=18) {
    1236. 

  1236. 								 filter1->input_sample(out_1d[sb18+ss], sb);
    1237. 

  1237.                          sb++;
    1238. 

  1238.                      }
    1239. 

  1239.                     	filter1->calculate_pcm_samples(buffer);
    1240. 

  1240. 					  }
    1241. 

  1241. 					} else {
    1242. 

  1242. 					  for (ss=0;ss<SSLIMIT;ss++) { // Polyphase synthesis
    1243. 

  1243.                   	sb = 0;
    1244. 

  1244.                  		for (sb18=0; sb18<576; sb18+=18) {
    1245. 

  1245. 								 filter2->input_sample(out_1d[sb18+ss], sb);
    1246. 

  1246.                          sb++;
    1247. 

  1247.                      }
    1248. 

  1248.                     	filter2->calculate_pcm_samples(buffer);
    1249. 

  1249. 					  }
    1250. 

  1250. 

  1251.                }
    1252. 

  1252. 			}	// channels
    1253. 

  1253. 	 }	// granule
    1254. 

  1254.  	 buffer->write_buffer(1);
    1255. 

  1255. }
    1256. 

  1256. 

  1257.