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