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