1 #include "huffman.h"
2 #include "mpeg3private.h"
3 #include "mpeg3protos.h"
4 #include "tables.h"
5
6 #include <stdio.h>
7 #include <string.h>
8
9 struct gr_info_s
10 {
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 float *full_gain[3];
28 float *pow2gain;
29 };
30
31 struct sideinfo_s
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
41
42
43
44
45
46
47
48
get_scale_factors_1(mpeg3_layer_t * audio,int * scf,struct gr_info_s * gr_info,int ch,int gr)49 static int get_scale_factors_1(mpeg3_layer_t *audio,
50 int *scf,
51 struct gr_info_s *gr_info,
52 int ch,
53 int gr)
54 {
55 static unsigned char slen[2][16] =
56 {{0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4},
57 {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3}};
58 int numbits;
59 int num0 = slen[0][gr_info->scalefac_compress];
60 int num1 = slen[1][gr_info->scalefac_compress];
61
62 if (gr_info->block_type == 2)
63 {
64 int i = 18;
65 numbits = (num0 + num1) * 18;
66
67 if (gr_info->mixed_block_flag)
68 {
69 for(i = 8; i; i--)
70 *scf++ = mpeg3bits_getbits(audio->stream, num0);
71 i = 9;
72 /* num0 * 17 + num1 * 18 */
73 numbits -= num0;
74 }
75
76 for( ; i; i--)
77 *scf++ = mpeg3bits_getbits(audio->stream, num0);
78 for(i = 18; i; i--)
79 *scf++ = mpeg3bits_getbits(audio->stream, num1);
80 /* short[13][0..2] = 0 */
81 *scf++ = 0;
82 *scf++ = 0;
83 *scf++ = 0;
84 }
85 else
86 {
87 int i;
88 int scfsi = gr_info->scfsi;
89
90 if(scfsi < 0)
91 {
92 /* scfsi < 0 => granule == 0 */
93 for(i = 11; i; i--)
94 {
95 *scf++ = mpeg3bits_getbits(audio->stream, num0);
96 }
97 for(i = 10; i; i--)
98 *scf++ = mpeg3bits_getbits(audio->stream, num1);
99 numbits = (num0 + num1) * 10 + num0;
100 *scf++ = 0;
101 }
102 else
103 {
104 numbits = 0;
105 if(!(scfsi & 0x8))
106 {
107 for(i = 0; i < 6; i++)
108 {
109 *scf++ = mpeg3bits_getbits(audio->stream, num0);
110 }
111 numbits += num0 * 6;
112 }
113 else
114 {
115 scf += 6;
116 }
117
118 if(!(scfsi & 0x4))
119 {
120 for(i = 0; i < 5; i++)
121 *scf++ = mpeg3bits_getbits(audio->stream, num0);
122 numbits += num0 * 5;
123 }
124 else
125 {
126 scf += 5;
127 }
128
129 if(!(scfsi & 0x2))
130 {
131 for(i = 0; i < 5; i++)
132 *scf++ = mpeg3bits_getbits(audio->stream, num1);
133 numbits += num1 * 5;
134 }
135 else
136 {
137 scf += 5;
138 }
139
140 if(!(scfsi & 0x1))
141 {
142 for(i = 0; i < 5; i++)
143 *scf++ = mpeg3bits_getbits(audio->stream, num1);
144 numbits += num1 * 5;
145 }
146 else
147 {
148 scf += 5;
149 }
150 *scf++ = 0; /* no l[21] in original sources */
151 }
152 }
153 return numbits;
154 }
155
get_scale_factors_2(mpeg3_layer_t * audio,int * scf,struct gr_info_s * gr_info,int i_stereo)156 static int get_scale_factors_2(mpeg3_layer_t *audio,
157 int *scf,
158 struct gr_info_s *gr_info,
159 int i_stereo)
160 {
161 unsigned char *pnt;
162 int i, j, n = 0, numbits = 0;
163 unsigned int slen;
164 static unsigned char stab[3][6][4] =
165 {{{ 6, 5, 5,5 }, { 6, 5, 7,3 }, { 11,10,0,0},
166 { 7, 7, 7,0 }, { 6, 6, 6,3 }, { 8, 8,5,0}},
167 {{ 9, 9, 9,9 }, { 9, 9,12,6 }, { 18,18,0,0},
168 {12,12,12,0 }, {12, 9, 9,6 }, { 15,12,9,0}},
169 {{ 6, 9, 9,9 }, { 6, 9,12,6 }, { 15,18,0,0},
170 { 6,15,12,0 }, { 6,12, 9,6 }, { 6,18,9,0}}};
171
172 /* i_stereo AND second channel -> do_layer3() checks this */
173 if(i_stereo)
174 slen = mpeg3_i_slen2[gr_info->scalefac_compress >> 1];
175 else
176 slen = mpeg3_n_slen2[gr_info->scalefac_compress];
177
178 gr_info->preflag = (slen >> 15) & 0x1;
179
180 n = 0;
181 if(gr_info->block_type == 2 )
182 {
183 n++;
184 if(gr_info->mixed_block_flag)
185 n++;
186 }
187
188 pnt = stab[n][(slen >> 12) & 0x7];
189
190 for(i = 0; i < 4; i++)
191 {
192 int num = slen & 0x7;
193 slen >>= 3;
194 if(num)
195 {
196 for(j = 0; j < (int)(pnt[i]); j++)
197 *scf++ = mpeg3bits_getbits(audio->stream, num);
198 numbits += pnt[i] * num;
199 }
200 else
201 {
202 for(j = 0; j < (int)(pnt[i]); j++)
203 *scf++ = 0;
204 }
205 }
206
207 n = (n << 1) + 1;
208 for(i = 0; i < n; i++)
209 *scf++ = 0;
210
211 return numbits;
212 }
213
214 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};
215 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};
216
217 /*
218 * Dequantize samples (includes huffman decoding)
219 *
220 * 24 is enough because tab13 has max. a 19 bit huffvector
221 */
222
223 #define BITSHIFT ((sizeof(int32_t) - 1) * 8)
224 #define REFRESH_MASK \
225 while(num < BITSHIFT) \
226 { \
227 mask |= mpeg3bits_getbits(audio->stream, 8) << (BITSHIFT - num); \
228 num += 8; \
229 part2remain -= 8; \
230 }
231
232
dequantize_sample(mpeg3_layer_t * audio,float xr[SBLIMIT][SSLIMIT],int * scf,struct gr_info_s * gr_info,int sfreq,int part2bits)233 static int dequantize_sample(mpeg3_layer_t *audio,
234 float xr[SBLIMIT][SSLIMIT],
235 int *scf,
236 struct gr_info_s *gr_info,
237 int sfreq,
238 int part2bits)
239 {
240 int shift = 1 + gr_info->scalefac_scale;
241 float *xrpnt = (float*)xr;
242 int l[3],l3;
243 int part2remain = gr_info->part2_3_length - part2bits;
244 int *me;
245 int num = mpeg3bits_getbitoffset(audio->stream);
246 int32_t mask = mpeg3bits_getbits(audio->stream, num);
247 //printf("III_dequantize_sample 1 %08x %d\n", mask, num);
248 mask = mask << (BITSHIFT + 8 - num);
249 part2remain -= num;
250
251 {
252 int bv = gr_info->big_values;
253 int region1 = gr_info->region1start;
254 int region2 = gr_info->region2start;
255
256 l3 = ((576 >> 1) - bv) >> 1;
257
258 /*
259 * we may lose the 'odd' bit here !!
260 * check this later again
261 */
262
263 if(bv <= region1)
264 {
265 l[0] = bv;
266 l[1] = 0;
267 l[2] = 0;
268 }
269 else
270 {
271 l[0] = region1;
272 if(bv <= region2)
273 {
274 l[1] = bv - l[0]; l[2] = 0;
275 }
276 else
277 {
278 l[1] = region2 - l[0];
279 l[2] = bv - region2;
280 }
281 }
282 }
283
284 if(gr_info->block_type == 2)
285 {
286 /*
287 * decoding with short or mixed mode BandIndex table
288 */
289 int i, max[4];
290 int step = 0, lwin = 3, cb = 0;
291 register float v = 0.0;
292 register int *m, mc;
293
294 if(gr_info->mixed_block_flag)
295 {
296 max[3] = -1;
297 max[0] = max[1] = max[2] = 2;
298 m = mpeg3_map[sfreq][0];
299 me = mpeg3_mapend[sfreq][0];
300 }
301 else
302 {
303 max[0] = max[1] = max[2] = max[3] = -1;
304 /* max[3] not floatly needed in this case */
305 m = mpeg3_map[sfreq][1];
306 me = mpeg3_mapend[sfreq][1];
307 }
308
309 mc = 0;
310 for(i = 0; i < 2; i++)
311 {
312 int lp = l[i];
313 struct newhuff *h = mpeg3_ht + gr_info->table_select[i];
314 for( ; lp; lp--, mc--)
315 {
316 register int x,y;
317 if(!mc)
318 {
319 mc = *m++;
320 xrpnt = ((float*)xr) + (*m++);
321 lwin = *m++;
322 cb = *m++;
323 if(lwin == 3)
324 {
325 v = gr_info->pow2gain[(*scf++) << shift];
326 step = 1;
327 }
328 else
329 {
330 v = gr_info->full_gain[lwin][(*scf++) << shift];
331 step = 3;
332 }
333 }
334
335 {
336 register short *val = h->table;
337 REFRESH_MASK;
338 while((y = *val++) < 0)
339 {
340 if (mask < 0)
341 val -= y;
342 num--;
343 mask <<= 1;
344 }
345 x = y >> 4;
346 y &= 0xf;
347 }
348
349 if(x == 15 && h->linbits)
350 {
351 max[lwin] = cb;
352 REFRESH_MASK;
353 x += ((uint32_t)mask) >> (BITSHIFT + 8 - h->linbits);
354 num -= h->linbits + 1;
355 mask <<= h->linbits;
356 if(mask < 0)
357 *xrpnt = -mpeg3_ispow[x] * v;
358 else
359 *xrpnt = mpeg3_ispow[x] * v;
360 mask <<= 1;
361 }
362 else
363 if(x)
364 {
365 max[lwin] = cb;
366 if(mask < 0)
367 *xrpnt = -mpeg3_ispow[x] * v;
368 else
369 *xrpnt = mpeg3_ispow[x] * v;
370 num--;
371 mask <<= 1;
372 }
373 else
374 *xrpnt = 0.0;
375
376 xrpnt += step;
377 if(y == 15 && h->linbits)
378 {
379 max[lwin] = cb;
380 REFRESH_MASK;
381 y += ((uint32_t) mask) >> (BITSHIFT + 8 - h->linbits);
382 num -= h->linbits + 1;
383 mask <<= h->linbits;
384 if(mask < 0)
385 *xrpnt = -mpeg3_ispow[y] * v;
386 else
387 *xrpnt = mpeg3_ispow[y] * v;
388 mask <<= 1;
389 }
390 else
391 if(y)
392 {
393 max[lwin] = cb;
394 if(mask < 0)
395 *xrpnt = -mpeg3_ispow[y] * v;
396 else
397 *xrpnt = mpeg3_ispow[y] * v;
398 num--;
399 mask <<= 1;
400 }
401 else
402 *xrpnt = 0.0;
403 xrpnt += step;
404 }
405 }
406
407 for( ;l3 && (part2remain + num > 0); l3--)
408 {
409 struct newhuff *h = mpeg3_htc + gr_info->count1table_select;
410 register short *val = h->table, a;
411
412 REFRESH_MASK;
413 while((a = *val++) < 0)
414 {
415 if (mask < 0)
416 val -= a;
417 num--;
418 mask <<= 1;
419 }
420 if(part2remain + num <= 0)
421 {
422 num -= part2remain + num;
423 break;
424 }
425
426 for(i = 0; i < 4; i++)
427 {
428 if(!(i & 1))
429 {
430 if(!mc)
431 {
432 mc = *m++;
433 xrpnt = ((float*)xr) + (*m++);
434 lwin = *m++;
435 cb = *m++;
436 if(lwin == 3)
437 {
438 v = gr_info->pow2gain[(*scf++) << shift];
439 step = 1;
440 }
441 else
442 {
443 v = gr_info->full_gain[lwin][(*scf++) << shift];
444 step = 3;
445 }
446 }
447 mc--;
448 }
449 if((a & (0x8 >> i)))
450 {
451 max[lwin] = cb;
452 if(part2remain + num <= 0)
453 {
454 break;
455 }
456 if(mask < 0)
457 *xrpnt = -v;
458 else
459 *xrpnt = v;
460 num--;
461 mask <<= 1;
462 }
463 else
464 *xrpnt = 0.0;
465 xrpnt += step;
466 }
467 }
468
469 if(lwin < 3)
470 {
471 /* short band? */
472 while(1)
473 {
474 for( ;mc > 0; mc--)
475 {
476 /* short band -> step=3 */
477 *xrpnt = 0.0;
478 xrpnt += 3;
479 *xrpnt = 0.0;
480 xrpnt += 3;
481 }
482 if(m >= me)
483 break;
484 mc = *m++;
485 xrpnt = ((float*)xr) + *m++;
486 /* optimize: field will be set to zero at the end of the function */
487 if(*m++ == 0)
488 break;
489 /* cb */
490 m++;
491 }
492 }
493
494 gr_info->maxband[0] = max[0] + 1;
495 gr_info->maxband[1] = max[1] + 1;
496 gr_info->maxband[2] = max[2] + 1;
497 gr_info->maxbandl = max[3] + 1;
498
499 {
500 int rmax = max[0] > max[1] ? max[0] : max[1];
501 rmax = (rmax > max[2] ? rmax : max[2]) + 1;
502 gr_info->maxb = rmax ? mpeg3_shortLimit[sfreq][rmax] : mpeg3_longLimit[sfreq][max[3] + 1];
503 }
504
505 }
506 else
507 {
508 /*
509 * decoding with 'long' BandIndex table (block_type != 2)
510 */
511 int *pretab = gr_info->preflag ? pretab1 : pretab2;
512 int i, max = -1;
513 int cb = 0;
514 int *m = mpeg3_map[sfreq][2];
515 register float v = 0.0;
516 int mc = 0;
517
518 /*
519 * long hash table values
520 */
521 for(i = 0; i < 3; i++)
522 {
523 int lp = l[i];
524 struct newhuff *h = mpeg3_ht + gr_info->table_select[i];
525
526 for(; lp; lp--, mc--)
527 {
528 int x, y;
529
530 if(!mc)
531 {
532 mc = *m++;
533 cb = *m++;
534 if(cb == 21)
535 v = 0.0;
536 else
537 v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
538 }
539 {
540 register short *val = h->table;
541 REFRESH_MASK;
542 while((y = *val++) < 0)
543 {
544 if(mask < 0)
545 val -= y;
546 num--;
547 mask <<= 1;
548 }
549 x = y >> 4;
550 y &= 0xf;
551 }
552
553 if(x == 15 && h->linbits)
554 {
555 max = cb;
556 REFRESH_MASK;
557 x += ((uint32_t) mask) >> (BITSHIFT + 8 - h->linbits);
558 num -= h->linbits + 1;
559 mask <<= h->linbits;
560 if(mask < 0)
561 *xrpnt++ = -mpeg3_ispow[x] * v;
562 else
563 *xrpnt++ = mpeg3_ispow[x] * v;
564 mask <<= 1;
565 }
566 else
567 if(x)
568 {
569 max = cb;
570 if(mask < 0)
571 *xrpnt++ = -mpeg3_ispow[x] * v;
572 else
573 *xrpnt++ = mpeg3_ispow[x] * v;
574 num--;
575 mask <<= 1;
576 }
577 else
578 *xrpnt++ = 0.0;
579
580 if(y == 15 && h->linbits)
581 {
582 max = cb;
583 REFRESH_MASK;
584 y += ((uint32_t) mask) >> (BITSHIFT + 8 - h->linbits);
585 num -= h->linbits + 1;
586 mask <<= h->linbits;
587 if(mask < 0)
588 *xrpnt++ = -mpeg3_ispow[y] * v;
589 else
590 *xrpnt++ = mpeg3_ispow[y] * v;
591 mask <<= 1;
592 }
593 else
594 if(y)
595 {
596 max = cb;
597 if(mask < 0)
598 *xrpnt++ = -mpeg3_ispow[y] * v;
599 else
600 *xrpnt++ = mpeg3_ispow[y] * v;
601 num--;
602 mask <<= 1;
603 }
604 else
605 *xrpnt++ = 0.0;
606 }
607 }
608
609 /*
610 * short (count1table) values
611 */
612 for( ; l3 && (part2remain + num > 0); l3--)
613 {
614 struct newhuff *h = mpeg3_htc + gr_info->count1table_select;
615 register short *val = h->table, a;
616
617 REFRESH_MASK;
618 while((a = *val++) < 0)
619 {
620 if(mask < 0)
621 val -= a;
622 num--;
623 mask <<= 1;
624 }
625 if(part2remain + num <= 0)
626 {
627 num -= part2remain + num;
628 break;
629 }
630
631 for(i = 0; i < 4; i++)
632 {
633 if(!(i & 1))
634 {
635 if(!mc)
636 {
637 mc = *m++;
638 cb = *m++;
639 if(cb == 21)
640 v = 0.0;
641 else
642 v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift];
643 }
644 mc--;
645 }
646 if((a & (0x8 >> i)))
647 {
648 max = cb;
649 if(part2remain + num <= 0)
650 {
651 break;
652 }
653 if(mask < 0)
654 *xrpnt++ = -v;
655 else
656 *xrpnt++ = v;
657 num--;
658 mask <<= 1;
659 }
660 else
661 *xrpnt++ = 0.0;
662 }
663 }
664
665 gr_info->maxbandl = max + 1;
666 gr_info->maxb = mpeg3_longLimit[sfreq][gr_info->maxbandl];
667 }
668
669 part2remain += num;
670
671 //
672 mpeg3bits_start_reverse(audio->stream);
673 mpeg3bits_getbits_reverse(audio->stream, num);
674 mpeg3bits_start_forward(audio->stream);
675 //printf("III_dequantize_sample 3 %d %04x\n", audio->stream->bit_number, mpeg3bits_showbits(audio->stream, 16));
676 num = 0;
677
678 while(xrpnt < &xr[SBLIMIT][0])
679 *xrpnt++ = 0.0;
680
681 while(part2remain > 16)
682 {
683 mpeg3bits_getbits(audio->stream, 16); /* Dismiss stuffing Bits */
684 part2remain -= 16;
685 }
686
687 if(part2remain > 0)
688 {
689 mpeg3bits_getbits(audio->stream, part2remain);
690 }
691 else
692 if(part2remain < 0)
693 {
694 printf("dequantize_sample: can't rewind stream %d bits! data=%02x%02x%02x%02x\n",
695 -part2remain,
696 (unsigned char)audio->stream->input_ptr[-3],
697 (unsigned char)audio->stream->input_ptr[-2],
698 (unsigned char)audio->stream->input_ptr[-1],
699 (unsigned char)audio->stream->input_ptr[0]);
700 return 1; /* -> error */
701 }
702 return 0;
703 }
704
get_side_info(mpeg3_layer_t * audio,struct sideinfo_s * si,int channels,int ms_stereo,long sfreq,int single,int lsf)705 static int get_side_info(mpeg3_layer_t *audio,
706 struct sideinfo_s *si,
707 int channels,
708 int ms_stereo,
709 long sfreq,
710 int single,
711 int lsf)
712 {
713 int ch, gr;
714 int powdiff = (single == 3) ? 4 : 0;
715 static const int tabs[2][5] = { { 2,9,5,3,4 } , { 1,8,1,2,9 } };
716 const int *tab = tabs[lsf];
717
718 si->main_data_begin = mpeg3bits_getbits(audio->stream, tab[1]);
719 if(channels == 1)
720 si->private_bits = mpeg3bits_getbits(audio->stream, tab[2]);
721 else
722 si->private_bits = mpeg3bits_getbits(audio->stream, tab[3]);
723 if(!lsf)
724 {
725 for(ch = 0; ch < channels; ch++)
726 {
727 si->ch[ch].gr[0].scfsi = -1;
728 si->ch[ch].gr[1].scfsi = mpeg3bits_getbits(audio->stream, 4);
729 }
730 }
731
732 for(gr = 0; gr < tab[0]; gr++)
733 {
734 for(ch = 0; ch < channels; ch++)
735 {
736 register struct gr_info_s *gr_info = &(si->ch[ch].gr[gr]);
737
738 gr_info->part2_3_length = mpeg3bits_getbits(audio->stream, 12);
739 gr_info->big_values = mpeg3bits_getbits(audio->stream, 9);
740 if(gr_info->big_values > 288)
741 {
742 fprintf(stderr,"get_side_info: big_values too large!\n");
743 gr_info->big_values = 288;
744 }
745 gr_info->pow2gain = mpeg3_gainpow2 + 256 - mpeg3bits_getbits(audio->stream, 8) + powdiff;
746 if(ms_stereo)
747 gr_info->pow2gain += 2;
748 gr_info->scalefac_compress = mpeg3bits_getbits(audio->stream, tab[4]);
749
750 if(mpeg3bits_getbits(audio->stream, 1))
751 {
752 /* window switch flag */
753 int i;
754 gr_info->block_type = mpeg3bits_getbits(audio->stream, 2);
755 gr_info->mixed_block_flag = mpeg3bits_getbits(audio->stream, 1);
756 gr_info->table_select[0] = mpeg3bits_getbits(audio->stream, 5);
757 gr_info->table_select[1] = mpeg3bits_getbits(audio->stream, 5);
758 /*
759 * table_select[2] not needed, because there is no region2,
760 * but to satisfy some verifications tools we set it either.
761 */
762 gr_info->table_select[2] = 0;
763 for(i = 0; i < 3; i++)
764 gr_info->full_gain[i] = gr_info->pow2gain + (mpeg3bits_getbits(audio->stream, 3) << 3);
765
766 if(gr_info->block_type == 0)
767 {
768 fprintf(stderr,"Blocktype == 0 and window-switching == 1 not allowed.\n");
769 return 1;
770 }
771
772 /* region_count/start parameters are implicit in this case. */
773 if(!lsf || gr_info->block_type == 2)
774 gr_info->region1start = 36 >> 1;
775 else
776 {
777 /* check this again for 2.5 and sfreq=8 */
778 if(sfreq == 8)
779 gr_info->region1start = 108 >> 1;
780 else
781 gr_info->region1start = 54 >> 1;
782 }
783 gr_info->region2start = 576 >> 1;
784 }
785 else
786 {
787 int i, r0c, r1c;
788 for(i = 0; i < 3; i++)
789 gr_info->table_select[i] = mpeg3bits_getbits(audio->stream, 5);
790
791 r0c = mpeg3bits_getbits(audio->stream, 4);
792 r1c = mpeg3bits_getbits(audio->stream, 3);
793 gr_info->region1start = mpeg3_bandInfo[sfreq].longIdx[r0c + 1] >> 1 ;
794 gr_info->region2start = mpeg3_bandInfo[sfreq].longIdx[r0c + 1 + r1c + 1] >> 1;
795 gr_info->block_type = 0;
796 gr_info->mixed_block_flag = 0;
797 }
798 if(!lsf) gr_info->preflag = mpeg3bits_getbits(audio->stream, 1);
799 gr_info->scalefac_scale = mpeg3bits_getbits(audio->stream, 1);
800 gr_info->count1table_select = mpeg3bits_getbits(audio->stream, 1);
801 }
802 }
803 return 0;
804 }
805
hybrid(mpeg3_layer_t * audio,float fsIn[SBLIMIT][SSLIMIT],float tsOut[SSLIMIT][SBLIMIT],int ch,struct gr_info_s * gr_info)806 static int hybrid(mpeg3_layer_t *audio,
807 float fsIn[SBLIMIT][SSLIMIT],
808 float tsOut[SSLIMIT][SBLIMIT],
809 int ch,
810 struct gr_info_s *gr_info)
811 {
812 float *tspnt = (float *) tsOut;
813 float *rawout1,*rawout2;
814 int bt, sb = 0;
815
816
817 {
818 int b = audio->mp3_blc[ch];
819 rawout1 = audio->mp3_block[b][ch];
820 b = -b + 1;
821 rawout2 = audio->mp3_block[b][ch];
822 audio->mp3_blc[ch] = b;
823 }
824
825 if(gr_info->mixed_block_flag)
826 {
827 sb = 2;
828 mpeg3audio_dct36(fsIn[0], rawout1, rawout2, mpeg3_win[0], tspnt);
829 mpeg3audio_dct36(fsIn[1], rawout1 + 18, rawout2 + 18, mpeg3_win1[0], tspnt + 1);
830 rawout1 += 36;
831 rawout2 += 36;
832 tspnt += 2;
833 }
834
835 bt = gr_info->block_type;
836 if(bt == 2)
837 {
838 for( ; sb < gr_info->maxb; sb += 2, tspnt += 2, rawout1 += 36, rawout2 += 36)
839 {
840 mpeg3audio_dct12(fsIn[sb] ,rawout1 ,rawout2 ,mpeg3_win[2] ,tspnt);
841 mpeg3audio_dct12(fsIn[sb + 1], rawout1 + 18, rawout2 + 18, mpeg3_win1[2], tspnt + 1);
842 }
843 }
844 else
845 {
846 for( ; sb < gr_info->maxb; sb += 2, tspnt += 2, rawout1 += 36, rawout2 += 36)
847 {
848 mpeg3audio_dct36(fsIn[sb], rawout1, rawout2, mpeg3_win[bt], tspnt);
849 mpeg3audio_dct36(fsIn[sb + 1], rawout1 + 18, rawout2 + 18, mpeg3_win1[bt], tspnt + 1);
850 }
851 }
852
853 for( ; sb < SBLIMIT; sb++, tspnt++)
854 {
855 int i;
856 for(i = 0; i < SSLIMIT; i++)
857 {
858 tspnt[i * SBLIMIT] = *rawout1++;
859 *rawout2++ = 0.0;
860 }
861 }
862 return 0;
863 }
864
antialias(mpeg3_layer_t * audio,float xr[SBLIMIT][SSLIMIT],struct gr_info_s * gr_info)865 static int antialias(mpeg3_layer_t *audio,
866 float xr[SBLIMIT][SSLIMIT],
867 struct gr_info_s *gr_info)
868 {
869 int sblim;
870
871 if(gr_info->block_type == 2)
872 {
873 if(!gr_info->mixed_block_flag)
874 return 0;
875 sblim = 1;
876 }
877 else
878 {
879 sblim = gr_info->maxb-1;
880 }
881
882 /* 31 alias-reduction operations between each pair of sub-bands */
883 /* with 8 butterflies between each pair */
884
885 {
886 int sb;
887 float *xr1 = (float*)xr[1];
888
889 for(sb = sblim; sb; sb--, xr1 += 10)
890 {
891 int ss;
892 float *cs, *ca;
893 float *xr2;
894 cs = mpeg3_aa_cs;
895 ca = mpeg3_aa_ca;
896 xr2 = xr1;
897
898 for(ss = 7; ss >= 0; ss--)
899 {
900 /* upper and lower butterfly inputs */
901 register float bu, bd;
902 bu = *--xr2;
903 bd = *xr1;
904 *xr2 = (bu * (*cs) ) - (bd * (*ca) );
905 *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) );
906 }
907 }
908 }
909 return 0;
910 }
911
912 /*
913 * III_stereo: calculate float channel values for Joint-I-Stereo-mode
914 */
calc_i_stereo(mpeg3_layer_t * audio,float xr_buf[2][SBLIMIT][SSLIMIT],int * scalefac,struct gr_info_s * gr_info,int sfreq,int ms_stereo,int lsf)915 static int calc_i_stereo(mpeg3_layer_t *audio,
916 float xr_buf[2][SBLIMIT][SSLIMIT],
917 int *scalefac,
918 struct gr_info_s *gr_info,
919 int sfreq,
920 int ms_stereo,
921 int lsf)
922 {
923 float (*xr)[SBLIMIT*SSLIMIT] = (float (*)[SBLIMIT*SSLIMIT] ) xr_buf;
924 struct mpeg3_bandInfoStruct *bi = &mpeg3_bandInfo[sfreq];
925 const float *tab1, *tab2;
926
927 int tab;
928 /* TODO: optimize as static */
929 static const float *tabs[3][2][2] =
930 {
931 { { mpeg3_tan1_1, mpeg3_tan2_1 } , { mpeg3_tan1_2, mpeg3_tan2_2 } },
932 { { mpeg3_pow1_1[0], mpeg3_pow2_1[0] } , { mpeg3_pow1_2[0], mpeg3_pow2_2[0] } } ,
933 { { mpeg3_pow1_1[1], mpeg3_pow2_1[1] } , { mpeg3_pow1_2[1], mpeg3_pow2_2[1] } }
934 };
935
936 tab = lsf + (gr_info->scalefac_compress & lsf);
937 tab1 = tabs[tab][ms_stereo][0];
938 tab2 = tabs[tab][ms_stereo][1];
939
940 if(gr_info->block_type == 2)
941 {
942 int lwin,do_l = 0;
943 if(gr_info->mixed_block_flag)
944 do_l = 1;
945
946 for(lwin = 0; lwin < 3; lwin++)
947 {
948 /* process each window */
949 /* get first band with zero values */
950 /* sfb is minimal 3 for mixed mode */
951 int is_p, sb, idx, sfb = gr_info->maxband[lwin];
952 if(sfb > 3) do_l = 0;
953
954 for( ; sfb < 12 ; sfb++)
955 {
956 /* scale: 0-15 */
957 is_p = scalefac[sfb * 3 + lwin - gr_info->mixed_block_flag];
958 if(is_p != 7)
959 {
960 float t1, t2;
961 sb = bi->shortDiff[sfb];
962 idx = bi->shortIdx[sfb] + lwin;
963 t1 = tab1[is_p];
964 t2 = tab2[is_p];
965 for( ; sb > 0; sb--, idx += 3)
966 {
967 float v = xr[0][idx];
968 xr[0][idx] = v * t1;
969 xr[1][idx] = v * t2;
970 }
971 }
972 }
973
974 /* in the original: copy 10 to 11 , here: copy 11 to 12 maybe still wrong??? (copy 12 to 13?) */
975 /* scale: 0-15 */
976 is_p = scalefac[11 * 3 + lwin - gr_info->mixed_block_flag];
977 sb = bi->shortDiff[12];
978 idx = bi->shortIdx[12] + lwin;
979 if(is_p != 7)
980 {
981 float t1, t2;
982 t1 = tab1[is_p];
983 t2 = tab2[is_p];
984 for( ; sb > 0; sb--, idx += 3)
985 {
986 float v = xr[0][idx];
987 xr[0][idx] = v * t1;
988 xr[1][idx] = v * t2;
989 }
990 }
991 } /* end for(lwin; .. ; . ) */
992
993 /* also check l-part, if ALL bands in the three windows are 'empty'
994 * and mode = mixed_mode
995 */
996 if(do_l)
997 {
998 int sfb = gr_info->maxbandl;
999 int idx = bi->longIdx[sfb];
1000
1001 for ( ; sfb < 8; sfb++)
1002 {
1003 int sb = bi->longDiff[sfb];
1004 /* scale: 0-15 */
1005 int is_p = scalefac[sfb];
1006 if(is_p != 7)
1007 {
1008 float t1, t2;
1009 t1 = tab1[is_p];
1010 t2 = tab2[is_p];
1011 for( ; sb > 0; sb--, idx++)
1012 {
1013 float v = xr[0][idx];
1014 xr[0][idx] = v * t1;
1015 xr[1][idx] = v * t2;
1016 }
1017 }
1018 else
1019 idx += sb;
1020 }
1021 }
1022 }
1023 else
1024 {
1025 /* ((gr_info->block_type != 2)) */
1026 int sfb = gr_info->maxbandl;
1027 int is_p, idx = bi->longIdx[sfb];
1028 for( ; sfb < 21; sfb++)
1029 {
1030 int sb = bi->longDiff[sfb];
1031 /* scale: 0-15 */
1032 is_p = scalefac[sfb];
1033 if(is_p != 7)
1034 {
1035 float t1, t2;
1036 t1 = tab1[is_p];
1037 t2 = tab2[is_p];
1038 for( ; sb > 0; sb--, idx++)
1039 {
1040 float v = xr[0][idx];
1041 xr[0][idx] = v * t1;
1042 xr[1][idx] = v * t2;
1043 }
1044 }
1045 else
1046 idx += sb;
1047 }
1048
1049 is_p = scalefac[20];
1050 if(is_p != 7)
1051 {
1052 /* copy l-band 20 to l-band 21 */
1053 int sb;
1054 float t1 = tab1[is_p], t2 = tab2[is_p];
1055
1056 for(sb = bi->longDiff[21]; sb > 0; sb--, idx++)
1057 {
1058 float v = xr[0][idx];
1059 xr[0][idx] = v * t1;
1060 xr[1][idx] = v * t2;
1061 }
1062 }
1063 } /* ... */
1064 return 0;
1065 }
1066
mpeg3audio_dolayer3(mpeg3_layer_t * audio,char * frame,int frame_size,float ** output,int render)1067 int mpeg3audio_dolayer3(mpeg3_layer_t *audio,
1068 char *frame,
1069 int frame_size,
1070 float **output,
1071 int render)
1072 {
1073 int gr, ch, ss;
1074 /* max 39 for short[13][3] mode, mixed: 38, long: 22 */
1075 int scalefacs[2][39];
1076 struct sideinfo_s sideinfo;
1077 int single = audio->single;
1078 int ms_stereo, i_stereo;
1079 int sfreq = audio->sampling_frequency_code;
1080 int stereo1, granules;
1081 int i;
1082 int output_offset = 0;
1083
1084 //printf("mpeg3audio_dolayer3 1\n");
1085 // Skip header
1086 frame += 4;
1087 frame_size -= 4;
1088
1089 /* flip/init buffer */
1090 audio->bsbufold = audio->bsbuf;
1091 audio->bsbuf = audio->bsspace[audio->bsnum] + 512;
1092 audio->bsnum ^= 1;
1093
1094 /* Copy frame into history buffer */
1095 memcpy(audio->bsbuf, frame, frame_size);
1096
1097 /*
1098 * printf(__FUNCTION__ " %d %02x%02x%02x%02x\n",
1099 * audio->first_frame,
1100 * (unsigned char)audio->bsbuf[0],
1101 * (unsigned char)audio->bsbuf[1],
1102 * (unsigned char)audio->bsbuf[2],
1103 * (unsigned char)audio->bsbuf[3]);
1104 */
1105
1106
1107 if(!audio->first_frame)
1108 {
1109 /* Set up bitstream to use buffer */
1110 mpeg3bits_use_ptr(audio->stream, audio->bsbuf);
1111
1112 //printf(__FUNCTION__ " 4\n");
1113 //printf(__FUNCTION__ " 7 %x\n", mpeg3bits_showbits(audio->stream, 16));
1114 /* CRC must be skipped here for proper alignment with the backstep */
1115 if(audio->error_protection)
1116 mpeg3bits_getbits(audio->stream, 16);
1117 //printf(__FUNCTION__ " 8 %x\n", mpeg3bits_showbits(audio->stream, 16));
1118 //printf(__FUNCTION__ " 5\n");
1119
1120 if(audio->channels == 1)
1121 {
1122 /* stream is mono */
1123 stereo1 = 1;
1124 single = 0;
1125 }
1126 else
1127 {
1128 /* Stereo */
1129 stereo1 = 2;
1130 }
1131
1132 if(audio->mode == MPG_MD_JOINT_STEREO)
1133 {
1134 ms_stereo = (audio->mode_ext & 0x2) >> 1;
1135 i_stereo = audio->mode_ext & 0x1;
1136 }
1137 else
1138 ms_stereo = i_stereo = 0;
1139
1140 if(audio->lsf)
1141 {
1142 granules = 1;
1143 }
1144 else
1145 {
1146 granules = 2;
1147 }
1148 //printf(__FUNCTION__ " 6\n");
1149
1150 if(get_side_info(audio,
1151 &sideinfo,
1152 audio->channels,
1153 ms_stereo,
1154 sfreq,
1155 single,
1156 audio->lsf))
1157 {
1158 mpeg3_layer_reset(audio);
1159 return output_offset;
1160 }
1161
1162 //printf(__FUNCTION__ " 7\n");
1163 /* Step back */
1164 if(sideinfo.main_data_begin >= 512)
1165 {
1166 return output_offset;
1167 }
1168
1169 if(sideinfo.main_data_begin)
1170 {
1171 /*
1172 * printf(__FUNCTION__ " 7 %d %d %d\n",
1173 * audio->ssize,
1174 * sideinfo.main_data_begin,
1175 * audio->prev_framesize);
1176 */
1177 memcpy(audio->bsbuf + audio->ssize - sideinfo.main_data_begin,
1178 audio->bsbufold + audio->prev_framesize - sideinfo.main_data_begin,
1179 sideinfo.main_data_begin);
1180 mpeg3bits_use_ptr(audio->stream,
1181 audio->bsbuf + audio->ssize - sideinfo.main_data_begin);
1182 }
1183
1184
1185 for(gr = 0; gr < granules; gr++)
1186 {
1187 float hybridIn [2][SBLIMIT][SSLIMIT];
1188 float hybridOut[2][SSLIMIT][SBLIMIT];
1189
1190 {
1191 struct gr_info_s *gr_info = &(sideinfo.ch[0].gr[gr]);
1192 int32_t part2bits;
1193 if(audio->lsf)
1194 part2bits = get_scale_factors_2(audio, scalefacs[0], gr_info, 0);
1195 else
1196 part2bits = get_scale_factors_1(audio, scalefacs[0], gr_info, 0, gr);
1197 //printf("dolayer3 4 %04x\n", mpeg3bits_showbits(audio->stream, 16));
1198
1199 if(dequantize_sample(audio,
1200 hybridIn[0],
1201 scalefacs[0],
1202 gr_info,
1203 sfreq,
1204 part2bits))
1205 {
1206 mpeg3_layer_reset(audio);
1207 return output_offset;
1208 }
1209 //printf("dolayer3 5 %04x\n", mpeg3bits_showbits(audio->stream, 16));
1210 }
1211
1212 if(audio->channels == 2)
1213 {
1214 struct gr_info_s *gr_info = &(sideinfo.ch[1].gr[gr]);
1215 int32_t part2bits;
1216 if(audio->lsf)
1217 part2bits = get_scale_factors_2(audio, scalefacs[1], gr_info, i_stereo);
1218 else
1219 part2bits = get_scale_factors_1(audio, scalefacs[1], gr_info, 1, gr);
1220
1221 if(dequantize_sample(audio,
1222 hybridIn[1],
1223 scalefacs[1],
1224 gr_info,
1225 sfreq,
1226 part2bits))
1227 {
1228 mpeg3_layer_reset(audio);
1229 return output_offset;
1230 }
1231
1232 if(ms_stereo)
1233 {
1234 int i;
1235 int maxb = sideinfo.ch[0].gr[gr].maxb;
1236 if(sideinfo.ch[1].gr[gr].maxb > maxb)
1237 maxb = sideinfo.ch[1].gr[gr].maxb;
1238 for(i = 0; i < SSLIMIT * maxb; i++)
1239 {
1240 float tmp0 = ((float*)hybridIn[0])[i];
1241 float tmp1 = ((float*)hybridIn[1])[i];
1242 ((float*)hybridIn[0])[i] = tmp0 + tmp1;
1243 ((float*)hybridIn[1])[i] = tmp0 - tmp1;
1244 }
1245 }
1246
1247 if(i_stereo)
1248 calc_i_stereo(audio, hybridIn, scalefacs[1], gr_info, sfreq, ms_stereo, audio->lsf);
1249
1250 if(ms_stereo || i_stereo || (single == 3))
1251 {
1252 if(gr_info->maxb > sideinfo.ch[0].gr[gr].maxb)
1253 sideinfo.ch[0].gr[gr].maxb = gr_info->maxb;
1254 else
1255 gr_info->maxb = sideinfo.ch[0].gr[gr].maxb;
1256 }
1257
1258 switch(single)
1259 {
1260 case 3:
1261 {
1262 register int i;
1263 register float *in0 = (float*)hybridIn[0], *in1 = (float*)hybridIn[1];
1264 /* *0.5 done by pow-scale */
1265 for(i = 0; i < SSLIMIT * gr_info->maxb; i++, in0++)
1266 *in0 = (*in0 + *in1++);
1267 }
1268 break;
1269 case 1:
1270 {
1271 register int i;
1272 register float *in0 = (float*)hybridIn[0], *in1 = (float*)hybridIn[1];
1273 for(i = 0; i < SSLIMIT * gr_info->maxb; i++)
1274 *in0++ = *in1++;
1275 }
1276 break;
1277 }
1278 }
1279 //printf(__FUNCTION__ " 9\n");
1280
1281 for(ch = 0; ch < stereo1; ch++)
1282 {
1283 struct gr_info_s *gr_info = &(sideinfo.ch[ch].gr[gr]);
1284 //printf(__FUNCTION__ " 9.1\n");
1285 antialias(audio, hybridIn[ch], gr_info);
1286 //printf(__FUNCTION__ " 9.2\n");
1287 hybrid(audio, hybridIn[ch], hybridOut[ch], ch, gr_info);
1288 //printf(__FUNCTION__ " 9.3\n");
1289 }
1290
1291 //printf(__FUNCTION__ " 10\n");
1292
1293
1294 for(ss = 0; ss < SSLIMIT; ss++)
1295 {
1296 if(single >= 0)
1297 {
1298 if(render)
1299 mpeg3audio_synth_stereo(audio,
1300 hybridOut[0][ss],
1301 0,
1302 output[0],
1303 &(output_offset));
1304 else
1305 output_offset += 32;
1306 }
1307 else
1308 {
1309 int p1 = output_offset;
1310 if(render)
1311 {
1312 mpeg3audio_synth_stereo(audio,
1313 hybridOut[0][ss],
1314 0,
1315 output[0],
1316 &p1);
1317 mpeg3audio_synth_stereo(audio,
1318 hybridOut[1][ss],
1319 1,
1320 output[1],
1321 &(output_offset));
1322 }
1323 else
1324 output_offset += 32;
1325 }
1326 }
1327 }
1328 }
1329 else
1330 {
1331 audio->first_frame = 0;
1332 }
1333
1334 //printf(__FUNCTION__ " 12\n");
1335
1336
1337 return output_offset;
1338 }
1339
1340
1341
1342
1343
1344
1345
mpeg3_layer_reset(mpeg3_layer_t * audio)1346 void mpeg3_layer_reset(mpeg3_layer_t *audio)
1347 {
1348 //printf("mpeg3_layer_reset 1\n");
1349 audio->first_frame = 1;
1350 // audio->prev_framesize = 0;
1351 // bzero(audio->bsspace, sizeof(audio->bsspace));
1352 bzero(audio->mp3_block, sizeof(audio->mp3_block));
1353 bzero(audio->mp3_blc, sizeof(audio->mp3_blc));
1354 mpeg3audio_reset_synths(audio);
1355 }
1356
1357
1358
1359
1360
1361
1362 /* Return 1 if the head check doesn't find a header. */
mpeg3_layer_check(unsigned char * data)1363 int mpeg3_layer_check(unsigned char *data)
1364 {
1365 uint32_t head = ((uint32_t)(data[0] << 24)) |
1366 ((uint32_t)(data[1] << 16)) |
1367 ((uint32_t)(data[2] << 8)) |
1368 ((uint32_t)data[3]);
1369
1370
1371 if((head & 0xffe00000) != 0xffe00000) return 1;
1372
1373 if(!((head >> 17) & 3)) return 1;
1374
1375 if(((head >> 12) & 0xf) == 0xf) return 1;
1376
1377 if(!((head >> 12) & 0xf)) return 1;
1378
1379 if(((head >> 10) & 0x3) == 0x3 ) return 1;
1380
1381 if(((head >> 19) & 1) == 1 && ((head >> 17) & 3) == 3 && ((head >> 16) & 1) == 1)
1382 return 1;
1383
1384 if((head & 0xffff0000) == 0xfffe0000) return 1;
1385 // JPEG header
1386 if((head & 0xffff0000) == 0xffed0000) return 1;
1387
1388 return 0;
1389 }
1390
1391
1392 /* Decode layer header */
mpeg3_layer_header(mpeg3_layer_t * layer_data,unsigned char * data)1393 int mpeg3_layer_header(mpeg3_layer_t *layer_data, unsigned char *data)
1394 {
1395 uint32_t header;
1396 int sampling_frequency_code;
1397 int layer;
1398 int lsf;
1399 int mpeg35;
1400 int channels;
1401 int mode;
1402
1403
1404 // ID3 tag
1405 switch(layer_data->id3_state)
1406 {
1407 case MPEG3_ID3_IDLE:
1408 if(data[0] == 0x49 &&
1409 data[1] == 0x44 &&
1410 data[2] == 0x33)
1411 {
1412 // Read header
1413 layer_data->id3_state = MPEG3_ID3_HEADER;
1414 layer_data->id3_current_byte = 0;
1415 return 0;
1416 }
1417 break;
1418
1419 case MPEG3_ID3_HEADER:
1420 layer_data->id3_current_byte++;
1421 if(layer_data->id3_current_byte >= 6)
1422 {
1423 layer_data->id3_size = (data[0] << 21) |
1424 (data[1] << 14) |
1425 (data[2] << 7) |
1426 (data[3]);
1427 layer_data->id3_current_byte = 0;
1428 layer_data->id3_state = MPEG3_ID3_SKIP;
1429
1430 /*
1431 * printf("mpeg3_layer_header %d %02x%02x%02x%02x size=0x%x layer_data->layer=%d\n",
1432 * __LINE__,
1433 * data[0],
1434 * data[1],
1435 * data[2],
1436 * data[3],
1437 * layer_data->id3_size,
1438 * layer_data->layer);
1439 */
1440
1441 }
1442 return 0;
1443 break;
1444
1445 case MPEG3_ID3_SKIP:
1446
1447
1448 /*
1449 * printf("mpeg3_layer_header %d layer_data->id3_current_byte=0x%x %02x%02x%02x%02x\n",
1450 * __LINE__,
1451 * layer_data->id3_current_byte,
1452 * data[0],
1453 * data[1],
1454 * data[2],
1455 * data[3]);
1456 */
1457
1458
1459 layer_data->id3_current_byte++;
1460 if(layer_data->id3_current_byte >= layer_data->id3_size)
1461 layer_data->id3_state = MPEG3_ID3_IDLE;
1462 return 0;
1463 break;
1464 }
1465
1466 if(mpeg3_layer_check(data))
1467 {
1468 return 0;
1469 }
1470
1471
1472
1473 // printf("mpeg3_layer_header %d layer_data->id3_state=%d %02x%02x%02x%02x\n",
1474 // __LINE__,
1475 // layer_data->id3_state,
1476 // data[0],
1477 // data[1],
1478 // data[2],
1479 // data[3]);
1480
1481
1482 header = (data[0] << 24) |
1483 (data[1] << 16) |
1484 (data[2] << 8) |
1485 data[3];
1486 if(header & (1 << 20))
1487 {
1488 lsf = (header & (1 << 19)) ? 0x0 : 0x1;
1489 mpeg35 = 0;
1490 }
1491 else
1492 {
1493 lsf = 1;
1494 mpeg35 = 1;
1495 }
1496
1497 layer = 4 - ((header >> 17) & 3);
1498
1499 //printf("mpeg3_layer_header 1 %d header=%08x layer=%d layer_data->layer=%d\n", __LINE__, header, layer, layer_data->layer);
1500 if(layer_data->layer != 0 &&
1501 layer != layer_data->layer)
1502 {
1503 return 0;
1504 }
1505
1506 if(mpeg35)
1507 sampling_frequency_code = 6 + ((header >> 10) & 0x3);
1508 else
1509 sampling_frequency_code = ((header >> 10) & 0x3) + (lsf * 3);
1510
1511
1512 if(layer_data->samplerate != 0 &&
1513 sampling_frequency_code != layer_data->sampling_frequency_code)
1514 {
1515 return 0;
1516 }
1517
1518 mode = ((header >> 6) & 0x3);
1519 channels = (mode == MPG_MD_MONO) ? 1 : 2;
1520 /*
1521 * if(layer_data->channels < 0)
1522 * else
1523 * if(layer_data->channels != channels)
1524 * return 0;
1525 */
1526
1527
1528 // if(channels > layer_data->channels)
1529 // layer_data->channels = channels;
1530 layer_data->channels = channels;
1531 layer_data->layer = layer;
1532 layer_data->lsf = lsf;
1533 layer_data->mpeg35 = mpeg35;
1534 layer_data->mode = mode;
1535 layer_data->sampling_frequency_code = sampling_frequency_code;
1536 layer_data->samplerate = mpeg3_freqs[layer_data->sampling_frequency_code];
1537 layer_data->error_protection = ((header >> 16) & 0x1) ^ 0x1;
1538
1539 layer_data->bitrate_index = ((header >> 12) & 0xf);
1540 layer_data->padding = ((header >> 9) & 0x1);
1541 layer_data->extension = ((header >> 8) & 0x1);
1542 layer_data->mode_ext = ((header >> 4) & 0x3);
1543 layer_data->copyright = ((header >> 3) & 0x1);
1544 layer_data->original = ((header >> 2) & 0x1);
1545 layer_data->emphasis = header & 0x3;
1546 if(layer_data->channels > 1)
1547 layer_data->single = -1;
1548 else
1549 layer_data->single = 3;
1550
1551 if(!layer_data->bitrate_index) return 0;
1552 layer_data->bitrate = 1000 * mpeg3_tabsel_123[layer_data->lsf][layer_data->layer - 1][layer_data->bitrate_index];
1553
1554 layer_data->prev_framesize = layer_data->framesize - 4;
1555 switch(layer_data->layer)
1556 {
1557 case 1:
1558 layer_data->framesize = (long)mpeg3_tabsel_123[layer_data->lsf][0][layer_data->bitrate_index] * 12000;
1559 layer_data->framesize /= mpeg3_freqs[layer_data->sampling_frequency_code];
1560 layer_data->framesize = ((layer_data->framesize + layer_data->padding) << 2);
1561 break;
1562 case 2:
1563 layer_data->framesize = (long)mpeg3_tabsel_123[layer_data->lsf][1][layer_data->bitrate_index] * 144000;
1564 layer_data->framesize /= mpeg3_freqs[layer_data->sampling_frequency_code];
1565 layer_data->framesize += layer_data->padding;
1566 break;
1567 case 3:
1568 if(layer_data->lsf)
1569 layer_data->ssize = (layer_data->channels == 1) ? 9 : 17;
1570 else
1571 layer_data->ssize = (layer_data->channels == 1) ? 17 : 32;
1572 if(layer_data->error_protection)
1573 layer_data->ssize += 2;
1574 layer_data->framesize = (long)mpeg3_tabsel_123[layer_data->lsf][2][layer_data->bitrate_index] * 144000;
1575 layer_data->framesize /= mpeg3_freqs[layer_data->sampling_frequency_code] << (layer_data->lsf);
1576 layer_data->framesize = layer_data->framesize + layer_data->padding;
1577 break;
1578 default:
1579 return 0;
1580 }
1581
1582
1583
1584
1585 /*
1586 * printf("mpeg3_layer_header %d bitrate=%d framesize=%d samplerate=%d channels=%d layer=%d\n",
1587 * __LINE__,
1588 * layer_data->bitrate,
1589 * layer_data->framesize,
1590 * layer_data->samplerate,
1591 * layer_data->channels,
1592 * layer_data->layer);
1593 */
1594
1595
1596
1597 if(layer_data->bitrate < 64000 && layer_data->layer != 3) return 0;
1598 if(layer_data->framesize > MAXFRAMESIZE) return 0;
1599 //printf("mpeg3_layer_header 10 %d\n", layer);
1600
1601 return layer_data->framesize;
1602 }
1603
1604
1605
1606
1607
1608
1609
1610
mpeg3_new_layer()1611 mpeg3_layer_t* mpeg3_new_layer()
1612 {
1613 mpeg3_layer_t *result = calloc(1, sizeof(mpeg3_layer_t));
1614 result->bsbuf = result->bsspace[1];
1615 result->bo = 1;
1616 result->channels = -1;
1617 result->stream = mpeg3bits_new_stream(0, 0);
1618 mpeg3_new_decode_tables(result);
1619 return result;
1620 }
1621
1622
1623
mpeg3_delete_layer(mpeg3_layer_t * audio)1624 void mpeg3_delete_layer(mpeg3_layer_t *audio)
1625 {
1626 mpeg3bits_delete_stream(audio->stream);
1627 free(audio);
1628 }
1629
1630
1631
1632