Mercurial > audlegacy

comparison Input/mpg123/layer3.c @ 0:cb178e5ad177 trunk

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[svn] Import audacious source.
author nenolod
date Mon, 24 Oct 2005 03:06:47 -0700
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:cb178e5ad177
1
2 /*
3 * Mpeg Layer-3 audio decoder
4 * --------------------------
5 * copyright (c) 1995-1999 by Michael Hipp.
6 * All rights reserved. See also 'README'
7 *
8 * Optimize-TODO: put short bands into the band-field without the stride of 3 reals
9 * Length-optimze: unify long and short band code where it is possible
10 */
11
12 #include <stdlib.h>
13 #include <math.h>
14
15 #include "audacious/output.h"
16
17 #include "mpg123.h"
18 #include "huffman.h"
19 #include "getbits.h"
20
21
22 static real ispow[8207];
23 static real aa_ca[8], aa_cs[8];
24 static real COS1[12][6];
25 static real win[4][36];
26 static real win1[4][36];
27 static real gainpow2[256 + 118 + 4];
28 real COS9[9];
29 static real COS6_1, COS6_2;
30 real tfcos36[9];
31 static real tfcos12[3];
32 #define NEW_DCT9
33 #ifdef NEW_DCT9
34 static real cos9[3], cos18[3];
35 #endif
36
37 #ifdef USE_SIMD
38 # define DCT36 (fr->dct36)
39 #else
40 # define DCT36 mpg123_dct36
41 #endif
42
43 struct bandInfoStruct {
44 int longIdx[23];
45 int longDiff[22];
46 int shortIdx[14];
47 int shortDiff[13];
48 };
49
50 int longLimit[9][23];
51 int shortLimit[9][14];
52
53 /* Used by the getbits macros */
54 static unsigned long rval;
55 static unsigned char rval_uc;
56
57 struct bandInfoStruct bandInfo[9] = {
58 /* MPEG 1.0 */
59 {{0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 52, 62, 74, 90, 110, 134, 162,
60 196, 238, 288, 342, 418, 576},
61 {4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10, 12, 16, 20, 24, 28, 34, 42, 50, 54,
62 76, 158},
63 {0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 30 * 3, 40 * 3, 52 * 3,
64 66 * 3, 84 * 3, 106 * 3, 136 * 3, 192 * 3},
65 {4, 4, 4, 4, 6, 8, 10, 12, 14, 18, 22, 30, 56}},
66
67 {{0, 4, 8, 12, 16, 20, 24, 30, 36, 42, 50, 60, 72, 88, 106, 128, 156,
68 190, 230, 276, 330, 384, 576},
69 {4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10, 12, 16, 18, 22, 28, 34, 40, 46, 54,
70 54, 192},
71 {0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 28 * 3, 38 * 3, 50 * 3,
72 64 * 3, 80 * 3, 100 * 3, 126 * 3, 192 * 3},
73 {4, 4, 4, 4, 6, 6, 10, 12, 14, 16, 20, 26, 66}},
74
75 {{0, 4, 8, 12, 16, 20, 24, 30, 36, 44, 54, 66, 82, 102, 126, 156, 194,
76 240, 296, 364, 448, 550, 576},
77 {4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12, 16, 20, 24, 30, 38, 46, 56, 68,
78 84, 102, 26},
79 {0, 4 * 3, 8 * 3, 12 * 3, 16 * 3, 22 * 3, 30 * 3, 42 * 3, 58 * 3,
80 78 * 3, 104 * 3, 138 * 3, 180 * 3, 192 * 3},
81 {4, 4, 4, 4, 6, 8, 12, 16, 20, 26, 34, 42, 12}},
82
83 /* MPEG 2.0 */
84 {{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200,
85 238, 284, 336, 396, 464, 522, 576},
86 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60,
87 68, 58, 54},
88 {0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 24 * 3, 32 * 3, 42 * 3, 56 * 3,
89 74 * 3, 100 * 3, 132 * 3, 174 * 3, 192 * 3},
90 {4, 4, 4, 6, 6, 8, 10, 14, 18, 26, 32, 42, 18}},
91 /*
92 { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576},
93 {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,52,64,70,76,36 } ,
94 */
95 /* changed 19th value fropm 330 to 332 */
96 {{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 114, 136, 162, 194,
97 232, 278, 332, 394, 464, 540, 576},
98 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 18, 22, 26, 32, 38, 46, 54, 62,
99 70, 76, 36},
100 {0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 26 * 3, 36 * 3, 48 * 3, 62 * 3,
101 80 * 3, 104 * 3, 136 * 3, 180 * 3, 192 * 3},
102 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 32, 44, 12}},
103
104 {{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200,
105 238, 284, 336, 396, 464, 522, 576},
106 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60,
107 68, 58, 54},
108 {0, 4 * 3, 8 * 3, 12 * 3, 18 * 3, 26 * 3, 36 * 3, 48 * 3, 62 * 3,
109 80 * 3, 104 * 3, 134 * 3, 174 * 3, 192 * 3},
110 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18}},
111 /* MPEG 2.5 */
112 {{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200,
113 238, 284, 336, 396, 464, 522, 576},
114 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60,
115 68, 58, 54},
116 {0, 12, 24, 36, 54, 78, 108, 144, 186, 240, 312, 402, 522, 576},
117 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18}},
118 {{0, 6, 12, 18, 24, 30, 36, 44, 54, 66, 80, 96, 116, 140, 168, 200,
119 238, 284, 336, 396, 464, 522, 576},
120 {6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16, 20, 24, 28, 32, 38, 46, 52, 60,
121 68, 58, 54},
122 {0, 12, 24, 36, 54, 78, 108, 144, 186, 240, 312, 402, 522, 576},
123 {4, 4, 4, 6, 8, 10, 12, 14, 18, 24, 30, 40, 18}},
124 {{0, 12, 24, 36, 48, 60, 72, 88, 108, 132, 160, 192, 232, 280, 336,
125 400, 476, 566, 568, 570, 572, 574, 576},
126 {12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 76, 90,
127 2, 2, 2, 2, 2},
128 {0, 24, 48, 72, 108, 156, 216, 288, 372, 480, 486, 492, 498, 576},
129 {8, 8, 8, 12, 16, 20, 24, 28, 36, 2, 2, 2, 26}},
130 };
131
132 static int mapbuf0[9][152];
133 static int mapbuf1[9][156];
134 static int mapbuf2[9][44];
135 static int *map[9][3];
136 static int *mapend[9][3];
137
138 static unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */
139 static unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */
140
141 static real tan1_1[16], tan2_1[16], tan1_2[16], tan2_2[16];
142 static real pow1_1[2][16], pow2_1[2][16], pow1_2[2][16], pow2_2[2][16];
143
144 /*
145 * init tables for layer-3
146 */
147 void
148 mpg123_init_layer3(int down_sample_sblimit)
149 {
150 int i, j, k, l;
151
152 for (i = -256; i < 118 + 4; i++)
153 gainpow2[i + 256] = pow((double) 2.0, -0.25 * (double) (i + 210));
154 for (i = 0; i < 8207; i++)
155 ispow[i] = pow((double) i, (double) 4.0 / 3.0);
156
157 for (i = 0; i < 8; i++) {
158 static double Ci[8] =
159 { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142,
160 -0.0037
161 };
162 double sq = sqrt(1.0 + Ci[i] * Ci[i]);
163
164 aa_cs[i] = 1.0 / sq;
165 aa_ca[i] = Ci[i] / sq;
166 }
167
168 for (i = 0; i < 18; i++) {
169 win[0][i] = win[1][i] =
170 0.5 * sin(M_PI / 72.0 * (double) (2 * (i + 0) + 1)) /
171 cos(M_PI * (double) (2 * (i + 0) + 19) / 72.0);
172 win[0][i + 18] = win[3][i + 18] =
173 0.5 * sin(M_PI / 72.0 * (double) (2 * (i + 18) + 1)) /
174 cos(M_PI * (double) (2 * (i + 18) + 19) / 72.0);
175 }
176 for (i = 0; i < 6; i++) {
177 win[1][i + 18] =
178 0.5 / cos(M_PI * (double) (2 * (i + 18) + 19) / 72.0);
179 win[3][i + 12] =
180 0.5 / cos(M_PI * (double) (2 * (i + 12) + 19) / 72.0);
181 win[1][i + 24] =
182 0.5 * sin(M_PI / 24.0 * (double) (2 * i + 13)) / cos(M_PI *
183 (double)
184 (2 *
185 (i +
186 24) +
187 19) / 72.0);
188 win[1][i + 30] = win[3][i] = 0.0;
189 win[3][i + 6] =
190 0.5 * sin(M_PI / 24.0 * (double) (2 * i + 1)) / cos(M_PI *
191 (double) (2
192 *
193 (i
194 +
195 6)
196 +
197 19)
198 / 72.0);
199 }
200
201 for (i = 0; i < 9; i++)
202 COS9[i] = cos(M_PI / 18.0 * (double) i);
203
204 for (i = 0; i < 9; i++)
205 tfcos36[i] = 0.5 / cos(M_PI * (double) (i * 2 + 1) / 36.0);
206 for (i = 0; i < 3; i++)
207 tfcos12[i] = 0.5 / cos(M_PI * (double) (i * 2 + 1) / 12.0);
208
209 COS6_1 = cos(M_PI / 6.0 * (double) 1);
210 COS6_2 = cos(M_PI / 6.0 * (double) 2);
211
212 #ifdef NEW_DCT9
213 cos9[0] = cos(1.0 * M_PI / 9.0);
214 cos9[1] = cos(5.0 * M_PI / 9.0);
215 cos9[2] = cos(7.0 * M_PI / 9.0);
216 cos18[0] = cos(1.0 * M_PI / 18.0);
217 cos18[1] = cos(11.0 * M_PI / 18.0);
218 cos18[2] = cos(13.0 * M_PI / 18.0);
219 #endif
220
221 for (i = 0; i < 12; i++) {
222 win[2][i] =
223 0.5 * sin(M_PI / 24.0 * (double) (2 * i + 1)) / cos(M_PI *
224 (double) (2
225 *
226 i
227 + 7)
228 / 24.0);
229 for (j = 0; j < 6; j++)
230 COS1[i][j] =
231 cos(M_PI / 24.0 * (double) ((2 * i + 7) * (2 * j + 1)));
232 }
233
234 for (j = 0; j < 4; j++) {
235 static int len[4] = { 36, 36, 12, 36 };
236
237 for (i = 0; i < len[j]; i += 2)
238 win1[j][i] = +win[j][i];
239 for (i = 1; i < len[j]; i += 2)
240 win1[j][i] = -win[j][i];
241 }
242
243 for (i = 0; i < 16; i++) {
244 double t = tan((double) i * M_PI / 12.0);
245
246 tan1_1[i] = t / (1.0 + t);
247 tan2_1[i] = 1.0 / (1.0 + t);
248 tan1_2[i] = M_SQRT2 * t / (1.0 + t);
249 tan2_2[i] = M_SQRT2 / (1.0 + t);
250
251 for (j = 0; j < 2; j++) {
252 double base = pow(2.0, -0.25 * (j + 1.0));
253 double p1 = 1.0, p2 = 1.0;
254
255 if (i > 0) {
256 if (i & 1)
257 p1 = pow(base, (i + 1.0) * 0.5);
258 else
259 p2 = pow(base, i * 0.5);
260 }
261 pow1_1[j][i] = p1;
262 pow2_1[j][i] = p2;
263 pow1_2[j][i] = M_SQRT2 * p1;
264 pow2_2[j][i] = M_SQRT2 * p2;
265 }
266 }
267
268 for (j = 0; j < 9; j++) {
269 struct bandInfoStruct *bi = &bandInfo[j];
270 int *mp;
271 int cb, lwin;
272 int *bdf;
273
274 mp = map[j][0] = mapbuf0[j];
275 bdf = bi->longDiff;
276 for (i = 0, cb = 0; cb < 8; cb++, i += *bdf++) {
277 *mp++ = (*bdf) >> 1;
278 *mp++ = i;
279 *mp++ = 3;
280 *mp++ = cb;
281 }
282 bdf = bi->shortDiff + 3;
283 for (cb = 3; cb < 13; cb++) {
284 int l = (*bdf++) >> 1;
285
286 for (lwin = 0; lwin < 3; lwin++) {
287 *mp++ = l;
288 *mp++ = i + lwin;
289 *mp++ = lwin;
290 *mp++ = cb;
291 }
292 i += 6 * l;
293 }
294 mapend[j][0] = mp;
295
296 mp = map[j][1] = mapbuf1[j];
297 bdf = bi->shortDiff + 0;
298 for (i = 0, cb = 0; cb < 13; cb++) {
299 int l = (*bdf++) >> 1;
300
301 for (lwin = 0; lwin < 3; lwin++) {
302 *mp++ = l;
303 *mp++ = i + lwin;
304 *mp++ = lwin;
305 *mp++ = cb;
306 }
307 i += 6 * l;
308 }
309 mapend[j][1] = mp;
310
311 mp = map[j][2] = mapbuf2[j];
312 bdf = bi->longDiff;
313 for (cb = 0; cb < 22; cb++) {
314 *mp++ = (*bdf++) >> 1;
315 *mp++ = cb;
316 }
317 mapend[j][2] = mp;
318
319 }
320
321 for (j = 0; j < 9; j++) {
322 for (i = 0; i < 23; i++) {
323 longLimit[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1;
324 if (longLimit[j][i] > (down_sample_sblimit))
325 longLimit[j][i] = down_sample_sblimit;
326 }
327 for (i = 0; i < 14; i++) {
328 shortLimit[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1;
329 if (shortLimit[j][i] > (down_sample_sblimit))
330 shortLimit[j][i] = down_sample_sblimit;
331 }
332 }
333
334 for (i = 0; i < 5; i++) {
335 for (j = 0; j < 6; j++) {
336 for (k = 0; k < 6; k++) {
337 int n = k + j * 6 + i * 36;
338
339 i_slen2[n] = i | (j << 3) | (k << 6) | (3 << 12);
340 }
341 }
342 }
343 for (i = 0; i < 4; i++) {
344 for (j = 0; j < 4; j++) {
345 for (k = 0; k < 4; k++) {
346 int n = k + j * 4 + i * 16;
347
348 i_slen2[n + 180] = i | (j << 3) | (k << 6) | (4 << 12);
349 }
350 }
351 }
352 for (i = 0; i < 4; i++) {
353 for (j = 0; j < 3; j++) {
354 int n = j + i * 3;
355
356 i_slen2[n + 244] = i | (j << 3) | (5 << 12);
357 n_slen2[n + 500] = i | (j << 3) | (2 << 12) | (1 << 15);
358 }
359 }
360
361 for (i = 0; i < 5; i++) {
362 for (j = 0; j < 5; j++) {
363 for (k = 0; k < 4; k++) {
364 for (l = 0; l < 4; l++) {
365 int n = l + k * 4 + j * 16 + i * 80;
366
367 n_slen2[n] =
368 i | (j << 3) | (k << 6) | (l << 9) | (0 << 12);
369 }
370 }
371 }
372 }
373 for (i = 0; i < 5; i++) {
374 for (j = 0; j < 5; j++) {
375 for (k = 0; k < 4; k++) {
376 int n = k + j * 4 + i * 20;
377
378 n_slen2[n + 400] = i | (j << 3) | (k << 6) | (1 << 12);
379 }
380 }
381 }
382 }
383
384 /*
385 * read additional side information (for MPEG 1 and MPEG 2)
386 */
387 static int
388 III_get_side_info(struct III_sideinfo *si, int stereo,
389 int ms_stereo, long sfreq, int single, int lsf)
390 {
391 int ch, gr;
392 int powdiff = (single == 3) ? 4 : 0;
393
394 static const int tabs[2][5] = { {2, 9, 5, 3, 4}, {1, 8, 1, 2, 9} };
395 const int *tab = tabs[lsf];
396
397 si->main_data_begin = mpg123_getbits(tab[1]);
398 if (stereo == 1)
399 si->private_bits = mpg123_getbits_fast(tab[2]);
400 else
401 si->private_bits = mpg123_getbits_fast(tab[3]);
402
403 if (!lsf) {
404 for (ch = 0; ch < stereo; ch++) {
405 si->ch[ch].gr[0].scfsi = -1;
406 si->ch[ch].gr[1].scfsi = mpg123_getbits_fast(4);
407 }
408 }
409
410 for (gr = 0; gr < tab[0]; gr++) {
411 for (ch = 0; ch < stereo; ch++) {
412 register struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
413
414 gr_info->part2_3_length = mpg123_getbits(12);
415 gr_info->big_values = mpg123_getbits(9);
416 if (gr_info->big_values > 288) {
417 /* fprintf(stderr, "big_values too large!\n"); */
418 /* gr_info->big_values = 288; */
419 return 0;
420 }
421 gr_info->pow2gain =
422 gainpow2 + 256 - mpg123_getbits_fast(8) + powdiff;
423 if (ms_stereo)
424 gr_info->pow2gain += 2;
425 gr_info->scalefac_compress = mpg123_getbits(tab[4]);
426
427 if (mpg123_get1bit()) { /* window switch flag */
428 int i;
429
430 gr_info->block_type = mpg123_getbits_fast(2);
431 gr_info->mixed_block_flag = mpg123_get1bit();
432 gr_info->table_select[0] = mpg123_getbits_fast(5);
433 gr_info->table_select[1] = mpg123_getbits_fast(5);
434 /*
435 * table_select[2] not needed, because
436 * there is no region2, but to satisfy
437 * some verifications tools we set it
438 * either.
439 */
440 gr_info->table_select[2] = 0;
441 for (i = 0; i < 3; i++)
442 gr_info->full_gain[i] =
443 gr_info->pow2gain + (mpg123_getbits_fast(3) << 3);
444
445 if (gr_info->block_type == 0) {
446 /* fprintf(stderr, "Blocktype == 0 and window-switching == 1 not allowed.\n"); */
447 /* exit(1); */
448 return 0;
449 }
450
451 /* region_count/start parameters are implicit in this case. */
452 if (!lsf || gr_info->block_type == 2)
453 gr_info->region1start = 36 >> 1;
454 else {
455 /* check this again for 2.5 and sfreq=8 */
456 if (sfreq == 8)
457 gr_info->region1start = 108 >> 1;
458 else
459 gr_info->region1start = 54 >> 1;
460 }
461 gr_info->region2start = 576 >> 1;
462 }
463 else {
464 int i, r0c, r1c;
465
466 for (i = 0; i < 3; i++)
467 gr_info->table_select[i] = mpg123_getbits_fast(5);
468 r0c = mpg123_getbits_fast(4);
469 r1c = mpg123_getbits_fast(3);
470 gr_info->region1start = bandInfo[sfreq].longIdx[r0c + 1] >> 1;
471 if (r0c + r1c + 2 > 22)
472 gr_info->region2start = 576 >> 1;
473 else
474 gr_info->region2start =
475 bandInfo[sfreq].longIdx[r0c + 1 + r1c + 1] >> 1;
476 gr_info->block_type = 0;
477 gr_info->mixed_block_flag = 0;
478 }
479 if (!lsf)
480 gr_info->preflag = mpg123_get1bit();
481 gr_info->scalefac_scale = mpg123_get1bit();
482 gr_info->count1table_select = mpg123_get1bit();
483 }
484 }
485 return 1;
486 }
487
488
489 /*
490 * read scalefactors
491 */
492 static int
493 III_get_scale_factors_1(int *scf, struct gr_info_s *gr_info)
494 {
495 static const unsigned char slen[2][16] = {
496 {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
497 {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}
498 };
499 int numbits;
500 int num0 = slen[0][gr_info->scalefac_compress];
501 int num1 = slen[1][gr_info->scalefac_compress];
502
503 if (gr_info->block_type == 2) {
504 int i = 18;
505
506 numbits = (num0 + num1) * 18;
507
508 if (gr_info->mixed_block_flag) {
509 for (i = 8; i; i--)
510 *scf++ = mpg123_getbits_fast(num0);
511 i = 9;
512 numbits -= num0; /* num0 * 17 + num1 * 18 */
513 }
514
515 for (; i; i--)
516 *scf++ = mpg123_getbits_fast(num0);
517 for (i = 18; i; i--)
518 *scf++ = mpg123_getbits_fast(num1);
519 *scf++ = 0;
520 *scf++ = 0;
521 *scf++ = 0; /* short[13][0..2] = 0 */
522 }
523 else {
524 int i;
525 int scfsi = gr_info->scfsi;
526
527 if (scfsi < 0) { /* scfsi < 0 => granule == 0 */
528 for (i = 11; i; i--)
529 *scf++ = mpg123_getbits_fast(num0);
530 for (i = 10; i; i--)
531 *scf++ = mpg123_getbits_fast(num1);
532 numbits = (num0 + num1) * 10 + num0;
533 *scf++ = 0;
534 }
535 else {
536 numbits = 0;
537 if (!(scfsi & 0x8)) {
538 for (i = 0; i < 6; i++)
539 *scf++ = mpg123_getbits_fast(num0);
540 numbits += num0 * 6;
541 }
542 else {
543 scf += 6;
544 }
545
546 if (!(scfsi & 0x4)) {
547 for (i = 0; i < 5; i++)
548 *scf++ = mpg123_getbits_fast(num0);
549 numbits += num0 * 5;
550 }
551 else {
552 scf += 5;
553 }
554
555 if (!(scfsi & 0x2)) {
556 for (i = 0; i < 5; i++)
557 *scf++ = mpg123_getbits_fast(num1);
558 numbits += num1 * 5;
559 }
560 else {
561 scf += 5;
562 }
563
564 if (!(scfsi & 0x1)) {
565 for (i = 0; i < 5; i++)
566 *scf++ = mpg123_getbits_fast(num1);
567 numbits += num1 * 5;
568 }
569 else {
570 scf += 5;
571 }
572 *scf++ = 0; /* no l[21] in original sources */
573 }
574 }
575 return numbits;
576 }
577
578 static int
579 III_get_scale_factors_2(int *scf, struct gr_info_s *gr_info, int i_stereo)
580 {
581 unsigned char *pnt;
582 int i, j, n = 0, numbits = 0;
583 unsigned int slen;
584
585 static unsigned char stab[3][6][4] = {
586 {{6, 5, 5, 5}, {6, 5, 7, 3}, {11, 10, 0, 0},
587 {7, 7, 7, 0}, {6, 6, 6, 3}, {8, 8, 5, 0}},
588 {{9, 9, 9, 9}, {9, 9, 12, 6}, {18, 18, 0, 0},
589 {12, 12, 12, 0}, {12, 9, 9, 6}, {15, 12, 9, 0}},
590 {{6, 9, 9, 9}, {6, 9, 12, 6}, {15, 18, 0, 0},
591 {6, 15, 12, 0}, {6, 12, 9, 6}, {6, 18, 9, 0}}
592 };
593
594 if (i_stereo) /* i_stereo AND second channel -> mpg123_do_layer3() checks this */
595 slen = i_slen2[gr_info->scalefac_compress >> 1];
596 else
597 slen = n_slen2[gr_info->scalefac_compress];
598
599 gr_info->preflag = (slen >> 15) & 0x1;
600
601 n = 0;
602 if (gr_info->block_type == 2) {
603 n++;
604 if (gr_info->mixed_block_flag)
605 n++;
606 }
607
608 pnt = stab[n][(slen >> 12) & 0x7];
609
610 for (i = 0; i < 4; i++) {
611 int num = slen & 0x7;
612
613 slen >>= 3;
614 if (num) {
615 for (j = 0; j < (int) (pnt[i]); j++)
616 *scf++ = mpg123_getbits_fast(num);
617 numbits += pnt[i] * num;
618 }
619 else {
620 for (j = 0; j < (int) (pnt[i]); j++)
621 *scf++ = 0;
622 }
623 }
624
625 n = (n << 1) + 1;
626 for (i = 0; i < n; i++)
627 *scf++ = 0;
628
629 return numbits;
630 }
631
632 static int pretab1[22] =
633 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 };
634 static int pretab2[22] =
635 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
636
637 /*
638 * Dequantize samples (includes huffman decoding)
639 */
640 /* 24 is enough because tab13 has max. a 19 bit huffvector */
641 #define BITSHIFT ((sizeof (long) - 1) * 8)
642
643 #define REFRESH_MASK() \
644 while(num < BITSHIFT) { \
645 mask |= ((unsigned long)mpg123_getbyte()) << (BITSHIFT - num); \
646 num += 8; \
647 part2remain -= 8; \
648 }
649
650 static int
651 III_dequantize_sample(real xr[SBLIMIT][SSLIMIT], int *scf,
652 struct gr_info_s *gr_info, int sfreq, int part2bits)
653 {
654 int shift = 1 + gr_info->scalefac_scale;
655 real *xrpnt = (real *) xr;
656 int l[3], l3;
657 int part2remain = gr_info->part2_3_length - part2bits;
658 int *me;
659
660 int num = mpg123_getbitoffset();
661 long mask;
662 /* we must split this, because for num==0 the shift is undefined if you do it in one step */
663 mask = ((unsigned long) mpg123_getbits(num)) << BITSHIFT;
664 mask <<= 8 - num;
665 part2remain -= num;
666
667 {
668 int bv = gr_info->big_values;
669 int region1 = gr_info->region1start;
670 int region2 = gr_info->region2start;
671
672 l3 = ((576 >> 1) - bv) >> 1;
673 /*
674 * we may lose the 'odd' bit here !!
675 * check this later again
676 */
677 if (bv <= region1) {
678 l[0] = bv;
679 l[1] = 0;
680 l[2] = 0;
681 }
682 else {
683 l[0] = region1;
684 if (bv <= region2) {
685 l[1] = bv - l[0];
686 l[2] = 0;
687 }
688 else {
689 l[1] = region2 - l[0];
690 l[2] = bv - region2;
691 }
692 }
693 }
694
695 if (gr_info->block_type == 2) {
696 /*
697 * decoding with short or mixed mode BandIndex table
698 */
699 int i, max[4];
700 int step = 0, lwin = 3, cb = 0;
701 register real v = 0.0;
702 register int *m, mc;
703
704 if (gr_info->mixed_block_flag) {
705 max[3] = -1;
706 max[0] = max[1] = max[2] = 2;
707 m = map[sfreq][0];
708 me = mapend[sfreq][0];
709 }
710 else {
711 max[0] = max[1] = max[2] = max[3] = -1;
712 /* max[3] not really needed in this case */
713 m = map[sfreq][1];
714 me = mapend[sfreq][1];
715 }
716
717 mc = 0;
718 for (i = 0; i < 2; i++) {
719 int lp = l[i];
720 struct newhuff *h = ht + gr_info->table_select[i];
721
722 for (; lp; lp--, mc--) {
723 register int x, y;
724 if ((!mc)) {
725 mc = *m++;
726 xrpnt = ((real *) xr) + (*m++);
727 lwin = *m++;
728 cb = *m++;
729 if (lwin == 3) {
730 v = gr_info->pow2gain[(*scf++) << shift];
731 step = 1;
732 }
733 else {
734 v = gr_info->full_gain[lwin][(*scf++) << shift];
735 step = 3;
736 }
737 }
738 {
739 register short *val = h->table;
740
741 REFRESH_MASK();
742 while ((y = *val++) < 0) {
743 if (mask < 0)
744 val -= y;
745 num--;
746 mask <<= 1;
747 }
748 x = y >> 4;
749 y &= 0xf;
750 }
751 if (x == 15 && h->linbits) {
752 max[lwin] = cb;
753 REFRESH_MASK();
754 x += ((unsigned long) mask) >> (BITSHIFT + 8 -
755 h->linbits);
756 num -= h->linbits + 1;
757 mask <<= h->linbits;
758 if (mask < 0)
759 *xrpnt = -ispow[x] * v;
760 else
761 *xrpnt = ispow[x] * v;
762 mask <<= 1;
763 }
764 else if (x) {
765 max[lwin] = cb;
766 if (mask < 0)
767 *xrpnt = -ispow[x] * v;
768 else
769 *xrpnt = ispow[x] * v;
770 num--;
771 mask <<= 1;
772 }
773 else
774 *xrpnt = 0.0;
775 xrpnt += step;
776 if (y == 15 && h->linbits) {
777 max[lwin] = cb;
778 REFRESH_MASK();
779 y += ((unsigned long) mask) >> (BITSHIFT + 8 -
780 h->linbits);
781 num -= h->linbits + 1;
782 mask <<= h->linbits;
783 if (mask < 0)
784 *xrpnt = -ispow[y] * v;
785 else
786 *xrpnt = ispow[y] * v;
787 mask <<= 1;
788 }
789 else if (y) {
790 max[lwin] = cb;
791 if (mask < 0)
792 *xrpnt = -ispow[y] * v;
793 else
794 *xrpnt = ispow[y] * v;
795 num--;
796 mask <<= 1;
797 }
798 else
799 *xrpnt = 0.0;
800 xrpnt += step;
801 }
802 }
803
804 for (; l3 && (part2remain + num > 0); l3--) {
805 struct newhuff *h = htc + gr_info->count1table_select;
806 register short *val = h->table, a;
807
808 REFRESH_MASK();
809 while ((a = *val++) < 0) {
810 if (mask < 0)
811 val -= a;
812 num--;
813 mask <<= 1;
814 }
815 if (part2remain + num <= 0) {
816 num -= part2remain + num;
817 break;
818 }
819
820 for (i = 0; i < 4; i++) {
821 if (!(i & 1)) {
822 if (!mc) {
823 mc = *m++;
824 xrpnt = ((real *) xr) + (*m++);
825 lwin = *m++;
826 cb = *m++;
827 if (lwin == 3) {
828 v = gr_info->pow2gain[(*scf++) << shift];
829 step = 1;
830 }
831 else {
832 v = gr_info->full_gain[lwin][(*scf++) << shift];
833 step = 3;
834 }
835 }
836 mc--;
837 }
838 if ((a & (0x8 >> i))) {
839 max[lwin] = cb;
840 if (part2remain + num <= 0) {
841 break;
842 }
843 if (mask < 0)
844 *xrpnt = -v;
845 else
846 *xrpnt = v;
847 num--;
848 mask <<= 1;
849 }
850 else
851 *xrpnt = 0.0;
852 xrpnt += step;
853 }
854 }
855
856 if (lwin < 3) { /* short band? */
857 while (1) {
858 /* HACK Prevent overflowing the xr buffer */
859 if (mc * 6 > &xr[SBLIMIT][SSLIMIT] - xrpnt)
860 return 1;
861
862 for (; mc > 0; mc--) {
863 *xrpnt = 0.0;
864 xrpnt += 3; /* short band -> step=3 */
865 *xrpnt = 0.0;
866 xrpnt += 3;
867 }
868 if (m >= me)
869 break;
870 mc = *m++;
871 xrpnt = ((real *) xr) + *m++;
872 if (*m++ == 0)
873 break; /* optimize: field will be set to zero at the end of the function */
874 m++; /* cb */
875 }
876 }
877
878 gr_info->maxband[0] = max[0] + 1;
879 gr_info->maxband[1] = max[1] + 1;
880 gr_info->maxband[2] = max[2] + 1;
881 gr_info->maxbandl = max[3] + 1;
882
883 {
884 int rmax = max[0] > max[1] ? max[0] : max[1];
885
886 rmax = (rmax > max[2] ? rmax : max[2]) + 1;
887 gr_info->maxb =
888 rmax ? shortLimit[sfreq][rmax] : longLimit[sfreq][max[3] + 1];
889 }
890
891 }
892 else {
893 /*
894 * decoding with 'long' BandIndex table (block_type != 2)
895 */
896 int *pretab = gr_info->preflag ? pretab1 : pretab2;
897 int i, max = -1;
898 int cb = 0;
899 int *m = map[sfreq][2];
900 register real v = 0.0;
901 int mc = 0;
902
903 /*
904 * long hash table values
905 */
906 for (i = 0; i < 3; i++) {
907 int lp = l[i];
908 struct newhuff *h = ht + gr_info->table_select[i];
909
910 for (; lp; lp--, mc--) {
911 int x, y;
912
913 if (!mc) {
914 mc = *m++;
915 cb = *m++;
916 /* if (cb == 21) */
917 /* v = 0.0; */
918 /* else */
919 v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
920
921 }
922 {
923 register short *val = h->table;
924 REFRESH_MASK();
925 while ((y = *val++) < 0) {
926 if (mask < 0)
927 val -= y;
928 num--;
929 mask <<= 1;
930 }
931 x = y >> 4;
932 y &= 0xf;
933 }
934
935 if (x == 15 && h->linbits) {
936 max = cb;
937 REFRESH_MASK();
938 x += ((unsigned long) mask) >> (BITSHIFT + 8 -
939 h->linbits);
940 num -= h->linbits + 1;
941 mask <<= h->linbits;
942 if (mask < 0)
943 *xrpnt++ = -ispow[x] * v;
944 else
945 *xrpnt++ = ispow[x] * v;
946 mask <<= 1;
947 }
948 else if (x) {
949 max = cb;
950 if (mask < 0)
951 *xrpnt++ = -ispow[x] * v;
952 else
953 *xrpnt++ = ispow[x] * v;
954 num--;
955 mask <<= 1;
956 }
957 else
958 *xrpnt++ = 0.0;
959
960 if (y == 15 && h->linbits) {
961 max = cb;
962 REFRESH_MASK();
963 y += ((unsigned long) mask) >> (BITSHIFT + 8 -
964 h->linbits);
965 num -= h->linbits + 1;
966 mask <<= h->linbits;
967 if (mask < 0)
968 *xrpnt++ = -ispow[y] * v;
969 else
970 *xrpnt++ = ispow[y] * v;
971 mask <<= 1;
972 }
973 else if (y) {
974 max = cb;
975 if (mask < 0)
976 *xrpnt++ = -ispow[y] * v;
977 else
978 *xrpnt++ = ispow[y] * v;
979 num--;
980 mask <<= 1;
981 }
982 else
983 *xrpnt++ = 0.0;
984 }
985 }
986
987 /*
988 * short (count1table) values
989 */
990 for (; l3 && (part2remain + num > 0); l3--) {
991 struct newhuff *h = htc + gr_info->count1table_select;
992 register short *val = h->table, a;
993
994 REFRESH_MASK();
995 while ((a = *val++) < 0) {
996 if (mask < 0)
997 val -= a;
998 num--;
999 mask <<= 1;
1000 }
1001 if (part2remain + num <= 0) {
1002 num -= part2remain + num;
1003 break;
1004 }
1005
1006 for (i = 0; i < 4; i++) {
1007 if (!(i & 1)) {
1008 if (!mc) {
1009 mc = *m++;
1010 cb = *m++;
1011 /* if (cb == 21) */
1012 /* v = 0.0; */
1013 /* else */
1014 v = gr_info->
1015 pow2gain[((*scf++) + (*pretab++)) << shift];
1016 }
1017 mc--;
1018 }
1019 if ((a & (0x8 >> i))) {
1020 max = cb;
1021 if (part2remain + num <= 0) {
1022 break;
1023 }
1024 if (mask < 0)
1025 *xrpnt++ = -v;
1026 else
1027 *xrpnt++ = v;
1028 num--;
1029 mask <<= 1;
1030 }
1031 else
1032 *xrpnt++ = 0.0;
1033 }
1034 }
1035
1036 gr_info->maxbandl = max + 1;
1037 gr_info->maxb = longLimit[sfreq][gr_info->maxbandl];
1038 }
1039
1040 part2remain += num;
1041 mpg123_backbits(num);
1042 num = 0;
1043
1044 while (xrpnt < &xr[SBLIMIT][0])
1045 *xrpnt++ = 0.0;
1046
1047 while (part2remain > 16) {
1048 mpg123_getbits(16); /* Dismiss stuffing Bits */
1049 part2remain -= 16;
1050 }
1051 if (part2remain > 0)
1052 mpg123_getbits(part2remain);
1053 else if (part2remain < 0) {
1054 /* fprintf(stderr, "mpg123: Can't rewind stream by %d bits!\n", */
1055 /* -part2remain); */
1056 return 1; /* -> error */
1057 }
1058 return 0;
1059 }
1060
1061 /*
1062 * III_stereo: calculate real channel values for Joint-I-Stereo-mode
1063 */
1064 static void
1065 III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT], int *scalefac,
1066 struct gr_info_s *gr_info, int sfreq, int ms_stereo, int lsf)
1067 {
1068 real(*xr)[SBLIMIT * SSLIMIT] = (real(*)[SBLIMIT * SSLIMIT]) xr_buf;
1069 struct bandInfoStruct *bi = &bandInfo[sfreq];
1070
1071 const real *tab1, *tab2;
1072
1073 #if 1
1074 int tab;
1075 static const real *tabs[3][2][2] = {
1076 {{tan1_1, tan2_1}, {tan1_2, tan2_2}},
1077 {{pow1_1[0], pow2_1[0]}, {pow1_2[0], pow2_2[0]}},
1078 {{pow1_1[1], pow2_1[1]}, {pow1_2[1], pow2_2[1]}}
1079 };
1080
1081 tab = lsf + (gr_info->scalefac_compress & lsf);
1082 tab1 = tabs[tab][ms_stereo][0];
1083 tab2 = tabs[tab][ms_stereo][1];
1084 #else
1085 if (lsf) {
1086 int p = gr_info->scalefac_compress & 0x1;
1087
1088 if (ms_stereo) {
1089 tab1 = pow1_2[p];
1090 tab2 = pow2_2[p];
1091 }
1092 else {
1093 tab1 = pow1_1[p];
1094 tab2 = pow2_1[p];
1095 }
1096 }
1097 else {
1098 if (ms_stereo) {
1099 tab1 = tan1_2;
1100 tab2 = tan2_2;
1101 }
1102 else {
1103 tab1 = tan1_1;
1104 tab2 = tan2_1;
1105 }
1106 }
1107 #endif
1108
1109 if (gr_info->block_type == 2) {
1110 int lwin, do_l = 0;
1111
1112 if (gr_info->mixed_block_flag)
1113 do_l = 1;
1114
1115 for (lwin = 0; lwin < 3; lwin++) { /* process each window */
1116 /* get first band with zero values */
1117 int is_p, sb, idx, sfb = gr_info->maxband[lwin]; /* sfb is minimal 3 for mixed mode */
1118
1119 if (sfb > 3)
1120 do_l = 0;
1121
1122 for (; sfb < 12; sfb++) {
1123 is_p = scalefac[sfb * 3 + lwin - gr_info->mixed_block_flag]; /* scale: 0-15 */
1124 if (is_p != 7) {
1125 real t1, t2;
1126
1127 sb = bi->shortDiff[sfb];
1128 idx = bi->shortIdx[sfb] + lwin;
1129 t1 = tab1[is_p];
1130 t2 = tab2[is_p];
1131 for (; sb > 0; sb--, idx += 3) {
1132 real v = xr[0][idx];
1133
1134 xr[0][idx] = v * t1;
1135 xr[1][idx] = v * t2;
1136 }
1137 }
1138 }
1139
1140 #if 1
1141 /* in the original: copy 10 to 11 , here: copy 11 to 12
1142 maybe still wrong??? (copy 12 to 13?) */
1143 is_p = scalefac[11 * 3 + lwin - gr_info->mixed_block_flag]; /* scale: 0-15 */
1144 sb = bi->shortDiff[12];
1145 idx = bi->shortIdx[12] + lwin;
1146 #else
1147 is_p = scalefac[10 * 3 + lwin - gr_info->mixed_block_flag]; /* scale: 0-15 */
1148 sb = bi->shortDiff[11];
1149 idx = bi->shortIdx[11] + lwin;
1150 #endif
1151 if (is_p != 7) {
1152 real t1, t2;
1153 t1 = tab1[is_p];
1154 t2 = tab2[is_p];
1155 for (; sb > 0; sb--, idx += 3) {
1156 real v = xr[0][idx];
1157 xr[0][idx] = v * t1;
1158 xr[1][idx] = v * t2;
1159 }
1160 }
1161 } /* end for(lwin; .. ; . ) */
1162
1163 /* also check l-part, if ALL bands in the three windows are 'empty'
1164 * and mode = mixed_mode
1165 */
1166 if (do_l) {
1167 int sfb = gr_info->maxbandl;
1168 int idx = bi->longIdx[sfb];
1169
1170 for (; sfb < 8; sfb++) {
1171 int sb = bi->longDiff[sfb];
1172 int is_p = scalefac[sfb]; /* scale: 0-15 */
1173
1174 if (is_p != 7) {
1175 real t1, t2;
1176
1177 t1 = tab1[is_p];
1178 t2 = tab2[is_p];
1179 for (; sb > 0; sb--, idx++) {
1180 real v = xr[0][idx];
1181
1182 xr[0][idx] = v * t1;
1183 xr[1][idx] = v * t2;
1184 }
1185 }
1186 else
1187 idx += sb;
1188 }
1189 }
1190 }
1191 else { /* ((gr_info->block_type != 2)) */
1192 int sfb = gr_info->maxbandl;
1193 int is_p, idx = bi->longIdx[sfb];
1194
1195 /* hmm ... maybe the maxbandl stuff for i-stereo is buggy? */
1196 if (sfb <= 21) {
1197 for (; sfb < 21; sfb++) {
1198 int sb = bi->longDiff[sfb];
1199
1200 is_p = scalefac[sfb]; /* scale: 0-15 */
1201 if (is_p != 7) {
1202 real t1, t2;
1203 t1 = tab1[is_p];
1204 t2 = tab2[is_p];
1205 for (; sb > 0; sb--, idx++) {
1206 real v = xr[0][idx];
1207 xr[0][idx] = v * t1;
1208 xr[1][idx] = v * t2;
1209 }
1210 }
1211 else
1212 idx += sb;
1213 }
1214
1215 is_p = scalefac[20];
1216 if (is_p != 7) { /* copy l-band 20 to l-band 21 */
1217 int sb;
1218 real t1 = tab1[is_p], t2 = tab2[is_p];
1219
1220 for (sb = bi->longDiff[21]; sb > 0; sb--, idx++) {
1221 real v = xr[0][idx];
1222
1223 xr[0][idx] = v * t1;
1224 xr[1][idx] = v * t2;
1225 }
1226 }
1227 }
1228 } /* ... */
1229 }
1230
1231 static void
1232 III_antialias(real xr[SBLIMIT][SSLIMIT], struct gr_info_s *gr_info)
1233 {
1234 int sblim;
1235
1236 if (gr_info->block_type == 2) {
1237 if (!gr_info->mixed_block_flag)
1238 return;
1239 sblim = 1;
1240 }
1241 else {
1242 sblim = gr_info->maxb - 1;
1243 }
1244
1245 /* 31 alias-reduction operations between each pair of sub-bands */
1246 /* with 8 butterflies between each pair */
1247
1248 {
1249 int sb;
1250 real *xr1 = (real *) xr[1];
1251
1252 if (sblim < 1 || sblim > SBLIMIT)
1253 return;
1254
1255 for (sb = sblim; sb; sb--, xr1 += 10) {
1256 int ss;
1257 real *cs = aa_cs, *ca = aa_ca;
1258 real *xr2 = xr1;
1259
1260 for (ss = 7; ss >= 0; ss--) { /* upper and lower butterfly inputs */
1261 register real bu = *--xr2, bd = *xr1;
1262
1263 *xr2 = (bu * (*cs)) - (bd * (*ca));
1264 *xr1++ = (bd * (*cs++)) + (bu * (*ca++));
1265 }
1266 }
1267 }
1268 }
1269
1270 /*
1271 This is an optimized DCT from Jeff Tsay's maplay 1.2+ package.
1272 Saved one multiplication by doing the 'twiddle factor' stuff
1273 together with the window mul. (MH)
1274
1275 This uses Byeong Gi Lee's Fast Cosine Transform algorithm, but the
1276 9 point IDCT needs to be reduced further. Unfortunately, I don't
1277 know how to do that, because 9 is not an even number. - Jeff.
1278
1279 ****************************************************************
1280
1281 9 Point Inverse Discrete Cosine Transform
1282
1283 This piece of code is Copyright 1997 Mikko Tommila and is freely usable
1284 by anybody. The algorithm itself is of course in the public domain.
1285
1286 Again derived heuristically from the 9-point WFTA.
1287
1288 The algorithm is optimized (?) for speed, not for small rounding errors or
1289 good readability.
1290
1291 36 additions, 11 multiplications
1292
1293 Again this is very likely sub-optimal.
1294
1295 The code is optimized to use a minimum number of temporary variables,
1296 so it should compile quite well even on 8-register Intel x86 processors.
1297 This makes the code quite obfuscated and very difficult to understand.
1298
1299 References:
1300 [1] S. Winograd: "On Computing the Discrete Fourier Transform",
1301 Mathematics of Computation, Volume 32, Number 141, January 1978,
1302 Pages 175-199
1303 */
1304
1305 /*------------------------------------------------------------------*/
1306 /* */
1307 /* Function: Calculation of the inverse MDCT */
1308 /* */
1309 /*------------------------------------------------------------------*/
1310
1311 #define MACRO(v) \
1312 do { \
1313 real tmpval; \
1314 \
1315 tmpval = tmp[(v)] + tmp[17-(v)]; \
1316 out2[9+(v)] = tmpval * w[27+(v)]; \
1317 out2[8-(v)] = tmpval * w[26-(v)]; \
1318 tmpval = tmp[(v)] - tmp[17-(v)]; \
1319 ts[SBLIMIT*(8-(v))] = out1[8-(v)] + tmpval * w[8-(v)]; \
1320 ts[SBLIMIT*(9+(v))] = out1[9+(v)] + tmpval * w[9+(v)]; \
1321 } while (0)
1322
1323 #ifndef USE_SIMD
1324 static
1325 #endif
1326 void
1327 mpg123_dct36(real * inbuf, real * o1, real * o2, real * wintab, real * tsbuf)
1328 {
1329 real tmp[18];
1330 register real *in = inbuf;
1331
1332 in[17] += in[16];
1333 in[16] += in[15];
1334 in[15] += in[14];
1335 in[14] += in[13];
1336 in[13] += in[12];
1337 in[12] += in[11];
1338 in[11] += in[10];
1339 in[10] += in[9];
1340 in[9] += in[8];
1341 in[8] += in[7];
1342 in[7] += in[6];
1343 in[6] += in[5];
1344 in[5] += in[4];
1345 in[4] += in[3];
1346 in[3] += in[2];
1347 in[2] += in[1];
1348 in[1] += in[0];
1349
1350 in[17] += in[15];
1351 in[15] += in[13];
1352 in[13] += in[11];
1353 in[11] += in[9];
1354 in[9] += in[7];
1355 in[7] += in[5];
1356 in[5] += in[3];
1357 in[3] += in[1];
1358
1359
1360 {
1361 real t3;
1362 {
1363 real t0, t1, t2;
1364
1365 t0 = COS6_2 * (in[8] + in[16] - in[4]);
1366 t1 = COS6_2 * in[12];
1367
1368 t3 = in[0];
1369 t2 = t3 - t1 - t1;
1370 tmp[1] = tmp[7] = t2 - t0;
1371 tmp[4] = t2 + t0 + t0;
1372 t3 += t1;
1373
1374 t2 = COS6_1 * (in[10] + in[14] - in[2]);
1375 tmp[1] -= t2;
1376 tmp[7] += t2;
1377 }
1378 {
1379 real t0, t1, t2;
1380
1381 t0 = cos9[0] * (in[4] + in[8]);
1382 t1 = cos9[1] * (in[8] - in[16]);
1383 t2 = cos9[2] * (in[4] + in[16]);
1384
1385 tmp[2] = tmp[6] = t3 - t0 - t2;
1386 tmp[0] = tmp[8] = t3 + t0 + t1;
1387 tmp[3] = tmp[5] = t3 - t1 + t2;
1388 }
1389 }
1390 {
1391 real t1, t2, t3;
1392
1393 t1 = cos18[0] * (in[2] + in[10]);
1394 t2 = cos18[1] * (in[10] - in[14]);
1395 t3 = COS6_1 * in[6];
1396
1397 {
1398 real t0 = t1 + t2 + t3;
1399 tmp[0] += t0;
1400 tmp[8] -= t0;
1401 }
1402
1403 t2 -= t3;
1404 t1 -= t3;
1405
1406 t3 = cos18[2] * (in[2] + in[14]);
1407
1408 t1 += t3;
1409 tmp[3] += t1;
1410 tmp[5] -= t1;
1411
1412 t2 -= t3;
1413 tmp[2] += t2;
1414 tmp[6] -= t2;
1415 }
1416
1417 {
1418 real t0, t1, t2, t3, t4, t5, t6, t7;
1419
1420 t1 = COS6_2 * in[13];
1421 t2 = COS6_2 * (in[9] + in[17] - in[5]);
1422
1423 t3 = in[1] + t1;
1424 t4 = in[1] - t1 - t1;
1425 t5 = t4 - t2;
1426
1427 t0 = cos9[0] * (in[5] + in[9]);
1428 t1 = cos9[1] * (in[9] - in[17]);
1429
1430 tmp[13] = (t4 + t2 + t2) * tfcos36[17 - 13];
1431 t2 = cos9[2] * (in[5] + in[17]);
1432
1433 t6 = t3 - t0 - t2;
1434 t0 += t3 + t1;
1435 t3 += t2 - t1;
1436
1437 t2 = cos18[0] * (in[3] + in[11]);
1438 t4 = cos18[1] * (in[11] - in[15]);
1439 t7 = COS6_1 * in[7];
1440
1441 t1 = t2 + t4 + t7;
1442 tmp[17] = (t0 + t1) * tfcos36[17 - 17];
1443 tmp[9] = (t0 - t1) * tfcos36[17 - 9];
1444 t1 = cos18[2] * (in[3] + in[15]);
1445 t2 += t1 - t7;
1446
1447 tmp[14] = (t3 + t2) * tfcos36[17 - 14];
1448 t0 = COS6_1 * (in[11] + in[15] - in[3]);
1449 tmp[12] = (t3 - t2) * tfcos36[17 - 12];
1450
1451 t4 -= t1 + t7;
1452
1453 tmp[16] = (t5 - t0) * tfcos36[17 - 16];
1454 tmp[10] = (t5 + t0) * tfcos36[17 - 10];
1455 tmp[15] = (t6 + t4) * tfcos36[17 - 15];
1456 tmp[11] = (t6 - t4) * tfcos36[17 - 11];
1457 }
1458
1459 {
1460 register real *out2 = o2;
1461 register real *w = wintab;
1462 register real *out1 = o1;
1463 register real *ts = tsbuf;
1464
1465 MACRO(0);
1466 MACRO(1);
1467 MACRO(2);
1468 MACRO(3);
1469 MACRO(4);
1470 MACRO(5);
1471 MACRO(6);
1472 MACRO(7);
1473 MACRO(8);
1474 }
1475 }
1476
1477 /*
1478 * new DCT12
1479 */
1480 static void
1481 dct12(real * in, real * rawout1, real * rawout2,
1482 register real * wi, register real * ts)
1483 {
1484
1485 #define DCT12_PART1() \
1486 do { \
1487 in5 = in[5*3]; \
1488 in5 += (in4 = in[4*3]); \
1489 in4 += (in3 = in[3*3]); \
1490 in3 += (in2 = in[2*3]); \
1491 in2 += (in1 = in[1*3]); \
1492 in1 += (in0 = in[0*3]); \
1493 \
1494 in5 += in3; in3 += in1; \
1495 \
1496 in2 *= COS6_1; \
1497 in3 *= COS6_1; \
1498 } while (0)
1499
1500 #define DCT12_PART2() \
1501 do { \
1502 in0 += in4 * COS6_2; \
1503 \
1504 in4 = in0 + in2; \
1505 in0 -= in2; \
1506 \
1507 in1 += in5 * COS6_2; \
1508 \
1509 in5 = (in1 + in3) * tfcos12[0]; \
1510 in1 = (in1 - in3) * tfcos12[2]; \
1511 \
1512 in3 = in4 + in5; \
1513 in4 -= in5; \
1514 \
1515 in2 = in0 + in1; \
1516 in0 -= in1; \
1517 } while (0)
1518
1519
1520 {
1521 real in0, in1, in2, in3, in4, in5;
1522 register real *out1 = rawout1;
1523
1524 ts[SBLIMIT * 0] = out1[0];
1525 ts[SBLIMIT * 1] = out1[1];
1526 ts[SBLIMIT * 2] = out1[2];
1527 ts[SBLIMIT * 3] = out1[3];
1528 ts[SBLIMIT * 4] = out1[4];
1529 ts[SBLIMIT * 5] = out1[5];
1530
1531 DCT12_PART1();
1532
1533 {
1534 real tmp0, tmp1 = (in0 - in4);
1535
1536 {
1537 real tmp2 = (in1 - in5) * tfcos12[1];
1538
1539 tmp0 = tmp1 + tmp2;
1540 tmp1 -= tmp2;
1541 }
1542 ts[(17 - 1) * SBLIMIT] = out1[17 - 1] + tmp0 * wi[11 - 1];
1543 ts[(12 + 1) * SBLIMIT] = out1[12 + 1] + tmp0 * wi[6 + 1];
1544 ts[(6 + 1) * SBLIMIT] = out1[6 + 1] + tmp1 * wi[1];
1545 ts[(11 - 1) * SBLIMIT] = out1[11 - 1] + tmp1 * wi[5 - 1];
1546 }
1547
1548 DCT12_PART2();
1549
1550 ts[(17 - 0) * SBLIMIT] = out1[17 - 0] + in2 * wi[11 - 0];
1551 ts[(12 + 0) * SBLIMIT] = out1[12 + 0] + in2 * wi[6 + 0];
1552 ts[(12 + 2) * SBLIMIT] = out1[12 + 2] + in3 * wi[6 + 2];
1553 ts[(17 - 2) * SBLIMIT] = out1[17 - 2] + in3 * wi[11 - 2];
1554
1555 ts[(6 + 0) * SBLIMIT] = out1[6 + 0] + in0 * wi[0];
1556 ts[(11 - 0) * SBLIMIT] = out1[11 - 0] + in0 * wi[5 - 0];
1557 ts[(6 + 2) * SBLIMIT] = out1[6 + 2] + in4 * wi[2];
1558 ts[(11 - 2) * SBLIMIT] = out1[11 - 2] + in4 * wi[5 - 2];
1559 }
1560
1561 in++;
1562
1563 {
1564 real in0, in1, in2, in3, in4, in5;
1565 register real *out2 = rawout2;
1566
1567 DCT12_PART1();
1568
1569 {
1570 real tmp0, tmp1 = (in0 - in4);
1571
1572 {
1573 real tmp2 = (in1 - in5) * tfcos12[1];
1574
1575 tmp0 = tmp1 + tmp2;
1576 tmp1 -= tmp2;
1577 }
1578 out2[5 - 1] = tmp0 * wi[11 - 1];
1579 out2[0 + 1] = tmp0 * wi[6 + 1];
1580 ts[(12 + 1) * SBLIMIT] += tmp1 * wi[1];
1581 ts[(17 - 1) * SBLIMIT] += tmp1 * wi[5 - 1];
1582 }
1583
1584 DCT12_PART2();
1585
1586 out2[5 - 0] = in2 * wi[11 - 0];
1587 out2[0 + 0] = in2 * wi[6 + 0];
1588 out2[0 + 2] = in3 * wi[6 + 2];
1589 out2[5 - 2] = in3 * wi[11 - 2];
1590
1591 ts[(12 + 0) * SBLIMIT] += in0 * wi[0];
1592 ts[(17 - 0) * SBLIMIT] += in0 * wi[5 - 0];
1593 ts[(12 + 2) * SBLIMIT] += in4 * wi[2];
1594 ts[(17 - 2) * SBLIMIT] += in4 * wi[5 - 2];
1595 }
1596
1597 in++;
1598
1599 {
1600 real in0, in1, in2, in3, in4, in5;
1601 register real *out2 = rawout2;
1602
1603 out2[12] = out2[13] = out2[14] = out2[15] = out2[16] = out2[17] = 0.0;
1604
1605 DCT12_PART1();
1606
1607 {
1608 real tmp0, tmp1 = (in0 - in4);
1609
1610 {
1611 real tmp2 = (in1 - in5) * tfcos12[1];
1612
1613 tmp0 = tmp1 + tmp2;
1614 tmp1 -= tmp2;
1615 }
1616 out2[11 - 1] = tmp0 * wi[11 - 1];
1617 out2[6 + 1] = tmp0 * wi[6 + 1];
1618 out2[0 + 1] += tmp1 * wi[1];
1619 out2[5 - 1] += tmp1 * wi[5 - 1];
1620 }
1621
1622 DCT12_PART2();
1623
1624 out2[11 - 0] = in2 * wi[11 - 0];
1625 out2[6 + 0] = in2 * wi[6 + 0];
1626 out2[6 + 2] = in3 * wi[6 + 2];
1627 out2[11 - 2] = in3 * wi[11 - 2];
1628
1629 out2[0 + 0] += in0 * wi[0];
1630 out2[5 - 0] += in0 * wi[5 - 0];
1631 out2[0 + 2] += in4 * wi[2];
1632 out2[5 - 2] += in4 * wi[5 - 2];
1633 }
1634 }
1635
1636 /*
1637 * III_hybrid
1638 */
1639 static void
1640 III_hybrid(real fsIn[SBLIMIT][SSLIMIT],
1641 real tsOut[SSLIMIT][SBLIMIT], int ch,
1642 struct gr_info_s *gr_info, struct frame *fr)
1643 {
1644 static real block[2][2][SBLIMIT * SSLIMIT] = { {{0,}} };
1645 static int blc[2] = { 0, 0 };
1646
1647 real *tspnt = (real *) tsOut;
1648 real *rawout1, *rawout2;
1649 int bt, sb = 0;
1650
1651 {
1652 int b = blc[ch];
1653 rawout1 = block[b][ch];
1654 b = -b + 1;
1655 rawout2 = block[b][ch];
1656 blc[ch] = b;
1657 }
1658
1659 if (gr_info->mixed_block_flag) {
1660 sb = 2;
1661 DCT36(fsIn[0], rawout1, rawout2, win[0], tspnt);
1662 DCT36(fsIn[1], rawout1 + 18, rawout2 + 18, win1[0], tspnt + 1);
1663 rawout1 += 36;
1664 rawout2 += 36;
1665 tspnt += 2;
1666 }
1667
1668 bt = gr_info->block_type;
1669 if (bt == 2) {
1670 for (; sb < gr_info->maxb;
1671 sb += 2, tspnt += 2, rawout1 += 36, rawout2 += 36) {
1672 dct12(fsIn[sb], rawout1, rawout2, win[2], tspnt);
1673 dct12(fsIn[sb + 1], rawout1 + 18, rawout2 + 18, win1[2],
1674 tspnt + 1);
1675 }
1676 }
1677 else {
1678 for (; sb < gr_info->maxb;
1679 sb += 2, tspnt += 2, rawout1 += 36, rawout2 += 36) {
1680 DCT36(fsIn[sb], rawout1, rawout2, win[bt], tspnt);
1681 DCT36(fsIn[sb + 1], rawout1 + 18, rawout2 + 18, win1[bt],
1682 tspnt + 1);
1683 }
1684 }
1685
1686 for (; sb < SBLIMIT; sb++, tspnt++) {
1687 int i;
1688 for (i = 0; i < SSLIMIT; i++) {
1689 tspnt[i * SBLIMIT] = *rawout1++;
1690 *rawout2++ = 0.0;
1691 }
1692 }
1693 }
1694
1695 /*
1696 * main layer3 handler
1697 */
1698 int
1699 mpg123_do_layer3(struct frame *fr)
1700 {
1701 int gr, ch, ss;
1702 int scalefacs[2][39]; /* max 39 for short[13][3] mode, mixed: 38, long: 22 */
1703 struct III_sideinfo sideinfo;
1704 int stereo = fr->stereo;
1705 int single = fr->single;
1706 int ms_stereo, i_stereo;
1707 int sfreq = fr->sampling_frequency;
1708 int stereo1, granules;
1709
1710 if (stereo == 1) { /* stream is mono */
1711 stereo1 = 1;
1712 single = 0;
1713 }
1714 else if (single >= 0) /* stream is stereo, but force to mono */
1715 stereo1 = 1;
1716 else
1717 stereo1 = 2;
1718
1719 if (fr->mode == MPG_MD_JOINT_STEREO) {
1720 ms_stereo = (fr->mode_ext & 0x2) >> 1;
1721 i_stereo = fr->mode_ext & 0x1;
1722 }
1723 else
1724 ms_stereo = i_stereo = 0;
1725
1726 granules = fr->lsf ? 1 : 2;
1727 if (!III_get_side_info
1728 (&sideinfo, stereo, ms_stereo, sfreq, single, fr->lsf))
1729 return 0;
1730
1731 mpg123_set_pointer(sideinfo.main_data_begin);
1732
1733 for (gr = 0; gr < granules; gr++) {
1734 real hybridIn[2][SBLIMIT][SSLIMIT];
1735 real hybridOut[2][SSLIMIT][SBLIMIT];
1736
1737 {
1738 struct gr_info_s *gr_info = &(sideinfo.ch[0].gr[gr]);
1739 long part2bits;
1740
1741 if (fr->lsf)
1742 part2bits = III_get_scale_factors_2(scalefacs[0], gr_info, 0);
1743 else
1744 part2bits = III_get_scale_factors_1(scalefacs[0], gr_info);
1745
1746 if (III_dequantize_sample
1747 (hybridIn[0], scalefacs[0], gr_info, sfreq, part2bits))
1748 return 0;
1749 }
1750
1751 if (stereo == 2) {
1752 struct gr_info_s *gr_info = &(sideinfo.ch[1].gr[gr]);
1753 long part2bits;
1754
1755 if (fr->lsf)
1756 part2bits =
1757 III_get_scale_factors_2(scalefacs[1], gr_info, i_stereo);
1758 else
1759 part2bits = III_get_scale_factors_1(scalefacs[1], gr_info);
1760
1761 if (III_dequantize_sample
1762 (hybridIn[1], scalefacs[1], gr_info, sfreq, part2bits))
1763 return 0;
1764
1765 if (ms_stereo) {
1766 int i;
1767 int maxb = sideinfo.ch[0].gr[gr].maxb;
1768
1769 if (sideinfo.ch[1].gr[gr].maxb > maxb)
1770 maxb = sideinfo.ch[1].gr[gr].maxb;
1771 for (i = 0; i < SSLIMIT * maxb; i++) {
1772 real tmp0 = ((real *) hybridIn[0])[i];
1773 real tmp1 = ((real *) hybridIn[1])[i];
1774 ((real *) hybridIn[0])[i] = tmp0 + tmp1;
1775 ((real *) hybridIn[1])[i] = tmp0 - tmp1;
1776 }
1777 }
1778
1779 if (i_stereo)
1780 III_i_stereo(hybridIn, scalefacs[1], gr_info, sfreq,
1781 ms_stereo, fr->lsf);
1782
1783 if (ms_stereo || i_stereo || (single == 3)) {
1784 if (gr_info->maxb > sideinfo.ch[0].gr[gr].maxb)
1785 sideinfo.ch[0].gr[gr].maxb = gr_info->maxb;
1786 else
1787 gr_info->maxb = sideinfo.ch[0].gr[gr].maxb;
1788 }
1789
1790 switch (single) {
1791 case 3:
1792 {
1793 register int i;
1794 register real *in0 = (real *) hybridIn[0],
1795 *in1 = (real *) hybridIn[1];
1796 for (i = 0; i < SSLIMIT * gr_info->maxb; i++, in0++)
1797 *in0 = (*in0 + *in1++); /* *0.5 done by pow-scale */
1798 }
1799 break;
1800 case 1:
1801 {
1802 register int i;
1803 register real *in0 = (real *) hybridIn[0],
1804 *in1 = (real *) hybridIn[1];
1805 for (i = 0; i < SSLIMIT * gr_info->maxb; i++)
1806 *in0++ = *in1++;
1807 }
1808 break;
1809 }
1810 }
1811
1812 #ifdef XMMS_EQ
1813 if (mpg123_info->eq_active) {
1814 int i, sb;
1815
1816 if (single < 0) {
1817 for (sb = 0, i = 0; sb < SBLIMIT; sb++) {
1818 for (ss = 0; ss < SSLIMIT; ss++) {
1819 hybridIn[0][sb][ss] *= mpg123_info->eq_mul[i];
1820 hybridIn[1][sb][ss] *= mpg123_info->eq_mul[i++];
1821 }
1822 }
1823 }
1824 else {
1825 for (sb = 0, i = 0; sb < SBLIMIT; sb++) {
1826 for (ss = 0; ss < SSLIMIT; ss++)
1827 hybridIn[0][sb][ss] *= mpg123_info->eq_mul[i++];
1828 }
1829 }
1830 }
1831 #endif
1832
1833 #ifdef USE_SIMD
1834 if (fr->synth_type == SYNTH_MMX && single < 0) {
1835 int i, sb;
1836
1837 for (sb = 0, i = 0; sb < SBLIMIT; sb++) {
1838 for (ss = 0; ss < SSLIMIT; ss++) {
1839 hybridIn[0][sb][ss] *= 16384.0;
1840 hybridIn[1][sb][ss] *= 16384.0;
1841 }
1842 }
1843 }
1844 #endif
1845 for (ch = 0; ch < stereo1; ch++) {
1846 struct gr_info_s *gr_info = &(sideinfo.ch[ch].gr[gr]);
1847
1848 III_antialias(hybridIn[ch], gr_info);
1849 if (gr_info->maxb < 1 || gr_info->maxb > SBLIMIT)
1850 return 0;
1851 III_hybrid(hybridIn[ch], hybridOut[ch], ch, gr_info, fr);
1852 }
1853
1854 for (ss = 0; ss < SSLIMIT; ss++) {
1855 if (single >= 0) {
1856 (fr->synth_mono) (hybridOut[0][ss], mpg123_pcm_sample,
1857 &mpg123_pcm_point);
1858 }
1859 else {
1860 int p1 = mpg123_pcm_point;
1861
1862 (fr->synth) (hybridOut[0][ss], 0, mpg123_pcm_sample, &p1);
1863 (fr->synth) (hybridOut[1][ss], 1, mpg123_pcm_sample,
1864 &mpg123_pcm_point);
1865 }
1866 }
1867
1868 if (mpg123_info->output_audio && mpg123_info->jump_to_time == -1) {
1869 produce_audio(mpg123_ip.output->written_time(),
1870 mpg123_cfg.resolution ==
1871 16 ? FMT_S16_NE : FMT_U8,
1872 mpg123_cfg.channels ==
1873 2 ? fr->stereo : 1, mpg123_pcm_point,
1874 mpg123_pcm_sample, &mpg123_info->going);
1875 }
1876
1877 mpg123_pcm_point = 0;
1878 }
1879 return 1;
1880 }