?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Comment unused code in libmad. Clean up initialization and memset'ing of decoder...
[kugel-rb.git] / apps / codecs / libmad / layer3.c
blob0198e66a3d662183a104cae093302c62c041c9c3
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$
20 */
21
22 # ifdef HAVE_CONFIG_H
23 # include "config.h"
24 # endif
25
26 # include "global.h"
27
28 # include <string.h>
29
30 # ifdef HAVE_ASSERT_H
31 # include <assert.h>
32 # endif
33
34 # ifdef HAVE_LIMITS_H
35 # include <limits.h>
36 # else
37 # undef CHAR_BIT
38 # define CHAR_BIT 8
39 # endif
40
41 # include "fixed.h"
42 # include "bit.h"
43 # include "stream.h"
44 # include "frame.h"
45 # include "huffman.h"
46 # include "layer3.h"
47
48 /* depending on the cpu "leftshift32" may be supported or not */
49 # if defined(CPU_COLDFIRE)
50 #define MAXLSHIFT 32
51 #else
52 #define MAXLSHIFT 31
53 #endif
54
55 /* --- Layer III ----------------------------------------------------------- */
56
57 enum {
58 count1table_select = 0x01,
59 scalefac_scale = 0x02,
60 preflag = 0x04,
61 mixed_block_flag = 0x08
62 };
63
64 enum {
65 I_STEREO = 0x1,
66 MS_STEREO = 0x2
67 };
68
69 struct sideinfo {
70 unsigned int main_data_begin;
71 unsigned int private_bits;
72
73 unsigned char scfsi[2];
74
75 struct granule {
76 struct channel {
77 /* from side info */
78 unsigned short part2_3_length;
79 unsigned short big_values;
80 unsigned short global_gain;
81 unsigned short scalefac_compress;
82
83 unsigned char flags;
84 unsigned char block_type;
85 unsigned char table_select[3];
86 unsigned char subblock_gain[3];
87 unsigned char region0_count;
88 unsigned char region1_count;
89
90 /* from main_data */
91 unsigned char scalefac[39]; /* scalefac_l and/or scalefac_s */
92 } ch[2];
93 } gr[2];
94 };
95
96 /*
97 * scalefactor bit lengths
98 * derived from section 2.4.2.7 of ISO/IEC 11172-3
99 */
100 static
101 struct {
102 unsigned char slen1;
103 unsigned char slen2;
104 } const sflen_table[16] = {
105 { 0, 0 }, { 0, 1 }, { 0, 2 }, { 0, 3 },
106 { 3, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 },
107 { 2, 1 }, { 2, 2 }, { 2, 3 }, { 3, 1 },
108 { 3, 2 }, { 3, 3 }, { 4, 2 }, { 4, 3 }
109 };
110
111 /*
112 * number of LSF scalefactor band values
113 * derived from section 2.4.3.2 of ISO/IEC 13818-3
114 */
115 static
116 unsigned char const nsfb_table[6][3][4] = {
117 { { 6, 5, 5, 5 },
118 { 9, 9, 9, 9 },
119 { 6, 9, 9, 9 } },
120
121 { { 6, 5, 7, 3 },
122 { 9, 9, 12, 6 },
123 { 6, 9, 12, 6 } },
124
125 { { 11, 10, 0, 0 },
126 { 18, 18, 0, 0 },
127 { 15, 18, 0, 0 } },
128
129 { { 7, 7, 7, 0 },
130 { 12, 12, 12, 0 },
131 { 6, 15, 12, 0 } },
132
133 { { 6, 6, 6, 3 },
134 { 12, 9, 9, 6 },
135 { 6, 12, 9, 6 } },
136
137 { { 8, 8, 5, 0 },
138 { 15, 12, 9, 0 },
139 { 6, 18, 9, 0 } }
140 };
141
142 /*
143 * MPEG-1 scalefactor band widths
144 * derived from Table B.8 of ISO/IEC 11172-3
145 */
146 static
147 unsigned char const sfb_48000_long[] = {
148 4, 4, 4, 4, 4, 4, 6, 6, 6, 8, 10,
149 12, 16, 18, 22, 28, 34, 40, 46, 54, 54, 192
150 };
151
152 static
153 unsigned char const sfb_44100_long[] = {
154 4, 4, 4, 4, 4, 4, 6, 6, 8, 8, 10,
155 12, 16, 20, 24, 28, 34, 42, 50, 54, 76, 158
156 };
157
158 static
159 unsigned char const sfb_32000_long[] = {
160 4, 4, 4, 4, 4, 4, 6, 6, 8, 10, 12,
161 16, 20, 24, 30, 38, 46, 56, 68, 84, 102, 26
162 };
163
164 static
165 unsigned char const sfb_48000_short[] = {
166 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
167 6, 6, 6, 6, 6, 10, 10, 10, 12, 12, 12, 14, 14,
168 14, 16, 16, 16, 20, 20, 20, 26, 26, 26, 66, 66, 66
169 };
170
171 static
172 unsigned char const sfb_44100_short[] = {
173 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
174 6, 6, 8, 8, 8, 10, 10, 10, 12, 12, 12, 14, 14,
175 14, 18, 18, 18, 22, 22, 22, 30, 30, 30, 56, 56, 56
176 };
177
178 static
179 unsigned char const sfb_32000_short[] = {
180 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 6,
181 6, 6, 8, 8, 8, 12, 12, 12, 16, 16, 16, 20, 20,
182 20, 26, 26, 26, 34, 34, 34, 42, 42, 42, 12, 12, 12
183 };
184
185 static
186 unsigned char const sfb_48000_mixed[] = {
187 /* long */ 4, 4, 4, 4, 4, 4, 6, 6,
188 /* short */ 4, 4, 4, 6, 6, 6, 6, 6, 6, 10,
189 10, 10, 12, 12, 12, 14, 14, 14, 16, 16,
190 16, 20, 20, 20, 26, 26, 26, 66, 66, 66
191 };
192
193 static
194 unsigned char const sfb_44100_mixed[] = {
195 /* long */ 4, 4, 4, 4, 4, 4, 6, 6,
196 /* short */ 4, 4, 4, 6, 6, 6, 8, 8, 8, 10,
197 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
198 18, 22, 22, 22, 30, 30, 30, 56, 56, 56
199 };
200
201 static
202 unsigned char const sfb_32000_mixed[] = {
203 /* long */ 4, 4, 4, 4, 4, 4, 6, 6,
204 /* short */ 4, 4, 4, 6, 6, 6, 8, 8, 8, 12,
205 12, 12, 16, 16, 16, 20, 20, 20, 26, 26,
206 26, 34, 34, 34, 42, 42, 42, 12, 12, 12
207 };
208
209 /*
210 * MPEG-2 scalefactor band widths
211 * derived from Table B.2 of ISO/IEC 13818-3
212 */
213 static
214 unsigned char const sfb_24000_long[] = {
215 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
216 18, 22, 26, 32, 38, 46, 54, 62, 70, 76, 36
217 };
218
219 static
220 unsigned char const sfb_22050_long[] = {
221 6, 6, 6, 6, 6, 6, 8, 10, 12, 14, 16,
222 20, 24, 28, 32, 38, 46, 52, 60, 68, 58, 54
223 };
224
225 # define sfb_16000_long sfb_22050_long
226
227 static
228 unsigned char const sfb_24000_short[] = {
229 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8,
230 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
231 18, 24, 24, 24, 32, 32, 32, 44, 44, 44, 12, 12, 12
232 };
233
234 static
235 unsigned char const sfb_22050_short[] = {
236 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 6,
237 6, 6, 8, 8, 8, 10, 10, 10, 14, 14, 14, 18, 18,
238 18, 26, 26, 26, 32, 32, 32, 42, 42, 42, 18, 18, 18
239 };
240
241 static
242 unsigned char const sfb_16000_short[] = {
243 4, 4, 4, 4, 4, 4, 4, 4, 4, 6, 6, 6, 8,
244 8, 8, 10, 10, 10, 12, 12, 12, 14, 14, 14, 18, 18,
245 18, 24, 24, 24, 30, 30, 30, 40, 40, 40, 18, 18, 18
246 };
247
248 static
249 unsigned char const sfb_24000_mixed[] = {
250 /* long */ 6, 6, 6, 6, 6, 6,
251 /* short */ 6, 6, 6, 8, 8, 8, 10, 10, 10, 12,
252 12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
253 24, 32, 32, 32, 44, 44, 44, 12, 12, 12
254 };
255
256 static
257 unsigned char const sfb_22050_mixed[] = {
258 /* long */ 6, 6, 6, 6, 6, 6,
259 /* short */ 6, 6, 6, 6, 6, 6, 8, 8, 8, 10,
260 10, 10, 14, 14, 14, 18, 18, 18, 26, 26,
261 26, 32, 32, 32, 42, 42, 42, 18, 18, 18
262 };
263
264 static
265 unsigned char const sfb_16000_mixed[] = {
266 /* long */ 6, 6, 6, 6, 6, 6,
267 /* short */ 6, 6, 6, 8, 8, 8, 10, 10, 10, 12,
268 12, 12, 14, 14, 14, 18, 18, 18, 24, 24,
269 24, 30, 30, 30, 40, 40, 40, 18, 18, 18
270 };
271
272 /*
273 * MPEG 2.5 scalefactor band widths
274 * derived from public sources
275 */
276 # define sfb_12000_long sfb_16000_long
277 # define sfb_11025_long sfb_12000_long
278
279 static
280 unsigned char const sfb_8000_long[] = {
281 12, 12, 12, 12, 12, 12, 16, 20, 24, 28, 32,
282 40, 48, 56, 64, 76, 90, 2, 2, 2, 2, 2
283 };
284
285 # define sfb_12000_short sfb_16000_short
286 # define sfb_11025_short sfb_12000_short
287
288 static
289 unsigned char const sfb_8000_short[] = {
290 8, 8, 8, 8, 8, 8, 8, 8, 8, 12, 12, 12, 16,
291 16, 16, 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36,
292 36, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26
293 };
294
295 # define sfb_12000_mixed sfb_16000_mixed
296 # define sfb_11025_mixed sfb_12000_mixed
297
298 /* the 8000 Hz short block scalefactor bands do not break after
299 the first 36 frequency lines, so this is probably wrong */
300 static
301 unsigned char const sfb_8000_mixed[] = {
302 /* long */ 12, 12, 12,
303 /* short */ 4, 4, 4, 8, 8, 8, 12, 12, 12, 16, 16, 16,
304 20, 20, 20, 24, 24, 24, 28, 28, 28, 36, 36, 36,
305 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 26, 26
306 };
307
308 static
309 struct {
310 unsigned char const *l;
311 unsigned char const *s;
312 unsigned char const *m;
313 } const sfbwidth_table[9] = {
314 { sfb_48000_long, sfb_48000_short, sfb_48000_mixed },
315 { sfb_44100_long, sfb_44100_short, sfb_44100_mixed },
316 { sfb_32000_long, sfb_32000_short, sfb_32000_mixed },
317 { sfb_24000_long, sfb_24000_short, sfb_24000_mixed },
318 { sfb_22050_long, sfb_22050_short, sfb_22050_mixed },
319 { sfb_16000_long, sfb_16000_short, sfb_16000_mixed },
320 { sfb_12000_long, sfb_12000_short, sfb_12000_mixed },
321 { sfb_11025_long, sfb_11025_short, sfb_11025_mixed },
322 { sfb_8000_long, sfb_8000_short, sfb_8000_mixed }
323 };
324
325 /*
326 * scalefactor band preemphasis (used only when preflag is set)
327 * derived from Table B.6 of ISO/IEC 11172-3
328 */
329 static
330 unsigned char const pretab[22] = {
331 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 3, 3, 3, 2, 0
332 };
333
334 /*
335 * table for requantization
336 *
337 * rq_table[x].mantissa * 2^(rq_table[x].exponent) = x^(4/3)
338 *
339 * format rq_table: bit31-27=exponent bit26-0=mantissa
340 */
341 static
342 unsigned long const rq_table[8207] = {
343 # include "rq_table.dat"
344 };
345
346 /*
347 * fractional powers of two
348 * used for requantization and joint stereo decoding
349 *
350 * root_table[3 + x] = 2^(x/4)
351 */
352 mad_fixed_t const root_table[7] ICONST_ATTR = {
353 MAD_F(0x09837f05) /* 2^(-3/4) == 0.59460355750136 */,
354 MAD_F(0x0b504f33) /* 2^(-2/4) == 0.70710678118655 */,
355 MAD_F(0x0d744fcd) /* 2^(-1/4) == 0.84089641525371 */,
356 MAD_F(0x10000000) /* 2^( 0/4) == 1.00000000000000 */,
357 MAD_F(0x1306fe0a) /* 2^(+1/4) == 1.18920711500272 */,
358 MAD_F(0x16a09e66) /* 2^(+2/4) == 1.41421356237310 */,
359 MAD_F(0x1ae89f99) /* 2^(+3/4) == 1.68179283050743 */
360 };
361
362 /*
363 * coefficients for aliasing reduction
364 * derived from Table B.9 of ISO/IEC 11172-3
365 *
366 * c[] = { -0.6, -0.535, -0.33, -0.185, -0.095, -0.041, -0.0142, -0.0037 }
367 * cs[i] = 1 / sqrt(1 + c[i]^2)
368 * ca[i] = c[i] / sqrt(1 + c[i]^2)
369 */
370 mad_fixed_t const cs[8] ICONST_ATTR = {
371 +MAD_F(0x0db84a81) /* +0.857492926 */, +MAD_F(0x0e1b9d7f) /* +0.881741997 */,
372 +MAD_F(0x0f31adcf) /* +0.949628649 */, +MAD_F(0x0fbba815) /* +0.983314592 */,
373 +MAD_F(0x0feda417) /* +0.995517816 */, +MAD_F(0x0ffc8fc8) /* +0.999160558 */,
374 +MAD_F(0x0fff964c) /* +0.999899195 */, +MAD_F(0x0ffff8d3) /* +0.999993155 */
375 };
376
377 mad_fixed_t const ca[8] ICONST_ATTR = {
378 -MAD_F(0x083b5fe7) /* -0.514495755 */, -MAD_F(0x078c36d2) /* -0.471731969 */,
379 -MAD_F(0x05039814) /* -0.313377454 */, -MAD_F(0x02e91dd1) /* -0.181913200 */,
380 -MAD_F(0x0183603a) /* -0.094574193 */, -MAD_F(0x00a7cb87) /* -0.040965583 */,
381 -MAD_F(0x003a2847) /* -0.014198569 */, -MAD_F(0x000f27b4) /* -0.003699975 */
382 };
383
384 /*
385 * IMDCT coefficients for short blocks
386 * derived from section 2.4.3.4.10.2 of ISO/IEC 11172-3
387 *
388 * imdct_s[i/even][k] = cos((PI / 24) * (2 * (i / 2) + 7) * (2 * k + 1))
389 * imdct_s[i /odd][k] = cos((PI / 24) * (2 * (6 + (i-1)/2) + 7) * (2 * k + 1))
390 */
391 mad_fixed_t const imdct_s[6][6] ICONST_ATTR = {
392 # include "imdct_s.dat"
393 };
394
395 # if !defined(ASO_IMDCT)
396 /*
397 * windowing coefficients for long blocks
398 * derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3
399 *
400 * window_l[i] = sin((PI / 36) * (i + 1/2))
401 */
402 static
403 mad_fixed_t const window_l[36] ICONST_ATTR = {
404 MAD_F(0x00b2aa3e) /* 0.043619387 */, MAD_F(0x0216a2a2) /* 0.130526192 */,
405 MAD_F(0x03768962) /* 0.216439614 */, MAD_F(0x04cfb0e2) /* 0.300705800 */,
406 MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x07635284) /* 0.461748613 */,
407 MAD_F(0x0898c779) /* 0.537299608 */, MAD_F(0x09bd7ca0) /* 0.608761429 */,
408 MAD_F(0x0acf37ad) /* 0.675590208 */, MAD_F(0x0bcbe352) /* 0.737277337 */,
409 MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x0d7e8807) /* 0.843391446 */,
410
411 MAD_F(0x0e313245) /* 0.887010833 */, MAD_F(0x0ec835e8) /* 0.923879533 */,
412 MAD_F(0x0f426cb5) /* 0.953716951 */, MAD_F(0x0f9ee890) /* 0.976296007 */,
413 MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ffc19fd) /* 0.999048222 */,
414 MAD_F(0x0ffc19fd) /* 0.999048222 */, MAD_F(0x0fdcf549) /* 0.991444861 */,
415 MAD_F(0x0f9ee890) /* 0.976296007 */, MAD_F(0x0f426cb5) /* 0.953716951 */,
416 MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0e313245) /* 0.887010833 */,
417
418 MAD_F(0x0d7e8807) /* 0.843391446 */, MAD_F(0x0cb19346) /* 0.793353340 */,
419 MAD_F(0x0bcbe352) /* 0.737277337 */, MAD_F(0x0acf37ad) /* 0.675590208 */,
420 MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0898c779) /* 0.537299608 */,
421 MAD_F(0x07635284) /* 0.461748613 */, MAD_F(0x061f78aa) /* 0.382683432 */,
422 MAD_F(0x04cfb0e2) /* 0.300705800 */, MAD_F(0x03768962) /* 0.216439614 */,
423 MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x00b2aa3e) /* 0.043619387 */,
424 };
425 # endif /* ASO_IMDCT */
426
427 /*
428 * windowing coefficients for short blocks
429 * derived from section 2.4.3.4.10.3 of ISO/IEC 11172-3
430 *
431 * window_s[i] = sin((PI / 12) * (i + 1/2))
432 */
433 mad_fixed_t const window_s[12] ICONST_ATTR = {
434 MAD_F(0x0216a2a2) /* 0.130526192 */, MAD_F(0x061f78aa) /* 0.382683432 */,
435 MAD_F(0x09bd7ca0) /* 0.608761429 */, MAD_F(0x0cb19346) /* 0.793353340 */,
436 MAD_F(0x0ec835e8) /* 0.923879533 */, MAD_F(0x0fdcf549) /* 0.991444861 */,
437 MAD_F(0x0fdcf549) /* 0.991444861 */, MAD_F(0x0ec835e8) /* 0.923879533 */,
438 MAD_F(0x0cb19346) /* 0.793353340 */, MAD_F(0x09bd7ca0) /* 0.608761429 */,
439 MAD_F(0x061f78aa) /* 0.382683432 */, MAD_F(0x0216a2a2) /* 0.130526192 */,
440 };
441
442 /*
443 * coefficients for intensity stereo processing
444 * derived from section 2.4.3.4.9.3 of ISO/IEC 11172-3
445 *
446 * is_ratio[i] = tan(i * (PI / 12))
447 * is_table[i] = is_ratio[i] / (1 + is_ratio[i])
448 */
449 static
450 mad_fixed_t const is_table[7] = {
451 MAD_F(0x00000000) /* 0.000000000 */,
452 MAD_F(0x0361962f) /* 0.211324865 */,
453 MAD_F(0x05db3d74) /* 0.366025404 */,
454 MAD_F(0x08000000) /* 0.500000000 */,
455 MAD_F(0x0a24c28c) /* 0.633974596 */,
456 MAD_F(0x0c9e69d1) /* 0.788675135 */,
457 MAD_F(0x10000000) /* 1.000000000 */
458 };
459
460 /*
461 * coefficients for LSF intensity stereo processing
462 * derived from section 2.4.3.2 of ISO/IEC 13818-3
463 *
464 * is_lsf_table[0][i] = (1 / sqrt(sqrt(2)))^(i + 1)
465 * is_lsf_table[1][i] = (1 / sqrt(2)) ^(i + 1)
466 */
467 static
468 mad_fixed_t const is_lsf_table[2][15] = {
469 {
470 MAD_F(0x0d744fcd) /* 0.840896415 */,
471 MAD_F(0x0b504f33) /* 0.707106781 */,
472 MAD_F(0x09837f05) /* 0.594603558 */,
473 MAD_F(0x08000000) /* 0.500000000 */,
474 MAD_F(0x06ba27e6) /* 0.420448208 */,
475 MAD_F(0x05a8279a) /* 0.353553391 */,
476 MAD_F(0x04c1bf83) /* 0.297301779 */,
477 MAD_F(0x04000000) /* 0.250000000 */,
478 MAD_F(0x035d13f3) /* 0.210224104 */,
479 MAD_F(0x02d413cd) /* 0.176776695 */,
480 MAD_F(0x0260dfc1) /* 0.148650889 */,
481 MAD_F(0x02000000) /* 0.125000000 */,
482 MAD_F(0x01ae89fa) /* 0.105112052 */,
483 MAD_F(0x016a09e6) /* 0.088388348 */,
484 MAD_F(0x01306fe1) /* 0.074325445 */
485 }, {
486 MAD_F(0x0b504f33) /* 0.707106781 */,
487 MAD_F(0x08000000) /* 0.500000000 */,
488 MAD_F(0x05a8279a) /* 0.353553391 */,
489 MAD_F(0x04000000) /* 0.250000000 */,
490 MAD_F(0x02d413cd) /* 0.176776695 */,
491 MAD_F(0x02000000) /* 0.125000000 */,
492 MAD_F(0x016a09e6) /* 0.088388348 */,
493 MAD_F(0x01000000) /* 0.062500000 */,
494 MAD_F(0x00b504f3) /* 0.044194174 */,
495 MAD_F(0x00800000) /* 0.031250000 */,
496 MAD_F(0x005a827a) /* 0.022097087 */,
497 MAD_F(0x00400000) /* 0.015625000 */,
498 MAD_F(0x002d413d) /* 0.011048543 */,
499 MAD_F(0x00200000) /* 0.007812500 */,
500 MAD_F(0x0016a09e) /* 0.005524272 */
501 }
502 };
503
504 /*
505 * NAME: III_sideinfo()
506 * DESCRIPTION: decode frame side information from a bitstream
507 */
508 static
509 enum mad_error III_sideinfo(struct mad_bitptr *ptr, unsigned int nch,
510 int lsf, struct sideinfo *si,
511 unsigned int *data_bitlen,
512 unsigned int *priv_bitlen)
513 {
514 unsigned int ngr, gr, ch, i;
515 enum mad_error result = MAD_ERROR_NONE;
516
517 *data_bitlen = 0;
518 *priv_bitlen = lsf ? ((nch == 1) ? 1 : 2) : ((nch == 1) ? 5 : 3);
519
520 si->main_data_begin = mad_bit_read(ptr, lsf ? 8 : 9);
521 si->private_bits = mad_bit_read(ptr, *priv_bitlen);
522
523 ngr = 1;
524 if (!lsf) {
525 ngr = 2;
526
527 for (ch = 0; ch < nch; ++ch)
528 si->scfsi[ch] = mad_bit_read(ptr, 4);
529 }
530
531 for (gr = 0; gr < ngr; ++gr) {
532 struct granule *granule = &si->gr[gr];
533
534 for (ch = 0; ch < nch; ++ch) {
535 struct channel *channel = &granule->ch[ch];
536
537 channel->part2_3_length = mad_bit_read(ptr, 12);
538 channel->big_values = mad_bit_read(ptr, 9);
539 channel->global_gain = mad_bit_read(ptr, 8);
540 channel->scalefac_compress = mad_bit_read(ptr, lsf ? 9 : 4);
541
542 *data_bitlen += channel->part2_3_length;
543
544 if (channel->big_values > 288 && result == 0)
545 result = MAD_ERROR_BADBIGVALUES;
546
547 channel->flags = 0;
548
549 /* window_switching_flag */
550 if (mad_bit_read(ptr, 1)) {
551 channel->block_type = mad_bit_read(ptr, 2);
552
553 if (channel->block_type == 0 && result == 0)
554 result = MAD_ERROR_BADBLOCKTYPE;
555
556 if (!lsf && channel->block_type == 2 && si->scfsi[ch] && result == 0)
557 result = MAD_ERROR_BADSCFSI;
558
559 channel->region0_count = 7;
560 channel->region1_count = 36;
561
562 if (mad_bit_read(ptr, 1))
563 channel->flags |= mixed_block_flag;
564 else if (channel->block_type == 2)
565 channel->region0_count = 8;
566
567 for (i = 0; i < 2; ++i)
568 channel->table_select[i] = mad_bit_read(ptr, 5);
569
570 # if defined(DEBUG)
571 channel->table_select[2] = 4; /* not used */
572 # endif
573
574 for (i = 0; i < 3; ++i)
575 channel->subblock_gain[i] = mad_bit_read(ptr, 3);
576 }
577 else {
578 channel->block_type = 0;
579
580 for (i = 0; i < 3; ++i)
581 channel->table_select[i] = mad_bit_read(ptr, 5);
582
583 channel->region0_count = mad_bit_read(ptr, 4);
584 channel->region1_count = mad_bit_read(ptr, 3);
585 }
586
587 /* [preflag,] scalefac_scale, count1table_select */
588 channel->flags |= mad_bit_read(ptr, lsf ? 2 : 3);
589 }
590 }
591
592 return result;
593 }
594
595 /*
596 * NAME: III_scalefactors_lsf()
597 * DESCRIPTION: decode channel scalefactors for LSF from a bitstream
598 */
599 static
600 unsigned int III_scalefactors_lsf(struct mad_bitptr *ptr,
601 struct channel *channel,
602 struct channel *gr1ch, int mode_extension)
603 {
604 struct mad_bitptr start;
605 unsigned int scalefac_compress, index, slen[4], part, n, i;
606 unsigned char const *nsfb;
607
608 start = *ptr;
609
610 scalefac_compress = channel->scalefac_compress;
611 index = (channel->block_type == 2) ?
612 ((channel->flags & mixed_block_flag) ? 2 : 1) : 0;
613
614 if (!((mode_extension & I_STEREO) && gr1ch)) {
615 if (scalefac_compress < 400) {
616 slen[0] = (scalefac_compress >> 4) / 5;
617 slen[1] = (scalefac_compress >> 4) % 5;
618 slen[2] = (scalefac_compress % 16) >> 2;
619 slen[3] = scalefac_compress % 4;
620
621 nsfb = nsfb_table[0][index];
622 }
623 else if (scalefac_compress < 500) {
624 scalefac_compress -= 400;
625
626 slen[0] = (scalefac_compress >> 2) / 5;
627 slen[1] = (scalefac_compress >> 2) % 5;
628 slen[2] = scalefac_compress % 4;
629 slen[3] = 0;
630
631 nsfb = nsfb_table[1][index];
632 }
633 else {
634 scalefac_compress -= 500;
635
636 slen[0] = scalefac_compress / 3;
637 slen[1] = scalefac_compress % 3;
638 slen[2] = 0;
639 slen[3] = 0;
640
641 channel->flags |= preflag;
642
643 nsfb = nsfb_table[2][index];
644 }
645
646 n = 0;
647 for (part = 0; part < 4; ++part) {
648 for (i = 0; i < nsfb[part]; ++i)
649 channel->scalefac[n++] = mad_bit_read(ptr, slen[part]);
650 }
651
652 while (n < 39)
653 channel->scalefac[n++] = 0;
654 }
655 else { /* (mode_extension & I_STEREO) && gr1ch (i.e. ch == 1) */
656 scalefac_compress >>= 1;
657
658 if (scalefac_compress < 180) {
659 slen[0] = scalefac_compress / 36;
660 slen[1] = (scalefac_compress % 36) / 6;
661 slen[2] = (scalefac_compress % 36) % 6;
662 slen[3] = 0;
663
664 nsfb = nsfb_table[3][index];
665 }
666 else if (scalefac_compress < 244) {
667 scalefac_compress -= 180;
668
669 slen[0] = (scalefac_compress % 64) >> 4;
670 slen[1] = (scalefac_compress % 16) >> 2;
671 slen[2] = scalefac_compress % 4;
672 slen[3] = 0;
673
674 nsfb = nsfb_table[4][index];
675 }
676 else {
677 scalefac_compress -= 244;
678
679 slen[0] = scalefac_compress / 3;
680 slen[1] = scalefac_compress % 3;
681 slen[2] = 0;
682 slen[3] = 0;
683
684 nsfb = nsfb_table[5][index];
685 }
686
687 n = 0;
688 for (part = 0; part < 4; ++part) {
689 unsigned int max, is_pos;
690
691 max = (1 << slen[part]) - 1;
692
693 for (i = 0; i < nsfb[part]; ++i) {
694 is_pos = mad_bit_read(ptr, slen[part]);
695
696 channel->scalefac[n] = is_pos;
697 gr1ch->scalefac[n++] = (is_pos == max);
698 }
699 }
700
701 while (n < 39) {
702 channel->scalefac[n] = 0;
703 gr1ch->scalefac[n++] = 0; /* apparently not illegal */
704 }
705 }
706
707 return mad_bit_length(&start, ptr);
708 }
709
710 /*
711 * NAME: III_scalefactors()
712 * DESCRIPTION: decode channel scalefactors of one granule from a bitstream
713 */
714 static
715 unsigned int III_scalefactors(struct mad_bitptr *ptr, struct channel *channel,
716 struct channel const *gr0ch, unsigned int scfsi)
717 {
718 struct mad_bitptr start;
719 unsigned int slen1, slen2, sfbi;
720
721 start = *ptr;
722
723 slen1 = sflen_table[channel->scalefac_compress].slen1;
724 slen2 = sflen_table[channel->scalefac_compress].slen2;
725
726 if (channel->block_type == 2) {
727 unsigned int nsfb;
728
729 sfbi = 0;
730
731 nsfb = (channel->flags & mixed_block_flag) ? 8 + 3 * 3 : 6 * 3;
732 while (nsfb--)
733 channel->scalefac[sfbi++] = mad_bit_read(ptr, slen1);
734
735 nsfb = 6 * 3;
736 while (nsfb--)
737 channel->scalefac[sfbi++] = mad_bit_read(ptr, slen2);
738
739 nsfb = 1 * 3;
740 while (nsfb--)
741 channel->scalefac[sfbi++] = 0;
742 }
743 else { /* channel->block_type != 2 */
744 if (scfsi & 0x8) {
745 for (sfbi = 0; sfbi < 6; ++sfbi)
746 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
747 }
748 else {
749 for (sfbi = 0; sfbi < 6; ++sfbi)
750 channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
751 }
752
753 if (scfsi & 0x4) {
754 for (sfbi = 6; sfbi < 11; ++sfbi)
755 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
756 }
757 else {
758 for (sfbi = 6; sfbi < 11; ++sfbi)
759 channel->scalefac[sfbi] = mad_bit_read(ptr, slen1);
760 }
761
762 if (scfsi & 0x2) {
763 for (sfbi = 11; sfbi < 16; ++sfbi)
764 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
765 }
766 else {
767 for (sfbi = 11; sfbi < 16; ++sfbi)
768 channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
769 }
770
771 if (scfsi & 0x1) {
772 for (sfbi = 16; sfbi < 21; ++sfbi)
773 channel->scalefac[sfbi] = gr0ch->scalefac[sfbi];
774 }
775 else {
776 for (sfbi = 16; sfbi < 21; ++sfbi)
777 channel->scalefac[sfbi] = mad_bit_read(ptr, slen2);
778 }
779
780 channel->scalefac[21] = 0;
781 }
782
783 return mad_bit_length(&start, ptr);
784 }
785
786 /*
787 * The Layer III formula for requantization and scaling is defined by
788 * section 2.4.3.4.7.1 of ISO/IEC 11172-3, as follows:
789 *
790 * long blocks:
791 * xr[i] = sign(is[i]) * abs(is[i])^(4/3) *
792 * 2^((1/4) * (global_gain - 210)) *
793 * 2^-(scalefac_multiplier *
794 * (scalefac_l[sfb] + preflag * pretab[sfb]))
795 *
796 * short blocks:
797 * xr[i] = sign(is[i]) * abs(is[i])^(4/3) *
798 * 2^((1/4) * (global_gain - 210 - 8 * subblock_gain[w])) *
799 * 2^-(scalefac_multiplier * scalefac_s[sfb][w])
800 *
801 * where:
802 * scalefac_multiplier = (scalefac_scale + 1) / 2
803 *
804 * The routines III_exponents() and III_requantize() facilitate this
805 * calculation.
806 */
807
808 /*
809 * NAME: III_exponents()
810 * DESCRIPTION: calculate scalefactor exponents
811 */
812 static
813 void III_exponents(struct channel const *channel,
814 unsigned char const *sfbwidth, signed int exponents[39])
815 {
816 signed int gain;
817 unsigned int scalefac_multiplier, sfbi;
818
819 gain = (signed int) channel->global_gain - 210;
820 scalefac_multiplier = (channel->flags & scalefac_scale) ? 2 : 1;
821
822 if (channel->block_type == 2) {
823 unsigned int l;
824 signed int gain0, gain1, gain2;
825
826 sfbi = l = 0;
827
828 if (channel->flags & mixed_block_flag) {
829 unsigned int premask;
830
831 premask = (channel->flags & preflag) ? ~0 : 0;
832
833 /* long block subbands 0-1 */
834
835 while (l < 36) {
836 exponents[sfbi] = gain -
837 (signed int) ((channel->scalefac[sfbi] + (pretab[sfbi] & premask)) <<
838 scalefac_multiplier);
839
840 l += sfbwidth[sfbi++];
841 }
842 }
843
844 /* this is probably wrong for 8000 Hz short/mixed blocks */
845
846 gain0 = gain - 8 * (signed int) channel->subblock_gain[0];
847 gain1 = gain - 8 * (signed int) channel->subblock_gain[1];
848 gain2 = gain - 8 * (signed int) channel->subblock_gain[2];
849
850 while (l < 576) {
851 exponents[sfbi + 0] = gain0 -
852 (signed int) (channel->scalefac[sfbi + 0] << scalefac_multiplier);
853 exponents[sfbi + 1] = gain1 -
854 (signed int) (channel->scalefac[sfbi + 1] << scalefac_multiplier);
855 exponents[sfbi + 2] = gain2 -
856 (signed int) (channel->scalefac[sfbi + 2] << scalefac_multiplier);
857 unsigned int w = sfbwidth[sfbi];
858 l += 3 * w;
859 sfbi += 3;
860 }
861 }
862 else { /* channel->block_type != 2 */
863 if (channel->flags & preflag) {
864 for (sfbi = 0; sfbi < 22; ++sfbi) {
865 exponents[sfbi] = gain -
866 (signed int) ((channel->scalefac[sfbi] + pretab[sfbi]) <<
867 scalefac_multiplier);
868 }
869 }
870 else {
871 for (sfbi = 0; sfbi < 22; ++sfbi) {
872 exponents[sfbi] = gain -
873 (signed int) (channel->scalefac[sfbi] << scalefac_multiplier);
874 }
875 }
876 }
877 }
878
879 /*
880 * NAME: III_requantize()
881 * DESCRIPTION: requantize one (positive) value
882 */
883 static
884 mad_fixed_t III_requantize(unsigned int value, signed int exp)
885 {
886 mad_fixed_t requantized;
887 signed int frac;
888 unsigned long power;
889
890 frac = exp % 4; /* assumes sign(frac) == sign(exp) */
891 exp /= 4;
892
893 /* format rq_table: bit31-27=exponent bit26-0=mantissa */
894 power = rq_table[value];
895 requantized = power & 0x07ffffff;
896 exp += power >> 27;
897
898 if (exp < 0) {
899 if (-exp >= (signed int) (sizeof(mad_fixed_t) * CHAR_BIT)) {
900 /* underflow */
901 requantized = 0;
902 }
903 else {
904 requantized += 1L << (-exp - 1);
905 requantized >>= -exp;
906 }
907 }
908 else {
909 if (exp >= 5) {
910 /* overflow */
911 # if defined(DEBUG)
912 fprintf(stderr, "requantize overflow (%f * 2^%d)\n",
913 mad_f_todouble(requantized), exp);
914 # endif
915 requantized = MAD_F_MAX;
916 }
917 else
918 requantized <<= exp;
919 }
920
921 return frac ? mad_f_mul(requantized, root_table[3 + frac]) : requantized;
922 }
923
924 /* we must take care that sz >= bits and sz < sizeof(long) lest bits == 0 */
925 # if defined(CPU_ARM)
926 # define MASK(cache, sz, bits) \
927 ({ unsigned long res; \
928 asm ("mov %0, #1\n\t" \
929 "rsb %0, %0, %0, lsl %3\n\t" \
930 "and %0, %0, %1, lsr %2" \
931 : "=&r" (res) : "r" (cache), "r" ((sz) - (bits)), "r" (bits)); \
932 res; \
933 })
934 #else
935 # define MASK(cache, sz, bits) \
936 (((cache) >> ((sz) - (bits))) & ((1 << (bits)) - 1))
937 #endif
938 # define MASK1BIT(cache, sz) \
939 ((cache) & (1 << ((sz) - 1)))
940
941 /*
942 * NAME: III_huffdecode()
943 * DESCRIPTION: decode Huffman code words of one channel of one granule
944 */
945 static
946 enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576],
947 struct channel *channel,
948 unsigned char const *sfbwidth,
949 unsigned int part2_length)
950 {
951 unsigned int bits;
952 signed int exponents[39], exp;
953 signed int const *expptr;
954 struct mad_bitptr peek;
955 signed int bits_left, cachesz;
956 register mad_fixed_t *xr;
957 mad_fixed_t const *sfbound;
958 register unsigned long bitcache;
959
960 bits_left = (signed) channel->part2_3_length - (signed) part2_length;
961 if (bits_left < 0)
962 return MAD_ERROR_BADPART3LEN;
963
964 III_exponents(channel, sfbwidth, exponents);
965
966 peek = *ptr;
967 cachesz = 0;
968 sfbound = xr = xrarr;
969 mad_bit_skip(ptr, bits_left);
970
971 /* big_values */
972 {
973 int region;
974 struct hufftable const *entry;
975 union huffpair const *table;
976 unsigned int linbits, startbits, rcount;
977 mad_fixed_t reqcache[16];
978 mad_fixed_t const *xr_end, *xr_big_val;
979
980 rcount = 1;
981 expptr = &exponents[0];
982 region = -1;
983 exp = 0x3210; /* start value */
984 bitcache = 0;
985 linbits = startbits = 0;
986 table = NULL;
987 xr_big_val = xr + 2 * channel->big_values;
988
989 while(xr < xr_big_val)
990 {
991 sfbound += *sfbwidth++;
992 xr_end = sfbound > xr_big_val ? xr_big_val : sfbound;
993
994 /* change table if region boundary */
995 if(--rcount == 0)
996 {
997 if(exp == 0x3210)
998 rcount = channel->region0_count + 1;
999 else
1000 if(region == 0)
1001 rcount = channel->region1_count + 1;
1002 else
1003 rcount = 0; /* all remaining */
1004
1005 entry = &mad_huff_pair_table[channel->table_select[++region]];
1006 table = entry->table;
1007 linbits = entry->linbits;
1008 startbits = entry->startbits;
1009
1010 if(table == 0)
1011 return MAD_ERROR_BADHUFFTABLE;
1012 }
1013
1014 if(exp != *expptr)
1015 {
1016 exp = *expptr;
1017 /* clear cache */
1018 memset(reqcache, 0, sizeof(reqcache));
1019 }
1020
1021 ++expptr;
1022
1023 if(linbits)
1024 {
1025 for( ; xr<xr_end; xr+=2)
1026 {
1027 union huffpair const *pair;
1028 register mad_fixed_t requantized;
1029 unsigned int clumpsz, value;
1030
1031 /* maxhuffcode(hufftab16,hufftab24)=17bit + sign(x,y)=2bit */
1032 if(cachesz < 19)
1033 {
1034 if(cachesz < 0)
1035 return MAD_ERROR_BADHUFFDATA; /* cache underrun */
1036
1037 bits = MAXLSHIFT - cachesz;
1038 bitcache = (bitcache << bits) | mad_bit_read(&peek, bits);
1039 cachesz += bits;
1040 }
1041
1042 /* hcod (0..19) */
1043 clumpsz = startbits;
1044 pair = &table[MASK(bitcache, cachesz, clumpsz)];
1045
1046 while(!pair->final)
1047 {
1048 cachesz -= clumpsz;
1049 clumpsz = pair->ptr.bits;
1050 pair = &table[pair->ptr.offset + MASK(bitcache, cachesz, clumpsz)];
1051 }
1052
1053 cachesz -= pair->value.hlen;
1054
1055 /* x (0..14) */
1056 value = pair->value.x;
1057 if(value == 0)
1058 xr[0] = 0;
1059 else
1060 {
1061 if(value == 15)
1062 {
1063 /* maxlinbits=13bit + sign(x,y)=2bit */
1064 if(cachesz < 15)
1065 {
1066 if(cachesz < 0)
1067 return MAD_ERROR_BADHUFFDATA; /* cache underrun */
1068
1069 bits = MAXLSHIFT - cachesz;
1070 bitcache = (bitcache << bits) | mad_bit_read(&peek, bits);
1071 cachesz += bits;
1072 }
1073
1074 requantized = III_requantize(15+MASK(bitcache, cachesz, linbits), exp);
1075 cachesz -= linbits;
1076 }
1077 else
1078 {
1079 if(reqcache[value])
1080 requantized = reqcache[value];
1081 else
1082 requantized = reqcache[value] = III_requantize(value, exp);
1083 }
1084
1085 xr[0] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
1086 }
1087
1088 /* y (0..14) */
1089 value = pair->value.y;
1090 if(value == 0)
1091 xr[1] = 0;
1092 else
1093 {
1094 if(value == 15)
1095 {
1096 /* maxlinbits=13bit + sign(y)=1bit */
1097 if(cachesz < 14)
1098 {
1099 if(cachesz < 0)
1100 return MAD_ERROR_BADHUFFDATA; /* cache underrun */
1101
1102 bits = MAXLSHIFT - cachesz;
1103 bitcache = (bitcache << bits) | mad_bit_read(&peek, bits);
1104 cachesz += bits;
1105 }
1106
1107 requantized = III_requantize(15+MASK(bitcache, cachesz, linbits), exp);
1108 cachesz -= linbits;
1109 }
1110 else
1111 {
1112 if(reqcache[value])
1113 requantized = reqcache[value];
1114 else
1115 requantized = reqcache[value] = III_requantize(value, exp);
1116 }
1117 xr[1] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
1118 }
1119 }
1120 }
1121 else
1122 {
1123 for( ; xr<xr_end; xr+=2)
1124 {
1125 union huffpair const *pair;
1126 register mad_fixed_t requantized;
1127 unsigned int clumpsz, value;
1128
1129 /* maxlookup=4bit + sign(x,y)=2bit */
1130 if(cachesz < 6)
1131 {
1132 if(cachesz < 0)
1133 return MAD_ERROR_BADHUFFDATA; /* cache underrun */
1134
1135 bits = MAXLSHIFT - cachesz;
1136 bitcache = (bitcache << bits) | mad_bit_read(&peek, bits);
1137 cachesz += bits;
1138 }
1139
1140 /* hcod (0..19) */
1141 clumpsz = startbits;
1142 pair = &table[MASK(bitcache, cachesz, clumpsz)];
1143
1144 while(!pair->final)
1145 {
1146 cachesz -= clumpsz;
1147
1148 /* maxlookup=4bit + sign(x,y)=2bit */
1149 if(cachesz < 6)
1150 {
1151 if(cachesz < 0)
1152 return MAD_ERROR_BADHUFFDATA; /* cache underrun */
1153
1154 bits = MAXLSHIFT - cachesz;
1155 bitcache = (bitcache << bits) | mad_bit_read(&peek, bits);
1156 cachesz += bits;
1157 }
1158
1159 clumpsz = pair->ptr.bits;
1160 pair = &table[pair->ptr.offset + MASK(bitcache, cachesz, clumpsz)];
1161 }
1162
1163 cachesz -= pair->value.hlen;
1164
1165 /* x (0..1) */
1166 value = pair->value.x;
1167 if(value == 0)
1168 xr[0] = 0;
1169 else
1170 {
1171 if(reqcache[value])
1172 requantized = reqcache[value];
1173 else
1174 requantized = reqcache[value] = III_requantize(value, exp);
1175
1176 xr[0] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
1177 }
1178
1179 /* y (0..1) */
1180 value = pair->value.y;
1181 if(value == 0)
1182 xr[1] = 0;
1183 else
1184 {
1185 if(reqcache[value])
1186 requantized = reqcache[value];
1187 else
1188 requantized = reqcache[value] = III_requantize(value, exp);
1189
1190 xr[1] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized;
1191 }
1192 }
1193 }
1194 }
1195 }
1196
1197 bits_left = ptr->readbit - peek.readbit;
1198
1199 if(bits_left + cachesz < 0)
1200 return MAD_ERROR_BADHUFFDATA; /* big_values overrun */
1201
1202 /* count1 */
1203 {
1204 union huffquad const *table;
1205 register mad_fixed_t requantized;
1206
1207 table = mad_huff_quad_table[channel->flags & count1table_select];
1208
1209 requantized = III_requantize(1, exp);
1210
1211 while(xr <= &xrarr[572] && bits_left + cachesz > 0)
1212 {
1213 union huffquad const *quad;
1214
1215 /* hcod (1..6) */
1216 if(cachesz < 10)
1217 {
1218 if(cachesz < 0)
1219 return MAD_ERROR_BADHUFFDATA; /* cache underrun */
1220
1221 bits = MAXLSHIFT - cachesz;
1222 bitcache = (bitcache << bits) | mad_bit_read(&peek, bits);
1223 cachesz += bits;
1224 bits_left -= bits;
1225 }
1226
1227 quad = &table[MASK(bitcache, cachesz, 4)];
1228
1229 /* quad tables guaranteed to have at most one extra lookup */
1230 if (!quad->final) {
1231 cachesz -= 4;
1232
1233 quad = &table[quad->ptr.offset +
1234 MASK(bitcache, cachesz, quad->ptr.bits)];
1235 }
1236
1237 cachesz -= quad->value.hlen;
1238
1239 if (xr == sfbound) {
1240 sfbound += *sfbwidth++;
1241
1242 if (exp != *expptr) {
1243 exp = *expptr;
1244 requantized = III_requantize(1, exp);
1245 }
1246
1247 ++expptr;
1248 }
1249
1250 /* v (0..1) */
1251 xr[0] = quad->value.v ?
1252 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1253
1254 /* w (0..1) */
1255 xr[1] = quad->value.w ?
1256 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1257
1258 xr += 2;
1259
1260 if (xr == sfbound) {
1261 sfbound += *sfbwidth++;
1262
1263 if (exp != *expptr) {
1264 exp = *expptr;
1265 requantized = III_requantize(1, exp);
1266 }
1267
1268 ++expptr;
1269 }
1270
1271 /* x (0..1) */
1272 xr[0] = quad->value.x ?
1273 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1274
1275 /* y (0..1) */
1276 xr[1] = quad->value.y ?
1277 (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0;
1278
1279 xr += 2;
1280 }
1281
1282 if(bits_left + cachesz < 0)
1283 {
1284 /* technically the bitstream is misformatted, but apparently
1285 some encoders are just a bit sloppy with stuffing bits */
1286 xr -= 4;
1287 }
1288 }
1289
1290 /* rzero */
1291 memset(xr, 0, (char*)&xrarr[576] - (char*)xr);
1292
1293 return MAD_ERROR_NONE;
1294 }
1295
1296 # undef MASK
1297 # undef MASK1BIT
1298
1299 /*
1300 * NAME: III_reorder()
1301 * DESCRIPTION: reorder frequency lines of a short block into subband order
1302 */
1303 static
1304 void III_reorder(mad_fixed_t xr[576], struct channel const *channel,
1305 unsigned char const sfbwidth[39])
1306 {
1307 mad_fixed_t tmp[32][3][6];
1308 unsigned int sb, l, f, w, sbw[3], sw[3];
1309
1310 /* this is probably wrong for 8000 Hz mixed blocks */
1311
1312 sb = 0;
1313 if (channel->flags & mixed_block_flag) {
1314 sb = 2;
1315
1316 l = 0;
1317 while (l < 36)
1318 l += *sfbwidth++;
1319 }
1320
1321 for (w = 0; w < 3; ++w) {
1322 sbw[w] = sb;
1323 sw[w] = 0;
1324 }
1325
1326 f = *sfbwidth++;
1327 w = 0;
1328
1329 for (l = 18 * sb; l < 576; ++l) {
1330 if (f-- == 0) {
1331 f = *sfbwidth++ - 1;
1332 w = (w + 1) % 3;
1333 }
1334
1335 unsigned int sbww = sbw[w];
1336 tmp[sbww][w][sw[w]++] = xr[l];
1337
1338 if (sw[w] == 6) {
1339 sw[w] = 0;
1340 ++sbw[w];
1341 }
1342 }
1343
1344 memcpy(&xr[18 * sb], &tmp[sb], (576 - 18 * sb) * sizeof(mad_fixed_t));
1345 }
1346
1347 /*
1348 * NAME: III_stereo()
1349 * DESCRIPTION: perform joint stereo processing on a granule
1350 */
1351 static
1352 enum mad_error III_stereo(mad_fixed_t xr[2][576],
1353 struct granule const *granule,
1354 struct mad_header *header,
1355 unsigned char const *sfbwidth)
1356 {
1357 short modes[39];
1358 unsigned int sfbi, l, n, i;
1359
1360 if (granule->ch[0].block_type !=
1361 granule->ch[1].block_type ||
1362 (granule->ch[0].flags & mixed_block_flag) !=
1363 (granule->ch[1].flags & mixed_block_flag))
1364 return MAD_ERROR_BADSTEREO;
1365
1366 for (i = 0; i < 39; ++i)
1367 modes[i] = header->mode_extension;
1368
1369 /* intensity stereo */
1370
1371 if (header->mode_extension & I_STEREO) {
1372 struct channel const *right_ch = &granule->ch[1];
1373 mad_fixed_t const *right_xr = xr[1];
1374 unsigned int is_pos;
1375
1376 header->flags |= MAD_FLAG_I_STEREO;
1377
1378 /* first determine which scalefactor bands are to be processed */
1379
1380 if (right_ch->block_type == 2) {
1381 unsigned int lower, start, max, bound[3], w;
1382
1383 lower = start = max = bound[0] = bound[1] = bound[2] = 0;
1384
1385 sfbi = l = 0;
1386
1387 if (right_ch->flags & mixed_block_flag) {
1388 while (l < 36) {
1389 n = sfbwidth[sfbi++];
1390
1391 for (i = 0; i < n; ++i) {
1392 if (right_xr[i]) {
1393 lower = sfbi;
1394 break;
1395 }
1396 }
1397
1398 right_xr += n;
1399 l += n;
1400 }
1401
1402 start = sfbi;
1403 }
1404
1405 w = 0;
1406 while (l < 576) {
1407 n = sfbwidth[sfbi++];
1408
1409 for (i = 0; i < n; ++i) {
1410 if (right_xr[i]) {
1411 max = bound[w] = sfbi;
1412 break;
1413 }
1414 }
1415
1416 right_xr += n;
1417 l += n;
1418 w = (w + 1) % 3;
1419 }
1420
1421 if (max)
1422 lower = start;
1423
1424 /* long blocks */
1425
1426 for (i = 0; i < lower; ++i)
1427 modes[i] = header->mode_extension & ~I_STEREO;
1428
1429 /* short blocks */
1430
1431 w = 0;
1432 for (i = start; i < max; ++i) {
1433 if (i < bound[w])
1434 modes[i] = header->mode_extension & ~I_STEREO;
1435
1436 w = (w + 1) % 3;
1437 }
1438 }
1439 else { /* right_ch->block_type != 2 */
1440 unsigned int bound;
1441
1442 bound = 0;
1443 for (sfbi = l = 0; l < 576; l += n) {
1444 n = sfbwidth[sfbi++];
1445
1446 for (i = 0; i < n; ++i) {
1447 if (right_xr[i]) {
1448 bound = sfbi;
1449 break;
1450 }
1451 }
1452
1453 right_xr += n;
1454 }
1455
1456 for (i = 0; i < bound; ++i)
1457 modes[i] = header->mode_extension & ~I_STEREO;
1458 }
1459
1460 /* now do the actual processing */
1461
1462 if (header->flags & MAD_FLAG_LSF_EXT) {
1463 unsigned char const *illegal_pos = granule[1].ch[1].scalefac;
1464 mad_fixed_t const *lsf_scale;
1465
1466 /* intensity_scale */
1467 lsf_scale = is_lsf_table[right_ch->scalefac_compress & 0x1];
1468
1469 for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
1470 n = sfbwidth[sfbi];
1471
1472 if (!(modes[sfbi] & I_STEREO))
1473 continue;
1474
1475 if (illegal_pos[sfbi]) {
1476 modes[sfbi] &= ~I_STEREO;
1477 continue;
1478 }
1479
1480 is_pos = right_ch->scalefac[sfbi];
1481
1482 for (i = 0; i < n; ++i) {
1483 register mad_fixed_t left;
1484
1485 left = xr[0][l + i];
1486
1487 if (is_pos == 0)
1488 xr[1][l + i] = left;
1489 else {
1490 register mad_fixed_t opposite;
1491
1492 opposite = mad_f_mul(left, lsf_scale[(is_pos - 1) / 2]);
1493
1494 if (is_pos & 1) {
1495 xr[0][l + i] = opposite;
1496 xr[1][l + i] = left;
1497 }
1498 else
1499 xr[1][l + i] = opposite;
1500 }
1501 }
1502 }
1503 }
1504 else { /* !(header->flags & MAD_FLAG_LSF_EXT) */
1505 for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
1506 n = sfbwidth[sfbi];
1507
1508 if (!(modes[sfbi] & I_STEREO))
1509 continue;
1510
1511 is_pos = right_ch->scalefac[sfbi];
1512
1513 if (is_pos >= 7) { /* illegal intensity position */
1514 modes[sfbi] &= ~I_STEREO;
1515 continue;
1516 }
1517
1518 for (i = 0; i < n; ++i) {
1519 register mad_fixed_t left;
1520
1521 left = xr[0][l + i];
1522
1523 xr[0][l + i] = mad_f_mul(left, is_table[ is_pos]);
1524 xr[1][l + i] = mad_f_mul(left, is_table[6 - is_pos]);
1525 }
1526 }
1527 }
1528 }
1529
1530 /* middle/side stereo */
1531
1532 if (header->mode_extension & MS_STEREO) {
1533 register mad_fixed_t invsqrt2;
1534
1535 header->flags |= MAD_FLAG_MS_STEREO;
1536
1537 invsqrt2 = root_table[3 + -2];
1538
1539 for (sfbi = l = 0; l < 576; ++sfbi, l += n) {
1540 n = sfbwidth[sfbi];
1541
1542 if (modes[sfbi] != MS_STEREO)
1543 continue;
1544
1545 for (i = 0; i < n; ++i) {
1546 register mad_fixed_t m, s;
1547
1548 m = xr[0][l + i];
1549 s = xr[1][l + i];
1550
1551 xr[0][l + i] = mad_f_mul(m + s, invsqrt2); /* l = (m + s) / sqrt(2) */
1552 xr[1][l + i] = mad_f_mul(m - s, invsqrt2); /* r = (m - s) / sqrt(2) */
1553 }
1554 }
1555 }
1556
1557 return MAD_ERROR_NONE;
1558 }
1559
1560 #if defined(CPU_ARM)
1561 void III_aliasreduce(mad_fixed_t xr[576], int lines);
1562 #else
1563 /*
1564 * NAME: III_aliasreduce()
1565 * DESCRIPTION: perform frequency line alias reduction
1566 */
1567 static
1568 void III_aliasreduce(mad_fixed_t xr[576], int lines)
1569 {
1570 mad_fixed_t const *bound;
1571 int i;
1572
1573 bound = &xr[lines];
1574 for (xr += 18; xr < bound; xr += 18) {
1575 for (i = 0; i < 8; ++i) {
1576 register mad_fixed_t a, b;
1577 register mad_fixed64hi_t hi;
1578 register mad_fixed64lo_t lo;
1579
1580 a = xr[-1 - i];
1581 b = xr[ i];
1582
1583 # if defined(ASO_ZEROCHECK)
1584 if (a | b) {
1585 # endif
1586 # if defined(CPU_COLDFIRE)
1587 (void)hi, (void)lo;
1588 asm volatile ("mac.l %[a], %[csi], %%acc0\n\t"
1589 "msac.l %[b], %[cai], %%acc0\n\t"
1590 "mac.l %[b], %[csi], %%acc1\n\t"
1591 "mac.l %[a], %[cai], %%acc1\n\t"
1592 "movclr.l %%acc0, %[a]\n\t"
1593 "asl.l #3, %[a]\n\t"
1594 "movclr.l %%acc1, %[b]\n\t"
1595 "asl.l #3, %[b]\n\t"
1596 : [a] "+d" (a), [b] "+d" (b)
1597 : [csi] "r" (cs[i]), [cai] "r" (ca[i]));
1598 xr[-1 - i] = a;
1599 xr[ i] = b;
1600 # else
1601 MAD_F_ML0(hi, lo, a, cs[i]);
1602 MAD_F_MLA(hi, lo, -b, ca[i]);
1603
1604 xr[-1 - i] = MAD_F_MLZ(hi, lo);
1605
1606 MAD_F_ML0(hi, lo, b, cs[i]);
1607 MAD_F_MLA(hi, lo, a, ca[i]);
1608
1609 xr[ i] = MAD_F_MLZ(hi, lo);
1610 # endif
1611 # if defined(ASO_ZEROCHECK)
1612 }
1613 # endif
1614 }
1615 }
1616 }
1617 #endif
1618
1619 # if defined(ASO_IMDCT)
1620 void III_imdct_l(mad_fixed_t const [18], mad_fixed_t [36], unsigned int);
1621 # else
1622 # if 0
1623 static
1624 void fastsdct(mad_fixed_t const x[9], mad_fixed_t y[18])
1625 {
1626 mad_fixed_t a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12;
1627 mad_fixed_t a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25;
1628 mad_fixed_t m0, m1, m2, m3, m4, m5, m6, m7;
1629
1630 enum {
1631 c0 = MAD_F(0x1f838b8d), /* 2 * cos( 1 * PI / 18) */
1632 c1 = MAD_F(0x1bb67ae8), /* 2 * cos( 3 * PI / 18) */
1633 c2 = MAD_F(0x18836fa3), /* 2 * cos( 4 * PI / 18) */
1634 c3 = MAD_F(0x1491b752), /* 2 * cos( 5 * PI / 18) */
1635 c4 = MAD_F(0x0af1d43a), /* 2 * cos( 7 * PI / 18) */
1636 c5 = MAD_F(0x058e86a0), /* 2 * cos( 8 * PI / 18) */
1637 c6 = -MAD_F(0x1e11f642) /* 2 * cos(16 * PI / 18) */
1638 };
1639
1640 a0 = x[3] + x[5];
1641 a1 = x[3] - x[5];
1642 a2 = x[6] + x[2];
1643 a3 = x[6] - x[2];
1644 a4 = x[1] + x[7];
1645 a5 = x[1] - x[7];
1646 a6 = x[8] + x[0];
1647 a7 = x[8] - x[0];
1648
1649 a8 = a0 + a2;
1650 a9 = a0 - a2;
1651 a10 = a0 - a6;
1652 a11 = a2 - a6;
1653 a12 = a8 + a6;
1654 a13 = a1 - a3;
1655 a14 = a13 + a7;
1656 a15 = a3 + a7;
1657 a16 = a1 - a7;
1658 a17 = a1 + a3;
1659
1660 m0 = mad_f_mul(a17, -c3);
1661 m1 = mad_f_mul(a16, -c0);
1662 m2 = mad_f_mul(a15, -c4);
1663 m3 = mad_f_mul(a14, -c1);
1664 m4 = mad_f_mul(a5, -c1);
1665 m5 = mad_f_mul(a11, -c6);
1666 m6 = mad_f_mul(a10, -c5);
1667 m7 = mad_f_mul(a9, -c2);
1668
1669 a18 = x[4] + a4;
1670 a19 = 2 * x[4] - a4;
1671 a20 = a19 + m5;
1672 a21 = a19 - m5;
1673 a22 = a19 + m6;
1674 a23 = m4 + m2;
1675 a24 = m4 - m2;
1676 a25 = m4 + m1;
1677
1678 /* output to every other slot for convenience */
1679
1680 y[ 0] = a18 + a12;
1681 y[ 2] = m0 - a25;
1682 y[ 4] = m7 - a20;
1683 y[ 6] = m3;
1684 y[ 8] = a21 - m6;
1685 y[10] = a24 - m1;
1686 y[12] = a12 - 2 * a18;
1687 y[14] = a23 + m0;
1688 y[16] = a22 + m7;
1689 }
1690
1691 static inline
1692 void sdctII(mad_fixed_t const x[18], mad_fixed_t X[18])
1693 {
1694 mad_fixed_t tmp[9];
1695 int i;
1696
1697 /* scale[i] = 2 * cos(PI * (2 * i + 1) / (2 * 18)) */
1698 static mad_fixed_t const scale[9] = {
1699 MAD_F(0x1fe0d3b4), MAD_F(0x1ee8dd47), MAD_F(0x1d007930),
1700 MAD_F(0x1a367e59), MAD_F(0x16a09e66), MAD_F(0x125abcf8),
1701 MAD_F(0x0d8616bc), MAD_F(0x08483ee1), MAD_F(0x02c9fad7)
1702 };
1703
1704 /* divide the 18-point SDCT-II into two 9-point SDCT-IIs */
1705
1706 /* even input butterfly */
1707
1708 for (i = 0; i < 9; i += 3) {
1709 tmp[i + 0] = x[i + 0] + x[18 - (i + 0) - 1];
1710 tmp[i + 1] = x[i + 1] + x[18 - (i + 1) - 1];
1711 tmp[i + 2] = x[i + 2] + x[18 - (i + 2) - 1];
1712 }
1713
1714 fastsdct(tmp, &X[0]);
1715
1716 /* odd input butterfly and scaling */
1717
1718 for (i = 0; i < 9; i += 3) {
1719 tmp[i + 0] = mad_f_mul(x[i + 0] - x[18 - (i + 0) - 1], scale[i + 0]);
1720 tmp[i + 1] = mad_f_mul(x[i + 1] - x[18 - (i + 1) - 1], scale[i + 1]);
1721 tmp[i + 2] = mad_f_mul(x[i + 2] - x[18 - (i + 2) - 1], scale[i + 2]);
1722 }
1723
1724 fastsdct(tmp, &X[1]);
1725
1726 /* output accumulation */
1727
1728 for (i = 3; i < 18; i += 8) {
1729 X[i + 0] -= X[(i + 0) - 2];
1730 X[i + 2] -= X[(i + 2) - 2];
1731 X[i + 4] -= X[(i + 4) - 2];
1732 X[i + 6] -= X[(i + 6) - 2];
1733 }
1734 }
1735
1736 static inline
1737 void dctIV(mad_fixed_t const y[18], mad_fixed_t X[18])
1738 {
1739 mad_fixed_t tmp[18];
1740 int i;
1741
1742 /* scale[i] = 2 * cos(PI * (2 * i + 1) / (4 * 18)) */
1743 static mad_fixed_t const scale[18] = {
1744 MAD_F(0x1ff833fa), MAD_F(0x1fb9ea93), MAD_F(0x1f3dd120),
1745 MAD_F(0x1e84d969), MAD_F(0x1d906bcf), MAD_F(0x1c62648b),
1746 MAD_F(0x1afd100f), MAD_F(0x1963268b), MAD_F(0x1797c6a4),
1747 MAD_F(0x159e6f5b), MAD_F(0x137af940), MAD_F(0x11318ef3),
1748 MAD_F(0x0ec6a507), MAD_F(0x0c3ef153), MAD_F(0x099f61c5),
1749 MAD_F(0x06ed12c5), MAD_F(0x042d4544), MAD_F(0x0165547c)
1750 };
1751
1752 /* scaling */
1753
1754 for (i = 0; i < 18; i += 3) {
1755 tmp[i + 0] = mad_f_mul(y[i + 0], scale[i + 0]);
1756 tmp[i + 1] = mad_f_mul(y[i + 1], scale[i + 1]);
1757 tmp[i + 2] = mad_f_mul(y[i + 2], scale[i + 2]);
1758 }
1759
1760 /* SDCT-II */
1761
1762 sdctII(tmp, X);
1763
1764 /* scale reduction and output accumulation */
1765
1766 X[0] /= 2;
1767 for (i = 1; i < 17; i += 4) {
1768 X[i + 0] = X[i + 0] / 2 - X[(i + 0) - 1];
1769 X[i + 1] = X[i + 1] / 2 - X[(i + 1) - 1];
1770 X[i + 2] = X[i + 2] / 2 - X[(i + 2) - 1];
1771 X[i + 3] = X[i + 3] / 2 - X[(i + 3) - 1];
1772 }
1773 X[17] = X[17] / 2 - X[16];
1774 }
1775
1776 /*
1777 * NAME: imdct36
1778 * DESCRIPTION: perform X[18]->x[36] IMDCT using Szu-Wei Lee's fast algorithm
1779 */
1780 static inline
1781 void imdct36(mad_fixed_t const x[18], mad_fixed_t y[36])
1782 {
1783 mad_fixed_t tmp[18];
1784 int i;
1785
1786 /* DCT-IV */
1787
1788 dctIV(x, tmp);
1789
1790 /* convert 18-point DCT-IV to 36-point IMDCT */
1791
1792 for (i = 0; i < 9; i += 3) {
1793 y[i + 0] = tmp[9 + (i + 0)];
1794 y[i + 1] = tmp[9 + (i + 1)];
1795 y[i + 2] = tmp[9 + (i + 2)];
1796 }
1797 for (i = 9; i < 27; i += 3) {
1798 y[i + 0] = -tmp[36 - (9 + (i + 0)) - 1];
1799 y[i + 1] = -tmp[36 - (9 + (i + 1)) - 1];
1800 y[i + 2] = -tmp[36 - (9 + (i + 2)) - 1];
1801 }
1802 for (i = 27; i < 36; i += 3) {
1803 y[i + 0] = -tmp[(i + 0) - 27];
1804 y[i + 1] = -tmp[(i + 1) - 27];
1805 y[i + 2] = -tmp[(i + 2) - 27];
1806 }
1807 }
1808 # else
1809 /*
1810 * NAME: imdct36
1811 * DESCRIPTION: perform X[18]->x[36] IMDCT
1812 */
1813
1814 # if defined(CPU_COLDFIRE)
1815 /* emac optimized imdct36, it is very ugly and i hope to replace it soon.
1816 * for now it is actually somewhat faster than the stock implementation.
1817 */
1818 static inline
1819 void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36])
1820 {
1821 mad_fixed_t t[16];
1822 /* assumes FRACBITS = 28 */
1823 asm volatile (
1824 /* MAD_F_ML0(hi, lo, X[4], MAD_F(0x0ec835e8)); */
1825 /* MAD_F_MLA(hi, lo, X[13], MAD_F(0x061f78aa)); */
1826 /* t6 = MAD_F_MLZ(hi, lo); */
1827 "move.l (4*4, %[X]), %%d0\n"
1828 "move.l #0x0ec835e8, %%d1\n"
1829 "move.l #0x061f78aa, %%d2\n"
1830 "mac.l %%d1, %%d0, (13*4, %[X]), %%d0, %%acc0\n"
1831 "mac.l %%d2, %%d0, ( 1*4, %[X]), %%d0, %%acc0\n"
1832 "move.l %%acc0, %%d7\n"
1833 "asl.l #3, %%d7\n"
1834 "move.l %%d7, (6*4, %[t])\n"
1835
1836 /* MAD_F_ML0(hi, lo, (t14 = X[1] - X[10]), -MAD_F(0x0ec835e8)); */
1837 /* MAD_F_MLA(hi, lo, (t15 = X[7] + X[16]), MAD_F(0x061f78aa)); */
1838 /* t4 = MAD_F_MLZ(hi, lo); */
1839 /* MAD_F_MLA(hi, lo, t14, -MAD_F(0x061f78aa)); */
1840 /* MAD_F_MLA(hi, lo, t15, -MAD_F(0x0ec835e8)); */
1841 /* t0 = MAD_F_MLZ(hi, lo); */
1842 "sub.l (10*4, %[X]), %%d0\n" /* t14 */
1843 "msac.l %%d0, %%d1, %%acc1\n"
1844 "msac.l %%d0, %%d2, (7*4, %[X]), %%d5, %%acc0\n"
1845 "add.l (16*4, %[X]), %%d5\n" /* t15 */
1846 "mac.l %%d5, %%d2, %%acc1\n"
1847 "msac.l %%d5, %%d1, ( %[X]), %%d5, %%acc0\n"
1848 "movclr.l %%acc1, %%d6\n"
1849 "asl.l #3, %%d6\n" /* t4 */
1850 "move.l %%d6, (4*4, %[t])\n"
1851 "move.l %%acc0, %%d0\n"
1852 "asl.l #3, %%d0\n" /* t0 */
1853 "move.l %%d0, (0*4, %[t])\n"
1854
1855 /* MAD_F_MLA(hi, lo, (t8 =X[0]-X[11]-X[12]), MAD_F(0x0216a2a2)); */
1856 /* MAD_F_MLA(hi, lo, (t9 =X[2]-X[ 9]-X[14]), MAD_F(0x09bd7ca0)); */
1857 /* MAD_F_MLA(hi, lo, (t10=X[3]-X[ 8]-X[15]), -MAD_F(0x0cb19346)); */
1858 /* MAD_F_MLA(hi, lo, (t11=X[5]-X[ 6]-X[17]), -MAD_F(0x0fdcf549)); */
1859 /* x[10] = -(x[7] = MAD_F_MLZ(hi, lo)); */
1860
1861 /* MAD_F_ML0(hi, lo, t8, -MAD_F(0x0cb19346)); */
1862 /* MAD_F_MLA(hi, lo, t9, MAD_F(0x0fdcf549)); */
1863 /* MAD_F_MLA(hi, lo, t10, MAD_F(0x0216a2a2)); */
1864 /* MAD_F_MLA(hi, lo, t11, -MAD_F(0x09bd7ca0)); */
1865 /* x[19] = x[34] = MAD_F_MLZ(hi, lo) - t0; */
1866
1867 /* MAD_F_ML0(hi, lo, t8, MAD_F(0x09bd7ca0)); */
1868 /* MAD_F_MLA(hi, lo, t9, -MAD_F(0x0216a2a2)); */
1869 /* MAD_F_MLA(hi, lo, t10, MAD_F(0x0fdcf549)); */
1870 /* MAD_F_MLA(hi, lo, t11, -MAD_F(0x0cb19346)); */
1871 /* x[ 1] = MAD_F_MLZ(hi, lo); */
1872
1873 /* MAD_F_ML0(hi, lo, t8, -MAD_F(0x0fdcf549)); */
1874 /* MAD_F_MLA(hi, lo, t9, -MAD_F(0x0cb19346)); */
1875 /* MAD_F_MLA(hi, lo, t10, -MAD_F(0x09bd7ca0)); */
1876 /* MAD_F_MLA(hi, lo, t11, -MAD_F(0x0216a2a2)); */
1877 /* x[25] = MAD_F_MLZ(hi, lo); */
1878
1879 /* t12 = t8 - t10; */
1880 /* t13 = t9 + t11; */
1881 "move.l #0x0216a2a2, %%d1\n"
1882 "move.l #0x0cb19346, %%d2\n"
1883 "move.l #0x09bd7ca0, %%d3\n"
1884 "move.l #0x0fdcf549, %%d4\n"
1885 "sub.l (11*4, %[X]), %%d5\n"
1886 "sub.l (12*4, %[X]), %%d5\n"
1887 "mac.l %%d1, %%d5, %%acc0\n"
1888 "msac.l %%d2, %%d5, %%acc1\n"
1889 "mac.l %%d3, %%d5, %%acc2\n"
1890 "msac.l %%d4, %%d5, (2*4, %[X]), %%d6, %%acc3\n"
1891 "sub.l ( 9*4, %[X]), %%d6\n"
1892 "sub.l (14*4, %[X]), %%d6\n"
1893 "mac.l %%d3, %%d6, %%acc0\n"
1894 "mac.l %%d4, %%d6, %%acc1\n"
1895 "msac.l %%d1, %%d6, %%acc2\n"
1896 "msac.l %%d2, %%d6, (3*4, %[X]), %%d7, %%acc3\n"
1897 "sub.l ( 8*4, %[X]), %%d7\n"
1898 "sub.l (15*4, %[X]), %%d7\n"
1899 "sub.l %%d7, %%d5\n" /* d5: t12 */
1900 "move.l %%d5, (12*4, %[t])\n"
1901 "msac.l %%d2, %%d7, %%acc0\n"
1902 "mac.l %%d1, %%d7, %%acc1\n"
1903 "mac.l %%d4, %%d7, %%acc2\n"
1904 "msac.l %%d3, %%d7, (5*4, %[X]), %%d7, %%acc3\n"
1905 "sub.l ( 6*4, %[X]), %%d7\n"
1906 "sub.l (17*4, %[X]), %%d7\n"
1907 "add.l %%d7, %%d6\n" /* d6: t13 */
1908 "move.l %%d6, (13*4, %[t])\n"
1909 "msac.l %%d4, %%d7, %%acc0\n"
1910 "msac.l %%d3, %%d7, %%acc1\n"
1911 "msac.l %%d2, %%d7, %%acc2\n"
1912 "msac.l %%d1, %%d7, (1*4, %[X]), %%d5, %%acc3\n"
1913
1914 "movclr.l %%acc0, %%d7\n"
1915 "asl.l #3, %%d7\n"
1916 "move.l %%d7, (7*4, %[x])\n"
1917 "neg.l %%d7\n"
1918 "move.l %%d7, (10*4, %[x])\n"
1919
1920 "movclr.l %%acc1, %%d7\n"
1921 "asl.l #3, %%d7\n"
1922 "sub.l %%d0, %%d7\n"
1923 "move.l %%d7, (19*4, %[x])\n"
1924 "move.l %%d7, (34*4, %[x])\n"
1925
1926 "movclr.l %%acc2, %%d7\n"
1927 "asl.l #3, %%d7\n"
1928 "move.l %%d7, ( 1*4, %[x])\n"
1929
1930 "movclr.l %%acc3, %%d7\n"
1931 "asl.l #3, %%d7\n"
1932 "move.l %%d7, (25*4, %[x])\n"
1933
1934 /* MAD_F_ML0(hi, lo, X[1], -MAD_F(0x09bd7ca0)); */
1935 /* MAD_F_MLA(hi, lo, X[7], MAD_F(0x0216a2a2)); */
1936 /* MAD_F_MLA(hi, lo, X[10], -MAD_F(0x0fdcf549)); */
1937 /* MAD_F_MLA(hi, lo, X[16], MAD_F(0x0cb19346)); */
1938 /* t1 = MAD_F_MLZ(hi, lo) + t6; */
1939
1940 /* MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0216a2a2)); */
1941 /* MAD_F_MLA(hi, lo, X[7], -MAD_F(0x09bd7ca0)); */
1942 /* MAD_F_MLA(hi, lo, X[10], MAD_F(0x0cb19346)); */
1943 /* MAD_F_MLA(hi, lo, X[16], MAD_F(0x0fdcf549)); */
1944 /* t3 = MAD_F_MLZ(hi, lo); */
1945
1946 /* MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0fdcf549)); */
1947 /* MAD_F_MLA(hi, lo, X[7], -MAD_F(0x0cb19346)); */
1948 /* MAD_F_MLA(hi, lo, X[10], -MAD_F(0x09bd7ca0)); */
1949 /* MAD_F_MLA(hi, lo, X[16], -MAD_F(0x0216a2a2)); */
1950 /* t5 = MAD_F_MLZ(hi, lo) - t6; */
1951 "msac.l %%d3, %%d5, %%acc0\n"
1952 "msac.l %%d1, %%d5, %%acc1\n"
1953 "msac.l %%d4, %%d5, ( 7*4, %[X]), %%d5, %%acc2\n"
1954 "mac.l %%d1, %%d5, %%acc0\n"
1955 "msac.l %%d3, %%d5, %%acc1\n"
1956 "msac.l %%d2, %%d5, (10*4, %[X]), %%d5, %%acc2\n"
1957 "msac.l %%d4, %%d5, %%acc0\n"
1958 "mac.l %%d2, %%d5, %%acc1\n"
1959 "msac.l %%d3, %%d5, (16*4, %[X]), %%d5, %%acc2\n"
1960 "mac.l %%d2, %%d5, %%acc0\n"
1961 "mac.l %%d4, %%d5, %%acc1\n"
1962 "msac.l %%d1, %%d5, ( 0*4, %[X]), %%d0, %%acc2\n"
1963
1964 "movclr.l %%acc0, %%d7\n"
1965 "asl.l #3, %%d7\n"
1966 "add.l (6*4, %[t]), %%d7\n" /* t1 */
1967
1968 "movclr.l %%acc1, %%d5\n"
1969 "asl.l #3, %%d5\n" /* t3 */
1970
1971 "movclr.l %%acc2, %%d6\n"
1972 "asl.l #3, %%d6\n"
1973 "sub.l (6*4, %[t]), %%d6\n" /* t5 */
1974 "move.l %%d6, (5*4, %[t])\n"
1975
1976 /* MAD_F_ML0(hi, lo, X[0], MAD_F(0x03768962)); */
1977 /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0e313245)); */
1978 /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0ffc19fd)); */
1979 /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0acf37ad)); */
1980 /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x04cfb0e2)); */
1981 /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0898c779)); */
1982 /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x0d7e8807)); */
1983 /* MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f426cb5)); */
1984 /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0bcbe352)); */
1985 /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x00b2aa3e)); */
1986 /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x07635284)); */
1987 /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0f9ee890)); */
1988 /* x[11] = -(x[6] = MAD_F_MLZ(hi, lo) + t1); */
1989 /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f426cb5)); */
1990 /* MAD_F_MLA(hi, lo, X[2], -MAD_F(0x00b2aa3e)); */
1991 /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x0898c779)); */
1992 /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x0f9ee890)); */
1993 /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x0acf37ad)); */
1994 /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x07635284)); */
1995 /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0e313245)); */
1996 /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0bcbe352)); */
1997 /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x03768962)); */
1998 /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0d7e8807)); */
1999 /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x0ffc19fd)); */
2000 /* MAD_F_MLA(hi, lo, X[17], MAD_F(0x04cfb0e2)); */
2001 /* x[23] = x[30] = MAD_F_MLZ(hi, lo) + t1; */
2002 /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0bcbe352)); */
2003 /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0d7e8807)); */
2004 /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x07635284)); */
2005 /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x04cfb0e2)); */
2006 /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f9ee890)); */
2007 /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0ffc19fd)); */
2008 /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x00b2aa3e)); */
2009 /* MAD_F_MLA(hi, lo, X[11], MAD_F(0x03768962)); */
2010 /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0f426cb5)); */
2011 /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0e313245)); */
2012 /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x0898c779)); */
2013 /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0acf37ad)); */
2014 /* x[18] = x[35] = MAD_F_MLZ(hi, lo) - t1; */
2015 "move.l #0x03768962, %%d1\n"
2016 "move.l #0x0f426cb5, %%d2\n"
2017 "move.l #0x0bcbe352, %%d3\n"
2018 "mac.l %%d1, %%d0, %%acc0\n"
2019 "msac.l %%d2, %%d0, %%acc1\n"
2020 "msac.l %%d3, %%d0, (11*4, %[X]), %%d0, %%acc2\n"
2021 "mac.l %%d2, %%d0, %%acc0\n"
2022 "msac.l %%d3, %%d0, %%acc1\n"
2023 "mac.l %%d1, %%d0, (12*4, %[X]), %%d0, %%acc2\n"
2024 "msac.l %%d3, %%d0, %%acc0\n"
2025 "msac.l %%d1, %%d0, %%acc1\n"
2026 "msac.l %%d2, %%d0, ( 2*4, %[X]), %%d0, %%acc2\n"
2027 "move.l #0x0e313245, %%d1\n"
2028 "move.l #0x00b2aa3e, %%d2\n"
2029 "move.l #0x0d7e8807, %%d3\n"
2030 "mac.l %%d1, %%d0, %%acc0\n"
2031 "msac.l %%d2, %%d0, %%acc1\n"
2032 "mac.l %%d3, %%d0, ( 9*4, %[X]), %%d0, %%acc2\n"
2033 "mac.l %%d3, %%d0, %%acc0\n"
2034 "msac.l %%d1, %%d0, %%acc1\n"
2035 "msac.l %%d2, %%d0, (14*4, %[X]), %%d0, %%acc2\n"
2036 "mac.l %%d2, %%d0, %%acc0\n"
2037 "mac.l %%d3, %%d0, %%acc1\n"
2038 "mac.l %%d1, %%d0, ( 3*4, %[X]), %%d0, %%acc2\n"
2039 "move.l #0x0ffc19fd, %%d1\n"
2040 "move.l #0x0898c779, %%d2\n"
2041 "move.l #0x07635284, %%d3\n"
2042 "msac.l %%d1, %%d0, %%acc0\n"
2043 "mac.l %%d2, %%d0, %%acc1\n"
2044 "msac.l %%d3, %%d0, ( 8*4, %[X]), %%d0, %%acc2\n"
2045 "msac.l %%d2, %%d0, %%acc0\n"
2046 "msac.l %%d3, %%d0, %%acc1\n"
2047 "msac.l %%d1, %%d0, (15*4, %[X]), %%d0, %%acc2\n"
2048 "msac.l %%d3, %%d0, %%acc0\n"
2049 "mac.l %%d1, %%d0, %%acc1\n"
2050 "mac.l %%d2, %%d0, ( 5*4, %[X]), %%d0, %%acc2\n"
2051 "move.l #0x0acf37ad, %%d1\n"
2052 "move.l #0x0f9ee890, %%d2\n"
2053 "move.l #0x04cfb0e2, %%d3\n"
2054 "msac.l %%d1, %%d0, %%acc0\n"
2055 "mac.l %%d2, %%d0, %%acc1\n"
2056 "mac.l %%d3, %%d0, ( 6*4, %[X]), %%d0, %%acc2\n"
2057 "mac.l %%d3, %%d0, %%acc0\n"
2058 "mac.l %%d1, %%d0, %%acc1\n"
2059 "mac.l %%d2, %%d0, (17*4, %[X]), %%d0, %%acc2\n"
2060 "msac.l %%d2, %%d0, %%acc0\n"
2061 "mac.l %%d3, %%d0, %%acc1\n"
2062 "msac.l %%d1, %%d0, ( 4*4, %[X]), %%d0, %%acc2\n"
2063
2064 "movclr.l %%acc0, %%d6\n"
2065 "asl.l #3, %%d6\n"
2066 "add.l %%d7, %%d6\n"
2067 "move.l %%d6, (6*4, %[x])\n"
2068 "neg.l %%d6\n"
2069 "move.l %%d6, (11*4, %[x])\n"
2070
2071 "movclr.l %%acc1, %%d6\n"
2072 "asl.l #3, %%d6\n"
2073 "add.l %%d7, %%d6\n"
2074 "move.l %%d6, (23*4, %[x])\n"
2075 "move.l %%d6, (30*4, %[x])\n"
2076
2077 "movclr.l %%acc2, %%d6\n"
2078 "asl.l #3, %%d6\n"
2079 "sub.l %%d7, %%d6\n"
2080 "move.l %%d6, (18*4, %[x])\n"
2081 "move.l %%d6, (35*4, %[x])\n"
2082
2083 /* MAD_F_ML0(hi, lo, X[4], MAD_F(0x061f78aa)); */
2084 /* MAD_F_MLA(hi, lo, X[13], -MAD_F(0x0ec835e8)); */
2085 /* t3 += (t7 = MAD_F_MLZ(hi, lo)); */
2086 /* t4 -= t7; */
2087 "move.l #0x061f78aa, %%d1\n"
2088 "mac.l %%d1, %%d0, (13*4, %[X]), %%d0, %%acc0\n"
2089 "move.l #0x0ec835e8, %%d1\n"
2090 "msac.l %%d1, %%d0, (1*4, %[X]), %%d0, %%acc0\n"
2091 "move.l %%acc0, %%d6\n"
2092 "asl.l #3, %%d6\n" /* t7 */
2093 "add.l %%d6, %%d5\n" /* t3 */
2094 "move.l (4*4, %[t]), %%d1\n"
2095 "sub.l %%d6, %%d1\n" /* t4 */
2096 "move.l %%d1, (4*4, %[t])\n"
2097
2098 /* MAD_F_MLA(hi, lo, X[1], -MAD_F(0x0cb19346)); */
2099 /* MAD_F_MLA(hi, lo, X[7], MAD_F(0x0fdcf549)); */
2100 /* MAD_F_MLA(hi, lo, X[10], MAD_F(0x0216a2a2)); */
2101 /* MAD_F_MLA(hi, lo, X[16], -MAD_F(0x09bd7ca0)); */
2102 /* t2 = MAD_F_MLZ(hi, lo); */
2103 "move.l #0x0cb19346, %%d1\n"
2104 "msac.l %%d1, %%d0, ( 7*4, %[X]), %%d0, %%acc0\n"
2105 "move.l #0x0fdcf549, %%d1\n"
2106 "mac.l %%d1, %%d0, (10*4, %[X]), %%d0, %%acc0\n"
2107 "move.l #0x0216a2a2, %%d1\n"
2108 "mac.l %%d1, %%d0, (16*4, %[X]), %%d0, %%acc0\n"
2109 "move.l #0x09bd7ca0, %%d1\n"
2110 "msac.l %%d1, %%d0, ( %[X]), %%d0, %%acc0\n"
2111 "move.l %%acc0, %%d7\n"
2112 "asl.l #3, %%d7\n" /* t2 */
2113
2114 /* MAD_F_MLA(hi, lo, X[0], MAD_F(0x04cfb0e2)); */
2115 /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0ffc19fd)); */
2116 /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0d7e8807)); */
2117 /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x03768962)); */
2118 /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0bcbe352)); */
2119 /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0e313245)); */
2120 /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x07635284)); */
2121 /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0acf37ad)); */
2122 /* MAD_F_MLA(hi, lo, X[12], MAD_F(0x0f9ee890)); */
2123 /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0898c779)); */
2124 /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x00b2aa3e)); */
2125 /* MAD_F_MLA(hi, lo, X[17], MAD_F(0x0f426cb5)); */
2126 /* x[12] = -(x[5] = MAD_F_MLZ(hi, lo)); */
2127 /* MAD_F_ML0(hi, lo, X[0], MAD_F(0x0acf37ad)); */
2128 /* MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0898c779)); */
2129 /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x0e313245)); */
2130 /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0f426cb5)); */
2131 /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x03768962)); */
2132 /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x00b2aa3e)); */
2133 /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0ffc19fd)); */
2134 /* MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f9ee890)); */
2135 /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x04cfb0e2)); */
2136 /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x07635284)); */
2137 /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x0d7e8807)); */
2138 /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0bcbe352)); */
2139 /* x[17] = -(x[0] = MAD_F_MLZ(hi, lo) + t2); */
2140 /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f9ee890)); */
2141 /* MAD_F_MLA(hi, lo, X[2], -MAD_F(0x07635284)); */
2142 /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x00b2aa3e)); */
2143 /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x0bcbe352)); */
2144 /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f426cb5)); */
2145 /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x0d7e8807)); */
2146 /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x0898c779)); */
2147 /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x04cfb0e2)); */
2148 /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0acf37ad)); */
2149 /* MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0ffc19fd)); */
2150 /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0e313245)); */
2151 /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x03768962)); */
2152 /* x[24] = x[29] = MAD_F_MLZ(hi, lo) + t2; */
2153 "move.l #0x0acf37ad, %%d1\n"
2154 "move.l #0x0f9ee890, %%d2\n"
2155 "move.l #0x04cfb0e2, %%d3\n"
2156 "mac.l %%d3, %%d0, %%acc0\n"
2157 "mac.l %%d1, %%d0, %%acc1\n"
2158 "msac.l %%d2, %%d0, (11*4, %[X]), %%d0, %%acc2\n"
2159 "msac.l %%d1, %%d0, %%acc0\n"
2160 "mac.l %%d2, %%d0, %%acc1\n"
2161 "msac.l %%d3, %%d0, (12*4, %[X]), %%d0, %%acc2\n"
2162 "mac.l %%d2, %%d0, %%acc0\n"
2163 "msac.l %%d3, %%d0, %%acc1\n"
2164 "msac.l %%d1, %%d0, ( 2*4, %[X]), %%d0, %%acc2\n"
2165 "move.l #0x0ffc19fd, %%d1\n"
2166 "move.l #0x0898c779, %%d2\n"
2167 "move.l #0x07635284, %%d3\n"
2168 "mac.l %%d1, %%d0, %%acc0\n"
2169 "msac.l %%d2, %%d0, %%acc1\n"
2170 "msac.l %%d3, %%d0, ( 9*4, %[X]), %%d0, %%acc2\n"
2171 "mac.l %%d3, %%d0, %%acc0\n"
2172 "msac.l %%d1, %%d0, %%acc1\n"
2173 "mac.l %%d2, %%d0, (14*4, %[X]), %%d0, %%acc2\n"
2174 "mac.l %%d2, %%d0, %%acc0\n"
2175 "mac.l %%d3, %%d0, %%acc1\n"
2176 "msac.l %%d1, %%d0, ( 3*4, %[X]), %%d0, %%acc2\n"
2177 "move.l #0x0e313245, %%d1\n"
2178 "move.l #0x00b2aa3e, %%d2\n"
2179 "move.l #0x0d7e8807, %%d3\n"
2180 "msac.l %%d3, %%d0, %%acc0\n"
2181 "mac.l %%d1, %%d0, %%acc1\n"
2182 "msac.l %%d2, %%d0, ( 8*4, %[X]), %%d0, %%acc2\n"
2183 "msac.l %%d1, %%d0, %%acc0\n"
2184 "mac.l %%d2, %%d0, %%acc1\n"
2185 "mac.l %%d3, %%d0, (15*4, %[X]), %%d0, %%acc2\n"
2186 "mac.l %%d2, %%d0, %%acc0\n"
2187 "mac.l %%d3, %%d0, %%acc1\n"
2188 "msac.l %%d1, %%d0, ( 5*4, %[X]), %%d0, %%acc2\n"
2189 "move.l #0x03768962, %%d1\n"
2190 "move.l #0x0f426cb5, %%d2\n"
2191 "move.l #0x0bcbe352, %%d3\n"
2192 "mac.l %%d1, %%d0, %%acc0\n"
2193 "msac.l %%d2, %%d0, %%acc1\n"
2194 "mac.l %%d3, %%d0, ( 6*4, %[X]), %%d0, %%acc2\n"
2195 "msac.l %%d3, %%d0, %%acc0\n"
2196 "msac.l %%d1, %%d0, %%acc1\n"
2197 "mac.l %%d2, %%d0, (17*4, %[X]), %%d0, %%acc2\n"
2198 "mac.l %%d2, %%d0, %%acc0\n"
2199 "msac.l %%d3, %%d0, %%acc1\n"
2200 "msac.l %%d1, %%d0, ( %[X]), %%d0, %%acc2\n"
2201
2202 "movclr.l %%acc0, %%d6\n"
2203 "asl.l #3, %%d6\n"
2204 "move.l %%d6, ( 5*4, %[x])\n"
2205 "neg.l %%d6\n"
2206 "move.l %%d6, (12*4, %[x])\n"
2207
2208 "movclr.l %%acc1, %%d6\n"
2209 "asl.l #3, %%d6\n"
2210 "add.l %%d7, %%d6\n"
2211 "move.l %%d6, ( %[x])\n"
2212 "neg.l %%d6\n"
2213 "move.l %%d6, (17*4, %[x])\n"
2214
2215 "movclr.l %%acc2, %%d6\n"
2216 "asl.l #3, %%d6\n"
2217 "add.l %%d7, %%d6\n"
2218 "move.l %%d6, (24*4, %[x])\n"
2219 "move.l %%d6, (29*4, %[x])\n"
2220
2221 /* MAD_F_ML0(hi, lo, X[0], MAD_F(0x00b2aa3e)); */
2222 /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x03768962)); */
2223 /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x04cfb0e2)); */
2224 /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x07635284)); */
2225 /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x0898c779)); */
2226 /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x0acf37ad)); */
2227 /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0bcbe352)); */
2228 /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0d7e8807)); */
2229 /* MAD_F_MLA(hi, lo, X[12], MAD_F(0x0e313245)); */
2230 /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f426cb5)); */
2231 /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0f9ee890)); */
2232 /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0ffc19fd)); */
2233 /* x[9] = -(x[8] = MAD_F_MLZ(hi, lo) + t3); */
2234
2235 /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0e313245)); */
2236 /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0bcbe352)); */
2237 /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x0f9ee890)); */
2238 /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0898c779)); */
2239 /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0ffc19fd)); */
2240 /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x04cfb0e2)); */
2241 /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f426cb5)); */
2242 /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x00b2aa3e)); */
2243 /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0d7e8807)); */
2244 /* MAD_F_MLA(hi, lo, X[14], -MAD_F(0x03768962)); */
2245 /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x0acf37ad)); */
2246 /* MAD_F_MLA(hi, lo, X[17], MAD_F(0x07635284)); */
2247 /* x[21] = x[32] = MAD_F_MLZ(hi, lo) + t3; */
2248
2249 /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0d7e8807)); */
2250 /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0f426cb5)); */
2251 /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x0acf37ad)); */
2252 /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0ffc19fd)); */
2253 /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x07635284)); */
2254 /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f9ee890)); */
2255 /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x03768962)); */
2256 /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0e313245)); */
2257 /* MAD_F_MLA(hi, lo, X[12], MAD_F(0x00b2aa3e)); */
2258 /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0bcbe352)); */
2259 /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x04cfb0e2)); */
2260 /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0898c779)); */
2261 /* x[20] = x[33] = MAD_F_MLZ(hi, lo) - t3; */
2262 "move.l #0x0e313245, %%d1\n"
2263 "move.l #0x00b2aa3e, %%d2\n"
2264 "move.l #0x0d7e8807, %%d3\n"
2265 "mac.l %%d2, %%d0, %%acc0\n"
2266 "msac.l %%d1, %%d0, %%acc1\n"
2267 "msac.l %%d3, %%d0, (11*4, %[X]), %%d0, %%acc2\n"
2268 "msac.l %%d3, %%d0, %%acc0\n"
2269 "msac.l %%d2, %%d0, %%acc1\n"
2270 "msac.l %%d1, %%d0, (12*4, %[X]), %%d0, %%acc2\n"
2271 "mac.l %%d1, %%d0, %%acc0\n"
2272 "msac.l %%d3, %%d0, %%acc1\n"
2273 "mac.l %%d2, %%d0, ( 2*4, %[X]), %%d0, %%acc2\n"
2274 "move.l #0x03768962, %%d1\n"
2275 "move.l #0x0f426cb5, %%d2\n"
2276 "move.l #0x0bcbe352, %%d3\n"
2277 "mac.l %%d1, %%d0, %%acc0\n"
2278 "mac.l %%d3, %%d0, %%acc1\n"
2279 "mac.l %%d2, %%d0, ( 9*4, %[X]), %%d0, %%acc2\n"
2280 "msac.l %%d3, %%d0, %%acc0\n"
2281 "mac.l %%d2, %%d0, %%acc1\n"
2282 "mac.l %%d1, %%d0, (14*4, %[X]), %%d0, %%acc2\n"
2283 "mac.l %%d2, %%d0, %%acc0\n"
2284 "msac.l %%d1, %%d0, %%acc1\n"
2285 "mac.l %%d3, %%d0, ( 3*4, %[X]), %%d0, %%acc2\n"
2286 "move.l #0x0acf37ad, %%d1\n"
2287 "move.l #0x0f9ee890, %%d2\n"
2288 "move.l #0x04cfb0e2, %%d3\n"
2289 "msac.l %%d3, %%d0, %%acc0\n"
2290 "mac.l %%d2, %%d0, %%acc1\n"
2291 "mac.l %%d1, %%d0, ( 8*4, %[X]), %%d0, %%acc2\n"
2292 "mac.l %%d1, %%d0, %%acc0\n"
2293 "mac.l %%d3, %%d0, %%acc1\n"
2294 "mac.l %%d2, %%d0, (15*4, %[X]), %%d0, %%acc2\n"
2295 "msac.l %%d2, %%d0, %%acc0\n"
2296 "mac.l %%d1, %%d0, %%acc1\n"
2297 "msac.l %%d3, %%d0, ( 5*4, %[X]), %%d0, %%acc2\n"
2298 "move.l #0x0ffc19fd, %%d1\n"
2299 "move.l #0x0898c779, %%d2\n"
2300 "move.l #0x07635284, %%d3\n"
2301 "msac.l %%d3, %%d0, %%acc0\n"
2302 "msac.l %%d2, %%d0, %%acc1\n"
2303 "msac.l %%d1, %%d0, ( 6*4, %[X]), %%d0, %%acc2\n"
2304 "mac.l %%d2, %%d0, %%acc0\n"
2305 "msac.l %%d1, %%d0, %%acc1\n"
2306 "msac.l %%d3, %%d0, (17*4, %[X]), %%d0, %%acc2\n"
2307 "msac.l %%d1, %%d0, %%acc0\n"
2308 "mac.l %%d3, %%d0, %%acc1\n"
2309 "msac.l %%d2, %%d0, (12*4, %[t]), %%d0, %%acc2\n"
2310
2311 "movclr.l %%acc0, %%d6\n"
2312 "asl.l #3, %%d6\n"
2313 "add.l %%d5, %%d6\n"
2314 "move.l %%d6, (8*4, %[x])\n"
2315 "neg.l %%d6\n"
2316 "move.l %%d6, (9*4, %[x])\n"
2317
2318 "movclr.l %%acc1, %%d6\n"
2319 "asl.l #3, %%d6\n"
2320 "add.l %%d5, %%d6\n"
2321 "move.l %%d6, (21*4, %[x])\n"
2322 "move.l %%d6, (32*4, %[x])\n"
2323
2324 "movclr.l %%acc2, %%d6\n"
2325 "asl.l #3, %%d6\n"
2326 "sub.l %%d5, %%d6\n"
2327 "move.l %%d6, (20*4, %[x])\n"
2328 "move.l %%d6, (33*4, %[x])\n"
2329
2330 /* MAD_F_ML0(hi, lo, t12, -MAD_F(0x0ec835e8)); */
2331 /* MAD_F_MLA(hi, lo, t13, MAD_F(0x061f78aa)); */
2332 /* x[22] = x[31] = MAD_F_MLZ(hi, lo) + t0; */
2333 "move.l #0x0ec835e8, %%d1\n"
2334 "move.l #0x061f78aa, %%d2\n"
2335 "msac.l %%d1, %%d0, (13*4, %[t]), %%d3, %%acc0\n"
2336 "mac.l %%d2, %%d3, ( 1*4, %[x]), %%d4, %%acc0\n"
2337 "movclr.l %%acc0, %%d6\n"
2338 "asl.l #3, %%d6\n"
2339 "add.l (0*4, %[t]), %%d6\n"
2340 "move.l %%d6, (22*4, %[x])\n"
2341 "move.l %%d6, (31*4, %[x])\n"
2342
2343 /* MAD_F_ML0(hi, lo, t12, MAD_F(0x061f78aa)); */
2344 /* MAD_F_MLA(hi, lo, t13, MAD_F(0x0ec835e8)); */
2345 /* x[13] = -(x[4] = MAD_F_MLZ(hi, lo) + t4); */
2346 /* x[16] = -(x[1] = x[1] + t4); */
2347 /* x[25] = x[28] = x[25] + t4; */
2348 "mac.l %%d2, %%d0, (4*4, %[t]), %%d2, %%acc0\n"
2349 "mac.l %%d1, %%d3, ( %[X]), %%d0, %%acc0\n"
2350 "movclr.l %%acc0, %%d6\n"
2351 "asl.l #3, %%d6\n"
2352 "add.l %%d2, %%d6\n"
2353 "move.l %%d6, ( 4*4, %[x])\n"
2354 "neg.l %%d6\n"
2355 "move.l %%d6, (13*4, %[x])\n"
2356
2357 "add.l %%d2, %%d4\n"
2358 "move.l %%d4, ( 1*4, %[x])\n"
2359 "neg.l %%d4\n"
2360 "move.l %%d4, (16*4, %[x])\n"
2361
2362 "move.l (25*4, %[x]), %%d4\n"
2363 "add.l %%d2, %%d4\n"
2364 "move.l %%d4, (25*4, %[x])\n"
2365 "move.l %%d4, (28*4, %[x])\n"
2366
2367 /* MAD_F_ML0(hi, lo, X[0], MAD_F(0x0898c779)); */
2368 /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x04cfb0e2)); */
2369 /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x0bcbe352)); */
2370 /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x00b2aa3e)); */
2371 /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x0e313245)); */
2372 /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x03768962)); */
2373 /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f9ee890)); */
2374 /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x07635284)); */
2375 /* MAD_F_MLA(hi, lo, X[12], MAD_F(0x0ffc19fd)); */
2376 /* MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0acf37ad)); */
2377 /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x0f426cb5)); */
2378 /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0d7e8807)); */
2379 /* x[15] = -(x[2] = MAD_F_MLZ(hi, lo) + t5); */
2380 /* MAD_F_ML0(hi, lo, X[0], MAD_F(0x07635284)); */
2381 /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0acf37ad)); */
2382 /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x03768962)); */
2383 /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x0d7e8807)); */
2384 /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x00b2aa3e)); */
2385 /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f426cb5)); */
2386 /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x04cfb0e2)); */
2387 /* MAD_F_MLA(hi, lo, X[11], MAD_F(0x0ffc19fd)); */
2388 /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0898c779)); */
2389 /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f9ee890)); */
2390 /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0bcbe352)); */
2391 /* MAD_F_MLA(hi, lo, X[17], MAD_F(0x0e313245)); */
2392 /* x[14] = -(x[3] = MAD_F_MLZ(hi, lo) + t5); */
2393 /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0ffc19fd)); */
2394 /* MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0f9ee890)); */
2395 /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0f426cb5)); */
2396 /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0e313245)); */
2397 /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0d7e8807)); */
2398 /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0bcbe352)); */
2399 /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0acf37ad)); */
2400 /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0898c779)); */
2401 /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x07635284)); */
2402 /* MAD_F_MLA(hi, lo, X[14], -MAD_F(0x04cfb0e2)); */
2403 /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x03768962)); */
2404 /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x00b2aa3e)); */
2405 /* x[26] = x[27] = MAD_F_MLZ(hi, lo) + t5; */
2406 "move.l #0x0ffc19fd, %%d1\n"
2407 "move.l #0x0898c779, %%d2\n"
2408 "move.l #0x07635284, %%d3\n"
2409 "mac.l %%d2, %%d0, %%acc0\n"
2410 "mac.l %%d3, %%d0, %%acc1\n"
2411 "msac.l %%d1, %%d0, (11*4, %[X]), %%d0, %%acc2\n"
2412 "msac.l %%d3, %%d0, %%acc0\n"
2413 "mac.l %%d1, %%d0, %%acc1\n"
2414 "msac.l %%d2, %%d0, (12*4, %[X]), %%d0, %%acc2\n"
2415 "mac.l %%d1, %%d0, %%acc0\n"
2416 "msac.l %%d2, %%d0, %%acc1\n"
2417 "msac.l %%d3, %%d0, ( 2*4, %[X]), %%d0, %%acc2\n"
2418 "move.l #0x0acf37ad, %%d1\n"
2419 "move.l #0x0f9ee890, %%d2\n"
2420 "move.l #0x04cfb0e2, %%d3\n"
2421 "mac.l %%d3, %%d0, %%acc0\n"
2422 "mac.l %%d1, %%d0, %%acc1\n"
2423 "msac.l %%d2, %%d0, ( 9*4, %[X]), %%d0, %%acc2\n"
2424 "mac.l %%d2, %%d0, %%acc0\n"
2425 "msac.l %%d3, %%d0, %%acc1\n"
2426 "msac.l %%d1, %%d0, (14*4, %[X]), %%d0, %%acc2\n"
2427 "msac.l %%d1, %%d0, %%acc0\n"
2428 "mac.l %%d2, %%d0, %%acc1\n"
2429 "msac.l %%d3, %%d0, ( 3*4, %[X]), %%d0, %%acc2\n"
2430 "move.l #0x03768962, %%d1\n"
2431 "move.l #0x0f426cb5, %%d2\n"
2432 "move.l #0x0bcbe352, %%d3\n"
2433 "mac.l %%d3, %%d0, %%acc0\n"
2434 "mac.l %%d1, %%d0, %%acc1\n"
2435 "msac.l %%d2, %%d0, ( 8*4, %[X]), %%d0, %%acc2\n"
2436 "msac.l %%d1, %%d0, %%acc0\n"
2437 "mac.l %%d2, %%d0, %%acc1\n"
2438 "msac.l %%d3, %%d0, (15*4, %[X]), %%d0, %%acc2\n"
2439 "mac.l %%d2, %%d0, %%acc0\n"
2440 "msac.l %%d3, %%d0, %%acc1\n"
2441 "msac.l %%d1, %%d0, ( 5*4, %[X]), %%d0, %%acc2\n"
2442 "move.l #0x0e313245, %%d1\n"
2443 "move.l #0x00b2aa3e, %%d2\n"
2444 "move.l #0x0d7e8807, %%d3\n"
2445 "mac.l %%d2, %%d0, %%acc0\n"
2446 "mac.l %%d3, %%d0, %%acc1\n"
2447 "msac.l %%d1, %%d0, ( 6*4, %[X]), %%d0, %%acc2\n"
2448 "mac.l %%d1, %%d0, %%acc0\n"
2449 "msac.l %%d2, %%d0, %%acc1\n"
2450 "msac.l %%d3, %%d0, (17*4, %[X]), %%d0, %%acc2\n"
2451 "msac.l %%d3, %%d0, %%acc0\n"
2452 "mac.l %%d1, %%d0, %%acc1\n"
2453 "msac.l %%d2, %%d0, ( 5*4, %[t]), %%d6, %%acc2\n"
2454 "movclr.l %%acc0, %%d7\n"
2455 "asl.l #3, %%d7\n"
2456 "add.l %%d6, %%d7\n"
2457 "move.l %%d7, (2*4, %[x])\n"
2458 "neg.l %%d7\n"
2459 "move.l %%d7, (15*4, %[x])\n"
2460
2461 "movclr.l %%acc1, %%d7\n"
2462 "asl.l #3, %%d7\n"
2463 "add.l %%d6, %%d7\n"
2464 "move.l %%d7, (3*4, %[x])\n"
2465 "neg.l %%d7\n"
2466 "move.l %%d7, (14*4, %[x])\n"
2467
2468 "movclr.l %%acc2, %%d7\n"
2469 "asl.l #3, %%d7\n"
2470 "add.l %%d6, %%d7\n"
2471 "move.l %%d7, (26*4, %[x])\n"
2472 "move.l %%d7, (27*4, %[x])\n"
2473
2474 : : [X] "a" (X), [x] "a" (x), [t] "a" (t)
2475 : "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7");
2476 /* pfew */
2477 }
2478
2479 #else
2480
2481 static inline
2482 void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36])
2483 {
2484 mad_fixed_t t0, t1, t2, t3, t4, t5, t6, t7;
2485 mad_fixed_t t8, t9, t10, t11, t12, t13, t14, t15;
2486 register mad_fixed64hi_t hi;
2487 register mad_fixed64lo_t lo;
2488
2489 MAD_F_ML0(hi, lo, (t14 = X[1] - X[10]), -MAD_F(0x0ec835e8));
2490 MAD_F_MLA(hi, lo, (t15 = X[7] + X[16]), MAD_F(0x061f78aa));
2491 t4 = MAD_F_MLZ(hi, lo);
2492
2493 MAD_F_ML0(hi, lo, X[4], MAD_F(0x0ec835e8));
2494 MAD_F_MLA(hi, lo, X[13], MAD_F(0x061f78aa));
2495 t6 = MAD_F_MLZ(hi, lo);
2496
2497 MAD_F_MLA(hi, lo, t14, -MAD_F(0x061f78aa));
2498 MAD_F_MLA(hi, lo, t15, -MAD_F(0x0ec835e8));
2499 t0 = MAD_F_MLZ(hi, lo);
2500
2501 MAD_F_MLA(hi, lo, (t8 =X[0]-X[11]-X[12]), MAD_F(0x0216a2a2));
2502 MAD_F_MLA(hi, lo, (t9 =X[2]-X[ 9]-X[14]), MAD_F(0x09bd7ca0));
2503 MAD_F_MLA(hi, lo, (t10=X[3]-X[ 8]-X[15]), -MAD_F(0x0cb19346));
2504 MAD_F_MLA(hi, lo, (t11=X[5]-X[ 6]-X[17]), -MAD_F(0x0fdcf549));
2505 x[10] = -(x[7] = MAD_F_MLZ(hi, lo));
2506
2507 MAD_F_ML0(hi, lo, t8, -MAD_F(0x0cb19346));
2508 MAD_F_MLA(hi, lo, t9, MAD_F(0x0fdcf549));
2509 MAD_F_MLA(hi, lo, t10, MAD_F(0x0216a2a2));
2510 MAD_F_MLA(hi, lo, t11, -MAD_F(0x09bd7ca0));
2511 x[19] = x[34] = MAD_F_MLZ(hi, lo) - t0;
2512
2513 MAD_F_ML0(hi, lo, t8, MAD_F(0x09bd7ca0));
2514 MAD_F_MLA(hi, lo, t9, -MAD_F(0x0216a2a2));
2515 MAD_F_MLA(hi, lo, t10, MAD_F(0x0fdcf549));
2516 MAD_F_MLA(hi, lo, t11, -MAD_F(0x0cb19346));
2517 x[ 1] = MAD_F_MLZ(hi, lo);
2518
2519 MAD_F_ML0(hi, lo, t8, -MAD_F(0x0fdcf549));
2520 MAD_F_MLA(hi, lo, t9, -MAD_F(0x0cb19346));
2521 MAD_F_MLA(hi, lo, t10, -MAD_F(0x09bd7ca0));
2522 MAD_F_MLA(hi, lo, t11, -MAD_F(0x0216a2a2));
2523 x[25] = MAD_F_MLZ(hi, lo);
2524
2525 t12 = t8 - t10;
2526 t13 = t9 + t11;
2527
2528 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x09bd7ca0));
2529 MAD_F_MLA(hi, lo, X[7], MAD_F(0x0216a2a2));
2530 MAD_F_MLA(hi, lo, X[10], -MAD_F(0x0fdcf549));
2531 MAD_F_MLA(hi, lo, X[16], MAD_F(0x0cb19346));
2532 t1 = MAD_F_MLZ(hi, lo) + t6;
2533
2534 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0216a2a2));
2535 MAD_F_MLA(hi, lo, X[7], -MAD_F(0x09bd7ca0));
2536 MAD_F_MLA(hi, lo, X[10], MAD_F(0x0cb19346));
2537 MAD_F_MLA(hi, lo, X[16], MAD_F(0x0fdcf549));
2538 t3 = MAD_F_MLZ(hi, lo);
2539
2540 MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0fdcf549));
2541 MAD_F_MLA(hi, lo, X[7], -MAD_F(0x0cb19346));
2542 MAD_F_MLA(hi, lo, X[10], -MAD_F(0x09bd7ca0));
2543 MAD_F_MLA(hi, lo, X[16], -MAD_F(0x0216a2a2));
2544 t5 = MAD_F_MLZ(hi, lo) - t6;
2545
2546 MAD_F_ML0(hi, lo, X[0], MAD_F(0x03768962));
2547 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0e313245));
2548 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0ffc19fd));
2549 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0acf37ad));
2550 MAD_F_MLA(hi, lo, X[6], MAD_F(0x04cfb0e2));
2551 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0898c779));
2552 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0d7e8807));
2553 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f426cb5));
2554 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0bcbe352));
2555 MAD_F_MLA(hi, lo, X[14], MAD_F(0x00b2aa3e));
2556 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x07635284));
2557 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0f9ee890));
2558 x[11] = -(x[6] = MAD_F_MLZ(hi, lo) + t1);
2559
2560 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f426cb5));
2561 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x00b2aa3e));
2562 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0898c779));
2563 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0f9ee890));
2564 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0acf37ad));
2565 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x07635284));
2566 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0e313245));
2567 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0bcbe352));
2568 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x03768962));
2569 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0d7e8807));
2570 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0ffc19fd));
2571 MAD_F_MLA(hi, lo, X[17], MAD_F(0x04cfb0e2));
2572 x[23] = x[30] = MAD_F_MLZ(hi, lo) + t1;
2573
2574 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0bcbe352));
2575 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0d7e8807));
2576 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x07635284));
2577 MAD_F_MLA(hi, lo, X[5], MAD_F(0x04cfb0e2));
2578 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f9ee890));
2579 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0ffc19fd));
2580 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x00b2aa3e));
2581 MAD_F_MLA(hi, lo, X[11], MAD_F(0x03768962));
2582 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0f426cb5));
2583 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0e313245));
2584 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0898c779));
2585 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0acf37ad));
2586 x[18] = x[35] = MAD_F_MLZ(hi, lo) - t1;
2587
2588 MAD_F_ML0(hi, lo, X[4], MAD_F(0x061f78aa));
2589 MAD_F_MLA(hi, lo, X[13], -MAD_F(0x0ec835e8));
2590 t3+= (t7 = MAD_F_MLZ(hi, lo));
2591 t4-= t7;
2592
2593 MAD_F_MLA(hi, lo, X[1], -MAD_F(0x0cb19346));
2594 MAD_F_MLA(hi, lo, X[7], MAD_F(0x0fdcf549));
2595 MAD_F_MLA(hi, lo, X[10], MAD_F(0x0216a2a2));
2596 MAD_F_MLA(hi, lo, X[16], -MAD_F(0x09bd7ca0));
2597 t2 = MAD_F_MLZ(hi, lo);
2598
2599 MAD_F_MLA(hi, lo, X[0], MAD_F(0x04cfb0e2));
2600 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0ffc19fd));
2601 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0d7e8807));
2602 MAD_F_MLA(hi, lo, X[5], MAD_F(0x03768962));
2603 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0bcbe352));
2604 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0e313245));
2605 MAD_F_MLA(hi, lo, X[9], MAD_F(0x07635284));
2606 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0acf37ad));
2607 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0f9ee890));
2608 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0898c779));
2609 MAD_F_MLA(hi, lo, X[15], MAD_F(0x00b2aa3e));
2610 MAD_F_MLA(hi, lo, X[17], MAD_F(0x0f426cb5));
2611 x[12] = -(x[5] = MAD_F_MLZ(hi, lo));
2612
2613 MAD_F_ML0(hi, lo, X[0], MAD_F(0x0acf37ad));
2614 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0898c779));
2615 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0e313245));
2616 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0f426cb5));
2617 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x03768962));
2618 MAD_F_MLA(hi, lo, X[8], MAD_F(0x00b2aa3e));
2619 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0ffc19fd));
2620 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f9ee890));
2621 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x04cfb0e2));
2622 MAD_F_MLA(hi, lo, X[14], MAD_F(0x07635284));
2623 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0d7e8807));
2624 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0bcbe352));
2625 x[17] = -(x[0] = MAD_F_MLZ(hi, lo) + t2);
2626
2627 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f9ee890));
2628 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x07635284));
2629 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x00b2aa3e));
2630 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0bcbe352));
2631 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f426cb5));
2632 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0d7e8807));
2633 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0898c779));
2634 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x04cfb0e2));
2635 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0acf37ad));
2636 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0ffc19fd));
2637 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0e313245));
2638 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x03768962));
2639 x[24] = x[29] = MAD_F_MLZ(hi, lo) + t2;
2640
2641 MAD_F_ML0(hi, lo, X[0], MAD_F(0x00b2aa3e));
2642 MAD_F_MLA(hi, lo, X[2], MAD_F(0x03768962));
2643 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x04cfb0e2));
2644 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x07635284));
2645 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0898c779));
2646 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0acf37ad));
2647 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0bcbe352));
2648 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0d7e8807));
2649 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0e313245));
2650 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f426cb5));
2651 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0f9ee890));
2652 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0ffc19fd));
2653 x[9] = -(x[8] = MAD_F_MLZ(hi, lo) + t3);
2654
2655 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0e313245));
2656 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0bcbe352));
2657 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0f9ee890));
2658 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0898c779));
2659 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0ffc19fd));
2660 MAD_F_MLA(hi, lo, X[8], MAD_F(0x04cfb0e2));
2661 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f426cb5));
2662 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x00b2aa3e));
2663 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0d7e8807));
2664 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x03768962));
2665 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0acf37ad));
2666 MAD_F_MLA(hi, lo, X[17], MAD_F(0x07635284));
2667 x[21] = x[32] = MAD_F_MLZ(hi, lo) + t3;
2668
2669 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0d7e8807));
2670 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0f426cb5));
2671 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0acf37ad));
2672 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0ffc19fd));
2673 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x07635284));
2674 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f9ee890));
2675 MAD_F_MLA(hi, lo, X[9], MAD_F(0x03768962));
2676 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0e313245));
2677 MAD_F_MLA(hi, lo, X[12], MAD_F(0x00b2aa3e));
2678 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0bcbe352));
2679 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x04cfb0e2));
2680 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0898c779));
2681 x[20] = x[33] = MAD_F_MLZ(hi, lo) - t3;
2682
2683 MAD_F_ML0(hi, lo, t12, -MAD_F(0x0ec835e8));
2684 MAD_F_MLA(hi, lo, t13, MAD_F(0x061f78aa));
2685 x[22] = x[31] = MAD_F_MLZ(hi, lo) + t0;
2686
2687 MAD_F_ML0(hi, lo, t12, MAD_F(0x061f78aa));
2688 MAD_F_MLA(hi, lo, t13, MAD_F(0x0ec835e8));
2689 x[13] = -(x[4] = MAD_F_MLZ(hi, lo) + t4);
2690 x[16] = -(x[1] = x[1] + t4);
2691 x[25] = x[28] = x[25] + t4;
2692
2693 MAD_F_ML0(hi, lo, X[0], MAD_F(0x0898c779));
2694 MAD_F_MLA(hi, lo, X[2], MAD_F(0x04cfb0e2));
2695 MAD_F_MLA(hi, lo, X[3], MAD_F(0x0bcbe352));
2696 MAD_F_MLA(hi, lo, X[5], MAD_F(0x00b2aa3e));
2697 MAD_F_MLA(hi, lo, X[6], MAD_F(0x0e313245));
2698 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x03768962));
2699 MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f9ee890));
2700 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x07635284));
2701 MAD_F_MLA(hi, lo, X[12], MAD_F(0x0ffc19fd));
2702 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0acf37ad));
2703 MAD_F_MLA(hi, lo, X[15], MAD_F(0x0f426cb5));
2704 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0d7e8807));
2705 x[15] = -(x[2] = MAD_F_MLZ(hi, lo) + t5);
2706
2707 MAD_F_ML0(hi, lo, X[0], MAD_F(0x07635284));
2708 MAD_F_MLA(hi, lo, X[2], MAD_F(0x0acf37ad));
2709 MAD_F_MLA(hi, lo, X[3], MAD_F(0x03768962));
2710 MAD_F_MLA(hi, lo, X[5], MAD_F(0x0d7e8807));
2711 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x00b2aa3e));
2712 MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f426cb5));
2713 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x04cfb0e2));
2714 MAD_F_MLA(hi, lo, X[11], MAD_F(0x0ffc19fd));
2715 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0898c779));
2716 MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f9ee890));
2717 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0bcbe352));
2718 MAD_F_MLA(hi, lo, X[17], MAD_F(0x0e313245));
2719 x[14] = -(x[3] = MAD_F_MLZ(hi, lo) + t5);
2720
2721 MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0ffc19fd));
2722 MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0f9ee890));
2723 MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0f426cb5));
2724 MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0e313245));
2725 MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0d7e8807));
2726 MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0bcbe352));
2727 MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0acf37ad));
2728 MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0898c779));
2729 MAD_F_MLA(hi, lo, X[12], -MAD_F(0x07635284));
2730 MAD_F_MLA(hi, lo, X[14], -MAD_F(0x04cfb0e2));
2731 MAD_F_MLA(hi, lo, X[15], -MAD_F(0x03768962));
2732 MAD_F_MLA(hi, lo, X[17], -MAD_F(0x00b2aa3e));
2733 x[26] = x[27] = MAD_F_MLZ(hi, lo) + t5;
2734 }
2735 #endif /* CPU_COLDFIRE */
2736
2737 # endif
2738
2739 /*
2740 * NAME: III_imdct_l()
2741 * DESCRIPTION: perform IMDCT and windowing for long blocks
2742 */
2743 static
2744 void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36],
2745 unsigned int block_type)
2746 {
2747 unsigned int i;
2748
2749 /* IMDCT */
2750
2751 imdct36(X, z);
2752
2753 /* windowing */
2754
2755 switch (block_type) {
2756 case 0: /* normal window */
2757 # if defined(ASO_INTERLEAVE1)
2758 {
2759 register mad_fixed_t tmp1, tmp2;
2760
2761 tmp1 = window_l[0];
2762 tmp2 = window_l[1];
2763
2764 for (i = 0; i < 34; i += 2) {
2765 z[i + 0] = mad_f_mul(z[i + 0], tmp1);
2766 tmp1 = window_l[i + 2];
2767 z[i + 1] = mad_f_mul(z[i + 1], tmp2);
2768 tmp2 = window_l[i + 3];
2769 }
2770
2771 z[34] = mad_f_mul(z[34], tmp1);
2772 z[35] = mad_f_mul(z[35], tmp2);
2773 }
2774 # elif defined(ASO_INTERLEAVE2)
2775 {
2776 register mad_fixed_t tmp1, tmp2;
2777
2778 tmp1 = z[0];
2779 tmp2 = window_l[0];
2780
2781 for (i = 0; i < 35; ++i) {
2782 z[i] = mad_f_mul(tmp1, tmp2);
2783 tmp1 = z[i + 1];
2784 tmp2 = window_l[i + 1];
2785 }
2786
2787 z[35] = mad_f_mul(tmp1, tmp2);
2788 }
2789 # elif 1
2790 for (i = 0; i < 36; i += 4) {
2791 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
2792 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
2793 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
2794 z[i + 3] = mad_f_mul(z[i + 3], window_l[i + 3]);
2795 }
2796 # else
2797 for (i = 0; i < 36; ++i) z[i] = mad_f_mul(z[i], window_l[i]);
2798 # endif
2799 break;
2800
2801 case 1: /* start block */
2802 for (i = 0; i < 18; i += 3) {
2803 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
2804 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
2805 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
2806 }
2807 /* (i = 18; i < 24; ++i) z[i] unchanged */
2808 for (i = 24; i < 30; ++i) z[i] = mad_f_mul(z[i], window_s[i - 18]);
2809 for (i = 30; i < 36; ++i) z[i] = 0;
2810 break;
2811
2812 case 3: /* stop block */
2813 for (i = 0; i < 6; ++i) z[i] = 0;
2814 for (i = 6; i < 12; ++i) z[i] = mad_f_mul(z[i], window_s[i - 6]);
2815 /* (i = 12; i < 18; ++i) z[i] unchanged */
2816 for (i = 18; i < 36; i += 3) {
2817 z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]);
2818 z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]);
2819 z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]);
2820 }
2821 break;
2822 }
2823 }
2824 # endif /* ASO_IMDCT */
2825
2826 /*
2827 * NAME: III_imdct_s()
2828 * DESCRIPTION: perform IMDCT and windowing for short blocks
2829 */
2830
2831 # if defined(CPU_COLDFIRE)
2832 void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36]);
2833 #else
2834
2835 static
2836 void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36])
2837 {
2838 mad_fixed_t y[36], *yptr;
2839 mad_fixed_t const *wptr;
2840 int w, i;
2841 register mad_fixed64hi_t hi;
2842 register mad_fixed64lo_t lo;
2843
2844 /* IMDCT */
2845
2846 yptr = &y[0];
2847
2848 for (w = 0; w < 3; ++w) {
2849 register mad_fixed_t const (*s)[6];
2850
2851 s = imdct_s;
2852
2853 for (i = 0; i < 3; ++i) {
2854 MAD_F_ML0(hi, lo, X[0], (*s)[0]);
2855 MAD_F_MLA(hi, lo, X[1], (*s)[1]);
2856 MAD_F_MLA(hi, lo, X[2], (*s)[2]);
2857 MAD_F_MLA(hi, lo, X[3], (*s)[3]);
2858 MAD_F_MLA(hi, lo, X[4], (*s)[4]);
2859 MAD_F_MLA(hi, lo, X[5], (*s)[5]);
2860
2861 yptr[i + 0] = MAD_F_MLZ(hi, lo);
2862 yptr[5 - i] = -yptr[i + 0];
2863
2864 ++s;
2865
2866 MAD_F_ML0(hi, lo, X[0], (*s)[0]);
2867 MAD_F_MLA(hi, lo, X[1], (*s)[1]);
2868 MAD_F_MLA(hi, lo, X[2], (*s)[2]);
2869 MAD_F_MLA(hi, lo, X[3], (*s)[3]);
2870 MAD_F_MLA(hi, lo, X[4], (*s)[4]);
2871 MAD_F_MLA(hi, lo, X[5], (*s)[5]);
2872
2873 yptr[ i + 6] = MAD_F_MLZ(hi, lo);
2874 yptr[11 - i] = yptr[i + 6];
2875
2876 ++s;
2877 }
2878
2879 yptr += 12;
2880 X += 6;
2881 }
2882
2883 /* windowing, overlapping and concatenation */
2884
2885 yptr = &y[0];
2886 wptr = &window_s[0];
2887
2888 for (i = 0; i < 6; ++i) {
2889 z[i + 0] = 0;
2890 z[i + 6] = mad_f_mul(yptr[ 0 + 0], wptr[0]);
2891
2892 MAD_F_ML0(hi, lo, yptr[ 0 + 6], wptr[6]);
2893 MAD_F_MLA(hi, lo, yptr[12 + 0], wptr[0]);
2894
2895 z[i + 12] = MAD_F_MLZ(hi, lo);
2896
2897 MAD_F_ML0(hi, lo, yptr[12 + 6], wptr[6]);
2898 MAD_F_MLA(hi, lo, yptr[24 + 0], wptr[0]);
2899
2900 z[i + 18] = MAD_F_MLZ(hi, lo);
2901
2902 z[i + 24] = mad_f_mul(yptr[24 + 6], wptr[6]);
2903 z[i + 30] = 0;
2904
2905 ++yptr;
2906 ++wptr;
2907 }
2908 }
2909
2910 #endif
2911
2912 #ifdef CPU_ARM
2913 void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18],
2914 mad_fixed_t sample[18][32], unsigned int sb);
2915 #else
2916
2917 /*
2918 * NAME: III_overlap()
2919 * DESCRIPTION: perform overlap-add of windowed IMDCT outputs
2920 */
2921 static
2922 void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18],
2923 mad_fixed_t sample[18][32], unsigned int sb)
2924 {
2925 unsigned int i;
2926
2927 # if defined(ASO_INTERLEAVE2)
2928 {
2929 register mad_fixed_t tmp1, tmp2;
2930
2931 tmp1 = overlap[0];
2932 tmp2 = overlap[1];
2933
2934 for (i = 0; i < 16; i += 2) {
2935 sample[i + 0][sb] = output[i + 0 + 0] + tmp1;
2936 overlap[i + 0] = output[i + 0 + 18];
2937 tmp1 = overlap[i + 2];
2938
2939 sample[i + 1][sb] = output[i + 1 + 0] + tmp2;
2940 overlap[i + 1] = output[i + 1 + 18];
2941 tmp2 = overlap[i + 3];
2942 }
2943
2944 sample[16][sb] = output[16 + 0] + tmp1;
2945 overlap[16] = output[16 + 18];
2946 sample[17][sb] = output[17 + 0] + tmp2;
2947 overlap[17] = output[17 + 18];
2948 }
2949 # elif 0
2950 for (i = 0; i < 18; i += 2) {
2951 sample[i + 0][sb] = output[i + 0 + 0] + overlap[i + 0];
2952 overlap[i + 0] = output[i + 0 + 18];
2953
2954 sample[i + 1][sb] = output[i + 1 + 0] + overlap[i + 1];
2955 overlap[i + 1] = output[i + 1 + 18];
2956 }
2957 # else
2958 for (i = 0; i < 18; ++i) {
2959 sample[i][sb] = output[i + 0] + overlap[i];
2960 overlap[i] = output[i + 18];
2961 }
2962 # endif
2963 }
2964 #endif
2965
2966 /*
2967 * NAME: III_overlap_z()
2968 * DESCRIPTION: perform "overlap-add" of zero IMDCT outputs
2969 */
2970 static inline
2971 void III_overlap_z(mad_fixed_t overlap[18],
2972 mad_fixed_t sample[18][32], unsigned int sb)
2973 {
2974 unsigned int i;
2975
2976 # if defined(ASO_INTERLEAVE2)
2977 {
2978 register mad_fixed_t tmp1, tmp2;
2979
2980 tmp1 = overlap[0];
2981 tmp2 = overlap[1];
2982
2983 for (i = 0; i < 16; i += 2) {
2984 sample[i + 0][sb] = tmp1;
2985 overlap[i + 0] = 0;
2986 tmp1 = overlap[i + 2];
2987
2988 sample[i + 1][sb] = tmp2;
2989 overlap[i + 1] = 0;
2990 tmp2 = overlap[i + 3];
2991 }
2992
2993 sample[16][sb] = tmp1;
2994 overlap[16] = 0;
2995 sample[17][sb] = tmp2;
2996 overlap[17] = 0;
2997 }
2998 # else
2999 for (i = 0; i < 18; ++i) {
3000 sample[i][sb] = overlap[i];
3001 overlap[i] = 0;
3002 }
3003 # endif
3004 }
3005
3006 /*
3007 * NAME: III_freqinver()
3008 * DESCRIPTION: perform subband frequency inversion for odd sample lines
3009 */
3010 static
3011 void III_freqinver(mad_fixed_t sample[18][32], unsigned int sb)
3012 {
3013 unsigned int i;
3014
3015 # if 1 || defined(ASO_INTERLEAVE1) || defined(ASO_INTERLEAVE2)
3016 {
3017 register mad_fixed_t tmp1, tmp2;
3018
3019 tmp1 = sample[1][sb];
3020 tmp2 = sample[3][sb];
3021
3022 for (i = 1; i < 13; i += 4) {
3023 sample[i + 0][sb] = -tmp1;
3024 tmp1 = sample[i + 4][sb];
3025 sample[i + 2][sb] = -tmp2;
3026 tmp2 = sample[i + 6][sb];
3027 }
3028
3029 sample[13][sb] = -tmp1;
3030 tmp1 = sample[17][sb];
3031 sample[15][sb] = -tmp2;
3032 sample[17][sb] = -tmp1;
3033 }
3034 # else
3035 for (i = 1; i < 18; i += 2)
3036 sample[i][sb] = -sample[i][sb];
3037 # endif
3038 }
3039
3040 /*
3041 * NAME: III_decode()
3042 * DESCRIPTION: decode frame main_data
3043 */
3044 static
3045 enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame,
3046 struct sideinfo *si, unsigned int nch)
3047 {
3048 struct mad_header *header = &frame->header;
3049 unsigned int sfreqi, ngr, gr;
3050
3051 {
3052 unsigned int sfreq;
3053
3054 sfreq = header->samplerate;
3055 if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
3056 sfreq *= 2;
3057
3058 /* 48000 => 0, 44100 => 1, 32000 => 2,
3059 24000 => 3, 22050 => 4, 16000 => 5 */
3060 sfreqi = ((sfreq >> 7) & 0x000f) +
3061 ((sfreq >> 15) & 0x0001) - 8;
3062
3063 if (header->flags & MAD_FLAG_MPEG_2_5_EXT)
3064 sfreqi += 3;
3065 }
3066
3067 /* scalefactors, Huffman decoding, requantization */
3068
3069 ngr = (header->flags & MAD_FLAG_LSF_EXT) ? 1 : 2;
3070
3071 for (gr = 0; gr < ngr; ++gr) {
3072 struct granule *granule = &si->gr[gr];
3073 unsigned char const *sfbwidth[2];
3074 mad_fixed_t xr[2][576];
3075 unsigned int ch;
3076 enum mad_error error;
3077
3078 for (ch = 0; ch < nch; ++ch) {
3079 struct channel *channel = &granule->ch[ch];
3080 unsigned int part2_length;
3081
3082 sfbwidth[ch] = sfbwidth_table[sfreqi].l;
3083 if (channel->block_type == 2) {
3084 sfbwidth[ch] = (channel->flags & mixed_block_flag) ?
3085 sfbwidth_table[sfreqi].m : sfbwidth_table[sfreqi].s;
3086 }
3087
3088 if (header->flags & MAD_FLAG_LSF_EXT) {
3089 part2_length = III_scalefactors_lsf(ptr, channel,
3090 ch == 0 ? 0 : &si->gr[1].ch[1],
3091 header->mode_extension);
3092 }
3093 else {
3094 part2_length = III_scalefactors(ptr, channel, &si->gr[0].ch[ch],
3095 gr == 0 ? 0 : si->scfsi[ch]);
3096 }
3097
3098 error = III_huffdecode(ptr, xr[ch], channel, sfbwidth[ch], part2_length);
3099 if (error)
3100 return error;
3101 }
3102
3103 /* joint stereo processing */
3104
3105 if (header->mode == MAD_MODE_JOINT_STEREO && header->mode_extension) {
3106 error = III_stereo(xr, granule, header, sfbwidth[0]);
3107 if (error)
3108 return error;
3109 }
3110
3111 /* reordering, alias reduction, IMDCT, overlap-add, frequency inversion */
3112
3113 for (ch = 0; ch < nch; ++ch) {
3114 struct channel const *channel = &granule->ch[ch];
3115 mad_fixed_t (*sample)[32] = &((*frame->sbsample)[ch][18 * gr]);
3116 unsigned int sb, l, i, sblimit;
3117 mad_fixed_t output[36];
3118
3119 if (channel->block_type == 2) {
3120 III_reorder(xr[ch], channel, sfbwidth[ch]);
3121
3122 # if !defined(OPT_STRICT)
3123 /*
3124 * According to ISO/IEC 11172-3, "Alias reduction is not applied for
3125 * granules with block_type == 2 (short block)." However, other
3126 * sources suggest alias reduction should indeed be performed on the
3127 * lower two subbands of mixed blocks. Most other implementations do
3128 * this, so by default we will too.
3129 */
3130 if (channel->flags & mixed_block_flag)
3131 III_aliasreduce(xr[ch], 36);
3132 # endif
3133 }
3134 else
3135 III_aliasreduce(xr[ch], 576);
3136
3137 l = 0;
3138
3139 /* subbands 0-1 */
3140
3141 if (channel->block_type != 2 || (channel->flags & mixed_block_flag)) {
3142 unsigned int block_type;
3143
3144 block_type = channel->block_type;
3145 if (channel->flags & mixed_block_flag)
3146 block_type = 0;
3147
3148 /* long blocks */
3149 for (sb = 0; sb < 2; ++sb, l += 18) {
3150 III_imdct_l(&xr[ch][l], output, block_type);
3151 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
3152 }
3153 }
3154 else {
3155 /* short blocks */
3156 for (sb = 0; sb < 2; ++sb, l += 18) {
3157 III_imdct_s(&xr[ch][l], output);
3158 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
3159 }
3160 }
3161
3162 III_freqinver(sample, 1);
3163
3164 /* (nonzero) subbands 2-31 */
3165
3166 /*
3167 i = 576;
3168 while (i > 36 && xr[ch][i - 1] == 0)
3169 --i;
3170 */
3171
3172 {
3173 /* saves ~600k cycles */
3174 mad_fixed_t *p = &xr[ch][576];
3175 mad_fixed_t tmp = xr[ch][35];
3176 xr[ch][35] = 1;
3177 while (!*--p);
3178 xr[ch][35] = tmp;
3179 i = p - &xr[ch][0] + 1;
3180 }
3181 sblimit = 32 - (576 - i) / 18;
3182
3183 if (channel->block_type != 2) {
3184 /* long blocks */
3185 for (sb = 2; sb < sblimit; ++sb, l += 18) {
3186 III_imdct_l(&xr[ch][l], output, channel->block_type);
3187 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
3188
3189 if (sb & 1)
3190 III_freqinver(sample, sb);
3191 }
3192 }
3193 else {
3194 /* short blocks */
3195 for (sb = 2; sb < sblimit; ++sb, l += 18) {
3196 III_imdct_s(&xr[ch][l], output);
3197 III_overlap(output, (*frame->overlap)[ch][sb], sample, sb);
3198
3199 if (sb & 1)
3200 III_freqinver(sample, sb);
3201 }
3202 }
3203
3204 /* remaining (zero) subbands */
3205
3206 for (sb = sblimit; sb < 32; ++sb) {
3207 III_overlap_z((*frame->overlap)[ch][sb], sample, sb);
3208
3209 if (sb & 1)
3210 III_freqinver(sample, sb);
3211 }
3212 }
3213 }
3214
3215 return MAD_ERROR_NONE;
3216 }
3217
3218 /*
3219 * NAME: layer->III()
3220 * DESCRIPTION: decode a single Layer III frame
3221 */
3222 int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame)
3223 {
3224 struct mad_header *header = &frame->header;
3225 unsigned int nch, priv_bitlen, next_md_begin = 0;
3226 unsigned int si_len, data_bitlen, md_len;
3227 unsigned int frame_space, frame_used, frame_free;
3228 struct mad_bitptr ptr;
3229 struct sideinfo si;
3230 enum mad_error error;
3231 int result = 0;
3232
3233 #if 0 /* rockbox: do not allocate */
3234 /* allocate Layer III dynamic structures */
3235 /* rockbox: not used. Both pointers are linked to an array in rockbox'
3236 * apps/codecs/mpa.c before calling this. */
3237 if (stream->main_data == 0) {
3238 stream->main_data = malloc(MAD_BUFFER_MDLEN);
3239 if (stream->main_data == 0) {
3240 stream->error = MAD_ERROR_NOMEM;
3241 return -1;
3242 }
3243 }
3244
3245 if (frame->overlap == 0) {
3246 frame->overlap = calloc(2 * 32 * 18, sizeof(mad_fixed_t));
3247 if (frame->overlap == 0) {
3248 stream->error = MAD_ERROR_NOMEM;
3249 return -1;
3250 }
3251 }
3252 #else
3253 /* rockbox: This should not happen. Return with error. */
3254 if ((stream->main_data == 0) || (frame->overlap == 0)) {
3255 stream->error = MAD_ERROR_NOMEM;
3256 return -1;
3257 }
3258 #endif /* rockbox */
3259
3260 nch = MAD_NCHANNELS(header);
3261 si_len = (header->flags & MAD_FLAG_LSF_EXT) ?
3262 (nch == 1 ? 9 : 17) : (nch == 1 ? 17 : 32);
3263
3264 /* check frame sanity */
3265
3266 if (stream->next_frame - mad_bit_nextbyte(&stream->ptr) <
3267 (signed int) si_len) {
3268 stream->error = MAD_ERROR_BADFRAMELEN;
3269 stream->md_len = 0;
3270 return -1;
3271 }
3272
3273 /* check CRC word */
3274
3275 if (header->flags & MAD_FLAG_PROTECTION) {
3276 header->crc_check =
3277 mad_bit_crc(stream->ptr, si_len * CHAR_BIT, header->crc_check);
3278
3279 if (header->crc_check != header->crc_target &&
3280 !(frame->options & MAD_OPTION_IGNORECRC)) {
3281 stream->error = MAD_ERROR_BADCRC;
3282 result = -1;
3283 }
3284 }
3285
3286 /* decode frame side information */
3287
3288 error = III_sideinfo(&stream->ptr, nch, header->flags & MAD_FLAG_LSF_EXT,
3289 &si, &data_bitlen, &priv_bitlen);
3290 if (error && result == 0) {
3291 stream->error = error;
3292 result = -1;
3293 }
3294
3295 header->flags |= priv_bitlen;
3296 header->private_bits |= si.private_bits;
3297
3298 /* find main_data of next frame */
3299
3300 {
3301 struct mad_bitptr peek;
3302 unsigned long header;
3303
3304 mad_bit_init(&peek, stream->next_frame);
3305
3306 header = mad_bit_read(&peek, 32);
3307 if ((header & 0xffe60000L) /* syncword | layer */ == 0xffe20000L) {
3308 if (!(header & 0x00010000L)) /* protection_bit */
3309 mad_bit_skip(&peek, 16); /* crc_check */
3310
3311 next_md_begin =
3312 mad_bit_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8);
3313 }
3314
3315 mad_bit_finish(&peek);
3316 }
3317
3318 /* find main_data of this frame */
3319
3320 frame_space = stream->next_frame - mad_bit_nextbyte(&stream->ptr);
3321
3322 if (next_md_begin > si.main_data_begin + frame_space)
3323 next_md_begin = 0;
3324
3325 md_len = si.main_data_begin + frame_space - next_md_begin;
3326
3327 frame_used = 0;
3328
3329 if (si.main_data_begin == 0) {
3330 ptr = stream->ptr;
3331 stream->md_len = 0;
3332
3333 frame_used = md_len;
3334 }
3335 else {
3336 if (si.main_data_begin > stream->md_len) {
3337 if (result == 0) {
3338 stream->error = MAD_ERROR_BADDATAPTR;
3339 result = -1;
3340 }
3341 }
3342 else {
3343 mad_bit_init(&ptr,
3344 *stream->main_data + stream->md_len - si.main_data_begin);
3345
3346 if (md_len > si.main_data_begin) {
3347 assert(stream->md_len + md_len -
3348 si.main_data_begin <= MAD_BUFFER_MDLEN);
3349
3350 memcpy(*stream->main_data + stream->md_len,
3351 mad_bit_nextbyte(&stream->ptr),
3352 frame_used = md_len - si.main_data_begin);
3353 stream->md_len += frame_used;
3354 }
3355 }
3356 }
3357
3358 frame_free = frame_space - frame_used;
3359
3360 /* decode main_data */
3361
3362 if (result == 0) {
3363 error = III_decode(&ptr, frame, &si, nch);
3364 if (error) {
3365 stream->error = error;
3366 result = -1;
3367 }
3368
3369 /* designate ancillary bits */
3370
3371 stream->anc_ptr = ptr;
3372 stream->anc_bitlen = md_len * CHAR_BIT - data_bitlen;
3373 }
3374
3375 # if 0 && defined(DEBUG)
3376 fprintf(stderr,
3377 "main_data_begin:%u, md_len:%u, frame_free:%u, "
3378 "data_bitlen:%u, anc_bitlen: %u\n",
3379 si.main_data_begin, md_len, frame_free,
3380 data_bitlen, stream->anc_bitlen);
3381 # endif
3382
3383 /* preload main_data buffer with up to 511 bytes for next frame(s) */
3384
3385 if (frame_free >= next_md_begin) {
3386 memcpy(*stream->main_data,
3387 stream->next_frame - next_md_begin, next_md_begin);
3388 stream->md_len = next_md_begin;
3389 }
3390 else {
3391 if (md_len < si.main_data_begin) {
3392 unsigned int extra;
3393
3394 extra = si.main_data_begin - md_len;
3395 if (extra + frame_free > next_md_begin)
3396 extra = next_md_begin - frame_free;
3397
3398 if (extra < stream->md_len) {
3399 memmove(*stream->main_data,
3400 *stream->main_data + stream->md_len - extra, extra);
3401 stream->md_len = extra;
3402 }
3403 }
3404 else
3405 stream->md_len = 0;
3406
3407 memcpy(*stream->main_data + stream->md_len,
3408 stream->next_frame - frame_free, frame_free);
3409 stream->md_len += frame_free;
3410 }
3411
3412 return result;
3413 }
My public Rockbox git repo