1
2 /*
3 * mpadec - MPEG audio decoder
4 * Copyright (C) 2002-2004 Dmitriy Startsev (dstartsev@rambler.ru)
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /* $Id: layer3.c,v 1.3 2009/03/01 15:27:05 jpff Exp $ */
22
23 #include "mpadec_internal.h"
24
25 extern const uint32_t bitmask[17];
26 extern bandinfo_t band_info[];
27 extern newhuff_t hufft[], hufftc[];
28 extern const MYFLT newcos[8];
29 extern const MYFLT tfcos36[9];
30 extern const MYFLT tfcos12[3];
31 extern const MYFLT cs[8];
32 extern const MYFLT ca[8];
33
34 extern uint32_t getbits(mpadec_t mpadec, unsigned n);
35 extern uint16_t update_crc(uint16_t init, uint8_t *buf, int length);
36
decode_layer3_sideinfo(mpadec_t mpadec)37 static int decode_layer3_sideinfo(mpadec_t mpadec)
38 {
39 register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
40 int ch, gr, ms_stereo, powdiff, databits = 0;
41 static const uint8_t tabs[2][5] = { { 2, 9, 5, 3, 4 }, { 1, 8, 1, 2, 9 } };
42 const uint8_t *tab = tabs[mpa->frame.LSF];
43
44 ms_stereo = ((mpa->frame.mode == MPG_MD_JOINT_STEREO) &&
45 (mpa->frame.mode_ext & 2));
46 powdiff = ((mpa->frame.channels > 1) &&
47 (mpa->config.mode == MPADEC_CONFIG_MONO)) ? 4 : 0;
48 mpa->sideinfo.main_data_begin = GETBITS(tab[1]);
49 if (mpa->frame.channels == 1) mpa->sideinfo.private_bits = GETBITS(tab[2]);
50 else mpa->sideinfo.private_bits = GETBITS(tab[3]);
51 if (!mpa->frame.LSF) {
52 for (ch = 0; ch < mpa->frame.channels; ch++) {
53 mpa->sideinfo.ch[ch].gr[0].scfsi = -1;
54 mpa->sideinfo.ch[ch].gr[1].scfsi = GETBITS(4);
55 }
56 }
57 for (gr = 0; gr < tab[0]; gr++) {
58 for (ch = 0; ch < mpa->frame.channels; ch++) {
59 register grinfo_t *grinfo = &mpa->sideinfo.ch[ch].gr[gr];
60 grinfo->part2_3_length = GETBITS(12);
61 grinfo->big_values = GETBITS(9);
62 databits += grinfo->part2_3_length;
63 if (grinfo->big_values > 288) grinfo->big_values = 288;
64 grinfo->pow2gain = mpa->tables.gainpow2 + 256 - GETBITS(8) + powdiff;
65 if (ms_stereo) grinfo->pow2gain += 2;
66 grinfo->scalefac_compress = GETBITS(tab[4]);
67 if (GETBITS(1)) {
68 grinfo->block_type = (uint8_t)GETBITS(2);
69 grinfo->mixed_block_flag = (uint8_t)GETBITS(1);
70 grinfo->table_select[0] = GETBITS(5);
71 grinfo->table_select[1] = GETBITS(5);
72 grinfo->table_select[2] = 0;
73 grinfo->full_gain[0] = grinfo->pow2gain + (GETBITS(3) << 3);
74 grinfo->full_gain[1] = grinfo->pow2gain + (GETBITS(3) << 3);
75 grinfo->full_gain[2] = grinfo->pow2gain + (GETBITS(3) << 3);
76 if (!grinfo->block_type) {
77 mpa->error = TRUE;
78 return 0;
79 } else mpa->error = FALSE;
80 if (mpa->frame.LSF) {
81 if (grinfo->block_type == 2) {
82 if (grinfo->mixed_block_flag) {
83 if (mpa->frame.frequency_index == 8) grinfo->region1start = 48;
84 else grinfo->region1start = 48 >> 1;
85 } else {
86 if (mpa->frame.frequency_index == 8) grinfo->region1start = 36;
87 else grinfo->region1start = 36 >> 1;
88 }
89 } else {
90 if (mpa->frame.frequency_index == 8) grinfo->region1start = 54;
91 else grinfo->region1start = 54 >> 1;
92 }
93 } else grinfo->region1start = 36 >> 1;
94 grinfo->region2start = 576 >> 1;
95 } else {
96 grinfo->block_type = 0;
97 grinfo->mixed_block_flag = 0;
98 grinfo->table_select[0] = GETBITS(5);
99 grinfo->table_select[1] = GETBITS(5);
100 grinfo->table_select[2] = GETBITS(5);
101 {
102 register int tmp = GETBITS(4);
103 grinfo->region1start =
104 band_info[mpa->frame.frequency_index].long_idx[tmp + 1] >> 1;
105 tmp += GETBITS(3);
106 grinfo->region2start =
107 band_info[mpa->frame.frequency_index].long_idx[tmp + 2] >> 1;
108 }
109 }
110 if (!mpa->frame.LSF) grinfo->preflag = (uint8_t)GETBITS(1);
111 grinfo->scalefac_scale = (uint8_t)GETBITS(1);
112 grinfo->count1table_select = (uint8_t)GETBITS(1);
113 }
114 }
115 databits -= 8*mpa->sideinfo.main_data_begin;
116 return databits;
117 }
118
III_get_scale_factors(mpadec_t mpadec,grinfo_t * gr_info,int32_t * scf)119 static int III_get_scale_factors(mpadec_t mpadec, grinfo_t *gr_info, int32_t *scf)
120 {
121 register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
122 register grinfo_t *grinfo = gr_info;
123 int numbits = 0;
124 static uint8_t slen[2][16] =
125 { {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
126 {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3} };
127 static uint8_t stab[3][6][4] =
128 { { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} ,
129 { 7, 7, 7,0 } , { 6, 6, 6,3 } , { 8, 8,5,0} } ,
130 { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} ,
131 {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } ,
132 { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} ,
133 { 6,15,12,0 } , { 6,12, 9,6 } , { 6,18,9,0} } };
134
135 if (!mpa->frame.LSF) {
136 int i, num0 = slen[0][grinfo->scalefac_compress],
137 num1 = slen[1][grinfo->scalefac_compress];
138 if (grinfo->block_type == 2) {
139 i = 18; numbits = 18*(num0 + num1);
140 if (grinfo->mixed_block_flag) {
141 i--;
142 numbits -= num0;
143 }
144 for (; i; i--) *scf++ = GETBITS(num0);
145 for (i = 18; i; i--) *scf++ = GETBITS(num1);
146 scf[0] = scf[1] = scf[2] = 0;
147 } else {
148 if (grinfo->scfsi < 0) {
149 for (i = 11; i; i--) *scf++ = GETBITS(num0);
150 for (i = 10; i; i--) *scf++ = GETBITS(num1);
151 numbits = 10*(num0 + num1) + num0;
152 *scf = 0;
153 } else {
154 numbits = 0;
155 if (!(grinfo->scfsi & 8)) {
156 for (i = 6; i; i--) *scf++ = GETBITS(num0);
157 numbits += 6*num0;
158 } else scf += 6;
159 if (!(grinfo->scfsi & 4)) {
160 for (i = 5; i; i--) *scf++ = GETBITS(num0);
161 numbits += 5*num0;
162 } else scf += 5;
163 if (!(grinfo->scfsi & 2)) {
164 for (i = 5; i; i--) *scf++ = GETBITS(num1);
165 numbits += 5*num1;
166 } else scf += 5;
167 if (!(grinfo->scfsi & 1)) {
168 for (i = 5; i; i--) *scf++ = GETBITS(num1);
169 numbits += 5*num1;
170 } else scf += 5;
171 *scf = 0;
172 }
173 }
174 } else {
175 int i, j, n = 0;
176 unsigned s_len; uint8_t *pnt;
177 if ((mpa->frame.mode == MPG_MD_JOINT_STEREO) && (mpa->frame.mode_ext & 1)) {
178 s_len = mpa->tables.i_slen2[grinfo->scalefac_compress >> 1];
179 } else s_len = mpa->tables.n_slen2[grinfo->scalefac_compress];
180 grinfo->preflag = (uint8_t)((s_len >> 15) & 1);
181 if (grinfo->block_type == 2) n = grinfo->mixed_block_flag ? 2 : 1;
182 pnt = stab[n][(s_len >> 12) & 7];
183 for (i = 0; i < 4; i++) {
184 int num = s_len & 7;
185 s_len >>= 3;
186 if (num) {
187 for (j = 0; j < (int)pnt[i]; j++) *scf++ = GETBITS(num);
188 numbits += pnt[i]*num;
189 } else for (j = 0; j < (int)pnt[i]; j++) *scf++ = 0;
190 }
191 for (i = (n << 1) + 1; i; i--) *scf++ = 0;
192 }
193 return numbits;
194 }
195
III_decode_samples(mpadec_t mpadec,grinfo_t * gr_info,MYFLT xr[SBLIMIT][SSLIMIT],int32_t * scf,int part2bits)196 static int III_decode_samples(mpadec_t mpadec, grinfo_t *gr_info,
197 MYFLT xr[SBLIMIT][SSLIMIT], int32_t *scf,
198 int part2bits)
199 {
200 register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
201 register grinfo_t *grinfo = gr_info;
202 int shift = 1 + grinfo->scalefac_scale, l[3], l3;
203 int part2remain = grinfo->part2_3_length - part2bits;
204 MYFLT *xrptr = (MYFLT *)xr; int32_t *me;
205 static uint8_t pretab1[22] =
206 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0 };
207 static uint8_t pretab2[22] =
208 { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
209
210 l3 = ((576 >> 1) - grinfo->big_values) >> 1;
211 if (grinfo->big_values <= grinfo->region1start) {
212 l[0] = grinfo->big_values;
213 l[1] = l[2] = 0;
214 } else {
215 l[0] = grinfo->region1start;
216 if (grinfo->big_values <= grinfo->region2start) {
217 l[1] = grinfo->big_values - l[0]; l[2] = 0;
218 } else {
219 l[1] = grinfo->region2start - l[0];
220 l[2] = grinfo->big_values - grinfo->region2start;
221 }
222 }
223 if (grinfo->block_type == 2) {
224 int32_t i, max[4], step = 0, lwin = 0, cb = 0;
225 register MYFLT v = 0.0;
226 register int32_t *m, mc;
227
228 if (grinfo->mixed_block_flag) {
229 max[3] = -1;
230 max[0] = max[1] = max[2] = 2;
231 m = mpa->tables.map[mpa->frame.frequency_index][0];
232 me = mpa->tables.mapend[mpa->frame.frequency_index][0];
233 } else {
234 max[0] = max[1] = max[2] = max[3] = -1;
235 m = mpa->tables.map[mpa->frame.frequency_index][1];
236 me = mpa->tables.mapend[mpa->frame.frequency_index][1];
237 }
238 mc = 0;
239 for (i = 0; i < 2; i++) {
240 int lp = l[i];
241 newhuff_t *h = hufft + grinfo->table_select[i];
242 for (; lp; lp--, mc--) {
243 register int x, y;
244 if (!mc) {
245 mc = *m++;
246 xrptr = ((MYFLT *)xr) + (*m++);
247 lwin = *m++;
248 cb = *m++;
249 if (lwin == 3) {
250 v = grinfo->pow2gain[(*scf++) << shift];
251 step = 1;
252 } else {
253 v = grinfo->full_gain[lwin][(*scf++) << shift];
254 step = 3;
255 }
256 }
257 {
258 register int16_t *val = h->table;
259 while ((y = *val++) < 0) {
260 if (GETBITS(1)) val -= y;
261 part2remain--;
262 }
263 x = y >> 4;
264 y &= 0x0F;
265 }
266 if ((x == 15) && h->linbits) {
267 max[lwin] = cb;
268 part2remain -= h->linbits + 1;
269 x += GETBITS(h->linbits);
270 if (GETBITS(1)) *xrptr = -mpa->tables.ispow[x]*v;
271 else *xrptr = mpa->tables.ispow[x]*v;
272 } else if (x) {
273 max[lwin] = cb;
274 if (GETBITS(1)) *xrptr = -mpa->tables.ispow[x]*v;
275 else *xrptr = mpa->tables.ispow[x]*v;
276 part2remain--;
277 } else *xrptr = 0.0;
278 xrptr += step;
279 if ((y == 15) && h->linbits) {
280 max[lwin] = cb;
281 part2remain -= h->linbits + 1;
282 y += GETBITS(h->linbits);
283 if (GETBITS(1)) *xrptr = -mpa->tables.ispow[y]*v;
284 else *xrptr = mpa->tables.ispow[y]*v;
285 } else if (y) {
286 max[lwin] = cb;
287 if (GETBITS(1)) *xrptr = -mpa->tables.ispow[y]*v;
288 else *xrptr = mpa->tables.ispow[y]*v;
289 part2remain--;
290 } else *xrptr = 0.0;
291 xrptr += step;
292 }
293 }
294 for (; l3 && (part2remain > 0); l3--) {
295 newhuff_t *h = hufftc + grinfo->count1table_select;
296 register int16_t *val = h->table, a;
297 while ((a = *val++) < 0) {
298 part2remain--;
299 if (part2remain < 0) {
300 part2remain++;
301 a = 0;
302 break;
303 }
304 if (GETBITS(1)) val -= a;
305 }
306 for (i = 0; i < 4; i++) {
307 if (!(i & 1)) {
308 if (!mc) {
309 mc = *m++;
310 xrptr = ((MYFLT *)xr) + (*m++);
311 lwin = *m++;
312 cb = *m++;
313 if (lwin == 3) {
314 v = grinfo->pow2gain[(*scf++) << shift];
315 step = 1;
316 } else {
317 v = grinfo->full_gain[lwin][(*scf++) << shift];
318 step = 3;
319 }
320 }
321 mc--;
322 }
323 if (a & (8 >> i)) {
324 max[lwin] = cb;
325 part2remain--;
326 if (part2remain < 0) {
327 part2remain++;
328 break;
329 }
330 if (GETBITS(1)) *xrptr = -v;
331 else *xrptr = v;
332 } else *xrptr = 0.0;
333 xrptr += step;
334 }
335 }
336 if (lwin < 3) {
337 while (1) {
338 for (; mc > 0; mc--) {
339 xrptr[0] = xrptr[3] = 0.0;
340 xrptr += 6;
341 }
342 if (m >= me) break;
343 mc = *m++;
344 xrptr = ((MYFLT *)xr) + (*m++);
345 if ((*m++) == 0) break;
346 m++;
347 }
348 }
349 grinfo->maxband[0] = max[0] + 1;
350 grinfo->maxband[1] = max[1] + 1;
351 grinfo->maxband[2] = max[2] + 1;
352 grinfo->maxbandl = max[3] + 1;
353 {
354 int rmax = max[0] > max[1] ? max[0] : max[1];
355 rmax = (rmax > max[2] ? rmax : max[2]) + 1;
356 grinfo->maxb =
357 rmax ? mpa->tables.short_limit[mpa->frame.frequency_index][rmax] :
358 mpa->tables.long_limit[mpa->frame.frequency_index][max[3] + 1];
359 }
360 } else {
361 uint8_t *pretab = grinfo->preflag ? pretab1 : pretab2;
362 int32_t i, max = -1, cb = 0, mc = 0;
363 int32_t *m = mpa->tables.map[mpa->frame.frequency_index][2];
364 register MYFLT v = 0.0;
365
366 for (i = 0; i < 3; i++) {
367 int lp = l[i];
368 newhuff_t *h = hufft + grinfo->table_select[i];
369 for (; lp; lp--, mc--) {
370 register int x, y;
371 if (!mc) {
372 mc = *m++;
373 cb = *m++;
374 if (cb == 21) v = 0.0;
375 else v = grinfo->pow2gain[((*scf++) + (*pretab++)) << shift];
376 }
377 {
378 register int16_t *val = h->table;
379 while ((y = *val++) < 0) {
380 if (GETBITS(1)) val -= y;
381 part2remain--;
382 }
383 x = y >> 4;
384 y &= 0x0F;
385 }
386 if ((x == 15) && h->linbits) {
387 max = cb;
388 part2remain -= h->linbits + 1;
389 x += GETBITS(h->linbits);
390 if (GETBITS(1)) *xrptr++ = -mpa->tables.ispow[x]*v;
391 else *xrptr++ = mpa->tables.ispow[x]*v;
392 } else if (x) {
393 max = cb;
394 if (GETBITS(1)) *xrptr++ = -mpa->tables.ispow[x]*v;
395 else *xrptr++ = mpa->tables.ispow[x]*v;
396 part2remain--;
397 } else *xrptr++ = 0.0;
398 if ((y == 15) && h->linbits) {
399 max = cb;
400 part2remain -= h->linbits + 1;
401 y += GETBITS(h->linbits);
402 if (GETBITS(1)) *xrptr++ = -mpa->tables.ispow[y]*v;
403 else *xrptr++ = mpa->tables.ispow[y]*v;
404 } else if (y) {
405 max = cb;
406 if (GETBITS(1)) *xrptr++ = -mpa->tables.ispow[y]*v;
407 else *xrptr++ = mpa->tables.ispow[y]*v;
408 part2remain--;
409 } else *xrptr++ = 0.0;
410 }
411 }
412 for (; l3 && (part2remain > 0); l3--) {
413 newhuff_t *h = hufftc + grinfo->count1table_select;
414 register int16_t *val = h->table, a;
415 while ((a = *val++) < 0) {
416 part2remain--;
417 if (part2remain < 0) {
418 part2remain++;
419 a = 0;
420 break;
421 }
422 if (GETBITS(1)) val -= a;
423 }
424 for (i = 0; i < 4; i++) {
425 if (!(i & 1)) {
426 if (!mc) {
427 mc = *m++;
428 cb = *m++;
429 v = grinfo->pow2gain[((*scf++) + (*pretab++)) << shift];
430 }
431 mc--;
432 }
433 if (a & (8 >> i)) {
434 max = cb;
435 part2remain--;
436 if (part2remain < 0) {
437 part2remain++;
438 break;
439 }
440 if (GETBITS(1)) *xrptr++ = -v;
441 else *xrptr++ = v;
442 } else *xrptr++ = 0.0;
443 }
444 }
445 grinfo->maxbandl = max + 1;
446 grinfo->maxb = mpa->tables.long_limit[mpa->frame.frequency_index][max + 1];
447 }
448 while (xrptr < &xr[SBLIMIT][0]) *xrptr++ = 0.0;
449 while (part2remain > 0) {
450 register unsigned tmp, i = (part2remain > 16) ? 16 : part2remain;
451 tmp = GETBITS(i);
452 part2remain -= i;
453 i = tmp;
454 }
455 mpa->error = (uint8_t)((part2remain < 0) ? TRUE : FALSE);
456 return mpa->error;
457 }
458
III_i_stereo(mpadec_t mpadec,grinfo_t * gr_info,MYFLT xrbuf[2][SBLIMIT][SSLIMIT],int32_t * scalefac)459 static void III_i_stereo(mpadec_t mpadec, grinfo_t *gr_info,
460 MYFLT xrbuf[2][SBLIMIT][SSLIMIT], int32_t *scalefac)
461 {
462 register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
463 register grinfo_t *grinfo = gr_info;
464 MYFLT (*xr)[SBLIMIT*SSLIMIT] = (MYFLT (*)[SBLIMIT*SSLIMIT])xrbuf;
465 bandinfo_t *bi = &band_info[mpa->frame.frequency_index];
466 int tab = mpa->frame.LSF + (grinfo->scalefac_compress & mpa->frame.LSF);
467 int ms_stereo = ((mpa->frame.mode == MPG_MD_JOINT_STEREO) &&
468 (mpa->frame.mode_ext & 2)) ? TRUE : FALSE;
469 const MYFLT *tab1, *tab2;
470
471 tab1 = mpa->tables.istabs[tab][ms_stereo][0];
472 tab2 = mpa->tables.istabs[tab][ms_stereo][1];
473 if (grinfo->block_type == 2) {
474 int lwin, do_l = grinfo->mixed_block_flag;
475 for (lwin = 0; lwin < 3; lwin++) {
476 int32_t is_p, sb, idx, sfb = grinfo->maxband[lwin];
477 if (sfb > 3) do_l = FALSE;
478 for (; sfb < 12; sfb++) {
479 is_p = scalefac[3*sfb + lwin - grinfo->mixed_block_flag];
480 if (is_p != 7) {
481 MYFLT t1 = tab1[is_p], t2 = tab2[is_p];
482 sb = bi->short_diff[sfb];
483 idx = bi->short_idx[sfb] + lwin;
484 for (; sb; sb--, idx += 3) {
485 register MYFLT v = xr[0][idx];
486 xr[0][idx] = v*t1;
487 xr[1][idx] = v*t2;
488 }
489 }
490 }
491 is_p = scalefac[3*11 + lwin - grinfo->mixed_block_flag];
492 sb = bi->short_diff[12];
493 idx = bi->short_idx[12] + lwin;
494 if (is_p != 7) {
495 MYFLT t1 = tab1[is_p], t2 = tab2[is_p];
496 for (; sb; sb--, idx += 3) {
497 register MYFLT v = xr[0][idx];
498 xr[0][idx] = v*t1;
499 xr[1][idx] = v*t2;
500 }
501 }
502 }
503 if (do_l) {
504 int sfb = grinfo->maxbandl;
505 int idx = bi->long_idx[sfb];
506 for (; sfb < 8; sfb++) {
507 int sb = bi->long_diff[sfb];
508 int is_p = scalefac[sfb];
509 if (is_p != 7) {
510 MYFLT t1 = tab1[is_p], t2 = tab2[is_p];
511 for (; sb; sb--, idx++) {
512 register MYFLT v = xr[0][idx];
513 xr[0][idx] = v*t1;
514 xr[1][idx] = v*t2;
515 }
516 } else idx += sb;
517 }
518 }
519 } else {
520 int sfb = grinfo->maxbandl;
521 int is_p, idx = bi->long_idx[sfb];
522 for (; sfb < 21; sfb++) {
523 int sb = bi->long_diff[sfb];
524 is_p = scalefac[sfb];
525 if (is_p != 7) {
526 MYFLT t1 = tab1[is_p], t2 = tab2[is_p];
527 for (; sb; sb--, idx++) {
528 register MYFLT v = xr[0][idx];
529 xr[0][idx] = v*t1;
530 xr[1][idx] = v*t2;
531 }
532 } else idx += sb;
533 }
534 is_p = scalefac[20];
535 if (is_p != 7) {
536 int sb = bi->long_diff[21];
537 MYFLT t1 = tab1[is_p], t2 = tab2[is_p];
538 for (; sb; sb--, idx++) {
539 register MYFLT v = xr[0][idx];
540 xr[0][idx] = v*t1;
541 xr[1][idx] = v*t2;
542 }
543 }
544 }
545 }
546
III_antialias(grinfo_t * gr_info,MYFLT xr[SBLIMIT][SSLIMIT])547 static void III_antialias(grinfo_t *gr_info, MYFLT xr[SBLIMIT][SSLIMIT])
548 {
549 register grinfo_t *grinfo = gr_info;
550 int sblim;
551
552 if (grinfo->block_type == 2) {
553 if (!grinfo->mixed_block_flag) return;
554 sblim = 1;
555 } else sblim = grinfo->maxb - 1;
556 {
557 int sb;
558 MYFLT *xr1 = (MYFLT *)xr[1];
559 for (sb = sblim; sb; sb--, xr1 += 10) {
560 int ss;
561 MYFLT *xr2 = xr1;
562 for (ss = 0; ss < 8; ss++) {
563 register MYFLT bu = *--xr2, bd = *xr1;
564 *xr2 = bu*cs[ss] - bd*ca[ss];
565 *xr1++ = bd*cs[ss] + bu*ca[ss];
566 }
567 }
568 }
569 }
570
dct36(register MYFLT * in,register MYFLT * out1,register MYFLT * out2,register MYFLT * w,register MYFLT * ts)571 static void dct36(register MYFLT *in, register MYFLT *out1,
572 register MYFLT *out2, register MYFLT *w, register MYFLT *ts)
573 {
574 MYFLT tmp[18];
575
576 {
577 in[17] += in[16]; in[16] += in[15]; in[15] += in[14];
578 in[14] += in[13]; in[13] += in[12]; in[12] += in[11];
579 in[11] += in[10]; in[10] += in[9]; in[9] += in[8];
580 in[8] += in[7]; in[7] += in[6]; in[6] += in[5];
581 in[5] += in[4]; in[4] += in[3]; in[3] += in[2];
582 in[2] += in[1]; in[1] += in[0];
583
584 in[17] += in[15]; in[15] += in[13]; in[13] += in[11]; in[11] += in[9];
585 in[9] += in[7]; in[7] += in[5]; in[5] += in[3]; in[3] += in[1];
586
587 {
588 MYFLT t3;
589 {
590 MYFLT t0, t1, t2;
591
592 t0 = newcos[7]*(in[8] + in[16] - in[4]);
593 t1 = newcos[7]*in[12];
594 t3 = in[0];
595 t2 = t3 - t1 - t1;
596 tmp[1] = tmp[7] = t2 - t0;
597 tmp[4] = t2 + t0 + t0;
598 t3 += t1;
599 t2 = newcos[6]*(in[10] + in[14] - in[2]);
600 tmp[1] -= t2;
601 tmp[7] += t2;
602 }
603 {
604 MYFLT t0, t1, t2;
605
606 t0 = newcos[0]*(in[4] + in[8]);
607 t1 = newcos[1]*(in[8] - in[16]);
608 t2 = newcos[2]*(in[4] + in[16]);
609 tmp[2] = tmp[6] = t3 - t0 - t2;
610 tmp[0] = tmp[8] = t3 + t0 + t1;
611 tmp[3] = tmp[5] = t3 - t1 + t2;
612 }
613 }
614 {
615 MYFLT t1, t2, t3;
616
617 t1 = newcos[3]*(in[2] + in[10]);
618 t2 = newcos[4]*(in[10] - in[14]);
619 t3 = newcos[6]*in[6];
620 {
621 MYFLT t0 = t1 + t2 + t3;
622 tmp[0] += t0;
623 tmp[8] -= t0;
624 }
625 t2 -= t3;
626 t1 -= t3;
627 t3 = newcos[5]*(in[2] + in[14]);
628 t1 += t3;
629 tmp[3] += t1;
630 tmp[5] -= t1;
631 t2 -= t3;
632 tmp[2] += t2;
633 tmp[6] -= t2;
634 }
635 {
636 MYFLT t0, t1, t2, t3, t4, t5, t6, t7;
637
638 t1 = newcos[7]*in[13];
639 t2 = newcos[7]*(in[9] + in[17] - in[5]);
640 t3 = in[1] + t1;
641 t4 = in[1] - t1 - t1;
642 t5 = t4 - t2;
643 t0 = newcos[0]*(in[5] + in[9]);
644 t1 = newcos[1]*(in[9] - in[17]);
645 tmp[13] = (t4 + t2 + t2)*tfcos36[17 - 13];
646 t2 = newcos[2]*(in[5] + in[17]);
647 t6 = t3 - t0 - t2;
648 t0 += t3 + t1;
649 t3 += t2 - t1;
650 t2 = newcos[3]*(in[3] + in[11]);
651 t4 = newcos[4]*(in[11] - in[15]);
652 t7 = newcos[6]*in[7];
653 t1 = t2 + t4 + t7;
654 tmp[17] = (t0 + t1)*tfcos36[17 - 17];
655 tmp[9] = (t0 - t1)*tfcos36[17 - 9];
656 t1 = newcos[5]*(in[3] + in[15]);
657 t2 += t1 - t7;
658 tmp[14] = (t3 + t2)*tfcos36[17 - 14];
659 t0 = newcos[6]*(in[11] + in[15] - in[3]);
660 tmp[12] = (t3 - t2)*tfcos36[17 - 12];
661 t4 -= t1 + t7;
662 tmp[16] = (t5 - t0)*tfcos36[17 - 16];
663 tmp[10] = (t5 + t0)*tfcos36[17 - 10];
664 tmp[15] = (t6 + t4)*tfcos36[17 - 15];
665 tmp[11] = (t6 - t4)*tfcos36[17 - 11];
666 }
667 }
668 #define DCT36_MACRO(v) { \
669 register MYFLT tmpval = tmp[(v)] + tmp[17 - (v)]; \
670 out2[9 + (v)] = tmpval*w[27 + (v)]; \
671 out2[8 - (v)] = tmpval*w[26 - (v)]; \
672 tmpval = tmp[(v)] - tmp[17 - (v)]; \
673 ts[SBLIMIT*(8 - (v))] = out1[8 - (v)] + tmpval*w[8 - (v)]; \
674 ts[SBLIMIT*(9 + (v))] = out1[9 + (v)] + tmpval*w[9 + (v)]; \
675 }
676 {
677 DCT36_MACRO(0);
678 DCT36_MACRO(1);
679 DCT36_MACRO(2);
680 DCT36_MACRO(3);
681 DCT36_MACRO(4);
682 DCT36_MACRO(5);
683 DCT36_MACRO(6);
684 DCT36_MACRO(7);
685 DCT36_MACRO(8);
686 }
687 #undef DCT36_MACRO
688 }
689
690
dct12(register MYFLT * in,register MYFLT * out1,register MYFLT * out2,register MYFLT * w,register MYFLT * ts)691 static void dct12(register MYFLT *in, register MYFLT *out1,
692 register MYFLT *out2, register MYFLT *w, register MYFLT *ts)
693 {
694 #define DCT12_PART1 in5 = in[5*3]; \
695 in5 += (in4 = in[4*3]); \
696 in4 += (in3 = in[3*3]); \
697 in3 += (in2 = in[2*3]); \
698 in2 += (in1 = in[1*3]); \
699 in1 += (in0 = in[0*3]); \
700 in5 += in3; in3 += in1; \
701 in2 *= newcos[6]; \
702 in3 *= newcos[6];
703
704 #define DCT12_PART2 in0 += in4*newcos[7]; \
705 in4 = in0 + in2; \
706 in0 -= in2; \
707 in1 += in5*newcos[7]; \
708 in5 = (in1 + in3)*tfcos12[0]; \
709 in1 = (in1 - in3)*tfcos12[2]; \
710 in3 = in4 + in5; \
711 in4 -= in5; \
712 in2 = in0 + in1; \
713 in0 -= in1;
714
715 {
716 MYFLT in0, in1, in2, in3, in4, in5;
717
718 ts[0*SBLIMIT] = out1[0]; ts[1*SBLIMIT] = out1[1]; ts[2*SBLIMIT] = out1[2];
719 ts[3*SBLIMIT] = out1[3]; ts[4*SBLIMIT] = out1[4]; ts[5*SBLIMIT] = out1[5];
720
721 DCT12_PART1
722
723 {
724 register MYFLT tmp0, tmp1 = in0 - in4;
725 {
726 register MYFLT tmp2 = (in1 - in5)*tfcos12[1];
727 tmp0 = tmp1 + tmp2;
728 tmp1 -= tmp2;
729 }
730 ts[(17 - 1)*SBLIMIT] = out1[17 - 1] + tmp0*w[11 - 1];
731 ts[(12 + 1)*SBLIMIT] = out1[12 + 1] + tmp0*w[6 + 1];
732 ts[(6 + 1)*SBLIMIT] = out1[6 + 1] + tmp1*w[1];
733 ts[(11 - 1)*SBLIMIT] = out1[11 - 1] + tmp1*w[5 - 1];
734 }
735
736 DCT12_PART2
737
738 ts[(17 - 0)*SBLIMIT] = out1[17 - 0] + in2*w[11 - 0];
739 ts[(12 + 0)*SBLIMIT] = out1[12 + 0] + in2*w[6 + 0];
740 ts[(12 + 2)*SBLIMIT] = out1[12 + 2] + in3*w[6 + 2];
741 ts[(17 - 2)*SBLIMIT] = out1[17 - 2] + in3*w[11 - 2];
742 ts[(6 + 0)*SBLIMIT] = out1[6 + 0] + in0*w[0];
743 ts[(11 - 0)*SBLIMIT] = out1[11 - 0] + in0*w[5 - 0];
744 ts[(6 + 2)*SBLIMIT] = out1[6 + 2] + in4*w[2];
745 ts[(11 - 2)*SBLIMIT] = out1[11 - 2] + in4*w[5 - 2];
746 }
747 in++;
748 {
749 MYFLT in0, in1, in2, in3, in4, in5;
750
751 DCT12_PART1
752
753 {
754 register MYFLT tmp0, tmp1 = in0 - in4;
755 {
756 register MYFLT tmp2 = (in1 - in5)*tfcos12[1];
757 tmp0 = tmp1 + tmp2;
758 tmp1 -= tmp2;
759 }
760 out2[5 - 1] = tmp0*w[11 - 1];
761 out2[0 + 1] = tmp0*w[6 + 1];
762 ts[(12 + 1)*SBLIMIT] += tmp1*w[0 + 1];
763 ts[(17 - 1)*SBLIMIT] += tmp1*w[5 - 1];
764 }
765
766 DCT12_PART2
767
768 out2[5 - 0] = in2*w[11 - 0];
769 out2[0 + 0] = in2*w[6 + 0];
770 out2[0 + 2] = in3*w[6 + 2];
771 out2[5 - 2] = in3*w[11 - 2];
772 ts[(12 + 0)*SBLIMIT] += in0*w[0];
773 ts[(17 - 0)*SBLIMIT] += in0*w[5 - 0];
774 ts[(12 + 2)*SBLIMIT] += in4*w[2];
775 ts[(17 - 2)*SBLIMIT] += in4*w[5 - 2];
776 }
777 in++;
778 {
779 MYFLT in0, in1, in2, in3, in4, in5;
780
781 out2[12] = out2[13] = out2[14] = out2[15] = out2[16] = out2[17] = 0.0;
782
783 DCT12_PART1
784
785 {
786 register MYFLT tmp0, tmp1 = in0 - in4;
787 {
788 register MYFLT tmp2 = (in1 - in5)*tfcos12[1];
789 tmp0 = tmp1 + tmp2;
790 tmp1 -= tmp2;
791 }
792 out2[11 - 1] = tmp0*w[11 - 1];
793 out2[6 + 1] = tmp0*w[6 + 1];
794 out2[0 + 1] += tmp1*w[1];
795 out2[5 - 1] += tmp1*w[5 - 1];
796 }
797
798 DCT12_PART2
799
800 out2[11 - 0] = in2*w[11 - 0];
801 out2[6 + 0] = in2*w[6 + 0];
802 out2[6 + 2] = in3*w[6 + 2];
803 out2[11 - 2] = in3*w[11 - 2];
804 out2[0 + 0] += in0*w[0];
805 out2[5 - 0] += in0*w[5 - 0];
806 out2[0 + 2] += in4*w[2];
807 out2[5 - 2] += in4*w[5 - 2];
808 }
809 #undef DCT12_PART1
810 #undef DCT12_PART2
811 }
812
III_hybrid(mpadec_t mpadec,grinfo_t * gr_info,MYFLT fs_in[SBLIMIT][SSLIMIT],MYFLT ts_out[SSLIMIT][SBLIMIT],int channel)813 static void III_hybrid(mpadec_t mpadec, grinfo_t *gr_info,
814 MYFLT fs_in[SBLIMIT][SSLIMIT],
815 MYFLT ts_out[SSLIMIT][SBLIMIT], int channel)
816 {
817 register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
818 register grinfo_t *grinfo = gr_info;
819 MYFLT *tsptr = (MYFLT *)ts_out;
820 MYFLT *out1, *out2;
821 unsigned bt = grinfo->block_type, sb = 0;
822
823 {
824 register unsigned b = mpa->hybrid_block[channel];
825 out1 = mpa->hybrid_buffers[b][channel];
826 b ^= 1;
827 out2 = mpa->hybrid_buffers[b][channel];
828 mpa->hybrid_block[channel] = (uint8_t)b;
829 }
830 if (grinfo->mixed_block_flag) {
831 sb = 2;
832 dct36(fs_in[0], out1, out2, mpa->tables.win[0][0], tsptr);
833 dct36(fs_in[1], out1 + SSLIMIT, out2 + SSLIMIT,
834 mpa->tables.win[1][0], tsptr + 1);
835 out1 += 36; out2 += 36; tsptr += 2;
836 }
837 if (bt == 2) {
838 for (; sb < grinfo->maxb; sb += 2, out1 += 36, out2 += 36, tsptr += 2) {
839 dct12(fs_in[sb], out1, out2, mpa->tables.win[0][2], tsptr);
840 dct12(fs_in[sb + 1], out1 + SSLIMIT, out2 + SSLIMIT,
841 mpa->tables.win[1][2], tsptr + 1);
842 }
843 } else {
844 for (; sb < grinfo->maxb; sb += 2, out1 += 36, out2 += 36, tsptr += 2) {
845 dct36(fs_in[sb], out1, out2, mpa->tables.win[0][bt], tsptr);
846 dct36(fs_in[sb + 1], out1 + SSLIMIT, out2 + SSLIMIT,
847 mpa->tables.win[1][bt], tsptr + 1);
848 }
849 }
850 for (; sb < SBLIMIT; sb++, tsptr++) {
851 register int i;
852 for (i = 0; i < SSLIMIT; i++) {
853 tsptr[i*SBLIMIT] = *out1++;
854 *out2++ = 0.0;
855 }
856 }
857 }
858
decode_layer3(mpadec_t mpadec,uint8_t * buffer)859 void decode_layer3(mpadec_t mpadec, uint8_t *buffer)
860 {
861 register struct mpadec_t *mpa = (struct mpadec_t *)mpadec;
862 uint8_t *saved_next_byte = mpa->next_byte;
863 uint32_t saved_bytes_left = mpa->bytes_left;
864 int32_t dbits, scalefacs[2][39];
865 int ch, gr, ss, i_stereo, ms_stereo, single, channels,
866 granules = mpa->frame.LSF ? 1 : 2;
867
868 mpa->error = FALSE;
869 mpa->bits_left = 0;
870 if (mpa->config.crc && mpa->frame.CRC) {
871 mpa->crc = update_crc(mpa->crc, mpa->next_byte, mpa->ssize << 3);
872 if (mpa->crc != mpa->frame.crc) mpa->error = TRUE;
873 }
874 dbits = decode_layer3_sideinfo(mpa);
875 mpa->dsize = (((dbits < 0) ? 0 : dbits) + 7) >> 3;
876 mpa->next_byte = saved_next_byte + mpa->ssize;
877 mpa->bytes_left = saved_bytes_left - mpa->ssize;
878 mpa->bits_left = 0;
879 saved_next_byte = NULL;
880 saved_bytes_left = mpa->bytes_left;
881 if (mpa->error) mpa->sideinfo.main_data_begin = mpa->reservoir_size + 1;
882 if (mpa->sideinfo.main_data_begin) {
883 if (mpa->sideinfo.main_data_begin <= mpa->reservoir_size) {
884 uint8_t *ptr = mpa->reservoir + mpa->reservoir_size;
885 uint32_t tmp = mpa->frame.frame_size - mpa->hsize - mpa->ssize;
886 if (tmp > (sizeof(mpa->reservoir) - mpa->reservoir_size))
887 tmp = sizeof(mpa->reservoir) - mpa->reservoir_size;
888 saved_next_byte = mpa->next_byte;
889 memcpy(ptr, mpa->next_byte, tmp);
890 mpa->next_byte = ptr - mpa->sideinfo.main_data_begin;
891 mpa->bytes_left = mpa->sideinfo.main_data_begin + tmp;
892 } else {
893 uint32_t tmp = mpa->frame.frame_size - mpa->hsize - mpa->ssize;
894 if (tmp > 512) {
895 mpa->next_byte += tmp - 512;
896 mpa->bytes_left -= tmp - 512;
897 tmp = 512;
898 }
899 if ((mpa->reservoir_size) && (mpa->reservoir_size > 512)) {
900 memmove(mpa->reservoir, mpa->reservoir + mpa->reservoir_size - 512, 512);
901 mpa->reservoir_size = 512;
902 }
903 memcpy(mpa->reservoir + mpa->reservoir_size, mpa->next_byte, tmp);
904 mpa->reservoir_size += tmp;
905 mpa->next_byte += tmp;
906 mpa->bytes_left -= tmp;
907 memset(buffer, 0, mpa->frame.decoded_size);
908 mpa->error = TRUE;
909 return;
910 }
911 }
912 if (mpa->frame.mode == MPG_MD_JOINT_STEREO) {
913 i_stereo = mpa->frame.mode_ext & 1;
914 ms_stereo = (mpa->frame.mode_ext & 2) >> 1;
915 } else i_stereo = ms_stereo = 0;
916 if (mpa->frame.channels > 1) switch (mpa->config.mode) {
917 case MPADEC_CONFIG_MONO: single = 0; break;
918 case MPADEC_CONFIG_CHANNEL1: single = 1; break;
919 case MPADEC_CONFIG_CHANNEL2: single = 2; break;
920 default: single = -1; break;
921 } else single = 1;
922 channels = (single < 0) ? 2 : 1;
923 for (gr = 0; gr < granules; gr++) {
924 grinfo_t *grinfo = &mpa->sideinfo.ch[0].gr[gr];
925 int32_t part2bits = III_get_scale_factors(mpa, grinfo, scalefacs[0]);
926 if (III_decode_samples(mpa, grinfo, mpa->hybrid_in[0], scalefacs[0],
927 part2bits)) {
928 unsigned size = mpa->frame.decoded_size;
929 if (!mpa->frame.LSF && gr) size >>= 1;
930 memset(buffer, 0, size);
931 mpa->error = TRUE;
932 goto done;
933 }
934 if (mpa->frame.channels > 1) {
935 grinfo = &mpa->sideinfo.ch[1].gr[gr];
936 part2bits = III_get_scale_factors(mpa, grinfo, scalefacs[1]);
937 if (III_decode_samples(mpa, grinfo, mpa->hybrid_in[1], scalefacs[1],
938 part2bits)) {
939 unsigned size = mpa->frame.decoded_size;
940 if (!mpa->frame.LSF && gr) size >>= 1;
941 memset(buffer, 0, size);
942 mpa->error = TRUE;
943 goto done;
944 }
945 if (ms_stereo) {
946 MYFLT *in0 = (MYFLT *)(mpa->hybrid_in[0]),
947 *in1 = (MYFLT *)(mpa->hybrid_in[1]);
948 unsigned i, maxb = mpa->sideinfo.ch[0].gr[gr].maxb;
949 if (mpa->sideinfo.ch[1].gr[gr].maxb > maxb)
950 maxb = mpa->sideinfo.ch[1].gr[gr].maxb;
951 for (i = 0; i < SSLIMIT*maxb; i++) {
952 register MYFLT tmp0 = in0[i];
953 register MYFLT tmp1 = in1[i];
954 in0[i] = tmp0 + tmp1;
955 in1[i] = tmp0 - tmp1;
956 }
957 }
958 if (i_stereo) III_i_stereo(mpa, grinfo, mpa->hybrid_in, scalefacs[1]);
959 if (i_stereo || ms_stereo || !single) {
960 if (grinfo->maxb > mpa->sideinfo.ch[0].gr[gr].maxb)
961 mpa->sideinfo.ch[0].gr[gr].maxb = grinfo->maxb;
962 else grinfo->maxb = mpa->sideinfo.ch[0].gr[gr].maxb;
963 }
964 if (!single) {
965 register unsigned i;
966 MYFLT *in0 = (MYFLT *)(mpa->hybrid_in[0]),
967 *in1 = (MYFLT *)(mpa->hybrid_in[1]);
968 for (i = 0; i < SSLIMIT*grinfo->maxb; i++, in0++)
969 *in0 = (*in0 + *in1++);
970 } else if (single == 2) {
971 register unsigned i;
972 MYFLT *in0 = (MYFLT *)(mpa->hybrid_in[0]),
973 *in1 = (MYFLT *)(mpa->hybrid_in[1]);
974 for (i = 0; i < SSLIMIT*grinfo->maxb; i++, in0++) *in0 = *in1++;
975 }
976 }
977 for (ch = 0; ch < channels; ch++) {
978 grinfo = &mpa->sideinfo.ch[ch].gr[gr];
979 III_antialias(grinfo, mpa->hybrid_in[ch]);
980 III_hybrid(mpa, grinfo, mpa->hybrid_in[ch], mpa->hybrid_out[ch], ch);
981 }
982 if (single < 0) {
983 for (ss = 0; ss < SSLIMIT; ss++, buffer += mpa->synth_size) {
984 mpa->synth_func(mpa, mpa->hybrid_out[0][ss], 0, buffer);
985 mpa->synth_func(mpa, mpa->hybrid_out[1][ss], 1, buffer);
986 }
987 } else {
988 for (ss = 0; ss < SSLIMIT; ss++, buffer += mpa->synth_size) {
989 mpa->synth_func(mpa, mpa->hybrid_out[0][ss], 0, buffer);
990 }
991 }
992 }
993 done:
994 {
995 register unsigned n = mpa->bits_left >> 3;
996 mpa->next_byte -= n;
997 mpa->bytes_left += n;
998 if (saved_next_byte) {
999 uint32_t tmp = mpa->frame.frame_size - mpa->hsize - mpa->ssize;
1000 if (mpa->bytes_left) {
1001 if (mpa->bytes_left > 512) {
1002 mpa->next_byte += mpa->bytes_left - 512;
1003 mpa->bytes_left = 512;
1004 }
1005 memmove(mpa->reservoir, mpa->next_byte, mpa->bytes_left);
1006 mpa->reservoir_size = mpa->bytes_left;
1007 } else mpa->reservoir_size = 0;
1008 mpa->next_byte = saved_next_byte + tmp;
1009 mpa->bytes_left = saved_bytes_left - tmp;
1010 } else {
1011 uint32_t tmp = mpa->frame.frame_size - mpa->hsize - mpa->ssize;
1012 mpa->reservoir_size = 0;
1013 if (tmp > (saved_bytes_left - mpa->bytes_left)) {
1014 tmp -= saved_bytes_left - mpa->bytes_left;
1015 if (tmp > 512) {
1016 mpa->next_byte += tmp - 512;
1017 mpa->bytes_left -= tmp - 512;
1018 tmp = 512;
1019 }
1020 memcpy(mpa->reservoir, mpa->next_byte, tmp);
1021 mpa->reservoir_size = tmp;
1022 mpa->next_byte += tmp;
1023 mpa->bytes_left -= tmp;
1024 }
1025 }
1026 }
1027 }
1028