author | kergoth <kergoth> | 2002-01-25 22:14:26 (UTC) |
---|---|---|
committer | kergoth <kergoth> | 2002-01-25 22:14:26 (UTC) |
commit | 15318cad33835e4e2dc620d033e43cd930676cdd (patch) (unidiff) | |
tree | c2fa0399a2c47fda8e2cd0092c73a809d17f68eb /core/multimedia/opieplayer/libmpeg3/audio/layer3.c | |
download | opie-15318cad33835e4e2dc620d033e43cd930676cdd.zip opie-15318cad33835e4e2dc620d033e43cd930676cdd.tar.gz opie-15318cad33835e4e2dc620d033e43cd930676cdd.tar.bz2 |
Initial revision
Diffstat (limited to 'core/multimedia/opieplayer/libmpeg3/audio/layer3.c') (more/less context) (ignore whitespace changes)
-rw-r--r-- | core/multimedia/opieplayer/libmpeg3/audio/layer3.c | 1254 |
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 | |||
10 | struct 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 | |||
31 | struct 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 | |||
41 | int 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 | |||
148 | int 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 | |||
206 | 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}; | ||
207 | 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}; | ||
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 | |||
224 | int 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 | |||
690 | int 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 | |||
791 | int 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 | |||
850 | int 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 | */ | ||
900 | int 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 | ||
960 | maybe 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. */ | ||
1053 | int 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 | |||
1069 | int 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 | } | ||