1 /*
2 *
3 * This file is part of libmpeg3
4 *
5 * LibMPEG3
6 * Author: Adam Williams <broadcast@earthling.net>
7 * Page: heroine.linuxbox.com
8 * Page: http://www.smalltalkconsulting.com/html/mpeg3source.html (for Squeak)
9 *
10 LibMPEG3 was originally licenced under GPL. It was relicensed by
11 the author under the LGPL and the Squeak license on Nov 1st, 2000
12
13 This library is free software; you can redistribute it and/or
14 modify it under the terms of the GNU Lesser General Public
15 License as published by the Free Software Foundation; either
16 version 2.1 of the License, or (at your option) any later version.
17
18 This library is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 Lesser General Public License for more details.
22
23 You should have received a copy of the GNU Lesser General Public
24 License along with this library; if not, write to the Free Software
25 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26
27 Also licensed under the Squeak license.
28 http://www.squeak.org/license.html
29 */
30
31 #include "huffman.h"
32 #include "mpeg3audio.h"
33 #include "tables.h"
34
35 #include <stdio.h>
36 #include <string.h>
37
38 struct gr_info_s {
39 int scfsi;
40 unsigned part2_3_length;
41 unsigned big_values;
42 unsigned scalefac_compress;
43 unsigned block_type;
44 unsigned mixed_block_flag;
45 unsigned table_select[3];
46 unsigned subblock_gain[3];
47 unsigned maxband[3];
48 unsigned maxbandl;
49 unsigned maxb;
50 unsigned region1start;
51 unsigned region2start;
52 unsigned preflag;
53 unsigned scalefac_scale;
54 unsigned count1table_select;
55 float *full_gain[3];
56 float *pow2gain;
57 };
58
59 struct mpeg3_III_sideinfo
60 {
61 unsigned main_data_begin;
62 unsigned private_bits;
63 struct
64 {
65 struct gr_info_s gr[2];
66 } ch[2];
67 };
68
mpeg3audio_III_get_scale_factors_1(mpeg3audio_t * audio,int * scf,struct gr_info_s * gr_info,int ch,int gr)69 int mpeg3audio_III_get_scale_factors_1(mpeg3audio_t *audio,
70 int *scf,
71 struct gr_info_s *gr_info,
72 int ch,
73 int gr)
74 {
75 static unsigned char slen[2][16] =
76 {{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
77 {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}};
78 int numbits;
79 int num0 = slen[0][gr_info->scalefac_compress];
80 int num1 = slen[1][gr_info->scalefac_compress];
81
82 if (gr_info->block_type == 2)
83 {
84 int i = 18;
85 numbits = (num0 + num1) * 18;
86
87 if (gr_info->mixed_block_flag)
88 {
89 for(i = 8; i; i--)
90 *scf++ = mpeg3bits_getbits(audio->astream, num0);
91 i = 9;
92 /* num0 * 17 + num1 * 18 */
93 numbits -= num0;
94 }
95
96 for( ; i; i--)
97 *scf++ = mpeg3bits_getbits(audio->astream, num0);
98 for(i = 18; i; i--)
99 *scf++ = mpeg3bits_getbits(audio->astream, num1);
100 /* short[13][0..2] = 0 */
101 *scf++ = 0;
102 *scf++ = 0;
103 *scf++ = 0;
104 }
105 else
106 {
107 int i;
108 int scfsi = gr_info->scfsi;
109
110 if(scfsi < 0)
111 {
112 /* scfsi < 0 => granule == 0 */
113 for(i = 11; i; i--)
114 {
115 *scf++ = mpeg3bits_getbits(audio->astream, num0);
116 }
117 for(i = 10; i; i--)
118 *scf++ = mpeg3bits_getbits(audio->astream, num1);
119 numbits = (num0 + num1) * 10 + num0;
120 *scf++ = 0;
121 }
122 else
123 {
124 numbits = 0;
125 if(!(scfsi & 0x8))
126 {
127 for(i = 0; i < 6; i++)
128 {
129 *scf++ = mpeg3bits_getbits(audio->astream, num0);
130 }
131 numbits += num0 * 6;
132 }
133 else
134 {
135 scf += 6;
136 }
137
138 if(!(scfsi & 0x4))
139 {
140 for(i = 0; i < 5; i++)
141 *scf++ = mpeg3bits_getbits(audio->astream, num0);
142 numbits += num0 * 5;
143 }
144 else
145 {
146 scf += 5;
147 }
148
149 if(!(scfsi & 0x2))
150 {
151 for(i = 0; i < 5; i++)
152 *scf++ = mpeg3bits_getbits(audio->astream, num1);
153 numbits += num1 * 5;
154 }
155 else
156 {
157 scf += 5;
158 }
159
160 if(!(scfsi & 0x1))
161 {
162 for(i = 0; i < 5; i++)
163 *scf++ = mpeg3bits_getbits(audio->astream, num1);
164 numbits += num1 * 5;
165 }
166 else
167 {
168 scf += 5;
169 }
170 *scf++ = 0; /* no l[21] in original sources */
171 }
172 }
173 return numbits;
174 }
175
mpeg3audio_III_get_scale_factors_2(mpeg3audio_t * audio,int * scf,struct gr_info_s * gr_info,int i_stereo)176 int mpeg3audio_III_get_scale_factors_2(mpeg3audio_t *audio,
177 int *scf,
178 struct gr_info_s *gr_info,
179 int i_stereo)
180 {
181 unsigned char *pnt;
182 int i, j, n = 0, numbits = 0;
183 unsigned int slen;
184 static unsigned char stab[3][6][4] =
185 {{{ 6, 5, 5,5 }, { 6, 5, 7,3 }, { 11,10,0,0},
186 { 7, 7, 7,0 }, { 6, 6, 6,3 }, { 8, 8,5,0}},
187 {{ 9, 9, 9,9 }, { 9, 9,12,6 }, { 18,18,0,0},
188 {12,12,12,0 }, {12, 9, 9,6 }, { 15,12,9,0}},
189 {{ 6, 9, 9,9 }, { 6, 9,12,6 }, { 15,18,0,0},
190 { 6,15,12,0 }, { 6,12, 9,6 }, { 6,18,9,0}}};
191
192 /* i_stereo AND second channel -> do_layer3() checks this */
193 if(i_stereo)
194 slen = mpeg3_i_slen2[gr_info->scalefac_compress >> 1];
195 else
196 slen = mpeg3_n_slen2[gr_info->scalefac_compress];
197
198 gr_info->preflag = (slen >> 15) & 0x1;
199
200 n = 0;
201 if(gr_info->block_type == 2 )
202 {
203 n++;
204 if(gr_info->mixed_block_flag)
205 n++;
206 }
207
208 pnt = stab[n][(slen >> 12) & 0x7];
209
210 for(i = 0; i < 4; i++)
211 {
212 int num = slen & 0x7;
213 slen >>= 3;
214 if(num)
215 {
216 for(j = 0; j < (int)(pnt[i]); j++)
217 *scf++ = mpeg3bits_getbits(audio->astream, num);
218 numbits += pnt[i] * num;
219 }
220 else
221 {
222 for(j = 0; j < (int)(pnt[i]); j++)
223 *scf++ = 0;
224 }
225 }
226
227 n = (n << 1) + 1;
228 for(i = 0; i < n; i++)
229 *scf++ = 0;
230
231 return numbits;
232 }
233
234 static int pretab1[22] = {0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,2,2,3,3,3,2,0};
235 static int pretab2[22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
236
237 /*
238 * Dequantize samples (includes huffman decoding)
239 *
240 * 24 is enough because tab13 has max. a 19 bit huffvector
241 */
242
243 #define BITSHIFT ((sizeof(long) - 1) * 8)
244 #define REFRESH_MASK \
245 while(num < BITSHIFT) \
246 { \
247 mask |= mpeg3bits_getbits(audio->astream, 8) << (BITSHIFT - num); \
248 num += 8; \
249 part2remain -= 8; \
250 }
251
mpeg3audio_III_dequantize_sample(mpeg3audio_t * audio,float xr[SBLIMIT][SSLIMIT],int * scf,struct gr_info_s * gr_info,int sfreq,int part2bits)252 int mpeg3audio_III_dequantize_sample(mpeg3audio_t *audio,
253 float xr[SBLIMIT][SSLIMIT],
254 int *scf,
255 struct gr_info_s *gr_info,
256 int sfreq,
257 int part2bits)
258 {
259 int shift = 1 + gr_info->scalefac_scale;
260 float *xrpnt = (float*)xr;
261 int l[3],l3;
262 int part2remain = gr_info->part2_3_length - part2bits;
263 int *me;
264 int num = mpeg3bits_getbitoffset(audio->astream);
265 long mask = mpeg3bits_getbits(audio->astream, num);
266 //printf("III_dequantize_sample 1 %08x %d\n", mask, num);
267 mask = mask << (BITSHIFT + 8 - num);
268 part2remain -= num;
269
270 {
271 int bv = gr_info->big_values;
272 int region1 = gr_info->region1start;
273 int region2 = gr_info->region2start;
274
275 l3 = ((576 >> 1) - bv) >> 1;
276
277 /*
278 * we may lose the 'odd' bit here !!
279 * check this later again
280 */
281
282 if(bv <= region1)
283 {
284 l[0] = bv;
285 l[1] = 0;
286 l[2] = 0;
287 }
288 else
289 {
290 l[0] = region1;
291 if(bv <= region2)
292 {
293 l[1] = bv - l[0]; l[2] = 0;
294 }
295 else
296 {
297 l[1] = region2 - l[0];
298 l[2] = bv - region2;
299 }
300 }
301 }
302
303 if(gr_info->block_type == 2)
304 {
305 /*
306 * decoding with short or mixed mode BandIndex table
307 */
308 int i, max[4];
309 int step = 0, lwin = 3, cb = 0;
310 register float v = 0.0;
311 register int *m, mc;
312
313 if(gr_info->mixed_block_flag)
314 {
315 max[3] = -1;
316 max[0] = max[1] = max[2] = 2;
317 m = mpeg3_map[sfreq][0];
318 me = mpeg3_mapend[sfreq][0];
319 }
320 else
321 {
322 max[0] = max[1] = max[2] = max[3] = -1;
323 /* max[3] not floatly needed in this case */
324 m = mpeg3_map[sfreq][1];
325 me = mpeg3_mapend[sfreq][1];
326 }
327
328 mc = 0;
329 for(i = 0; i < 2; i++)
330 {
331 int lp = l[i];
332 struct newhuff *h = mpeg3_ht + gr_info->table_select[i];
333 for( ; lp; lp--, mc--)
334 {
335 register int x,y;
336 if(!mc)
337 {
338 mc = *m++;
339 xrpnt = ((float*)xr) + (*m++);
340 lwin = *m++;
341 cb = *m++;
342 if(lwin == 3)
343 {
344 v = gr_info->pow2gain[(*scf++) << shift];
345 step = 1;
346 }
347 else
348 {
349 v = gr_info->full_gain[lwin][(*scf++) << shift];
350 step = 3;
351 }
352 }
353
354 {
355 register short *val = h->table;
356 REFRESH_MASK;
357 while((y = *val++) < 0)
358 {
359 if (mask < 0)
360 val -= y;
361 num--;
362 mask <<= 1;
363 }
364 x = y >> 4;
365 y &= 0xf;
366 }
367
368 if(x == 15 && h->linbits)
369 {
370 max[lwin] = cb;
371 REFRESH_MASK;
372 x += ((unsigned long)mask) >> (BITSHIFT + 8 - h->linbits);
373 num -= h->linbits + 1;
374 mask <<= h->linbits;
375 if(mask < 0)
376 *xrpnt = -mpeg3_ispow[x] * v;
377 else
378 *xrpnt = mpeg3_ispow[x] * v;
379 mask <<= 1;
380 }
381 else
382 if(x)
383 {
384 max[lwin] = cb;
385 if(mask < 0)
386 *xrpnt = -mpeg3_ispow[x] * v;
387 else
388 *xrpnt = mpeg3_ispow[x] * v;
389 num--;
390 mask <<= 1;
391 }
392 else
393 *xrpnt = 0.0;
394
395 xrpnt += step;
396 if(y == 15 && h->linbits)
397 {
398 max[lwin] = cb;
399 REFRESH_MASK;
400 y += ((unsigned long) mask) >> (BITSHIFT + 8 - h->linbits);
401 num -= h->linbits + 1;
402 mask <<= h->linbits;
403 if(mask < 0)
404 *xrpnt = -mpeg3_ispow[y] * v;
405 else
406 *xrpnt = mpeg3_ispow[y] * v;
407 mask <<= 1;
408 }
409 else
410 if(y)
411 {
412 max[lwin] = cb;
413 if(mask < 0)
414 *xrpnt = -mpeg3_ispow[y] * v;
415 else
416 *xrpnt = mpeg3_ispow[y] * v;
417 num--;
418 mask <<= 1;
419 }
420 else
421 *xrpnt = 0.0;
422 xrpnt += step;
423 }
424 }
425
426 for( ;l3 && (part2remain + num > 0); l3--)
427 {
428 struct newhuff *h = mpeg3_htc + gr_info->count1table_select;
429 register short *val = h->table, a;
430
431 REFRESH_MASK;
432 while((a = *val++) < 0)
433 {
434 if (mask < 0)
435 val -= a;
436 num--;
437 mask <<= 1;
438 }
439 if(part2remain + num <= 0)
440 {
441 num -= part2remain + num;
442 break;
443 }
444
445 for(i = 0; i < 4; i++)
446 {
447 if(!(i & 1))
448 {
449 if(!mc)
450 {
451 mc = *m++;
452 xrpnt = ((float*)xr) + (*m++);
453 lwin = *m++;
454 cb = *m++;
455 if(lwin == 3)
456 {
457 v = gr_info->pow2gain[(*scf++) << shift];
458 step = 1;
459 }
460 else
461 {
462 v = gr_info->full_gain[lwin][(*scf++) << shift];
463 step = 3;
464 }
465 }
466 mc--;
467 }
468 if((a & (0x8 >> i)))
469 {
470 max[lwin] = cb;
471 if(part2remain + num <= 0)
472 {
473 break;
474 }
475 if(mask < 0)
476 *xrpnt = -v;
477 else
478 *xrpnt = v;
479 num--;
480 mask <<= 1;
481 }
482 else
483 *xrpnt = 0.0;
484 xrpnt += step;
485 }
486 }
487
488 if(lwin < 3)
489 {
490 /* short band? */
491 while(1)
492 {
493 for( ;mc > 0; mc--)
494 {
495 /* short band -> step=3 */
496 *xrpnt = 0.0;
497 xrpnt += 3;
498 *xrpnt = 0.0;
499 xrpnt += 3;
500 }
501 if(m >= me)
502 break;
503 mc = *m++;
504 xrpnt = ((float*)xr) + *m++;
505 /* optimize: field will be set to zero at the end of the function */
506 if(*m++ == 0)
507 break;
508 /* cb */
509 m++;
510 }
511 }
512
513 gr_info->maxband[0] = max[0] + 1;
514 gr_info->maxband[1] = max[1] + 1;
515 gr_info->maxband[2] = max[2] + 1;
516 gr_info->maxbandl = max[3] + 1;
517
518 {
519 int rmax = max[0] > max[1] ? max[0] : max[1];
520 rmax = (rmax > max[2] ? rmax : max[2]) + 1;
521 gr_info->maxb = rmax ? mpeg3_shortLimit[sfreq][rmax] : mpeg3_longLimit[sfreq][max[3] + 1];
522 }
523
524 }
525 else
526 {
527 /*
528 * decoding with 'long' BandIndex table (block_type != 2)
529 */
530 int *pretab = gr_info->preflag ? pretab1 : pretab2;
531 int i, max = -1;
532 int cb = 0;
533 int *m = mpeg3_map[sfreq][2];
534 register float v = 0.0;
535 int mc = 0;
536
537 /*
538 * long hash table values
539 */
540 for(i = 0; i < 3; i++)
541 {
542 int lp = l[i];
543 struct newhuff *h = mpeg3_ht + gr_info->table_select[i];
544
545 for(; lp; lp--, mc--)
546 {
547 int x, y;
548
549 if(!mc)
550 {
551 mc = *m++;
552 cb = *m++;
553 if(cb == 21)
554 v = 0.0;
555 else
556 v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
557 }
558 {
559 register short *val = h->table;
560 REFRESH_MASK;
561 while((y = *val++) < 0)
562 {
563 if(mask < 0)
564 val -= y;
565 num--;
566 mask <<= 1;
567 }
568 x = y >> 4;
569 y &= 0xf;
570 }
571
572 if(x == 15 && h->linbits)
573 {
574 max = cb;
575 REFRESH_MASK;
576 x += ((unsigned long) mask) >> (BITSHIFT + 8 - h->linbits);
577 num -= h->linbits + 1;
578 mask <<= h->linbits;
579 if(mask < 0)
580 *xrpnt++ = -mpeg3_ispow[x] * v;
581 else
582 *xrpnt++ = mpeg3_ispow[x] * v;
583 mask <<= 1;
584 }
585 else
586 if(x)
587 {
588 max = cb;
589 if(mask < 0)
590 *xrpnt++ = -mpeg3_ispow[x] * v;
591 else
592 *xrpnt++ = mpeg3_ispow[x] * v;
593 num--;
594 mask <<= 1;
595 }
596 else
597 *xrpnt++ = 0.0;
598
599 if(y == 15 && h->linbits)
600 {
601 max = cb;
602 REFRESH_MASK;
603 y += ((unsigned long) mask) >> (BITSHIFT + 8 - h->linbits);
604 num -= h->linbits + 1;
605 mask <<= h->linbits;
606 if(mask < 0)
607 *xrpnt++ = -mpeg3_ispow[y] * v;
608 else
609 *xrpnt++ = mpeg3_ispow[y] * v;
610 mask <<= 1;
611 }
612 else
613 if(y)
614 {
615 max = cb;
616 if(mask < 0)
617 *xrpnt++ = -mpeg3_ispow[y] * v;
618 else
619 *xrpnt++ = mpeg3_ispow[y] * v;
620 num--;
621 mask <<= 1;
622 }
623 else
624 *xrpnt++ = 0.0;
625 }
626 }
627
628 /*
629 * short (count1table) values
630 */
631 for( ; l3 && (part2remain + num > 0); l3--)
632 {
633 struct newhuff *h = mpeg3_htc + gr_info->count1table_select;
634 register short *val = h->table, a;
635
636 REFRESH_MASK;
637 while((a = *val++) < 0)
638 {
639 if(mask < 0)
640 val -= a;
641 num--;
642 mask <<= 1;
643 }
644 if(part2remain + num <= 0)
645 {
646 num -= part2remain + num;
647 break;
648 }
649
650 for(i = 0; i < 4; i++)
651 {
652 if(!(i & 1))
653 {
654 if(!mc)
655 {
656 mc = *m++;
657 cb = *m++;
658 if(cb == 21)
659 v = 0.0;
660 else
661 v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
662 }
663 mc--;
664 }
665 if((a & (0x8 >> i)))
666 {
667 max = cb;
668 if(part2remain + num <= 0)
669 {
670 break;
671 }
672 if(mask < 0)
673 *xrpnt++ = -v;
674 else
675 *xrpnt++ = v;
676 num--;
677 mask <<= 1;
678 }
679 else
680 *xrpnt++ = 0.0;
681 }
682 }
683
684 gr_info->maxbandl = max + 1;
685 gr_info->maxb = mpeg3_longLimit[sfreq][gr_info->maxbandl];
686 }
687
688 part2remain += num;
689
690 //printf("III_dequantize_sample 2 %d %04x\n", num, mpeg3bits_showbits(audio->astream, 16));
691 mpeg3bits_start_reverse(audio->astream);
692 mpeg3bits_getbits_reverse(audio->astream, num);
693 mpeg3bits_start_forward(audio->astream);
694 //printf("III_dequantize_sample 3 %d %04x\n", audio->astream->bit_number, mpeg3bits_showbits(audio->astream, 16));
695 num = 0;
696
697 while(xrpnt < &xr[SBLIMIT][0])
698 *xrpnt++ = 0.0;
699
700 while(part2remain > 16)
701 {
702 mpeg3bits_getbits(audio->astream, 16); /* Dismiss stuffing Bits */
703 part2remain -= 16;
704 }
705 if(part2remain > 0)
706 {
707 mpeg3bits_getbits(audio->astream, part2remain);
708 }
709 else
710 if(part2remain < 0)
711 {
712 fprintf(stderr,"mpeg3audio_III_dequantize_sample: Can't rewind stream %d bits!\n", -part2remain);
713 return 1; /* -> error */
714 }
715 return 0;
716 }
717
mpeg3audio_III_get_side_info(mpeg3audio_t * audio,struct mpeg3_III_sideinfo * si,int channels,int ms_stereo,long sfreq,int single,int lsf)718 int mpeg3audio_III_get_side_info(mpeg3audio_t *audio,
719 struct mpeg3_III_sideinfo *si,
720 int channels,
721 int ms_stereo,
722 long sfreq,
723 int single,
724 int lsf)
725 {
726 int ch, gr;
727 int powdiff = (single == 3) ? 4 : 0;
728 static const int tabs[2][5] = { { 2,9,5,3,4 } , { 1,8,1,2,9 } };
729 const int *tab = tabs[lsf];
730
731 si->main_data_begin = mpeg3bits_getbits(audio->astream, tab[1]);
732 if(channels == 1)
733 si->private_bits = mpeg3bits_getbits(audio->astream, tab[2]);
734 else
735 si->private_bits = mpeg3bits_getbits(audio->astream, tab[3]);
736 if(!lsf)
737 {
738 for(ch = 0; ch < channels; ch++)
739 {
740 si->ch[ch].gr[0].scfsi = -1;
741 si->ch[ch].gr[1].scfsi = mpeg3bits_getbits(audio->astream, 4);
742 }
743 }
744
745 for(gr = 0; gr < tab[0]; gr++)
746 {
747 for(ch = 0; ch < channels; ch++)
748 {
749 register struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
750
751 gr_info->part2_3_length = mpeg3bits_getbits(audio->astream, 12);
752 gr_info->big_values = mpeg3bits_getbits(audio->astream, 9);
753 if(gr_info->big_values > 288)
754 {
755 fprintf(stderr,"mpeg3_III_get_side_info: big_values too large!\n");
756 gr_info->big_values = 288;
757 }
758 gr_info->pow2gain = mpeg3_gainpow2 + 256 - mpeg3bits_getbits(audio->astream, 8) + powdiff;
759 if(ms_stereo)
760 gr_info->pow2gain += 2;
761 gr_info->scalefac_compress = mpeg3bits_getbits(audio->astream, tab[4]);
762
763 if(mpeg3bits_getbits(audio->astream, 1))
764 {
765 /* window switch flag */
766 int i;
767 gr_info->block_type = mpeg3bits_getbits(audio->astream, 2);
768 gr_info->mixed_block_flag = mpeg3bits_getbits(audio->astream, 1);
769 gr_info->table_select[0] = mpeg3bits_getbits(audio->astream, 5);
770 gr_info->table_select[1] = mpeg3bits_getbits(audio->astream, 5);
771 /*
772 * table_select[2] not needed, because there is no region2,
773 * but to satisfy some verifications tools we set it either.
774 */
775 gr_info->table_select[2] = 0;
776 for(i = 0; i < 3; i++)
777 gr_info->full_gain[i] = gr_info->pow2gain + (mpeg3bits_getbits(audio->astream, 3) << 3);
778
779 if(gr_info->block_type == 0)
780 {
781 fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n");
782 return 1;
783 }
784
785 /* region_count/start parameters are implicit in this case. */
786 if(!lsf || gr_info->block_type == 2)
787 gr_info->region1start = 36 >> 1;
788 else
789 {
790 /* check this again for 2.5 and sfreq=8 */
791 if(sfreq == 8)
792 gr_info->region1start = 108 >> 1;
793 else
794 gr_info->region1start = 54 >> 1;
795 }
796 gr_info->region2start = 576 >> 1;
797 }
798 else
799 {
800 int i, r0c, r1c;
801 for(i = 0; i < 3; i++)
802 gr_info->table_select[i] = mpeg3bits_getbits(audio->astream, 5);
803
804 r0c = mpeg3bits_getbits(audio->astream, 4);
805 r1c = mpeg3bits_getbits(audio->astream, 3);
806 gr_info->region1start = mpeg3_bandInfo[sfreq].longIdx[r0c + 1] >> 1 ;
807 gr_info->region2start = mpeg3_bandInfo[sfreq].longIdx[r0c + 1 + r1c + 1] >> 1;
808 gr_info->block_type = 0;
809 gr_info->mixed_block_flag = 0;
810 }
811 if(!lsf) gr_info->preflag = mpeg3bits_getbits(audio->astream, 1);
812 gr_info->scalefac_scale = mpeg3bits_getbits(audio->astream, 1);
813 gr_info->count1table_select = mpeg3bits_getbits(audio->astream, 1);
814 }
815 }
816 return 0;
817 }
818
mpeg3audio_III_hybrid(mpeg3audio_t * audio,float fsIn[SBLIMIT][SSLIMIT],float tsOut[SSLIMIT][SBLIMIT],int ch,struct gr_info_s * gr_info)819 int mpeg3audio_III_hybrid(mpeg3audio_t *audio,
820 float fsIn[SBLIMIT][SSLIMIT],
821 float tsOut[SSLIMIT][SBLIMIT],
822 int ch,
823 struct gr_info_s *gr_info)
824 {
825 float *tspnt = (float *) tsOut;
826 float *rawout1,*rawout2;
827 int bt, sb = 0;
828
829
830 {
831 int b = audio->mp3_blc[ch];
832 rawout1 = audio->mp3_block[b][ch];
833 b = -b + 1;
834 rawout2 = audio->mp3_block[b][ch];
835 audio->mp3_blc[ch] = b;
836 }
837
838 if(gr_info->mixed_block_flag)
839 {
840 sb = 2;
841 mpeg3audio_dct36(fsIn[0], rawout1, rawout2, mpeg3_win[0], tspnt);
842 mpeg3audio_dct36(fsIn[1], rawout1 + 18, rawout2 + 18, mpeg3_win1[0], tspnt + 1);
843 rawout1 += 36;
844 rawout2 += 36;
845 tspnt += 2;
846 }
847
848 bt = gr_info->block_type;
849 if(bt == 2)
850 {
851 for( ; sb < gr_info->maxb; sb += 2, tspnt += 2, rawout1 += 36, rawout2 += 36)
852 {
853 mpeg3audio_dct12(fsIn[sb] ,rawout1 ,rawout2 ,mpeg3_win[2] ,tspnt);
854 mpeg3audio_dct12(fsIn[sb + 1], rawout1 + 18, rawout2 + 18, mpeg3_win1[2], tspnt + 1);
855 }
856 }
857 else
858 {
859 for( ; sb < gr_info->maxb; sb += 2, tspnt += 2, rawout1 += 36, rawout2 += 36)
860 {
861 mpeg3audio_dct36(fsIn[sb], rawout1, rawout2, mpeg3_win[bt], tspnt);
862 mpeg3audio_dct36(fsIn[sb + 1], rawout1 + 18, rawout2 + 18, mpeg3_win1[bt], tspnt + 1);
863 }
864 }
865
866 for( ; sb < SBLIMIT; sb++, tspnt++)
867 {
868 int i;
869 for(i = 0; i < SSLIMIT; i++)
870 {
871 tspnt[i * SBLIMIT] = *rawout1++;
872 *rawout2++ = 0.0;
873 }
874 }
875 return 0;
876 }
877
mpeg3audio_III_antialias(mpeg3audio_t * audio,float xr[SBLIMIT][SSLIMIT],struct gr_info_s * gr_info)878 int mpeg3audio_III_antialias(mpeg3audio_t *audio,
879 float xr[SBLIMIT][SSLIMIT],
880 struct gr_info_s *gr_info)
881 {
882 int sblim;
883
884 if(gr_info->block_type == 2)
885 {
886 if(!gr_info->mixed_block_flag)
887 return 0;
888 sblim = 1;
889 }
890 else
891 {
892 sblim = gr_info->maxb-1;
893 }
894
895 /* 31 alias-reduction operations between each pair of sub-bands */
896 /* with 8 butterflies between each pair */
897
898 {
899 int sb;
900 float *xr1 = (float*)xr[1];
901
902 for(sb = sblim; sb; sb--, xr1 += 10)
903 {
904 int ss;
905 float *cs, *ca;
906 float *xr2;
907 cs = mpeg3_aa_cs;
908 ca = mpeg3_aa_ca;
909 xr2 = xr1;
910
911 for(ss = 7; ss >= 0; ss--)
912 {
913 /* upper and lower butterfly inputs */
914 register float bu, bd;
915 bu = *--xr2;
916 bd = *xr1;
917 *xr2 = (bu * (*cs) ) - (bd * (*ca) );
918 *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) );
919 }
920 }
921 }
922 return 0;
923 }
924
925 /*
926 * III_stereo: calculate float channel values for Joint-I-Stereo-mode
927 */
mpeg3audio_III_i_stereo(mpeg3audio_t * audio,float xr_buf[2][SBLIMIT][SSLIMIT],int * scalefac,struct gr_info_s * gr_info,int sfreq,int ms_stereo,int lsf)928 int mpeg3audio_III_i_stereo(mpeg3audio_t *audio,
929 float xr_buf[2][SBLIMIT][SSLIMIT],
930 int *scalefac,
931 struct gr_info_s *gr_info,
932 int sfreq,
933 int ms_stereo,
934 int lsf)
935 {
936 float (*xr)[SBLIMIT*SSLIMIT] = (float (*)[SBLIMIT*SSLIMIT] ) xr_buf;
937 struct mpeg3_bandInfoStruct *bi = &mpeg3_bandInfo[sfreq];
938 const float *tab1, *tab2;
939
940 int tab;
941 /* TODO: optimize as static */
942 static const float *tabs[3][2][2] =
943 {
944 { { mpeg3_tan1_1, mpeg3_tan2_1 } , { mpeg3_tan1_2, mpeg3_tan2_2 } },
945 { { mpeg3_pow1_1[0], mpeg3_pow2_1[0] } , { mpeg3_pow1_2[0], mpeg3_pow2_2[0] } } ,
946 { { mpeg3_pow1_1[1], mpeg3_pow2_1[1] } , { mpeg3_pow1_2[1], mpeg3_pow2_2[1] } }
947 };
948
949 tab = lsf + (gr_info->scalefac_compress & lsf);
950 tab1 = tabs[tab][ms_stereo][0];
951 tab2 = tabs[tab][ms_stereo][1];
952
953 if(gr_info->block_type == 2)
954 {
955 int lwin,do_l = 0;
956 if(gr_info->mixed_block_flag)
957 do_l = 1;
958
959 for(lwin = 0; lwin < 3; lwin++)
960 {
961 /* process each window */
962 /* get first band with zero values */
963 /* sfb is minimal 3 for mixed mode */
964 int is_p, sb, idx, sfb = gr_info->maxband[lwin];
965 if(sfb > 3) do_l = 0;
966
967 for( ; sfb < 12 ; sfb++)
968 {
969 /* scale: 0-15 */
970 is_p = scalefac[sfb * 3 + lwin - gr_info->mixed_block_flag];
971 if(is_p != 7)
972 {
973 float t1, t2;
974 sb = bi->shortDiff[sfb];
975 idx = bi->shortIdx[sfb] + lwin;
976 t1 = tab1[is_p];
977 t2 = tab2[is_p];
978 for( ; sb > 0; sb--, idx += 3)
979 {
980 float v = xr[0][idx];
981 xr[0][idx] = v * t1;
982 xr[1][idx] = v * t2;
983 }
984 }
985 }
986
987 /* in the original: copy 10 to 11 , here: copy 11 to 12
988 maybe still wrong??? (copy 12 to 13?) */
989 /* scale: 0-15 */
990 is_p = scalefac[11 * 3 + lwin - gr_info->mixed_block_flag];
991 sb = bi->shortDiff[12];
992 idx = bi->shortIdx[12] + lwin;
993 if(is_p != 7)
994 {
995 float t1, t2;
996 t1 = tab1[is_p];
997 t2 = tab2[is_p];
998 for( ; sb > 0; sb--, idx += 3)
999 {
1000 float v = xr[0][idx];
1001 xr[0][idx] = v * t1;
1002 xr[1][idx] = v * t2;
1003 }
1004 }
1005 } /* end for(lwin; .. ; . ) */
1006
1007 /* also check l-part, if ALL bands in the three windows are 'empty'
1008 * and mode = mixed_mode
1009 */
1010 if(do_l)
1011 {
1012 int sfb = gr_info->maxbandl;
1013 int idx = bi->longIdx[sfb];
1014
1015 for ( ; sfb < 8; sfb++)
1016 {
1017 int sb = bi->longDiff[sfb];
1018 /* scale: 0-15 */
1019 int is_p = scalefac[sfb];
1020 if(is_p != 7)
1021 {
1022 float t1, t2;
1023 t1 = tab1[is_p];
1024 t2 = tab2[is_p];
1025 for( ; sb > 0; sb--, idx++)
1026 {
1027 float v = xr[0][idx];
1028 xr[0][idx] = v * t1;
1029 xr[1][idx] = v * t2;
1030 }
1031 }
1032 else
1033 idx += sb;
1034 }
1035 }
1036 }
1037 else
1038 {
1039 /* ((gr_info->block_type != 2)) */
1040 int sfb = gr_info->maxbandl;
1041 int is_p, idx = bi->longIdx[sfb];
1042 for( ; sfb < 21; sfb++)
1043 {
1044 int sb = bi->longDiff[sfb];
1045 /* scale: 0-15 */
1046 is_p = scalefac[sfb];
1047 if(is_p != 7)
1048 {
1049 float t1, t2;
1050 t1 = tab1[is_p];
1051 t2 = tab2[is_p];
1052 for( ; sb > 0; sb--, idx++)
1053 {
1054 float v = xr[0][idx];
1055 xr[0][idx] = v * t1;
1056 xr[1][idx] = v * t2;
1057 }
1058 }
1059 else
1060 idx += sb;
1061 }
1062
1063 is_p = scalefac[20];
1064 if(is_p != 7)
1065 {
1066 /* copy l-band 20 to l-band 21 */
1067 int sb;
1068 float t1 = tab1[is_p], t2 = tab2[is_p];
1069
1070 for(sb = bi->longDiff[21]; sb > 0; sb--, idx++)
1071 {
1072 float v = xr[0][idx];
1073 xr[0][idx] = v * t1;
1074 xr[1][idx] = v * t2;
1075 }
1076 }
1077 } /* ... */
1078 }
1079
1080 /* Read just the frame after a seek. */
mpeg3audio_read_layer3_frame(mpeg3audio_t * audio)1081 int mpeg3audio_read_layer3_frame(mpeg3audio_t *audio)
1082 {
1083 int result = 0;
1084
1085 result = mpeg3audio_read_header(audio);
1086 if(!result)
1087 {
1088 audio->bsbufold = audio->bsbuf;
1089 audio->bsbuf = audio->bsspace[audio->bsnum] + 512;
1090 audio->bsnum ^= 1;
1091 result = mpeg3bits_read_buffer(audio->astream, audio->bsbuf, audio->framesize);
1092 }
1093
1094 return result;
1095 }
1096
mpeg3audio_dolayer3(mpeg3audio_t * audio)1097 int mpeg3audio_dolayer3(mpeg3audio_t *audio)
1098 {
1099 int gr, ch, ss;
1100 int scalefacs[2][39]; /* max 39 for short[13][3] mode, mixed: 38, long: 22 */
1101 struct mpeg3_III_sideinfo sideinfo;
1102 int channels = audio->channels;
1103 int single = audio->single;
1104 int ms_stereo, i_stereo;
1105 int sfreq = audio->sampling_frequency_code;
1106 int stereo1, granules;
1107 int i;
1108
1109 /* flip/init buffer */
1110 audio->bsbufold = audio->bsbuf;
1111 audio->bsbuf = audio->bsspace[audio->bsnum] + 512;
1112 audio->bsnum ^= 1;
1113
1114 /* read main data into memory */
1115 if(mpeg3bits_read_buffer(audio->astream, audio->bsbuf, audio->framesize))
1116 return 1;
1117 mpeg3bits_use_ptr(audio->astream, audio->bsbuf);
1118
1119 /* CRC must be skipped here for proper alignment with the backstep */
1120 if(audio->error_protection)
1121 mpeg3bits_getbits(audio->astream, 16);
1122
1123 if(channels == 1)
1124 {
1125 /* stream is mono */
1126 stereo1 = 1;
1127 single = 0;
1128 }
1129 else
1130 {
1131 /* Stereo */
1132 stereo1 = 2;
1133 }
1134
1135 if(audio->mode == MPG_MD_JOINT_STEREO)
1136 {
1137 ms_stereo = (audio->mode_ext & 0x2) >> 1;
1138 i_stereo = audio->mode_ext & 0x1;
1139 }
1140 else
1141 ms_stereo = i_stereo = 0;
1142
1143 if(audio->lsf)
1144 {
1145 granules = 1;
1146 }
1147 else
1148 {
1149 granules = 2;
1150 }
1151
1152 if(mpeg3audio_III_get_side_info(audio, &sideinfo, channels, ms_stereo, sfreq, single, audio->lsf))
1153 return 1;
1154
1155 /* Step back */
1156 if(sideinfo.main_data_begin >= 512)
1157 return 1;
1158
1159 if(sideinfo.main_data_begin)
1160 {
1161 memcpy(audio->bsbuf + audio->ssize - sideinfo.main_data_begin,
1162 audio->bsbufold + audio->prev_framesize - sideinfo.main_data_begin,
1163 sideinfo.main_data_begin);
1164 mpeg3bits_use_ptr(audio->astream, audio->bsbuf + audio->ssize - sideinfo.main_data_begin);
1165 }
1166
1167 for(gr = 0; gr < granules; gr++)
1168 {
1169 float hybridIn [2][SBLIMIT][SSLIMIT];
1170 float hybridOut[2][SSLIMIT][SBLIMIT];
1171
1172 {
1173 struct gr_info_s *gr_info = &(sideinfo.ch[0].gr[gr]);
1174 long part2bits;
1175 if(audio->lsf)
1176 part2bits = mpeg3audio_III_get_scale_factors_2(audio, scalefacs[0], gr_info, 0);
1177 else
1178 part2bits = mpeg3audio_III_get_scale_factors_1(audio, scalefacs[0], gr_info, 0, gr);
1179 //printf("dolayer3 4 %04x\n", mpeg3bits_showbits(audio->astream, 16));
1180
1181 if(mpeg3audio_III_dequantize_sample(audio, hybridIn[0], scalefacs[0], gr_info, sfreq, part2bits))
1182 {
1183 mpeg3bits_use_demuxer(audio->astream);
1184 return 1;
1185 }
1186 //printf("dolayer3 5 %04x\n", mpeg3bits_showbits(audio->astream, 16));
1187 }
1188
1189 if(channels == 2)
1190 {
1191 struct gr_info_s *gr_info = &(sideinfo.ch[1].gr[gr]);
1192 long part2bits;
1193 if(audio->lsf)
1194 part2bits = mpeg3audio_III_get_scale_factors_2(audio, scalefacs[1], gr_info, i_stereo);
1195 else
1196 part2bits = mpeg3audio_III_get_scale_factors_1(audio, scalefacs[1], gr_info, 1, gr);
1197
1198 if(mpeg3audio_III_dequantize_sample(audio, hybridIn[1], scalefacs[1], gr_info, sfreq, part2bits))
1199 {
1200 mpeg3bits_use_demuxer(audio->astream);
1201 return 1;
1202 }
1203
1204 if(ms_stereo)
1205 {
1206 int i;
1207 int maxb = sideinfo.ch[0].gr[gr].maxb;
1208 if(sideinfo.ch[1].gr[gr].maxb > maxb)
1209 maxb = sideinfo.ch[1].gr[gr].maxb;
1210 for(i = 0; i < SSLIMIT * maxb; i++)
1211 {
1212 float tmp0 = ((float*)hybridIn[0])[i];
1213 float tmp1 = ((float*)hybridIn[1])[i];
1214 ((float*)hybridIn[0])[i] = tmp0 + tmp1;
1215 ((float*)hybridIn[1])[i] = tmp0 - tmp1;
1216 }
1217 }
1218
1219 if(i_stereo)
1220 mpeg3audio_III_i_stereo(audio, hybridIn, scalefacs[1], gr_info, sfreq, ms_stereo, audio->lsf);
1221
1222 if(ms_stereo || i_stereo || (single == 3))
1223 {
1224 if(gr_info->maxb > sideinfo.ch[0].gr[gr].maxb)
1225 sideinfo.ch[0].gr[gr].maxb = gr_info->maxb;
1226 else
1227 gr_info->maxb = sideinfo.ch[0].gr[gr].maxb;
1228 }
1229
1230 switch(single)
1231 {
1232 case 3:
1233 {
1234 register int i;
1235 register float *in0 = (float*)hybridIn[0], *in1 = (float*)hybridIn[1];
1236 /* *0.5 done by pow-scale */
1237 for(i = 0; i < SSLIMIT * gr_info->maxb; i++, in0++)
1238 *in0 = (*in0 + *in1++);
1239 }
1240 break;
1241 case 1:
1242 {
1243 register int i;
1244 register float *in0 = (float*)hybridIn[0], *in1 = (float*)hybridIn[1];
1245 for(i = 0; i < SSLIMIT * gr_info->maxb; i++)
1246 *in0++ = *in1++;
1247 }
1248 break;
1249 }
1250 }
1251
1252 for(ch = 0; ch < stereo1; ch++)
1253 {
1254 struct gr_info_s *gr_info = &(sideinfo.ch[ch].gr[gr]);
1255 mpeg3audio_III_antialias(audio, hybridIn[ch], gr_info);
1256 mpeg3audio_III_hybrid(audio, hybridIn[ch], hybridOut[ch], ch, gr_info);
1257 }
1258
1259 for(ss = 0; ss < SSLIMIT; ss++)
1260 {
1261 if(single >= 0)
1262 {
1263 mpeg3audio_synth_mono(audio, hybridOut[0][ss], audio->pcm_sample, &(audio->pcm_point));
1264 }
1265 else
1266 {
1267 int p1 = audio->pcm_point;
1268 mpeg3audio_synth_stereo(audio, hybridOut[0][ss], 0, audio->pcm_sample, &p1);
1269 mpeg3audio_synth_stereo(audio, hybridOut[1][ss], 1, audio->pcm_sample, &(audio->pcm_point));
1270 }
1271
1272 if(audio->pcm_point / audio->channels >= audio->pcm_allocated - MPEG3AUDIO_PADDING * audio->channels)
1273 {
1274 /* Need more room */
1275 mpeg3audio_replace_buffer(audio, audio->pcm_allocated + MPEG3AUDIO_PADDING * audio->channels);
1276 }
1277 }
1278 }
1279
1280 mpeg3bits_use_demuxer(audio->astream);
1281 return 0;
1282 }
1283
1284
1285