summaryrefslogtreecommitdiff
path: root/core/multimedia/opieplayer/libmad/layer3.c
Unidiff
Diffstat (limited to 'core/multimedia/opieplayer/libmad/layer3.c') (more/less context) (show whitespace changes)
-rw-r--r--core/multimedia/opieplayer/libmad/layer3.c2492
1 files changed, 2492 insertions, 0 deletions
diff --git a/core/multimedia/opieplayer/libmad/layer3.c b/core/multimedia/opieplayer/libmad/layer3.c
new file mode 100644
index 0000000..194fc7e
--- a/dev/null
+++ b/core/multimedia/opieplayer/libmad/layer3.c
@@ -0,0 +1,2492 @@
1/*
2 * mad - MPEG audio decoder
3 * Copyright (C) 2000-2001 Robert Leslie
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 * $Id$
20 */
21
22# ifdef HAVE_CONFIG_H
23# include "libmad_config.h"
24# endif
25
26# include "libmad_global.h"
27
28# include <stdlib.h>
29# include <string.h>
30# include <assert.h>
31
32# ifdef HAVE_LIMITS_H
33# include <limits.h>
34# else
35# define CHAR_BIT 8
36# endif
37
38# include "fixed.h"
39# include "bit.h"
40# include "stream.h"
41# include "frame.h"
42# include "huffman.h"
43# include "layer3.h"
44
45/* --- Layer III ----------------------------------------------------------- */
46
47enum {
48 count1table_select = 0x01,
49 scalefac_scale = 0x02,
50 preflag = 0x04,
51 mixed_block_flag = 0x08
52};
53
54struct sideinfo {
55 unsigned int main_data_begin;
56 unsigned int private_bits;
57
58 unsigned char scfsi[2];
59
60 struct granule {
61 struct channel {
62 /* from side info */
63 unsigned short part2_3_length;
64 unsigned short big_values;
65 unsigned short global_gain;
66 unsigned short scalefac_compress;
67
68 unsigned char flags;
69 unsigned char block_type;
70 unsigned char table_select[3];
71 unsigned char subblock_gain[3];
72 unsigned char region0_count;
73 unsigned char region1_count;
74
75 /* from main_data */
76 unsigned char scalefac[39];/* scalefac_l and/or scalefac_s */
77 } ch[2];
78 } gr[2];
79};
80
81/*
82 * scalefactor bit lengths
83 * derived from section 2.4.2.7 of ISO/IEC 11172-3
84 */
85static
86struct {
87 unsigned char slen1;
88 unsigned char slen2;
89} const sflen_table[16] = {
90 { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 },
91 { 3, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },
92 { 2, 1 }, { 2, 2 }, { 2, 3 }, { 3, 1 },
93 { 3, 2 }, { 3, 3 }, { 4, 2 }, { 4, 3 }
94};
95
96/*
97 * number of LSF scalefactor band values
98 * derived from section 2.4.3.2 of ISO/IEC 13818-3
99 */
100static
101unsigned char const nsfb_table[6][3][4] = {
102 { { 6, 5, 5, 5 },
103 { 9, 9, 9, 9 },
104 { 6, 9, 9, 9 } },
105
106 { { 6, 5, 7, 3 },
107 { 9, 9, 12, 6 },
108 { 6, 9, 12, 6 } },
109
110 { { 11, 10, 0, 0 },
111 { 18, 18, 0, 0 },
112 { 15, 18, 0, 0 } },
113
114 { { 7, 7, 7, 0 },
115 { 12, 12, 12, 0 },
116 { 6, 15, 12, 0 } },
117
118 { { 6, 6, 6, 3 },
119 { 12, 9, 9, 6 },
120 { 6, 12, 9, 6 } },
121
122 { { 8, 8, 5, 0 },
123 { 15, 12, 9, 0 },
124 { 6, 18, 9, 0 } }
125};
126
127/*
128 * MPEG-1 scalefactor band widths
129 * derived from Table B.8 of ISO/IEC 11172-3
130 */
131static
132unsigned char const sfb_48000_long[] = {
133 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10,
134 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192
135};
136
137static
138unsigned char const sfb_44100_long[] = {
139 4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10,
140 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158
141};
142
143static
144unsigned char const sfb_32000_long[] = {
145 4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12,
146 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26
147};
148
149static
150unsigned char const sfb_48000_short[] = {
151 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
152 6, 6, 6, 6, 6, 10, 10, 10, 12, 12, 12, 14, 14,
153 14, 16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66
154};
155
156static
157unsigned char const sfb_44100_short[] = {
158 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
159 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14,
160 14, 18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56
161};
162
163static
164unsigned char const sfb_32000_short[] = {
165 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
166 6, 6, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20,
167 20, 26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12
168};
169
170static
171unsigned char const sfb_48000_mixed[] = {
172 /* long */ 4, 4, 4, 4, 4, 4, 6, 6,
173 /* short */ 4, 4, 4, 6, 6, 6, 6, 6, 6, 10,
174 10, 10, 12, 12, 12, 14, 14, 14, 16, 16,
175 16, 20, 20, 20, 26, 26, 26, 66, 66, 66
176};
177
178static
179unsigned char const sfb_44100_mixed[] = {
180 /* long */ 4, 4, 4, 4, 4, 4, 6, 6,
181 /* short */ 4, 4, 4, 6, 6, 6, 8, 8, 8, 10,
182 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
183 18, 22, 22, 22, 30, 30, 30, 56, 56, 56
184};
185
186static
187unsigned char const sfb_32000_mixed[] = {
188 /* long */ 4, 4, 4, 4, 4, 4, 6, 6,
189 /* short */ 4, 4, 4, 6, 6, 6, 8, 8, 8, 12,
190 12, 12, 16, 16, 16, 20, 20, 20, 26, 26,
191 26, 34, 34, 34, 42, 42, 42, 12, 12, 12
192};
193
194/*
195 * MPEG-2 scalefactor band widths
196 * derived from Table B.2 of ISO/IEC 13818-3
197 */
198static
199unsigned char const sfb_24000_long[] = {
200 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
201 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36
202};
203
204static
205unsigned char const sfb_22050_long[] = {
206 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
207 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54
208};
209
210# define sfb_16000_long sfb_22050_long
211
212static
213unsigned char const sfb_24000_short[] = {
214 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8,
215 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
216 18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12
217};
218
219static
220unsigned char const sfb_22050_short[] = {
221 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6,
222 6, 6, 8, 8, 8, 10, 10, 10, 14, 14, 14, 18, 18,
223 18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18
224};
225
226static
227unsigned char const sfb_16000_short[] = {
228 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8,
229 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
230 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18
231};
232
233static
234unsigned char const sfb_24000_mixed[] = {
235 /* long */ 6, 6, 6, 6, 6, 6,
236 /* short */ 6, 6, 6, 8, 8, 8, 10, 10, 10, 12,
237 12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
238 24, 32, 32, 32, 44, 44, 44, 12, 12, 12
239};
240
241static
242unsigned char const sfb_22050_mixed[] = {
243 /* long */ 6, 6, 6, 6, 6, 6,
244 /* short */ 6, 6, 6, 6, 6, 6, 8, 8, 8, 10,
245 10, 10, 14, 14, 14, 18, 18, 18, 26, 26,
246 26, 32, 32, 32, 42, 42, 42, 18, 18, 18
247};
248
249static
250unsigned char const sfb_16000_mixed[] = {
251 /* long */ 6, 6, 6, 6, 6, 6,
252 /* short */ 6, 6, 6, 8, 8, 8, 10, 10, 10, 12,
253 12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
254 24, 30, 30, 30, 40, 40, 40, 18, 18, 18
255};
256
257/*
258 * MPEG 2.5 scalefactor band widths
259 * derived from public sources
260 */
261# define sfb_12000_long sfb_16000_long
262# define sfb_11025_long sfb_12000_long
263
264static
265unsigned char const sfb_8000_long[] = {
266 12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32,
267 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2
268};
269
270# define sfb_12000_short sfb_16000_short
271# define sfb_11025_short sfb_12000_short
272
273static
274unsigned char const sfb_8000_short[] = {
275 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 16,
276 16, 16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36,
277 36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26
278};
279
280# define sfb_12000_mixed sfb_16000_mixed
281# define sfb_11025_mixed sfb_12000_mixed
282
283/* the 8000 Hz short block scalefactor bands do not break after the first 36
284 frequency lines, so this is probably wrong */
285static
286unsigned char const sfb_8000_mixed[] = {
287 /* long */ 12, 12, 12,
288 /* short */ 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16,
289 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36,
290 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26
291};
292
293static
294struct {
295 unsigned char const *l;
296 unsigned char const *s;
297 unsigned char const *m;
298} const sfbwidth_table[9] = {
299 { sfb_48000_long, sfb_48000_short, sfb_48000_mixed },
300 { sfb_44100_long, sfb_44100_short, sfb_44100_mixed },
301 { sfb_32000_long, sfb_32000_short, sfb_32000_mixed },
302 { sfb_24000_long, sfb_24000_short, sfb_24000_mixed },
303 { sfb_22050_long, sfb_22050_short, sfb_22050_mixed },
304 { sfb_16000_long, sfb_16000_short, sfb_16000_mixed },
305 { sfb_12000_long, sfb_12000_short, sfb_12000_mixed },
306 { sfb_11025_long, sfb_11025_short, sfb_11025_mixed },
307 { sfb_8000_long, sfb_8000_short, sfb_8000_mixed }
308};
309
310/*
311 * scalefactor band preemphasis (used only when preflag is set)
312 * derived from Table B.6 of ISO/IEC 11172-3
313 */
314static
315unsigned char const pretab[22] = {
316 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0
317};
318
319/*
320 * table for requantization
321 *
322 * rq_table[x].mantissa * 2^(rq_table[x].exponent) = x^(4/3)
323 */
324static
325struct fixedfloat {
326 unsigned long mantissa : 27;
327 unsigned short exponent : 5;
328} const rq_table[8207] = {
329# include "rq_table.dat"
330};
331
332/*
333 * fractional powers of two
334 * used for requantization and joint stereo decoding
335 *
336 * root_table[3 + x] = 2^(x/4)
337 */
338static
339mad_fixed_t const root_table[7] = {
340 MAD_F(0x09837f05) /* 2^(-3/4) == 0.59460355750136 */,
341 MAD_F(0x0b504f33) /* 2^(-2/4) == 0.70710678118655 */,
342 MAD_F(0x0d744fcd) /* 2^(-1/4) == 0.84089641525371 */,
343 MAD_F(0x10000000) /* 2^( 0/4) == 1.00000000000000 */,
344 MAD_F(0x1306fe0a) /* 2^(+1/4) == 1.18920711500272 */,
345 MAD_F(0x16a09e66) /* 2^(+2/4) == 1.41421356237310 */,
346 MAD_F(0x1ae89f99) /* 2^(+3/4) == 1.68179283050743 */
347};
348
349/*
350 * coefficients for aliasing reduction
351 * derived from Table B.9 of ISO/IEC 11172-3
352 *
353 * c[] = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 }
354 * cs[i] = 1 / sqrt(1 + c[i]^2)
355 * ca[i] = c[i] / sqrt(1 + c[i]^2)
356 */
357static
358mad_fixed_t const cs[8] = {
359 +MAD_F(0x0db84a81) /* +0.857492926 */, +MAD_F(0x0e1b9d7f) /* +0.881741997 */,
360 +MAD_F(0x0f31adcf) /* +0.949628649 */, +MAD_F(0x0fbba815) /* +0.983314592 */,
361 +MAD_F(0x0feda417) /* +0.995517816 */, +MAD_F(0x0ffc8fc8) /* +0.999160558 */,
362 +MAD_F(0x0fff964c) /* +0.999899195 */, +MAD_F(0x0ffff8d3) /* +0.999993155 */
363};
364
365static
366mad_fixed_t const ca[8] = {
367 -MAD_F(0x083b5fe7) /* -0.514495755 */, -MAD_F(0x078c36d2) /* -0.471731969 */,
368 -MAD_F(0x05039814) /* -0.313377454 */, -MAD_F(0x02e91dd1) /* -0.181913200 */,
369 -MAD_F(0x0183603a) /* -0.094574193 */, -MAD_F(0x00a7cb87) /* -0.040965583 */,
370 -MAD_F(0x003a2847) /* -0.014198569 */, -MAD_F(0x000f27b4) /* -0.003699975 */
371};
372
373/*
374 * IMDCT coefficients for short blocks
375 * derived from section 2.4.3.4.10.2 of ISO/IEC 11172-3
376 *
377 * imdct_s[i/even][k] = cos((PI / 24) * (2 * (i / 2) + 7) * (2 * k + 1))
378 * imdct_s[i /odd][k] = cos((PI / 24) * (2 * (6 + (i-1)/2) + 7) * (2 * k + 1))
379 */
380static
381mad_fixed_t const imdct_s[6][6] = {
382# include "imdct_s.dat"
383};
384
385# if !defined(ASO_IMDCT)
386/*
387 * windowing coefficients for long blocks
388 * derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3
389 *
390 * window_l[i] = sin((PI / 36) * (i + 1/2))
391 */
392static
393mad_fixed_t const window_l[36] = {
394 MAD_F(0x00b2aa3e) /* 0.043619387 */, MAD_F(0x0216a2a2) /* 0.130526192 */,
395 MAD_F(0x03768962) /* 0.216439614 */, MAD_F(0x04cfb0e2) /* 0.300705800 */,
396 MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x07635284) /* 0.461748613 */,
397 MAD_F(0x0898c779) /* 0.537299608 */, MAD_F(0x09bd7ca0) /* 0.608761429 */,
398 MAD_F(0x0acf37ad) /* 0.675590208 */, MAD_F(0x0bcbe352) /* 0.737277337 */,
399 MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x0d7e8807) /* 0.843391446 */,
400
401 MAD_F(0x0e313245) /* 0.887010833 */, MAD_F(0x0ec835e8) /* 0.923879533 */,
402 MAD_F(0x0f426cb5) /* 0.953716951 */, MAD_F(0x0f9ee890) /* 0.976296007 */,
403 MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ffc19fd) /* 0.999048222 */,
404 MAD_F(0x0ffc19fd) /* 0.999048222 */, MAD_F(0x0fdcf549) /* 0.991444861 */,
405 MAD_F(0x0f9ee890) /* 0.976296007 */, MAD_F(0x0f426cb5) /* 0.953716951 */,
406 MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0e313245) /* 0.887010833 */,
407
408 MAD_F(0x0d7e8807) /* 0.843391446 */, MAD_F(0x0cb19346) /* 0.793353340 */,
409 MAD_F(0x0bcbe352) /* 0.737277337 */, MAD_F(0x0acf37ad) /* 0.675590208 */,
410 MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0898c779) /* 0.537299608 */,
411 MAD_F(0x07635284) /* 0.461748613 */, MAD_F(0x061f78aa) /* 0.382683432 */,
412 MAD_F(0x04cfb0e2) /* 0.300705800 */, MAD_F(0x03768962) /* 0.216439614 */,
413 MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x00b2aa3e) /* 0.043619387 */,
414};
415# endif /* ASO_IMDCT */
416
417/*
418 * windowing coefficients for short blocks
419 * derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3
420 *
421 * window_s[i] = sin((PI / 12) * (i + 1/2))
422 */
423static
424mad_fixed_t const window_s[12] = {
425 MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x061f78aa) /* 0.382683432 */,
426 MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0cb19346) /* 0.793353340 */,
427 MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0fdcf549) /* 0.991444861 */,
428 MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ec835e8) /* 0.923879533 */,
429 MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x09bd7ca0) /* 0.608761429 */,
430 MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x0216a2a2) /* 0.130526192 */,
431};
432
433/*
434 * coefficients for intensity stereo processing
435 * derived from section 2.4.3.4.9.3 of ISO/IEC 11172-3
436 *
437 * is_ratio[i] = tan(i * (PI / 12))
438 * is_table[i] = is_ratio[i] / (1 + is_ratio[i])
439 */
440static
441mad_fixed_t const is_table[7] = {
442 MAD_F(0x00000000) /* 0.000000000 */,
443 MAD_F(0x0361962f) /* 0.211324865 */,
444 MAD_F(0x05db3d74) /* 0.366025404 */,
445 MAD_F(0x08000000) /* 0.500000000 */,
446 MAD_F(0x0a24c28c) /* 0.633974596 */,
447 MAD_F(0x0c9e69d1) /* 0.788675135 */,
448 MAD_F(0x10000000) /* 1.000000000 */
449};
450
451/*
452 * coefficients for LSF intensity stereo processing
453 * derived from section 2.4.3.2 of ISO/IEC 13818-3
454 *
455 * is_lsf_table[0][i] = (1 / sqrt(sqrt(2)))^(i + 1)
456 * is_lsf_table[1][i] = (1 / sqrt(2))^(i + 1)
457 */
458static
459mad_fixed_t const is_lsf_table[2][15] = {
460 {
461 MAD_F(0x0d744fcd) /* 0.840896415 */,
462 MAD_F(0x0b504f33) /* 0.707106781 */,
463 MAD_F(0x09837f05) /* 0.594603558 */,
464 MAD_F(0x08000000) /* 0.500000000 */,
465 MAD_F(0x06ba27e6) /* 0.420448208 */,
466 MAD_F(0x05a8279a) /* 0.353553391 */,
467 MAD_F(0x04c1bf83) /* 0.297301779 */,
468 MAD_F(0x04000000) /* 0.250000000 */,
469 MAD_F(0x035d13f3) /* 0.210224104 */,
470 MAD_F(0x02d413cd) /* 0.176776695 */,
471 MAD_F(0x0260dfc1) /* 0.148650889 */,
472 MAD_F(0x02000000) /* 0.125000000 */,
473 MAD_F(0x01ae89fa) /* 0.105112052 */,
474 MAD_F(0x016a09e6) /* 0.088388348 */,
475 MAD_F(0x01306fe1) /* 0.074325445 */
476 }, {
477 MAD_F(0x0b504f33) /* 0.707106781 */,
478 MAD_F(0x08000000) /* 0.500000000 */,
479 MAD_F(0x05a8279a) /* 0.353553391 */,
480 MAD_F(0x04000000) /* 0.250000000 */,
481 MAD_F(0x02d413cd) /* 0.176776695 */,
482 MAD_F(0x02000000) /* 0.125000000 */,
483 MAD_F(0x016a09e6) /* 0.088388348 */,
484 MAD_F(0x01000000) /* 0.062500000 */,
485 MAD_F(0x00b504f3) /* 0.044194174 */,
486 MAD_F(0x00800000) /* 0.031250000 */,
487 MAD_F(0x005a827a) /* 0.022097087 */,
488 MAD_F(0x00400000) /* 0.015625000 */,
489 MAD_F(0x002d413d) /* 0.011048543 */,
490 MAD_F(0x00200000) /* 0.007812500 */,
491 MAD_F(0x0016a09e) /* 0.005524272 */
492 }
493};
494
495/*
496 * NAME:III_sideinfo()
497 * DESCRIPTION:decode frame side information from a bitstream
498 */
499static
500enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch,
501 int lsf, struct sideinfo *si,
502 unsigned int *data_bitlen,
503 unsigned int *priv_bitlen)
504{
505 unsigned int ngr, gr, ch, i;
506 enum mad_error result = 0;
507
508 *data_bitlen = 0;
509 *priv_bitlen = lsf ? ((nch == 1) ? 1 : 2) : ((nch == 1) ? 5 : 3);
510
511 si->main_data_begin = mad_bit_read(ptr, lsf ? 8 : 9);
512 si->private_bits = mad_bit_read(ptr, *priv_bitlen);
513
514 ngr = 1;
515 if (!lsf) {
516 ngr = 2;
517
518 for (ch = 0; ch < nch; ++ch)
519 si->scfsi[ch] = mad_bit_read(ptr, 4);
520 }
521
522 for (gr = 0; gr < ngr; ++gr) {
523 struct granule *granule = &si->gr[gr];
524
525 for (ch = 0; ch < nch; ++ch) {
526 struct channel *channel = &granule->ch[ch];
527
528 channel->part2_3_length = mad_bit_read(ptr, 12);
529 channel->big_values = mad_bit_read(ptr, 9);
530 channel->global_gain = mad_bit_read(ptr, 8);
531 channel->scalefac_compress = mad_bit_read(ptr, lsf ? 9 : 4);
532
533 *data_bitlen += channel->part2_3_length;
534
535 if (channel->big_values > 288 && result == 0)
536 result = MAD_ERROR_BADBIGVALUES;
537
538 channel->flags = 0;
539
540 /* window_switching_flag */
541 if (mad_bit_read(ptr, 1)) {
542 channel->block_type = mad_bit_read(ptr, 2);
543
544 if (channel->block_type == 0 && result == 0)
545 result = MAD_ERROR_BADBLOCKTYPE;
546
547 if (!lsf && channel->block_type == 2 && si->scfsi[ch] && result == 0)
548 result = MAD_ERROR_BADSCFSI;
549
550 channel->region0_count = 7;
551 channel->region1_count = 36;
552
553 if (mad_bit_read(ptr, 1))
554 channel->flags |= mixed_block_flag;
555 else if (channel->block_type == 2)
556 channel->region0_count = 8;
557
558 for (i = 0; i < 2; ++i)
559 channel->table_select[i] = mad_bit_read(ptr, 5);
560
561# if defined(DEBUG)
562 channel->table_select[2] = 4; /* not used */
563# endif
564
565 for (i = 0; i < 3; ++i)
566 channel->subblock_gain[i] = mad_bit_read(ptr, 3);
567 }
568 else {
569 channel->block_type = 0;
570
571 for (i = 0; i < 3; ++i)
572 channel->table_select[i] = mad_bit_read(ptr, 5);
573
574 channel->region0_count = mad_bit_read(ptr, 4);
575 channel->region1_count = mad_bit_read(ptr, 3);
576 }
577
578 /* [preflag,] scalefac_scale, count1table_select */
579 channel->flags |= mad_bit_read(ptr, lsf ? 2 : 3);
580 }
581 }
582
583 return result;
584}
585
586/*
587 * NAME:III_scalefactors_lsf()
588 * DESCRIPTION:decode channel scalefactors for LSF from a bitstream
589 */
590static
591unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr,
592 struct channel *channel,
593 struct channel *gr1ch, int mode_extension)
594{
595 struct mad_bitptr start;
596 unsigned int scalefac_compress, index, slen[4], part, n, i;
597 unsigned char const *nsfb;
598
599 start = *ptr;
600
601 scalefac_compress = channel->scalefac_compress;
602 index = (channel->block_type == 2) ?
603 ((channel->flags & mixed_block_flag) ? 2 : 1) : 0;
604
605 if (!((mode_extension & 0x1) && gr1ch)) {
606 if (scalefac_compress < 400) {
607 slen[0] = (scalefac_compress >> 4) / 5;
608 slen[1] = (scalefac_compress >> 4) % 5;
609 slen[2] = (scalefac_compress % 16) >> 2;
610 slen[3] = scalefac_compress % 4;
611
612 nsfb = nsfb_table[0][index];
613 }
614 else if (scalefac_compress < 500) {
615 scalefac_compress -= 400;
616
617 slen[0] = (scalefac_compress >> 2) / 5;
618 slen[1] = (scalefac_compress >> 2) % 5;
619 slen[2] = scalefac_compress % 4;
620 slen[3] = 0;
621
622 nsfb = nsfb_table[1][index];
623 }
624 else {
625 scalefac_compress -= 500;
626
627 slen[0] = scalefac_compress / 3;
628 slen[1] = scalefac_compress % 3;
629 slen[2] = 0;
630 slen[3] = 0;
631
632 channel->flags |= preflag;
633
634 nsfb = nsfb_table[2][index];
635 }
636
637 n = 0;
638 for (part = 0; part < 4; ++part) {
639 for (i = 0; i < nsfb[part]; ++i)
640 channel->scalefac[n++] = mad_bit_read(ptr, slen[part]);
641 }
642
643 while (n < 39)
644 channel->scalefac[n++] = 0;
645 }
646 else { /* (mode_extension & 0x1) && gr1ch (i.e. ch == 1) */
647 scalefac_compress >>= 1;
648
649 if (scalefac_compress < 180) {
650 slen[0] = scalefac_compress / 36;
651 slen[1] = (scalefac_compress % 36) / 6;
652 slen[2] = (scalefac_compress % 36) % 6;
653 slen[3] = 0;
654
655 nsfb = nsfb_table[3][index];
656 }
657 else if (scalefac_compress < 244) {
658 scalefac_compress -= 180;
659
660 slen[0] = (scalefac_compress % 64) >> 4;
661 slen[1] = (scalefac_compress % 16) >> 2;
662 slen[2] = scalefac_compress % 4;
663 slen[3] = 0;
664
665 nsfb = nsfb_table[4][index];
666 }
667 else {
668 scalefac_compress -= 244;
669
670 slen[0] = scalefac_compress / 3;
671 slen[1] = scalefac_compress % 3;
672 slen[2] = 0;
673 slen[3] = 0;
674
675 nsfb = nsfb_table[5][index];
676 }
677
678 n = 0;
679 for (part = 0; part < 4; ++part) {
680 unsigned int max, is_pos;
681
682 max = (1 << slen[part]) - 1;
683
684 for (i = 0; i < nsfb[part]; ++i) {
685 is_pos = mad_bit_read(ptr, slen[part]);
686
687 channel->scalefac[n] = is_pos;
688 gr1ch->scalefac[n++] = (is_pos == max);
689 }
690 }
691
692 while (n < 39) {
693 channel->scalefac[n] = 0;
694 gr1ch->scalefac[n++] = 0; /* apparently not illegal */
695 }
696 }
697
698 return mad_bit_length(&start, ptr);
699}
700
701/*
702 * NAME:III_scalefactors()
703 * DESCRIPTION:decode channel scalefactors of one granule from a bitstream
704 */
705static
706unsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel,
707 struct channel const *gr0ch, unsigned int scfsi)
708{
709 struct mad_bitptr start;
710 unsigned int slen1, slen2, sfbi;
711
712 start = *ptr;
713
714 slen1 = sflen_table[channel->scalefac_compress].slen1;
715 slen2 = sflen_table[channel->scalefac_compress].slen2;
716
717 if (channel->block_type == 2) {
718 unsigned int nsfb;
719
720 sfbi = 0;
721
722 nsfb = (channel->flags & mixed_block_flag) ? 8 + 3 * 3 : 6 * 3;
723 while (nsfb--)
724 channel->scalefac[sfbi++] = mad_bit_read(ptr, slen1);
725
726 nsfb = 6 * 3;
727 while (nsfb--)
728 channel->scalefac[sfbi++] = mad_bit_read(ptr, slen2);
729
730 nsfb = 1 * 3;
731 while (nsfb--)
732 channel->scalefac[sfbi++] = 0;
733 }
734 else { /* channel->block_type != 2 */
735 if (scfsi & 0x8) {
736 for (sfbi = 0; sfbi < 6; ++sfbi)
737 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
738 }
739 else {
740 for (sfbi = 0; sfbi < 6; ++sfbi)
741 channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
742 }
743
744 if (scfsi & 0x4) {
745 for (sfbi = 6; sfbi < 11; ++sfbi)
746 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
747 }
748 else {
749 for (sfbi = 6; sfbi < 11; ++sfbi)
750 channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
751 }
752
753 if (scfsi & 0x2) {
754 for (sfbi = 11; sfbi < 16; ++sfbi)
755 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
756 }
757 else {
758 for (sfbi = 11; sfbi < 16; ++sfbi)
759 channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
760 }
761
762 if (scfsi & 0x1) {
763 for (sfbi = 16; sfbi < 21; ++sfbi)
764 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
765 }
766 else {
767 for (sfbi = 16; sfbi < 21; ++sfbi)
768 channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
769 }
770
771 channel->scalefac[21] = 0;
772 }
773
774 return mad_bit_length(&start, ptr);
775}
776
777/*
778 * NAME:III_exponents()
779 * DESCRIPTION:calculate scalefactor exponents
780 */
781static
782void III_exponents(struct channel const *channel,
783 unsigned char const *sfbwidth, signed int exponents[39])
784{
785 signed int gain;
786 unsigned int scalefac_multiplier, sfbi;
787
788 gain = (signed int) channel->global_gain - 210;
789 scalefac_multiplier = (channel->flags & scalefac_scale) ? 2 : 1;
790
791 if (channel->block_type == 2) {
792 unsigned int l;
793 signed int gain0, gain1, gain2;
794
795 sfbi = l = 0;
796
797 if (channel->flags & mixed_block_flag) {
798 unsigned int premask;
799
800 premask = (channel->flags & preflag) ? ~0 : 0;
801
802 /* long block subbands 0-1 */
803
804 while (l < 36) {
805 exponents[sfbi] = gain -
806 (signed int) ((channel->scalefac[sfbi] + (pretab[sfbi] & premask)) <<
807 scalefac_multiplier);
808
809 l += sfbwidth[sfbi++];
810 }
811 }
812
813 /* this is probably wrong for 8000 Hz short/mixed blocks */
814
815 gain0 = gain - 8 * (signed int) channel->subblock_gain[0];
816 gain1 = gain - 8 * (signed int) channel->subblock_gain[1];
817 gain2 = gain - 8 * (signed int) channel->subblock_gain[2];
818
819 while (l < 576) {
820 exponents[sfbi + 0] = gain0 -
821 (signed int) (channel->scalefac[sfbi + 0] << scalefac_multiplier);
822 exponents[sfbi + 1] = gain1 -
823 (signed int) (channel->scalefac[sfbi + 1] << scalefac_multiplier);
824 exponents[sfbi + 2] = gain2 -
825 (signed int) (channel->scalefac[sfbi + 2] << scalefac_multiplier);
826
827 l += 3 * sfbwidth[sfbi];
828 sfbi += 3;
829 }
830 }
831 else { /* channel->block_type != 2 */
832 if (channel->flags & preflag) {
833 for (sfbi = 0; sfbi < 22; ++sfbi) {
834 exponents[sfbi] = gain -
835 (signed int) ((channel->scalefac[sfbi] + pretab[sfbi]) <<
836 scalefac_multiplier);
837 }
838 }
839 else {
840 for (sfbi = 0; sfbi < 22; ++sfbi) {
841 exponents[sfbi] = gain -
842 (signed int) (channel->scalefac[sfbi] << scalefac_multiplier);
843 }
844 }
845 }
846}
847
848/*
849 * NAME:III_requantize()
850 * DESCRIPTION:requantize one (positive) value
851 */
852static
853mad_fixed_t III_requantize(unsigned int value, signed int exp)
854{
855 mad_fixed_t requantized;
856 signed int frac;
857 struct fixedfloat const *power;
858
859 /*
860 * long blocks:
861 * xr[i] = sign(is[i]) * abs(is[i])^(4/3) *
862 * 2^((1/4) * (global_gain - 210)) *
863 * 2^-(scalefac_multiplier *
864 * (scalefac_l[sfb] + preflag * pretab[sfb]))
865 *
866 * short blocks:
867 * xr[i] = sign(is[i]) * abs(is[i])^(4/3) *
868 * 2^((1/4) * (global_gain - 210 - 8 * subblock_gain[w])) *
869 * 2^-(scalefac_multiplier * scalefac_s[sfb][w])
870 *
871 * where:
872 * scalefac_multiplier = (scalefac_scale + 1) / 2
873 */
874
875 frac = exp % 4;
876 exp /= 4;
877
878 power = &rq_table[value];
879 requantized = power->mantissa;
880 exp += power->exponent;
881
882 if (exp < 0) {
883 if (-exp >= sizeof(mad_fixed_t) * CHAR_BIT) {
884 /* underflow */
885 requantized = 0;
886 }
887 else
888 requantized >>= -exp;
889 }
890 else {
891 if (exp >= 5) {
892 /* overflow */
893# if defined(DEBUG)
894 fprintf(stderr, "requantize overflow (%f * 2^%d)\n",
895 mad_f_todouble(requantized), exp);
896# endif
897 requantized = MAD_F_MAX;
898 }
899 else
900 requantized <<= exp;
901 }
902
903 return frac ? mad_f_mul(requantized, root_table[3 + frac]) : requantized;
904}
905
906/* we must take care that sz >= bits and sz < sizeof(long) lest bits == 0 */
907 # define MASK(cache, sz, bits)\
908 (((cache) >> ((sz) - (bits))) & ((1 << (bits)) - 1))
909# define MASK1BIT(cache, sz) \
910 ((cache) & (1 << ((sz) - 1)))
911
912/*
913 * NAME:III_huffdecode()
914 * DESCRIPTION:decode Huffman code words of one channel of one granule
915 */
916static
917enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xr[576],
918 struct channel *channel,
919 unsigned char const *sfbwidth,
920 unsigned int part2_length)
921{
922 signed int exponents[39], exp;
923 signed int const *expptr;
924 struct mad_bitptr peek;
925 signed int bits_left, cachesz;
926 register mad_fixed_t *xrptr;
927 mad_fixed_t const *sfbound;
928 register unsigned long bitcache;
929
930 bits_left = (signed) channel->part2_3_length - (signed) part2_length;
931 if (bits_left < 0)
932 return MAD_ERROR_BADPART3LEN;
933
934 III_exponents(channel, sfbwidth, exponents);
935
936 peek = *ptr;
937 mad_bit_skip(ptr, bits_left);
938
939 /* align bit reads to byte boundaries */
940 cachesz = mad_bit_bitsleft(&peek);
941 cachesz += ((32 - 1 - 24) + (24 - cachesz)) & ~7;
942
943 bitcache = mad_bit_read(&peek, cachesz);
944 bits_left -= cachesz;
945
946 xrptr = &xr[0];
947
948 /* big_values */
949 {
950 unsigned int region, rcount;
951 struct hufftable const *entry;
952 union huffpair const *table;
953 unsigned int linbits, startbits, big_values, reqhits;
954 mad_fixed_t reqcache[16];
955
956 sfbound = xrptr + *sfbwidth++;
957 rcount = channel->region0_count + 1;
958
959 entry = &mad_huff_pair_table[channel->table_select[region = 0]];
960 table = entry->table;
961 linbits = entry->linbits;
962 startbits = entry->startbits;
963
964 if (table == 0)
965 return MAD_ERROR_BADHUFFTABLE;
966
967 expptr = &exponents[0];
968 exp = *expptr++;
969 reqhits = 0;
970
971 big_values = channel->big_values;
972
973 while (big_values-- && cachesz + bits_left > 0) {
974 union huffpair const *pair;
975 unsigned int clumpsz, value;
976 register mad_fixed_t requantized;
977
978 if (xrptr == sfbound) {
979 sfbound += *sfbwidth++;
980
981 /* change table if region boundary */
982
983 if (--rcount == 0) {
984 if (region == 0)
985 rcount = channel->region1_count + 1;
986 else
987 rcount = 0; /* all remaining */
988
989 entry = &mad_huff_pair_table[channel->table_select[++region]];
990 table = entry->table;
991 linbits = entry->linbits;
992 startbits = entry->startbits;
993
994 if (table == 0)
995 return MAD_ERROR_BADHUFFTABLE;
996 }
997
998 if (exp != *expptr) {
999 exp = *expptr;
1000 reqhits = 0;
1001 }
1002
1003 ++expptr;
1004 }
1005
1006 if (cachesz < 21) {
1007 unsigned int bits;
1008
1009 bits = ((32 - 1 - 21) + (21 - cachesz)) & ~7;
1010 bitcache = (bitcache << bits) | mad_bit_read(&peek, bits);
1011 cachesz += bits;
1012 bits_left -= bits;
1013 }
1014
1015 /* hcod (0..19) */
1016
1017 clumpsz = startbits;
1018 pair = &table[MASK(bitcache, cachesz, clumpsz)];
1019
1020 while (!pair->final) {
1021 cachesz -= clumpsz;
1022
1023 clumpsz = pair->ptr.bits;
1024 pair = &table[pair->ptr.offset + MASK(bitcache, cachesz, clumpsz)];
1025 }
1026
1027 cachesz -= pair->value.hlen;
1028
1029 if (linbits) {
1030 /* x (0..14) */
1031
1032 value = pair->value.x;
1033
1034 switch (value) {
1035 case 0:
1036 xrptr[0] = 0;
1037 break;
1038
1039 case 15:
1040 if (cachesz < linbits + 2) {
1041 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16);
1042 cachesz += 16;
1043 bits_left -= 16;
1044 }
1045
1046 value += MASK(bitcache, cachesz, linbits);
1047 cachesz -= linbits;
1048
1049 requantized = III_requantize(value, exp);
1050 goto x_final;
1051
1052 default:
1053 if (reqhits & (1 << value))
1054 requantized = reqcache[value];
1055 else {
1056 reqhits |= (1 << value);
1057 requantized = reqcache[value] = III_requantize(value, exp);
1058 }
1059
1060 x_final:
1061 xrptr[0] = MASK1BIT(bitcache, cachesz--) ?
1062 -requantized : requantized;
1063 }
1064
1065 /* y (0..14) */
1066
1067 value = pair->value.y;
1068
1069 switch (value) {
1070 case 0:
1071 xrptr[1] = 0;
1072 break;
1073
1074 case 15:
1075 if (cachesz < linbits + 1) {
1076 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16);
1077 cachesz += 16;
1078 bits_left -= 16;
1079 }
1080
1081 value += MASK(bitcache, cachesz, linbits);
1082 cachesz -= linbits;
1083
1084 requantized = III_requantize(value, exp);
1085 goto y_final;
1086
1087 default:
1088 if (reqhits & (1 << value))
1089 requantized = reqcache[value];
1090 else {
1091 reqhits |= (1 << value);
1092 requantized = reqcache[value] = III_requantize(value, exp);
1093 }
1094
1095 y_final:
1096 xrptr[1] = MASK1BIT(bitcache, cachesz--) ?
1097 -requantized : requantized;
1098 }
1099 }
1100 else {
1101 /* x (0..1) */
1102
1103 value = pair->value.x;
1104
1105 if (value == 0)
1106 xrptr[0] = 0;
1107 else {
1108 if (reqhits & (1 << value))
1109 requantized = reqcache[value];
1110 else {
1111 reqhits |= (1 << value);
1112 requantized = reqcache[value] = III_requantize(value, exp);
1113 }
1114
1115 xrptr[0] = MASK1BIT(bitcache, cachesz--) ?
1116 -requantized : requantized;
1117 }
1118
1119 /* y (0..1) */
1120
1121 value = pair->value.y;
1122
1123 if (value == 0)
1124 xrptr[1] = 0;
1125 else {
1126 if (reqhits & (1 << value))
1127 requantized = reqcache[value];
1128 else {
1129 reqhits |= (1 << value);
1130 requantized = reqcache[value] = III_requantize(value, exp);
1131 }
1132
1133 xrptr[1] = MASK1BIT(bitcache, cachesz--) ?
1134 -requantized : requantized;
1135 }
1136 }
1137
1138 xrptr += 2;
1139 }
1140 }
1141
1142 if (cachesz + bits_left < 0)
1143 return MAD_ERROR_BADHUFFDATA; /* big_values overrun */
1144
1145 /* count1 */
1146 {
1147 union huffquad const *table;
1148 register mad_fixed_t requantized;
1149
1150 table = mad_huff_quad_table[channel->flags & count1table_select];
1151
1152 requantized = III_requantize(1, exp);
1153
1154 while (cachesz + bits_left > 0 && xrptr <= &xr[572]) {
1155 union huffquad const *quad;
1156
1157 /* hcod (1..6) */
1158
1159 if (cachesz < 10) {
1160 bitcache = (bitcache << 16) | mad_bit_read(&peek, 16);
1161 cachesz += 16;
1162 bits_left -= 16;
1163 }
1164
1165 quad = &table[MASK(bitcache, cachesz, 4)];
1166
1167 /* quad tables guaranteed to have at most one extra lookup */
1168 if (!quad->final) {
1169 cachesz -= 4;
1170
1171 quad = &table[quad->ptr.offset +
1172 MASK(bitcache, cachesz, quad->ptr.bits)];
1173 }
1174
1175 cachesz -= quad->value.hlen;
1176
1177 if (xrptr == sfbound) {
1178 sfbound += *sfbwidth++;
1179
1180 if (exp != *expptr) {
1181 exp = *expptr;
1182 requantized = III_requantize(1, exp);
1183 }
1184
1185 ++expptr;
1186 }
1187
1188 /* v (0..1) */
1189
1190 xrptr[0] = quad->value.v ?
1191 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1192
1193 /* w (0..1) */
1194
1195 xrptr[1] = quad->value.w ?
1196 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1197
1198 xrptr += 2;
1199
1200 if (xrptr == sfbound) {
1201 sfbound += *sfbwidth++;
1202
1203 if (exp != *expptr) {
1204 exp = *expptr;
1205 requantized = III_requantize(1, exp);
1206 }
1207
1208 ++expptr;
1209 }
1210
1211 /* x (0..1) */
1212
1213 xrptr[0] = quad->value.x ?
1214 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1215
1216 /* y (0..1) */
1217
1218 xrptr[1] = quad->value.y ?
1219 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1220
1221 xrptr += 2;
1222 }
1223
1224 if (cachesz + bits_left < 0) {
1225# if 0 && defined(DEBUG)
1226 fprintf(stderr, "huffman count1 overrun (%d bits)\n",
1227 -(cachesz + bits_left));
1228# endif
1229
1230 /* technically the bitstream is misformatted, but apparently
1231 some encoders are just a bit sloppy with stuffing bits */
1232
1233 xrptr -= 4;
1234 }
1235 }
1236
1237 assert(-bits_left <= MAD_BUFFER_GUARD * CHAR_BIT);
1238
1239# if 0 && defined(DEBUG)
1240 if (bits_left < 0)
1241 fprintf(stderr, "read %d bits too many\n", -bits_left);
1242 else if (cachesz + bits_left > 0)
1243 fprintf(stderr, "%d stuffing bits\n", cachesz + bits_left);
1244# endif
1245
1246 /* rzero */
1247 while (xrptr < &xr[576]) {
1248 xrptr[0] = 0;
1249 xrptr[1] = 0;
1250
1251 xrptr += 2;
1252 }
1253
1254 return 0;
1255}
1256
1257# undef MASK
1258# undef MASK1BIT
1259
1260/*
1261 * NAME:III_reorder()
1262 * DESCRIPTION:reorder frequency lines of a short block into subband order
1263 */
1264static
1265void III_reorder(mad_fixed_t xr[576], struct channel const *channel,
1266 unsigned char const sfbwidth[39])
1267{
1268 mad_fixed_t tmp[32][3][6];
1269 unsigned int sb, l, sfbi, f, w, sbw[3], sw[3];
1270
1271 /* this is probably wrong for 8000 Hz mixed blocks */
1272
1273 if (channel->flags & mixed_block_flag)
1274 sb = 2, sfbi = 3 * 3;
1275 else
1276 sb = 0, sfbi = 0;
1277
1278 for (w = 0; w < 3; ++w) {
1279 sbw[w] = sb;
1280 sw[w] = 0;
1281 }
1282
1283 f = sfbwidth[sfbi];
1284 w = 0;
1285
1286 for (l = 18 * sb; l < 576; ++l) {
1287 tmp[sbw[w]][w][sw[w]++] = xr[l];
1288
1289 if (sw[w] == 6) {
1290 sw[w] = 0;
1291 ++sbw[w];
1292 }
1293
1294 if (--f == 0) {
1295 if (++w == 3)
1296 w = 0;
1297
1298 f = sfbwidth[++sfbi];
1299 }
1300 }
1301
1302 memcpy(&xr[18 * sb], &tmp[sb], (576 - 18 * sb) * sizeof(mad_fixed_t));
1303}
1304
1305/*
1306 * NAME:III_stereo()
1307 * DESCRIPTION:perform joint stereo processing on a granule
1308 */
1309static
1310enum mad_error III_stereo(mad_fixed_t xr[2][576],
1311 struct granule const *granule,
1312 struct mad_header *header,
1313 unsigned char const *sfbwidth)
1314{
1315 short modes[39];
1316 unsigned int sfbi, l, n, i;
1317
1318 enum {
1319 i_stereo = 0x1,
1320 ms_stereo = 0x2
1321 };
1322
1323 if (granule->ch[0].block_type !=
1324 granule->ch[1].block_type ||
1325 (granule->ch[0].flags & mixed_block_flag) !=
1326 (granule->ch[1].flags & mixed_block_flag))
1327 return MAD_ERROR_BADSTEREO;
1328
1329 for (i = 0; i < 39; ++i)
1330 modes[i] = header->mode_extension;
1331
1332 /* intensity stereo */
1333
1334 if (header->mode_extension & i_stereo) {
1335 struct channel const *right_ch = &granule->ch[1];
1336 mad_fixed_t const *right_xr = xr[1];
1337 unsigned int is_pos;
1338
1339 header->flags |= MAD_FLAG_I_STEREO;
1340
1341 /* first determine which scalefactor bands are to be processed */
1342
1343 if (right_ch->block_type == 2) {
1344 unsigned int lower, start, max, bound[3], w;
1345
1346 lower = start = max = bound[0] = bound[1] = bound[2] = 0;
1347
1348 sfbi = l = 0;
1349
1350 if (right_ch->flags & mixed_block_flag) {
1351 while (l < 36) {
1352 n = sfbwidth[sfbi++];
1353
1354 for (i = 0; i < n; ++i) {
1355 if (right_xr[i]) {
1356 lower = sfbi;
1357 break;
1358 }
1359 }
1360
1361 right_xr += n;
1362 l += n;
1363 }
1364
1365 start = sfbi;
1366 }
1367
1368 w = 0;
1369 while (l < 576) {
1370 n = sfbwidth[sfbi++];
1371
1372 for (i = 0; i < n; ++i) {
1373 if (right_xr[i]) {
1374 max = bound[w] = sfbi;
1375 break;
1376 }
1377 }
1378
1379 right_xr += n;
1380 l += n;
1381 w = (w + 1) % 3;
1382 }
1383
1384 if (max)
1385 lower = start;
1386
1387 /* long blocks */
1388
1389 for (i = 0; i < lower; ++i)
1390 modes[i] = header->mode_extension & ~i_stereo;
1391
1392 /* short blocks */
1393
1394 w = 0;
1395 for (i = start; i < max; ++i) {
1396 if (i < bound[w])
1397 modes[i] = header->mode_extension & ~i_stereo;
1398
1399 w = (w + 1) % 3;
1400 }
1401 }
1402 else { /* right_ch->block_type != 2 */
1403 unsigned int bound;
1404
1405 bound = 0;
1406 for (sfbi = l = 0; l < 576; l += n) {
1407 n = sfbwidth[sfbi++];
1408
1409 for (i = 0; i < n; ++i) {
1410 if (right_xr[i]) {
1411 bound = sfbi;
1412 break;
1413 }
1414 }
1415
1416 right_xr += n;
1417 }
1418
1419 for (i = 0; i < bound; ++i)
1420 modes[i] = header->mode_extension & ~i_stereo;
1421 }
1422
1423 /* now do the actual processing */
1424
1425 if (header->flags & MAD_FLAG_LSF_EXT) {
1426 unsigned char const *illegal_pos = granule[1].ch[1].scalefac;
1427 mad_fixed_t const *lsf_scale;
1428
1429 /* intensity_scale */
1430 lsf_scale = is_lsf_table[right_ch->scalefac_compress & 0x1];
1431
1432 for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
1433 n = sfbwidth[sfbi];
1434
1435 if (!(modes[sfbi] & i_stereo))
1436 continue;
1437
1438 if (illegal_pos[sfbi]) {
1439 modes[sfbi] &= ~i_stereo;
1440 continue;
1441 }
1442
1443 is_pos = right_ch->scalefac[sfbi];
1444
1445 for (i = 0; i < n; ++i) {
1446 register mad_fixed_t left;
1447
1448 left = xr[0][l + i];
1449
1450 if (is_pos == 0)
1451 xr[1][l + i] = left;
1452 else {
1453 register mad_fixed_t opposite;
1454
1455 opposite = mad_f_mul(left, lsf_scale[(is_pos - 1) / 2]);
1456
1457 if (is_pos & 1) {
1458 xr[0][l + i] = opposite;
1459 xr[1][l + i] = left;
1460 }
1461 else
1462 xr[1][l + i] = opposite;
1463 }
1464 }
1465 }
1466 }
1467 else { /* !(header->flags & MAD_FLAG_LSF_EXT) */
1468 for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
1469 n = sfbwidth[sfbi];
1470
1471 if (!(modes[sfbi] & i_stereo))
1472 continue;
1473
1474 is_pos = right_ch->scalefac[sfbi];
1475
1476 if (is_pos >= 7) { /* illegal intensity position */
1477 modes[sfbi] &= ~i_stereo;
1478 continue;
1479 }
1480
1481 for (i = 0; i < n; ++i) {
1482 register mad_fixed_t left;
1483
1484 left = xr[0][l + i];
1485
1486 xr[0][l + i] = mad_f_mul(left, is_table[ is_pos]);
1487 xr[1][l + i] = mad_f_mul(left, is_table[6 - is_pos]);
1488 }
1489 }
1490 }
1491 }
1492
1493 /* middle/side stereo */
1494
1495 if (header->mode_extension & ms_stereo) {
1496 register mad_fixed_t invsqrt2;
1497
1498 header->flags |= MAD_FLAG_MS_STEREO;
1499
1500 invsqrt2 = root_table[3 + -2];
1501
1502 for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
1503 n = sfbwidth[sfbi];
1504
1505 if (modes[sfbi] != ms_stereo)
1506 continue;
1507
1508 for (i = 0; i < n; ++i) {
1509 register mad_fixed_t m, s;
1510
1511 m = xr[0][l + i];
1512 s = xr[1][l + i];
1513
1514 xr[0][l + i] = mad_f_mul(m + s, invsqrt2); /* l = (m + s) / sqrt(2) */
1515 xr[1][l + i] = mad_f_mul(m - s, invsqrt2); /* r = (m - s) / sqrt(2) */
1516 }
1517 }
1518 }
1519
1520 return 0;
1521}
1522
1523/*
1524 * NAME:III_aliasreduce()
1525 * DESCRIPTION:perform frequency line alias reduction
1526 */
1527static
1528void III_aliasreduce(mad_fixed_t xr[576], int lines)
1529{
1530 mad_fixed_t const *bound;
1531 int i;
1532
1533 bound = &xr[lines];
1534 for (xr += 18; xr < bound; xr += 18) {
1535 for (i = 0; i < 8; ++i) {
1536 register mad_fixed_t *aptr, *bptr, a, b;
1537 register mad_fixed64hi_t hi;
1538 register mad_fixed64lo_t lo;
1539
1540 aptr = &xr[-1 - i];
1541 bptr = &xr[ i];
1542
1543 a = *aptr;
1544 b = *bptr;
1545
1546# if defined(ASO_ZEROCHECK)
1547 if (a | b) {
1548# endif
1549 MAD_F_ML0(hi, lo, a, cs[i]);
1550 MAD_F_MLA(hi, lo, -b, ca[i]);
1551
1552 *aptr = MAD_F_MLZ(hi, lo);
1553
1554 MAD_F_ML0(hi, lo, b, cs[i]);
1555 MAD_F_MLA(hi, lo, a, ca[i]);
1556
1557 *bptr = MAD_F_MLZ(hi, lo);
1558# if defined(ASO_ZEROCHECK)
1559 }
1560# endif
1561 }
1562 }
1563}
1564
1565# if defined(ASO_IMDCT)
1566void III_imdct_l(mad_fixed_t const [18], mad_fixed_t [36], unsigned int);
1567# else
1568/*
1569 * NAME:imdct36
1570 * DESCRIPTION:perform X[18]->x[36] IMDCT
1571 */
1572static inline
1573void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36])
1574{
1575 mad_fixed_t t0, t1, t2, t3, t4, t5, t6, t7;
1576 mad_fixed_t t8, t9, t10, t11, t12, t13, t14, t15;
1577 register mad_fixed64hi_t hi;
1578 register mad_fixed64lo_t lo;
1579
1580 MAD_F_ML0(hi, lo, X[4], MAD_F(0x0ec835e8));
1581 MAD_F_MLA(hi, lo, X[13], MAD_F(0x061f78aa));
1582
1583 t6 = MAD_F_MLZ(hi, lo);
1584
1585 MAD_F_MLA(hi, lo, (t14 = X[1] - X[10]), -MAD_F(0x061f78aa));
1586 MAD_F_MLA(hi, lo, (t15 = X[7] + X[16]), -MAD_F(0x0ec835e8));
1587
1588 t0 = MAD_F_MLZ(hi, lo);
1589
1590 MAD_F_MLA(hi, lo, (t8 = X[0] - X[11] - X[12]), MAD_F(0x0216a2a2));
1591 MAD_F_MLA(hi, lo, (t9 = X[2] - X[9] - X[14]), MAD_F(0x09bd7ca0));
1592 MAD_F_MLA(hi, lo, (t10 = X[3] - X[8] - X[15]), -MAD_F(0x0cb19346));
1593 MAD_F_MLA(hi, lo, (t11 = X[5] - X[6] - X[17]), -MAD_F(0x0fdcf549));
1594
1595 x[7] = MAD_F_MLZ(hi, lo);
1596 x[10] = -x[7];
1597
1598 MAD_F_ML0(hi, lo, t8, -MAD_F(0x0cb19346));
1599 MAD_F_MLA(hi, lo, t9, MAD_F(0x0fdcf549));
1600 MAD_F_MLA(hi, lo, t10, MAD_F(0x0216a2a2));
1601 MAD_F_MLA(hi, lo, t11, -MAD_F(0x09bd7ca0));
1602
1603 x[19] = x[34] = MAD_F_MLZ(hi, lo) - t0;
1604
1605 t12 = X[0] - X[3] + X[8] - X[11] - X[12] + X[15];
1606 t13 = X[2] + X[5] - X[6] - X[9] - X[14] - X[17];
1607
1608 MAD_F_ML0(hi, lo, t12, -MAD_F(0x0ec835e8));
1609 MAD_F_MLA(hi, lo, t13, MAD_F(0x061f78aa));
1610
1611 x[22] = x[31] = MAD_F_MLZ(hi, lo) + t0;
1612
1613 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x09bd7ca0));
1614 MAD_F_MLA(hi, lo, X[7], MAD_F(0x0216a2a2));
1615 MAD_F_MLA(hi, lo, X[10], -MAD_F(0x0fdcf549));
1616 MAD_F_MLA(hi, lo, X[16], MAD_F(0x0cb19346));
1617
1618 t1 = MAD_F_MLZ(hi, lo) + t6;
1619
1620 MAD_F_ML0(hi, lo, X[0], MAD_F(0x03768962));
1621 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0e313245));
1622 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0ffc19fd));
1623 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0acf37ad));
1624 MAD_F_MLA(hi, lo, X[6], MAD_F(0x04cfb0e2));
1625 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0898c779));
1626 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0d7e8807));
1627 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f426cb5));
1628 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0bcbe352));
1629 MAD_F_MLA(hi, lo, X[14], MAD_F(0x00b2aa3e));
1630 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x07635284));
1631 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0f9ee890));
1632
1633 x[6] = MAD_F_MLZ(hi, lo) + t1;
1634 x[11] = -x[6];
1635
1636 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f426cb5));
1637 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x00b2aa3e));
1638 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0898c779));
1639 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0f9ee890));
1640 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0acf37ad));
1641 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x07635284));
1642 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0e313245));
1643 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0bcbe352));
1644 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x03768962));
1645 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0d7e8807));
1646 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0ffc19fd));
1647 MAD_F_MLA(hi, lo, X[17], MAD_F(0x04cfb0e2));
1648
1649 x[23] = x[30] = MAD_F_MLZ(hi, lo) + t1;
1650
1651 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0bcbe352));
1652 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0d7e8807));
1653 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x07635284));
1654 MAD_F_MLA(hi, lo, X[5], MAD_F(0x04cfb0e2));
1655 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f9ee890));
1656 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0ffc19fd));
1657 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x00b2aa3e));
1658 MAD_F_MLA(hi, lo, X[11], MAD_F(0x03768962));
1659 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0f426cb5));
1660 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0e313245));
1661 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0898c779));
1662 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0acf37ad));
1663
1664 x[18] = x[35] = MAD_F_MLZ(hi, lo) - t1;
1665
1666 MAD_F_ML0(hi, lo, X[4], MAD_F(0x061f78aa));
1667 MAD_F_MLA(hi, lo, X[13], -MAD_F(0x0ec835e8));
1668
1669 t7 = MAD_F_MLZ(hi, lo);
1670
1671 MAD_F_MLA(hi, lo, X[1], -MAD_F(0x0cb19346));
1672 MAD_F_MLA(hi, lo, X[7], MAD_F(0x0fdcf549));
1673 MAD_F_MLA(hi, lo, X[10], MAD_F(0x0216a2a2));
1674 MAD_F_MLA(hi, lo, X[16], -MAD_F(0x09bd7ca0));
1675
1676 t2 = MAD_F_MLZ(hi, lo);
1677
1678 MAD_F_MLA(hi, lo, X[0], MAD_F(0x04cfb0e2));
1679 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0ffc19fd));
1680 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0d7e8807));
1681 MAD_F_MLA(hi, lo, X[5], MAD_F(0x03768962));
1682 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0bcbe352));
1683 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0e313245));
1684 MAD_F_MLA(hi, lo, X[9], MAD_F(0x07635284));
1685 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0acf37ad));
1686 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0f9ee890));
1687 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0898c779));
1688 MAD_F_MLA(hi, lo, X[15], MAD_F(0x00b2aa3e));
1689 MAD_F_MLA(hi, lo, X[17], MAD_F(0x0f426cb5));
1690
1691 x[5] = MAD_F_MLZ(hi, lo);
1692 x[12] = -x[5];
1693
1694 MAD_F_ML0(hi, lo, X[0], MAD_F(0x0acf37ad));
1695 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0898c779));
1696 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0e313245));
1697 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0f426cb5));
1698 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x03768962));
1699 MAD_F_MLA(hi, lo, X[8], MAD_F(0x00b2aa3e));
1700 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0ffc19fd));
1701 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f9ee890));
1702 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x04cfb0e2));
1703 MAD_F_MLA(hi, lo, X[14], MAD_F(0x07635284));
1704 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0d7e8807));
1705 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0bcbe352));
1706
1707 x[0] = MAD_F_MLZ(hi, lo) + t2;
1708 x[17] = -x[0];
1709
1710 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f9ee890));
1711 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x07635284));
1712 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x00b2aa3e));
1713 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0bcbe352));
1714 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f426cb5));
1715 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0d7e8807));
1716 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0898c779));
1717 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x04cfb0e2));
1718 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0acf37ad));
1719 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0ffc19fd));
1720 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0e313245));
1721 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x03768962));
1722
1723 x[24] = x[29] = MAD_F_MLZ(hi, lo) + t2;
1724
1725 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0216a2a2));
1726 MAD_F_MLA(hi, lo, X[7], -MAD_F(0x09bd7ca0));
1727 MAD_F_MLA(hi, lo, X[10], MAD_F(0x0cb19346));
1728 MAD_F_MLA(hi, lo, X[16], MAD_F(0x0fdcf549));
1729
1730 t3 = MAD_F_MLZ(hi, lo) + t7;
1731
1732 MAD_F_ML0(hi, lo, X[0], MAD_F(0x00b2aa3e));
1733 MAD_F_MLA(hi, lo, X[2], MAD_F(0x03768962));
1734 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x04cfb0e2));
1735 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x07635284));
1736 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0898c779));
1737 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0acf37ad));
1738 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0bcbe352));
1739 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0d7e8807));
1740 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0e313245));
1741 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f426cb5));
1742 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0f9ee890));
1743 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0ffc19fd));
1744
1745 x[8] = MAD_F_MLZ(hi, lo) + t3;
1746 x[9] = -x[8];
1747
1748 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0e313245));
1749 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0bcbe352));
1750 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0f9ee890));
1751 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0898c779));
1752 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0ffc19fd));
1753 MAD_F_MLA(hi, lo, X[8], MAD_F(0x04cfb0e2));
1754 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f426cb5));
1755 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x00b2aa3e));
1756 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0d7e8807));
1757 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x03768962));
1758 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0acf37ad));
1759 MAD_F_MLA(hi, lo, X[17], MAD_F(0x07635284));
1760
1761 x[21] = x[32] = MAD_F_MLZ(hi, lo) + t3;
1762
1763 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0d7e8807));
1764 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0f426cb5));
1765 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0acf37ad));
1766 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0ffc19fd));
1767 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x07635284));
1768 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f9ee890));
1769 MAD_F_MLA(hi, lo, X[9], MAD_F(0x03768962));
1770 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0e313245));
1771 MAD_F_MLA(hi, lo, X[12], MAD_F(0x00b2aa3e));
1772 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0bcbe352));
1773 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x04cfb0e2));
1774 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0898c779));
1775
1776 x[20] = x[33] = MAD_F_MLZ(hi, lo) - t3;
1777
1778 MAD_F_ML0(hi, lo, t14, -MAD_F(0x0ec835e8));
1779 MAD_F_MLA(hi, lo, t15, MAD_F(0x061f78aa));
1780
1781 t4 = MAD_F_MLZ(hi, lo) - t7;
1782
1783 MAD_F_ML0(hi, lo, t12, MAD_F(0x061f78aa));
1784 MAD_F_MLA(hi, lo, t13, MAD_F(0x0ec835e8));
1785
1786 x[4] = MAD_F_MLZ(hi, lo) + t4;
1787 x[13] = -x[4];
1788
1789 MAD_F_ML0(hi, lo, t8, MAD_F(0x09bd7ca0));
1790 MAD_F_MLA(hi, lo, t9, -MAD_F(0x0216a2a2));
1791 MAD_F_MLA(hi, lo, t10, MAD_F(0x0fdcf549));
1792 MAD_F_MLA(hi, lo, t11, -MAD_F(0x0cb19346));
1793
1794 x[1] = MAD_F_MLZ(hi, lo) + t4;
1795 x[16] = -x[1];
1796
1797 MAD_F_ML0(hi, lo, t8, -MAD_F(0x0fdcf549));
1798 MAD_F_MLA(hi, lo, t9, -MAD_F(0x0cb19346));
1799 MAD_F_MLA(hi, lo, t10, -MAD_F(0x09bd7ca0));
1800 MAD_F_MLA(hi, lo, t11, -MAD_F(0x0216a2a2));
1801
1802 x[25] = x[28] = MAD_F_MLZ(hi, lo) + t4;
1803
1804 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0fdcf549));
1805 MAD_F_MLA(hi, lo, X[7], -MAD_F(0x0cb19346));
1806 MAD_F_MLA(hi, lo, X[10], -MAD_F(0x09bd7ca0));
1807 MAD_F_MLA(hi, lo, X[16], -MAD_F(0x0216a2a2));
1808
1809 t5 = MAD_F_MLZ(hi, lo) - t6;
1810
1811 MAD_F_ML0(hi, lo, X[0], MAD_F(0x0898c779));
1812 MAD_F_MLA(hi, lo, X[2], MAD_F(0x04cfb0e2));
1813 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0bcbe352));
1814 MAD_F_MLA(hi, lo, X[5], MAD_F(0x00b2aa3e));
1815 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0e313245));
1816 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x03768962));
1817 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f9ee890));
1818 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x07635284));
1819 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0ffc19fd));
1820 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0acf37ad));
1821 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0f426cb5));
1822 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0d7e8807));
1823
1824 x[2] = MAD_F_MLZ(hi, lo) + t5;
1825 x[15] = -x[2];
1826
1827 MAD_F_ML0(hi, lo, X[0], MAD_F(0x07635284));
1828 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0acf37ad));
1829 MAD_F_MLA(hi, lo, X[3], MAD_F(0x03768962));
1830 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0d7e8807));
1831 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x00b2aa3e));
1832 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f426cb5));
1833 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x04cfb0e2));
1834 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0ffc19fd));
1835 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0898c779));
1836 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f9ee890));
1837 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0bcbe352));
1838 MAD_F_MLA(hi, lo, X[17], MAD_F(0x0e313245));
1839
1840 x[3] = MAD_F_MLZ(hi, lo) + t5;
1841 x[14] = -x[3];
1842
1843 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0ffc19fd));
1844 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0f9ee890));
1845 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0f426cb5));
1846 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0e313245));
1847 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0d7e8807));
1848 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0bcbe352));
1849 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0acf37ad));
1850 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0898c779));
1851 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x07635284));
1852 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x04cfb0e2));
1853 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x03768962));
1854 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x00b2aa3e));
1855
1856 x[26] = x[27] = MAD_F_MLZ(hi, lo) + t5;
1857}
1858
1859/*
1860 * NAME:III_imdct_l()
1861 * DESCRIPTION:perform IMDCT and windowing for long blocks
1862 */
1863static
1864void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36],
1865 unsigned int block_type)
1866{
1867 unsigned int i;
1868
1869 /* IMDCT */
1870
1871 imdct36(X, z);
1872
1873 /* windowing */
1874
1875 switch (block_type) {
1876 case 0: /* normal window */
1877# if defined(ASO_INTERLEAVE1)
1878 {
1879 register mad_fixed_t tmp1, tmp2;
1880
1881 tmp1 = window_l[0];
1882 tmp2 = window_l[1];
1883
1884 for (i = 0; i < 34; i += 2) {
1885 z[i + 0] = mad_f_mul(z[i + 0], tmp1);
1886 tmp1 = window_l[i + 2];
1887 z[i + 1] = mad_f_mul(z[i + 1], tmp2);
1888 tmp2 = window_l[i + 3];
1889 }
1890
1891 z[34] = mad_f_mul(z[34], tmp1);
1892 z[35] = mad_f_mul(z[35], tmp2);
1893 }
1894# elif defined(ASO_INTERLEAVE2)
1895 {
1896 register mad_fixed_t tmp1, tmp2;
1897
1898 tmp1 = z[0];
1899 tmp2 = window_l[0];
1900
1901 for (i = 0; i < 35; ++i) {
1902 z[i] = mad_f_mul(tmp1, tmp2);
1903 tmp1 = z[i + 1];
1904 tmp2 = window_l[i + 1];
1905 }
1906
1907 z[35] = mad_f_mul(tmp1, tmp2);
1908 }
1909# elif 1
1910 for (i = 0; i < 36; i += 4) {
1911 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
1912 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
1913 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
1914 z[i + 3] = mad_f_mul(z[i + 3], window_l[i + 3]);
1915 }
1916# else
1917 for (i = 0; i < 36; ++i) z[i] = mad_f_mul(z[i], window_l[i]);
1918# endif
1919 break;
1920
1921 case 1: /* start block */
1922 for (i = 0; i < 18; ++i) z[i] = mad_f_mul(z[i], window_l[i]);
1923 /* (i = 18; i < 24; ++i) z[i] unchanged */
1924 for (i = 24; i < 30; ++i) z[i] = mad_f_mul(z[i], window_s[i - 18]);
1925 for (i = 30; i < 36; ++i) z[i] = 0;
1926 break;
1927
1928 case 3: /* stop block */
1929 for (i = 0; i < 6; ++i) z[i] = 0;
1930 for (i = 6; i < 12; ++i) z[i] = mad_f_mul(z[i], window_s[i - 6]);
1931 /* (i = 12; i < 18; ++i) z[i] unchanged */
1932 for (i = 18; i < 36; ++i) z[i] = mad_f_mul(z[i], window_l[i]);
1933 break;
1934 }
1935}
1936# endif /* ASO_IMDCT */
1937
1938/*
1939 * NAME:III_imdct_s()
1940 * DESCRIPTION:perform IMDCT and windowing for short blocks
1941 */
1942static
1943void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36])
1944{
1945 mad_fixed_t y[36], *yptr;
1946 mad_fixed_t const *wptr;
1947 int w, i;
1948 register mad_fixed64hi_t hi;
1949 register mad_fixed64lo_t lo;
1950
1951 /* IMDCT */
1952
1953 yptr = &y[0];
1954
1955 for (w = 0; w < 3; ++w) {
1956 register mad_fixed_t const (*s)[6];
1957
1958 s = imdct_s;
1959
1960 for (i = 0; i < 3; ++i) {
1961 MAD_F_ML0(hi, lo, X[0], (*s)[0]);
1962 MAD_F_MLA(hi, lo, X[1], (*s)[1]);
1963 MAD_F_MLA(hi, lo, X[2], (*s)[2]);
1964 MAD_F_MLA(hi, lo, X[3], (*s)[3]);
1965 MAD_F_MLA(hi, lo, X[4], (*s)[4]);
1966 MAD_F_MLA(hi, lo, X[5], (*s)[5]);
1967
1968 yptr[i + 0] = MAD_F_MLZ(hi, lo);
1969 yptr[5 - i] = -yptr[i + 0];
1970
1971 ++s;
1972
1973 MAD_F_ML0(hi, lo, X[0], (*s)[0]);
1974 MAD_F_MLA(hi, lo, X[1], (*s)[1]);
1975 MAD_F_MLA(hi, lo, X[2], (*s)[2]);
1976 MAD_F_MLA(hi, lo, X[3], (*s)[3]);
1977 MAD_F_MLA(hi, lo, X[4], (*s)[4]);
1978 MAD_F_MLA(hi, lo, X[5], (*s)[5]);
1979
1980 yptr[ i + 6] = MAD_F_MLZ(hi, lo);
1981 yptr[11 - i] = yptr[i + 6];
1982
1983 ++s;
1984 }
1985
1986 yptr += 12;
1987 X += 6;
1988 }
1989
1990 /* windowing, overlapping and concatenation */
1991
1992 yptr = &y[0];
1993 wptr = &window_s[0];
1994
1995 for (i = 0; i < 6; ++i) {
1996 z[i + 0] = 0;
1997 z[i + 6] = mad_f_mul(yptr[ 0 + 0], wptr[0]);
1998
1999 MAD_F_ML0(hi, lo, yptr[ 0 + 6], wptr[6]);
2000 MAD_F_MLA(hi, lo, yptr[12 + 0], wptr[0]);
2001
2002 z[i + 12] = MAD_F_MLZ(hi, lo);
2003
2004 MAD_F_ML0(hi, lo, yptr[12 + 6], wptr[6]);
2005 MAD_F_MLA(hi, lo, yptr[24 + 0], wptr[0]);
2006
2007 z[i + 18] = MAD_F_MLZ(hi, lo);
2008
2009 z[i + 24] = mad_f_mul(yptr[24 + 6], wptr[6]);
2010 z[i + 30] = 0;
2011
2012 ++yptr;
2013 ++wptr;
2014 }
2015}
2016
2017/*
2018 * NAME:III_overlap()
2019 * DESCRIPTION:perform overlap-add of windowed IMDCT outputs
2020 */
2021static
2022void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18],
2023 mad_fixed_t sample[18][32], unsigned int sb)
2024{
2025 unsigned int i;
2026
2027# if defined(ASO_INTERLEAVE2)
2028 {
2029 register mad_fixed_t tmp1, tmp2;
2030
2031 tmp1 = overlap[0];
2032 tmp2 = overlap[1];
2033
2034 for (i = 0; i < 16; i += 2) {
2035 sample[i + 0][sb] = output[i + 0] + tmp1;
2036 overlap[i + 0] = output[i + 0 + 18];
2037 tmp1 = overlap[i + 2];
2038
2039 sample[i + 1][sb] = output[i + 1] + tmp2;
2040 overlap[i + 1] = output[i + 1 + 18];
2041 tmp2 = overlap[i + 3];
2042 }
2043
2044 sample[16][sb] = output[16] + tmp1;
2045 overlap[16] = output[16 + 18];
2046 sample[17][sb] = output[17] + tmp2;
2047 overlap[17] = output[17 + 18];
2048 }
2049# elif 0
2050 for (i = 0; i < 18; i += 2) {
2051 sample[i + 0][sb] = output[i + 0] + overlap[i + 0];
2052 overlap[i + 0] = output[i + 0 + 18];
2053
2054 sample[i + 1][sb] = output[i + 1] + overlap[i + 1];
2055 overlap[i + 1] = output[i + 1 + 18];
2056 }
2057# else
2058 for (i = 0; i < 18; ++i) {
2059 sample[i][sb] = output[i] + overlap[i];
2060 overlap[i] = output[i + 18];
2061 }
2062# endif
2063}
2064
2065/*
2066 * NAME:III_overlap_z()
2067 * DESCRIPTION:perform "overlap-add" of zero IMDCT outputs
2068 */
2069static inline
2070void III_overlap_z(mad_fixed_t overlap[18],
2071 mad_fixed_t sample[18][32], unsigned int sb)
2072{
2073 unsigned int i;
2074
2075# if defined(ASO_INTERLEAVE2)
2076 {
2077 register mad_fixed_t tmp1, tmp2;
2078
2079 tmp1 = overlap[0];
2080 tmp2 = overlap[1];
2081
2082 for (i = 0; i < 16; i += 2) {
2083 sample[i + 0][sb] = tmp1;
2084 overlap[i + 0] = 0;
2085 tmp1 = overlap[i + 2];
2086
2087 sample[i + 1][sb] = tmp2;
2088 overlap[i + 1] = 0;
2089 tmp2 = overlap[i + 3];
2090 }
2091
2092 sample[16][sb] = tmp1;
2093 overlap[16] = 0;
2094 sample[17][sb] = tmp2;
2095 overlap[17] = 0;
2096 }
2097# else
2098 for (i = 0; i < 18; ++i) {
2099 sample[i][sb] = overlap[i];
2100 overlap[i] = 0;
2101 }
2102# endif
2103}
2104
2105/*
2106 * NAME:III_freqinver()
2107 * DESCRIPTION:perform subband frequency inversion for odd sample lines
2108 */
2109static
2110void III_freqinver(mad_fixed_t sample[18][32], unsigned int sb)
2111{
2112 unsigned int i;
2113
2114# if 1 || defined(ASO_INTERLEAVE1) || defined(ASO_INTERLEAVE2)
2115 {
2116 register mad_fixed_t tmp1, tmp2;
2117
2118 tmp1 = sample[1][sb];
2119 tmp2 = sample[3][sb];
2120
2121 for (i = 1; i < 13; i += 4) {
2122 sample[i + 0][sb] = -tmp1;
2123 tmp1 = sample[i + 4][sb];
2124 sample[i + 2][sb] = -tmp2;
2125 tmp2 = sample[i + 6][sb];
2126 }
2127
2128 sample[13][sb] = -tmp1;
2129 tmp1 = sample[17][sb];
2130 sample[15][sb] = -tmp2;
2131 sample[17][sb] = -tmp1;
2132 }
2133# else
2134 for (i = 1; i < 18; i += 2)
2135 sample[i][sb] = -sample[i][sb];
2136# endif
2137}
2138
2139/*
2140 * NAME:III_decode()
2141 * DESCRIPTION:decode frame main_data
2142 */
2143static
2144int III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
2145 struct sideinfo *si, unsigned int nch)
2146{
2147 struct mad_header *header = &frame->header;
2148 unsigned int sfreqi, ngr, gr;
2149
2150 {
2151 unsigned int sfreq;
2152
2153 sfreq = header->samplerate;
2154 if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
2155 sfreq *= 2;
2156
2157 /* 48000 => 0, 44100 => 1, 32000 => 2,
2158 24000 => 3, 22050 => 4, 16000 => 5 */
2159 sfreqi = ((sfreq >> 7) & 0x000f) +
2160 ((sfreq >> 15) & 0x0001) - 8;
2161
2162 if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
2163 sfreqi += 3;
2164 }
2165
2166 /* scalefactors, Huffman decoding, requantization */
2167
2168 ngr = (header->flags & MAD_FLAG_LSF_EXT) ? 1 : 2;
2169
2170 for (gr = 0; gr < ngr; ++gr) {
2171 struct granule *granule = &si->gr[gr];
2172 unsigned char const *sfbwidth = 0;
2173 mad_fixed_t xr[2][576];
2174 unsigned int ch;
2175 enum mad_error error;
2176
2177 for (ch = 0; ch < nch; ++ch) {
2178 struct channel *channel = &granule->ch[ch];
2179 unsigned int part2_length;
2180
2181 sfbwidth = sfbwidth_table[sfreqi].l;
2182 if (channel->block_type == 2) {
2183 sfbwidth = (channel->flags & mixed_block_flag) ?
2184 sfbwidth_table[sfreqi].m : sfbwidth_table[sfreqi].s;
2185 }
2186
2187 if (header->flags & MAD_FLAG_LSF_EXT) {
2188 part2_length = III_scalefactors_lsf(ptr, channel,
2189 ch == 0 ? 0 : &si->gr[1].ch[1],
2190 header->mode_extension);
2191 }
2192 else {
2193 part2_length = III_scalefactors(ptr, channel, &si->gr[0].ch[ch],
2194 gr == 0 ? 0 : si->scfsi[ch]);
2195 }
2196
2197 error = III_huffdecode(ptr, xr[ch], channel, sfbwidth, part2_length);
2198 if (error)
2199 return error;
2200 }
2201
2202 /* joint stereo processing */
2203
2204 if (header->mode == MAD_MODE_JOINT_STEREO && header->mode_extension) {
2205 error = III_stereo(xr, granule, header, sfbwidth);
2206 if (error)
2207 return error;
2208 }
2209
2210 /* reordering, alias reduction, IMDCT, overlap-add, frequency inversion */
2211
2212 for (ch = 0; ch < nch; ++ch) {
2213 struct channel const *channel = &granule->ch[ch];
2214 mad_fixed_t (*sample)[32] = &frame->sbsample[ch][18 * gr];
2215 unsigned int sb, l, i, sblimit;
2216 mad_fixed_t output[36];
2217
2218 if (channel->block_type == 2) {
2219 III_reorder(xr[ch], channel, sfbwidth_table[sfreqi].s);
2220
2221# if !defined(OPT_STRICT)
2222 /*
2223 * According to ISO/IEC 11172-3, "Alias reduction is not applied for
2224 * granules with block_type == 2 (short block)." However, other
2225 * sources suggest alias reduction should indeed be performed on the
2226 * lower two subbands of mixed blocks. Most other implementations do
2227 * this, so by default we will too.
2228 */
2229 if (channel->flags & mixed_block_flag)
2230 III_aliasreduce(xr[ch], 36);
2231# endif
2232 }
2233 else
2234 III_aliasreduce(xr[ch], 576);
2235
2236 l = 0;
2237
2238 /* subbands 0-1 */
2239
2240 if (channel->block_type != 2 || (channel->flags & mixed_block_flag)) {
2241 unsigned int block_type;
2242
2243 block_type = channel->block_type;
2244 if (channel->flags & mixed_block_flag)
2245 block_type = 0;
2246
2247 /* long blocks */
2248 for (sb = 0; sb < 2; ++sb, l += 18) {
2249 III_imdct_l(&xr[ch][l], output, block_type);
2250 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
2251 }
2252 }
2253 else {
2254 /* short blocks */
2255 for (sb = 0; sb < 2; ++sb, l += 18) {
2256 III_imdct_s(&xr[ch][l], output);
2257 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
2258 }
2259 }
2260
2261 III_freqinver(sample, 1);
2262
2263 /* (nonzero) subbands 2-31 */
2264
2265 i = 576;
2266 while (i > 36 && xr[ch][i - 1] == 0)
2267 --i;
2268
2269 sblimit = 32 - (576 - i) / 18;
2270
2271 if (channel->block_type != 2) {
2272 /* long blocks */
2273 for (sb = 2; sb < sblimit; ++sb, l += 18) {
2274 III_imdct_l(&xr[ch][l], output, channel->block_type);
2275 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
2276
2277 if (sb & 1)
2278 III_freqinver(sample, sb);
2279 }
2280 }
2281 else {
2282 /* short blocks */
2283 for (sb = 2; sb < sblimit; ++sb, l += 18) {
2284 III_imdct_s(&xr[ch][l], output);
2285 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
2286
2287 if (sb & 1)
2288 III_freqinver(sample, sb);
2289 }
2290 }
2291
2292 /* remaining (zero) subbands */
2293
2294 for (sb = sblimit; sb < 32; ++sb) {
2295 III_overlap_z((*frame->overlap)[ch][sb], sample, sb);
2296
2297 if (sb & 1)
2298 III_freqinver(sample, sb);
2299 }
2300 }
2301 }
2302
2303 return 0;
2304}
2305
2306/*
2307 * NAME:layer->III()
2308 * DESCRIPTION:decode a single Layer III frame
2309 */
2310int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
2311{
2312 struct mad_header *header = &frame->header;
2313 unsigned int nch, priv_bitlen, next_md_begin = 0;
2314 unsigned int si_len, data_bitlen, md_len;
2315 unsigned int frame_space, frame_used, frame_free;
2316 struct mad_bitptr ptr;
2317 struct sideinfo si;
2318 enum mad_error error;
2319 int result = 0;
2320
2321 /* allocate Layer III dynamic structures */
2322
2323 if (stream->main_data == 0) {
2324 stream->main_data = malloc(MAD_BUFFER_MDLEN);
2325 if (stream->main_data == 0) {
2326 stream->error = MAD_ERROR_NOMEM;
2327 return -1;
2328 }
2329 }
2330
2331 if (frame->overlap == 0) {
2332 frame->overlap = calloc(2 * 32 * 18, sizeof(mad_fixed_t));
2333 if (frame->overlap == 0) {
2334 stream->error = MAD_ERROR_NOMEM;
2335 return -1;
2336 }
2337 }
2338
2339 nch = MAD_NCHANNELS(header);
2340 si_len = (header->flags & MAD_FLAG_LSF_EXT) ?
2341 (nch == 1 ? 9 : 17) : (nch == 1 ? 17 : 32);
2342
2343 /* check frame sanity */
2344
2345 if (stream->next_frame - mad_bit_nextbyte(&stream->ptr) <
2346 (signed int) si_len) {
2347 stream->error = MAD_ERROR_BADFRAMELEN;
2348 stream->md_len = 0;
2349 return -1;
2350 }
2351
2352 /* check CRC word */
2353
2354 if (header->flags & MAD_FLAG_PROTECTION) {
2355 header->crc_check =
2356 mad_bit_crc(stream->ptr, si_len * CHAR_BIT, header->crc_check);
2357
2358 if (header->crc_check != header->crc_target &&
2359 !(frame->options & MAD_OPTION_IGNORECRC)) {
2360 stream->error = MAD_ERROR_BADCRC;
2361 result = -1;
2362 }
2363 }
2364
2365 /* decode frame side information */
2366
2367 error = III_sideinfo(&stream->ptr, nch, header->flags & MAD_FLAG_LSF_EXT,
2368 &si, &data_bitlen, &priv_bitlen);
2369 if (error && result == 0) {
2370 stream->error = error;
2371 result = -1;
2372 }
2373
2374 header->flags |= priv_bitlen;
2375 header->private_bits |= si.private_bits;
2376
2377 /* find main_data of next frame */
2378
2379 {
2380 struct mad_bitptr peek;
2381 unsigned long header;
2382
2383 mad_bit_init(&peek, stream->next_frame);
2384
2385 header = mad_bit_read(&peek, 32);
2386 if ((header & 0xffe60000L) /* syncword | layer */ == 0xffe20000L) {
2387 if (!(header & 0x00010000L)) /* protection_bit */
2388 mad_bit_skip(&peek, 16); /* crc_check */
2389
2390 next_md_begin =
2391 mad_bit_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8);
2392 }
2393
2394 mad_bit_finish(&peek);
2395 }
2396
2397 /* find main_data of this frame */
2398
2399 frame_space = stream->next_frame - mad_bit_nextbyte(&stream->ptr);
2400
2401 if (next_md_begin > si.main_data_begin + frame_space)
2402 next_md_begin = 0;
2403
2404 md_len = si.main_data_begin + frame_space - next_md_begin;
2405
2406 frame_used = 0;
2407
2408 if (si.main_data_begin == 0) {
2409 ptr = stream->ptr;
2410 stream->md_len = 0;
2411
2412 frame_used = md_len;
2413 }
2414 else {
2415 if (si.main_data_begin > stream->md_len) {
2416 if (result == 0) {
2417 stream->error = MAD_ERROR_BADDATAPTR;
2418 result = -1;
2419 }
2420 }
2421 else {
2422 mad_bit_init(&ptr,
2423 *stream->main_data + stream->md_len - si.main_data_begin);
2424
2425 if (md_len > si.main_data_begin) {
2426 assert(stream->md_len + md_len -
2427 si.main_data_begin <= MAD_BUFFER_MDLEN);
2428
2429 memcpy(*stream->main_data + stream->md_len,
2430 mad_bit_nextbyte(&stream->ptr),
2431 frame_used = md_len - si.main_data_begin);
2432 stream->md_len += frame_used;
2433 }
2434 }
2435 }
2436
2437 frame_free = frame_space - frame_used;
2438
2439 /* decode main_data */
2440
2441 if (result == 0) {
2442 error = III_decode(&ptr, frame, &si, nch);
2443 if (error) {
2444 stream->error = error;
2445 result = -1;
2446 }
2447 }
2448
2449 /* designate ancillary bits */
2450
2451 stream->anc_ptr = ptr;
2452 stream->anc_bitlen = md_len * CHAR_BIT - data_bitlen;
2453
2454# if 0 && defined(DEBUG)
2455 fprintf(stderr,
2456 "main_data_begin:%u, md_len:%u, frame_free:%u, "
2457 "data_bitlen:%u, anc_bitlen: %u\n",
2458 si.main_data_begin, md_len, frame_free,
2459 data_bitlen, stream->anc_bitlen);
2460# endif
2461
2462 /* preload main_data buffer with up to 511 bytes for next frame(s) */
2463
2464 if (frame_free >= next_md_begin) {
2465 memcpy(*stream->main_data,
2466 stream->next_frame - next_md_begin, next_md_begin);
2467 stream->md_len = next_md_begin;
2468 }
2469 else {
2470 if (md_len < si.main_data_begin) {
2471 unsigned int extra;
2472
2473 extra = si.main_data_begin - md_len;
2474 if (extra + frame_free > next_md_begin)
2475 extra = next_md_begin - frame_free;
2476
2477 if (extra < stream->md_len) {
2478 memmove(*stream->main_data,
2479 *stream->main_data + stream->md_len - extra, extra);
2480 stream->md_len = extra;
2481 }
2482 }
2483 else
2484 stream->md_len = 0;
2485
2486 memcpy(*stream->main_data + stream->md_len,
2487 stream->next_frame - frame_free, frame_free);
2488 stream->md_len += frame_free;
2489 }
2490
2491 return result;
2492}