diff options
author | Sean Bartell <wingedtachikoma@gmail.com> | 2011-06-25 21:32:25 -0400 |
---|---|---|
committer | Nils Wallménius <nils@rockbox.org> | 2012-04-25 22:13:20 +0200 |
commit | f40bfc9267b13b54e6379dfe7539447662879d24 (patch) | |
tree | 9b20069d5e62809ff434061ad730096836f916f2 /lib/rbcodec/codecs/libmad/layer3.c | |
parent | a0009907de7a0107d49040d8a180f140e2eff299 (diff) | |
download | rockbox-f40bfc9267b13b54e6379dfe7539447662879d24.tar.gz rockbox-f40bfc9267b13b54e6379dfe7539447662879d24.zip |
Add codecs to librbcodec.
Change-Id: Id7f4717d51ed02d67cb9f9cb3c0ada4a81843f97
Reviewed-on: http://gerrit.rockbox.org/137
Reviewed-by: Nils Wallménius <nils@rockbox.org>
Tested-by: Nils Wallménius <nils@rockbox.org>
Diffstat (limited to 'lib/rbcodec/codecs/libmad/layer3.c')
-rw-r--r-- | lib/rbcodec/codecs/libmad/layer3.c | 3107 |
1 files changed, 3107 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libmad/layer3.c b/lib/rbcodec/codecs/libmad/layer3.c new file mode 100644 index 0000000000..ffb0fb20ff --- /dev/null +++ b/lib/rbcodec/codecs/libmad/layer3.c | |||
@@ -0,0 +1,3107 @@ | |||
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 MEM_ALIGN_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 MEM_ALIGN_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 MEM_ALIGN_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 MEM_ALIGN_ATTR = { | ||
392 | # include "imdct_s.dat" | ||
393 | }; | ||
394 | |||
395 | # if !defined(FPM_ARM) | ||
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 MEM_ALIGN_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 /* FPM_ARM */ | ||
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 MEM_ALIGN_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(CPU_COLDFIRE) | ||
1584 | (void)hi, (void)lo; | ||
1585 | asm volatile ("mac.l %[a], %[csi], %%acc0\n\t" | ||
1586 | "msac.l %[b], %[cai], %%acc0\n\t" | ||
1587 | "mac.l %[b], %[csi], %%acc1\n\t" | ||
1588 | "mac.l %[a], %[cai], %%acc1\n\t" | ||
1589 | "movclr.l %%acc0, %[a]\n\t" | ||
1590 | "asl.l #3, %[a]\n\t" | ||
1591 | "movclr.l %%acc1, %[b]\n\t" | ||
1592 | "asl.l #3, %[b]\n\t" | ||
1593 | : [a] "+d" (a), [b] "+d" (b) | ||
1594 | : [csi] "r" (cs[i]), [cai] "r" (ca[i])); | ||
1595 | xr[-1 - i] = a; | ||
1596 | xr[ i] = b; | ||
1597 | # else | ||
1598 | MAD_F_ML0(hi, lo, a, cs[i]); | ||
1599 | MAD_F_MLA(hi, lo, -b, ca[i]); | ||
1600 | |||
1601 | xr[-1 - i] = MAD_F_MLZ(hi, lo); | ||
1602 | |||
1603 | MAD_F_ML0(hi, lo, b, cs[i]); | ||
1604 | MAD_F_MLA(hi, lo, a, ca[i]); | ||
1605 | |||
1606 | xr[ i] = MAD_F_MLZ(hi, lo); | ||
1607 | # endif | ||
1608 | } | ||
1609 | } | ||
1610 | } | ||
1611 | #endif | ||
1612 | |||
1613 | # if defined(FPM_ARM) | ||
1614 | void III_imdct_l(mad_fixed_t const [18], mad_fixed_t [36], unsigned int); | ||
1615 | # else | ||
1616 | /* | ||
1617 | * NAME: imdct36 | ||
1618 | * DESCRIPTION: perform X[18]->x[36] IMDCT | ||
1619 | */ | ||
1620 | # if defined(CPU_COLDFIRE) | ||
1621 | /* emac optimized imdct36, it is very ugly and i hope to replace it soon. | ||
1622 | * for now it is actually somewhat faster than the stock implementation. | ||
1623 | */ | ||
1624 | static inline | ||
1625 | void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36]) | ||
1626 | { | ||
1627 | mad_fixed_t t[16]; | ||
1628 | /* assumes FRACBITS = 28 */ | ||
1629 | asm volatile ( | ||
1630 | /* MAD_F_ML0(hi, lo, X[4], MAD_F(0x0ec835e8)); */ | ||
1631 | /* MAD_F_MLA(hi, lo, X[13], MAD_F(0x061f78aa)); */ | ||
1632 | /* t6 = MAD_F_MLZ(hi, lo); */ | ||
1633 | "move.l (4*4, %[X]), %%d0\n" | ||
1634 | "move.l #0x0ec835e8, %%d1\n" | ||
1635 | "move.l #0x061f78aa, %%d2\n" | ||
1636 | "mac.l %%d1, %%d0, (13*4, %[X]), %%d0, %%acc0\n" | ||
1637 | "mac.l %%d2, %%d0, ( 1*4, %[X]), %%d0, %%acc0\n" | ||
1638 | "move.l %%acc0, %%d7\n" | ||
1639 | "asl.l #3, %%d7\n" | ||
1640 | "move.l %%d7, (6*4, %[t])\n" | ||
1641 | |||
1642 | /* MAD_F_ML0(hi, lo, (t14 = X[1] - X[10]), -MAD_F(0x0ec835e8)); */ | ||
1643 | /* MAD_F_MLA(hi, lo, (t15 = X[7] + X[16]), MAD_F(0x061f78aa)); */ | ||
1644 | /* t4 = MAD_F_MLZ(hi, lo); */ | ||
1645 | /* MAD_F_MLA(hi, lo, t14, -MAD_F(0x061f78aa)); */ | ||
1646 | /* MAD_F_MLA(hi, lo, t15, -MAD_F(0x0ec835e8)); */ | ||
1647 | /* t0 = MAD_F_MLZ(hi, lo); */ | ||
1648 | "sub.l (10*4, %[X]), %%d0\n" /* t14 */ | ||
1649 | "msac.l %%d0, %%d1, %%acc1\n" | ||
1650 | "msac.l %%d0, %%d2, (7*4, %[X]), %%d5, %%acc0\n" | ||
1651 | "add.l (16*4, %[X]), %%d5\n" /* t15 */ | ||
1652 | "mac.l %%d5, %%d2, %%acc1\n" | ||
1653 | "msac.l %%d5, %%d1, ( %[X]), %%d5, %%acc0\n" | ||
1654 | "movclr.l %%acc1, %%d6\n" | ||
1655 | "asl.l #3, %%d6\n" /* t4 */ | ||
1656 | "move.l %%d6, (4*4, %[t])\n" | ||
1657 | "move.l %%acc0, %%d0\n" | ||
1658 | "asl.l #3, %%d0\n" /* t0 */ | ||
1659 | "move.l %%d0, (0*4, %[t])\n" | ||
1660 | |||
1661 | /* MAD_F_MLA(hi, lo, (t8 =X[0]-X[11]-X[12]), MAD_F(0x0216a2a2)); */ | ||
1662 | /* MAD_F_MLA(hi, lo, (t9 =X[2]-X[ 9]-X[14]), MAD_F(0x09bd7ca0)); */ | ||
1663 | /* MAD_F_MLA(hi, lo, (t10=X[3]-X[ 8]-X[15]), -MAD_F(0x0cb19346)); */ | ||
1664 | /* MAD_F_MLA(hi, lo, (t11=X[5]-X[ 6]-X[17]), -MAD_F(0x0fdcf549)); */ | ||
1665 | /* x[10] = -(x[7] = MAD_F_MLZ(hi, lo)); */ | ||
1666 | |||
1667 | /* MAD_F_ML0(hi, lo, t8, -MAD_F(0x0cb19346)); */ | ||
1668 | /* MAD_F_MLA(hi, lo, t9, MAD_F(0x0fdcf549)); */ | ||
1669 | /* MAD_F_MLA(hi, lo, t10, MAD_F(0x0216a2a2)); */ | ||
1670 | /* MAD_F_MLA(hi, lo, t11, -MAD_F(0x09bd7ca0)); */ | ||
1671 | /* x[19] = x[34] = MAD_F_MLZ(hi, lo) - t0; */ | ||
1672 | |||
1673 | /* MAD_F_ML0(hi, lo, t8, MAD_F(0x09bd7ca0)); */ | ||
1674 | /* MAD_F_MLA(hi, lo, t9, -MAD_F(0x0216a2a2)); */ | ||
1675 | /* MAD_F_MLA(hi, lo, t10, MAD_F(0x0fdcf549)); */ | ||
1676 | /* MAD_F_MLA(hi, lo, t11, -MAD_F(0x0cb19346)); */ | ||
1677 | /* x[ 1] = MAD_F_MLZ(hi, lo); */ | ||
1678 | |||
1679 | /* MAD_F_ML0(hi, lo, t8, -MAD_F(0x0fdcf549)); */ | ||
1680 | /* MAD_F_MLA(hi, lo, t9, -MAD_F(0x0cb19346)); */ | ||
1681 | /* MAD_F_MLA(hi, lo, t10, -MAD_F(0x09bd7ca0)); */ | ||
1682 | /* MAD_F_MLA(hi, lo, t11, -MAD_F(0x0216a2a2)); */ | ||
1683 | /* x[25] = MAD_F_MLZ(hi, lo); */ | ||
1684 | |||
1685 | /* t12 = t8 - t10; */ | ||
1686 | /* t13 = t9 + t11; */ | ||
1687 | "move.l #0x0216a2a2, %%d1\n" | ||
1688 | "move.l #0x0cb19346, %%d2\n" | ||
1689 | "move.l #0x09bd7ca0, %%d3\n" | ||
1690 | "move.l #0x0fdcf549, %%d4\n" | ||
1691 | "sub.l (11*4, %[X]), %%d5\n" | ||
1692 | "sub.l (12*4, %[X]), %%d5\n" | ||
1693 | "mac.l %%d1, %%d5, %%acc0\n" | ||
1694 | "msac.l %%d2, %%d5, %%acc1\n" | ||
1695 | "mac.l %%d3, %%d5, %%acc2\n" | ||
1696 | "msac.l %%d4, %%d5, (2*4, %[X]), %%d6, %%acc3\n" | ||
1697 | "sub.l ( 9*4, %[X]), %%d6\n" | ||
1698 | "sub.l (14*4, %[X]), %%d6\n" | ||
1699 | "mac.l %%d3, %%d6, %%acc0\n" | ||
1700 | "mac.l %%d4, %%d6, %%acc1\n" | ||
1701 | "msac.l %%d1, %%d6, %%acc2\n" | ||
1702 | "msac.l %%d2, %%d6, (3*4, %[X]), %%d7, %%acc3\n" | ||
1703 | "sub.l ( 8*4, %[X]), %%d7\n" | ||
1704 | "sub.l (15*4, %[X]), %%d7\n" | ||
1705 | "sub.l %%d7, %%d5\n" /* d5: t12 */ | ||
1706 | "move.l %%d5, (12*4, %[t])\n" | ||
1707 | "msac.l %%d2, %%d7, %%acc0\n" | ||
1708 | "mac.l %%d1, %%d7, %%acc1\n" | ||
1709 | "mac.l %%d4, %%d7, %%acc2\n" | ||
1710 | "msac.l %%d3, %%d7, (5*4, %[X]), %%d7, %%acc3\n" | ||
1711 | "sub.l ( 6*4, %[X]), %%d7\n" | ||
1712 | "sub.l (17*4, %[X]), %%d7\n" | ||
1713 | "add.l %%d7, %%d6\n" /* d6: t13 */ | ||
1714 | "move.l %%d6, (13*4, %[t])\n" | ||
1715 | "msac.l %%d4, %%d7, %%acc0\n" | ||
1716 | "msac.l %%d3, %%d7, %%acc1\n" | ||
1717 | "msac.l %%d2, %%d7, %%acc2\n" | ||
1718 | "msac.l %%d1, %%d7, (1*4, %[X]), %%d5, %%acc3\n" | ||
1719 | |||
1720 | "movclr.l %%acc0, %%d7\n" | ||
1721 | "asl.l #3, %%d7\n" | ||
1722 | "move.l %%d7, (7*4, %[x])\n" | ||
1723 | "neg.l %%d7\n" | ||
1724 | "move.l %%d7, (10*4, %[x])\n" | ||
1725 | |||
1726 | "movclr.l %%acc1, %%d7\n" | ||
1727 | "asl.l #3, %%d7\n" | ||
1728 | "sub.l %%d0, %%d7\n" | ||
1729 | "move.l %%d7, (19*4, %[x])\n" | ||
1730 | "move.l %%d7, (34*4, %[x])\n" | ||
1731 | |||
1732 | "movclr.l %%acc2, %%d7\n" | ||
1733 | "asl.l #3, %%d7\n" | ||
1734 | "move.l %%d7, ( 1*4, %[x])\n" | ||
1735 | |||
1736 | "movclr.l %%acc3, %%d7\n" | ||
1737 | "asl.l #3, %%d7\n" | ||
1738 | "move.l %%d7, (25*4, %[x])\n" | ||
1739 | |||
1740 | /* MAD_F_ML0(hi, lo, X[1], -MAD_F(0x09bd7ca0)); */ | ||
1741 | /* MAD_F_MLA(hi, lo, X[7], MAD_F(0x0216a2a2)); */ | ||
1742 | /* MAD_F_MLA(hi, lo, X[10], -MAD_F(0x0fdcf549)); */ | ||
1743 | /* MAD_F_MLA(hi, lo, X[16], MAD_F(0x0cb19346)); */ | ||
1744 | /* t1 = MAD_F_MLZ(hi, lo) + t6; */ | ||
1745 | |||
1746 | /* MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0216a2a2)); */ | ||
1747 | /* MAD_F_MLA(hi, lo, X[7], -MAD_F(0x09bd7ca0)); */ | ||
1748 | /* MAD_F_MLA(hi, lo, X[10], MAD_F(0x0cb19346)); */ | ||
1749 | /* MAD_F_MLA(hi, lo, X[16], MAD_F(0x0fdcf549)); */ | ||
1750 | /* t3 = MAD_F_MLZ(hi, lo); */ | ||
1751 | |||
1752 | /* MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0fdcf549)); */ | ||
1753 | /* MAD_F_MLA(hi, lo, X[7], -MAD_F(0x0cb19346)); */ | ||
1754 | /* MAD_F_MLA(hi, lo, X[10], -MAD_F(0x09bd7ca0)); */ | ||
1755 | /* MAD_F_MLA(hi, lo, X[16], -MAD_F(0x0216a2a2)); */ | ||
1756 | /* t5 = MAD_F_MLZ(hi, lo) - t6; */ | ||
1757 | "msac.l %%d3, %%d5, %%acc0\n" | ||
1758 | "msac.l %%d1, %%d5, %%acc1\n" | ||
1759 | "msac.l %%d4, %%d5, ( 7*4, %[X]), %%d5, %%acc2\n" | ||
1760 | "mac.l %%d1, %%d5, %%acc0\n" | ||
1761 | "msac.l %%d3, %%d5, %%acc1\n" | ||
1762 | "msac.l %%d2, %%d5, (10*4, %[X]), %%d5, %%acc2\n" | ||
1763 | "msac.l %%d4, %%d5, %%acc0\n" | ||
1764 | "mac.l %%d2, %%d5, %%acc1\n" | ||
1765 | "msac.l %%d3, %%d5, (16*4, %[X]), %%d5, %%acc2\n" | ||
1766 | "mac.l %%d2, %%d5, %%acc0\n" | ||
1767 | "mac.l %%d4, %%d5, %%acc1\n" | ||
1768 | "msac.l %%d1, %%d5, ( 0*4, %[X]), %%d0, %%acc2\n" | ||
1769 | |||
1770 | "movclr.l %%acc0, %%d7\n" | ||
1771 | "asl.l #3, %%d7\n" | ||
1772 | "add.l (6*4, %[t]), %%d7\n" /* t1 */ | ||
1773 | |||
1774 | "movclr.l %%acc1, %%d5\n" | ||
1775 | "asl.l #3, %%d5\n" /* t3 */ | ||
1776 | |||
1777 | "movclr.l %%acc2, %%d6\n" | ||
1778 | "asl.l #3, %%d6\n" | ||
1779 | "sub.l (6*4, %[t]), %%d6\n" /* t5 */ | ||
1780 | "move.l %%d6, (5*4, %[t])\n" | ||
1781 | |||
1782 | /* MAD_F_ML0(hi, lo, X[0], MAD_F(0x03768962)); */ | ||
1783 | /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0e313245)); */ | ||
1784 | /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0ffc19fd)); */ | ||
1785 | /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0acf37ad)); */ | ||
1786 | /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x04cfb0e2)); */ | ||
1787 | /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0898c779)); */ | ||
1788 | /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x0d7e8807)); */ | ||
1789 | /* MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f426cb5)); */ | ||
1790 | /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0bcbe352)); */ | ||
1791 | /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x00b2aa3e)); */ | ||
1792 | /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x07635284)); */ | ||
1793 | /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0f9ee890)); */ | ||
1794 | /* x[11] = -(x[6] = MAD_F_MLZ(hi, lo) + t1); */ | ||
1795 | /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f426cb5)); */ | ||
1796 | /* MAD_F_MLA(hi, lo, X[2], -MAD_F(0x00b2aa3e)); */ | ||
1797 | /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x0898c779)); */ | ||
1798 | /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x0f9ee890)); */ | ||
1799 | /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x0acf37ad)); */ | ||
1800 | /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x07635284)); */ | ||
1801 | /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0e313245)); */ | ||
1802 | /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0bcbe352)); */ | ||
1803 | /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x03768962)); */ | ||
1804 | /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0d7e8807)); */ | ||
1805 | /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x0ffc19fd)); */ | ||
1806 | /* MAD_F_MLA(hi, lo, X[17], MAD_F(0x04cfb0e2)); */ | ||
1807 | /* x[23] = x[30] = MAD_F_MLZ(hi, lo) + t1; */ | ||
1808 | /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0bcbe352)); */ | ||
1809 | /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0d7e8807)); */ | ||
1810 | /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x07635284)); */ | ||
1811 | /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x04cfb0e2)); */ | ||
1812 | /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f9ee890)); */ | ||
1813 | /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0ffc19fd)); */ | ||
1814 | /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x00b2aa3e)); */ | ||
1815 | /* MAD_F_MLA(hi, lo, X[11], MAD_F(0x03768962)); */ | ||
1816 | /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0f426cb5)); */ | ||
1817 | /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0e313245)); */ | ||
1818 | /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x0898c779)); */ | ||
1819 | /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0acf37ad)); */ | ||
1820 | /* x[18] = x[35] = MAD_F_MLZ(hi, lo) - t1; */ | ||
1821 | "move.l #0x03768962, %%d1\n" | ||
1822 | "move.l #0x0f426cb5, %%d2\n" | ||
1823 | "move.l #0x0bcbe352, %%d3\n" | ||
1824 | "mac.l %%d1, %%d0, %%acc0\n" | ||
1825 | "msac.l %%d2, %%d0, %%acc1\n" | ||
1826 | "msac.l %%d3, %%d0, (11*4, %[X]), %%d0, %%acc2\n" | ||
1827 | "mac.l %%d2, %%d0, %%acc0\n" | ||
1828 | "msac.l %%d3, %%d0, %%acc1\n" | ||
1829 | "mac.l %%d1, %%d0, (12*4, %[X]), %%d0, %%acc2\n" | ||
1830 | "msac.l %%d3, %%d0, %%acc0\n" | ||
1831 | "msac.l %%d1, %%d0, %%acc1\n" | ||
1832 | "msac.l %%d2, %%d0, ( 2*4, %[X]), %%d0, %%acc2\n" | ||
1833 | "move.l #0x0e313245, %%d1\n" | ||
1834 | "move.l #0x00b2aa3e, %%d2\n" | ||
1835 | "move.l #0x0d7e8807, %%d3\n" | ||
1836 | "mac.l %%d1, %%d0, %%acc0\n" | ||
1837 | "msac.l %%d2, %%d0, %%acc1\n" | ||
1838 | "mac.l %%d3, %%d0, ( 9*4, %[X]), %%d0, %%acc2\n" | ||
1839 | "mac.l %%d3, %%d0, %%acc0\n" | ||
1840 | "msac.l %%d1, %%d0, %%acc1\n" | ||
1841 | "msac.l %%d2, %%d0, (14*4, %[X]), %%d0, %%acc2\n" | ||
1842 | "mac.l %%d2, %%d0, %%acc0\n" | ||
1843 | "mac.l %%d3, %%d0, %%acc1\n" | ||
1844 | "mac.l %%d1, %%d0, ( 3*4, %[X]), %%d0, %%acc2\n" | ||
1845 | "move.l #0x0ffc19fd, %%d1\n" | ||
1846 | "move.l #0x0898c779, %%d2\n" | ||
1847 | "move.l #0x07635284, %%d3\n" | ||
1848 | "msac.l %%d1, %%d0, %%acc0\n" | ||
1849 | "mac.l %%d2, %%d0, %%acc1\n" | ||
1850 | "msac.l %%d3, %%d0, ( 8*4, %[X]), %%d0, %%acc2\n" | ||
1851 | "msac.l %%d2, %%d0, %%acc0\n" | ||
1852 | "msac.l %%d3, %%d0, %%acc1\n" | ||
1853 | "msac.l %%d1, %%d0, (15*4, %[X]), %%d0, %%acc2\n" | ||
1854 | "msac.l %%d3, %%d0, %%acc0\n" | ||
1855 | "mac.l %%d1, %%d0, %%acc1\n" | ||
1856 | "mac.l %%d2, %%d0, ( 5*4, %[X]), %%d0, %%acc2\n" | ||
1857 | "move.l #0x0acf37ad, %%d1\n" | ||
1858 | "move.l #0x0f9ee890, %%d2\n" | ||
1859 | "move.l #0x04cfb0e2, %%d3\n" | ||
1860 | "msac.l %%d1, %%d0, %%acc0\n" | ||
1861 | "mac.l %%d2, %%d0, %%acc1\n" | ||
1862 | "mac.l %%d3, %%d0, ( 6*4, %[X]), %%d0, %%acc2\n" | ||
1863 | "mac.l %%d3, %%d0, %%acc0\n" | ||
1864 | "mac.l %%d1, %%d0, %%acc1\n" | ||
1865 | "mac.l %%d2, %%d0, (17*4, %[X]), %%d0, %%acc2\n" | ||
1866 | "msac.l %%d2, %%d0, %%acc0\n" | ||
1867 | "mac.l %%d3, %%d0, %%acc1\n" | ||
1868 | "msac.l %%d1, %%d0, ( 4*4, %[X]), %%d0, %%acc2\n" | ||
1869 | |||
1870 | "movclr.l %%acc0, %%d6\n" | ||
1871 | "asl.l #3, %%d6\n" | ||
1872 | "add.l %%d7, %%d6\n" | ||
1873 | "move.l %%d6, (6*4, %[x])\n" | ||
1874 | "neg.l %%d6\n" | ||
1875 | "move.l %%d6, (11*4, %[x])\n" | ||
1876 | |||
1877 | "movclr.l %%acc1, %%d6\n" | ||
1878 | "asl.l #3, %%d6\n" | ||
1879 | "add.l %%d7, %%d6\n" | ||
1880 | "move.l %%d6, (23*4, %[x])\n" | ||
1881 | "move.l %%d6, (30*4, %[x])\n" | ||
1882 | |||
1883 | "movclr.l %%acc2, %%d6\n" | ||
1884 | "asl.l #3, %%d6\n" | ||
1885 | "sub.l %%d7, %%d6\n" | ||
1886 | "move.l %%d6, (18*4, %[x])\n" | ||
1887 | "move.l %%d6, (35*4, %[x])\n" | ||
1888 | |||
1889 | /* MAD_F_ML0(hi, lo, X[4], MAD_F(0x061f78aa)); */ | ||
1890 | /* MAD_F_MLA(hi, lo, X[13], -MAD_F(0x0ec835e8)); */ | ||
1891 | /* t3 += (t7 = MAD_F_MLZ(hi, lo)); */ | ||
1892 | /* t4 -= t7; */ | ||
1893 | "move.l #0x061f78aa, %%d1\n" | ||
1894 | "mac.l %%d1, %%d0, (13*4, %[X]), %%d0, %%acc0\n" | ||
1895 | "move.l #0x0ec835e8, %%d1\n" | ||
1896 | "msac.l %%d1, %%d0, (1*4, %[X]), %%d0, %%acc0\n" | ||
1897 | "move.l %%acc0, %%d6\n" | ||
1898 | "asl.l #3, %%d6\n" /* t7 */ | ||
1899 | "add.l %%d6, %%d5\n" /* t3 */ | ||
1900 | "move.l (4*4, %[t]), %%d1\n" | ||
1901 | "sub.l %%d6, %%d1\n" /* t4 */ | ||
1902 | "move.l %%d1, (4*4, %[t])\n" | ||
1903 | |||
1904 | /* MAD_F_MLA(hi, lo, X[1], -MAD_F(0x0cb19346)); */ | ||
1905 | /* MAD_F_MLA(hi, lo, X[7], MAD_F(0x0fdcf549)); */ | ||
1906 | /* MAD_F_MLA(hi, lo, X[10], MAD_F(0x0216a2a2)); */ | ||
1907 | /* MAD_F_MLA(hi, lo, X[16], -MAD_F(0x09bd7ca0)); */ | ||
1908 | /* t2 = MAD_F_MLZ(hi, lo); */ | ||
1909 | "move.l #0x0cb19346, %%d1\n" | ||
1910 | "msac.l %%d1, %%d0, ( 7*4, %[X]), %%d0, %%acc0\n" | ||
1911 | "move.l #0x0fdcf549, %%d1\n" | ||
1912 | "mac.l %%d1, %%d0, (10*4, %[X]), %%d0, %%acc0\n" | ||
1913 | "move.l #0x0216a2a2, %%d1\n" | ||
1914 | "mac.l %%d1, %%d0, (16*4, %[X]), %%d0, %%acc0\n" | ||
1915 | "move.l #0x09bd7ca0, %%d1\n" | ||
1916 | "msac.l %%d1, %%d0, ( %[X]), %%d0, %%acc0\n" | ||
1917 | "move.l %%acc0, %%d7\n" | ||
1918 | "asl.l #3, %%d7\n" /* t2 */ | ||
1919 | |||
1920 | /* MAD_F_MLA(hi, lo, X[0], MAD_F(0x04cfb0e2)); */ | ||
1921 | /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0ffc19fd)); */ | ||
1922 | /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0d7e8807)); */ | ||
1923 | /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x03768962)); */ | ||
1924 | /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0bcbe352)); */ | ||
1925 | /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0e313245)); */ | ||
1926 | /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x07635284)); */ | ||
1927 | /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0acf37ad)); */ | ||
1928 | /* MAD_F_MLA(hi, lo, X[12], MAD_F(0x0f9ee890)); */ | ||
1929 | /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0898c779)); */ | ||
1930 | /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x00b2aa3e)); */ | ||
1931 | /* MAD_F_MLA(hi, lo, X[17], MAD_F(0x0f426cb5)); */ | ||
1932 | /* x[12] = -(x[5] = MAD_F_MLZ(hi, lo)); */ | ||
1933 | /* MAD_F_ML0(hi, lo, X[0], MAD_F(0x0acf37ad)); */ | ||
1934 | /* MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0898c779)); */ | ||
1935 | /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x0e313245)); */ | ||
1936 | /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0f426cb5)); */ | ||
1937 | /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x03768962)); */ | ||
1938 | /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x00b2aa3e)); */ | ||
1939 | /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0ffc19fd)); */ | ||
1940 | /* MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f9ee890)); */ | ||
1941 | /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x04cfb0e2)); */ | ||
1942 | /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x07635284)); */ | ||
1943 | /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x0d7e8807)); */ | ||
1944 | /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0bcbe352)); */ | ||
1945 | /* x[17] = -(x[0] = MAD_F_MLZ(hi, lo) + t2); */ | ||
1946 | /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f9ee890)); */ | ||
1947 | /* MAD_F_MLA(hi, lo, X[2], -MAD_F(0x07635284)); */ | ||
1948 | /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x00b2aa3e)); */ | ||
1949 | /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x0bcbe352)); */ | ||
1950 | /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f426cb5)); */ | ||
1951 | /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x0d7e8807)); */ | ||
1952 | /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x0898c779)); */ | ||
1953 | /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x04cfb0e2)); */ | ||
1954 | /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0acf37ad)); */ | ||
1955 | /* MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0ffc19fd)); */ | ||
1956 | /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0e313245)); */ | ||
1957 | /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x03768962)); */ | ||
1958 | /* x[24] = x[29] = MAD_F_MLZ(hi, lo) + t2; */ | ||
1959 | "move.l #0x0acf37ad, %%d1\n" | ||
1960 | "move.l #0x0f9ee890, %%d2\n" | ||
1961 | "move.l #0x04cfb0e2, %%d3\n" | ||
1962 | "mac.l %%d3, %%d0, %%acc0\n" | ||
1963 | "mac.l %%d1, %%d0, %%acc1\n" | ||
1964 | "msac.l %%d2, %%d0, (11*4, %[X]), %%d0, %%acc2\n" | ||
1965 | "msac.l %%d1, %%d0, %%acc0\n" | ||
1966 | "mac.l %%d2, %%d0, %%acc1\n" | ||
1967 | "msac.l %%d3, %%d0, (12*4, %[X]), %%d0, %%acc2\n" | ||
1968 | "mac.l %%d2, %%d0, %%acc0\n" | ||
1969 | "msac.l %%d3, %%d0, %%acc1\n" | ||
1970 | "msac.l %%d1, %%d0, ( 2*4, %[X]), %%d0, %%acc2\n" | ||
1971 | "move.l #0x0ffc19fd, %%d1\n" | ||
1972 | "move.l #0x0898c779, %%d2\n" | ||
1973 | "move.l #0x07635284, %%d3\n" | ||
1974 | "mac.l %%d1, %%d0, %%acc0\n" | ||
1975 | "msac.l %%d2, %%d0, %%acc1\n" | ||
1976 | "msac.l %%d3, %%d0, ( 9*4, %[X]), %%d0, %%acc2\n" | ||
1977 | "mac.l %%d3, %%d0, %%acc0\n" | ||
1978 | "msac.l %%d1, %%d0, %%acc1\n" | ||
1979 | "mac.l %%d2, %%d0, (14*4, %[X]), %%d0, %%acc2\n" | ||
1980 | "mac.l %%d2, %%d0, %%acc0\n" | ||
1981 | "mac.l %%d3, %%d0, %%acc1\n" | ||
1982 | "msac.l %%d1, %%d0, ( 3*4, %[X]), %%d0, %%acc2\n" | ||
1983 | "move.l #0x0e313245, %%d1\n" | ||
1984 | "move.l #0x00b2aa3e, %%d2\n" | ||
1985 | "move.l #0x0d7e8807, %%d3\n" | ||
1986 | "msac.l %%d3, %%d0, %%acc0\n" | ||
1987 | "mac.l %%d1, %%d0, %%acc1\n" | ||
1988 | "msac.l %%d2, %%d0, ( 8*4, %[X]), %%d0, %%acc2\n" | ||
1989 | "msac.l %%d1, %%d0, %%acc0\n" | ||
1990 | "mac.l %%d2, %%d0, %%acc1\n" | ||
1991 | "mac.l %%d3, %%d0, (15*4, %[X]), %%d0, %%acc2\n" | ||
1992 | "mac.l %%d2, %%d0, %%acc0\n" | ||
1993 | "mac.l %%d3, %%d0, %%acc1\n" | ||
1994 | "msac.l %%d1, %%d0, ( 5*4, %[X]), %%d0, %%acc2\n" | ||
1995 | "move.l #0x03768962, %%d1\n" | ||
1996 | "move.l #0x0f426cb5, %%d2\n" | ||
1997 | "move.l #0x0bcbe352, %%d3\n" | ||
1998 | "mac.l %%d1, %%d0, %%acc0\n" | ||
1999 | "msac.l %%d2, %%d0, %%acc1\n" | ||
2000 | "mac.l %%d3, %%d0, ( 6*4, %[X]), %%d0, %%acc2\n" | ||
2001 | "msac.l %%d3, %%d0, %%acc0\n" | ||
2002 | "msac.l %%d1, %%d0, %%acc1\n" | ||
2003 | "mac.l %%d2, %%d0, (17*4, %[X]), %%d0, %%acc2\n" | ||
2004 | "mac.l %%d2, %%d0, %%acc0\n" | ||
2005 | "msac.l %%d3, %%d0, %%acc1\n" | ||
2006 | "msac.l %%d1, %%d0, ( %[X]), %%d0, %%acc2\n" | ||
2007 | |||
2008 | "movclr.l %%acc0, %%d6\n" | ||
2009 | "asl.l #3, %%d6\n" | ||
2010 | "move.l %%d6, ( 5*4, %[x])\n" | ||
2011 | "neg.l %%d6\n" | ||
2012 | "move.l %%d6, (12*4, %[x])\n" | ||
2013 | |||
2014 | "movclr.l %%acc1, %%d6\n" | ||
2015 | "asl.l #3, %%d6\n" | ||
2016 | "add.l %%d7, %%d6\n" | ||
2017 | "move.l %%d6, ( %[x])\n" | ||
2018 | "neg.l %%d6\n" | ||
2019 | "move.l %%d6, (17*4, %[x])\n" | ||
2020 | |||
2021 | "movclr.l %%acc2, %%d6\n" | ||
2022 | "asl.l #3, %%d6\n" | ||
2023 | "add.l %%d7, %%d6\n" | ||
2024 | "move.l %%d6, (24*4, %[x])\n" | ||
2025 | "move.l %%d6, (29*4, %[x])\n" | ||
2026 | |||
2027 | /* MAD_F_ML0(hi, lo, X[0], MAD_F(0x00b2aa3e)); */ | ||
2028 | /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x03768962)); */ | ||
2029 | /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x04cfb0e2)); */ | ||
2030 | /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x07635284)); */ | ||
2031 | /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x0898c779)); */ | ||
2032 | /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x0acf37ad)); */ | ||
2033 | /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0bcbe352)); */ | ||
2034 | /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0d7e8807)); */ | ||
2035 | /* MAD_F_MLA(hi, lo, X[12], MAD_F(0x0e313245)); */ | ||
2036 | /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f426cb5)); */ | ||
2037 | /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0f9ee890)); */ | ||
2038 | /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0ffc19fd)); */ | ||
2039 | /* x[9] = -(x[8] = MAD_F_MLZ(hi, lo) + t3); */ | ||
2040 | |||
2041 | /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0e313245)); */ | ||
2042 | /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0bcbe352)); */ | ||
2043 | /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x0f9ee890)); */ | ||
2044 | /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0898c779)); */ | ||
2045 | /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0ffc19fd)); */ | ||
2046 | /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x04cfb0e2)); */ | ||
2047 | /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f426cb5)); */ | ||
2048 | /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x00b2aa3e)); */ | ||
2049 | /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0d7e8807)); */ | ||
2050 | /* MAD_F_MLA(hi, lo, X[14], -MAD_F(0x03768962)); */ | ||
2051 | /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x0acf37ad)); */ | ||
2052 | /* MAD_F_MLA(hi, lo, X[17], MAD_F(0x07635284)); */ | ||
2053 | /* x[21] = x[32] = MAD_F_MLZ(hi, lo) + t3; */ | ||
2054 | |||
2055 | /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0d7e8807)); */ | ||
2056 | /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0f426cb5)); */ | ||
2057 | /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x0acf37ad)); */ | ||
2058 | /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0ffc19fd)); */ | ||
2059 | /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x07635284)); */ | ||
2060 | /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f9ee890)); */ | ||
2061 | /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x03768962)); */ | ||
2062 | /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0e313245)); */ | ||
2063 | /* MAD_F_MLA(hi, lo, X[12], MAD_F(0x00b2aa3e)); */ | ||
2064 | /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0bcbe352)); */ | ||
2065 | /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x04cfb0e2)); */ | ||
2066 | /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0898c779)); */ | ||
2067 | /* x[20] = x[33] = MAD_F_MLZ(hi, lo) - t3; */ | ||
2068 | "move.l #0x0e313245, %%d1\n" | ||
2069 | "move.l #0x00b2aa3e, %%d2\n" | ||
2070 | "move.l #0x0d7e8807, %%d3\n" | ||
2071 | "mac.l %%d2, %%d0, %%acc0\n" | ||
2072 | "msac.l %%d1, %%d0, %%acc1\n" | ||
2073 | "msac.l %%d3, %%d0, (11*4, %[X]), %%d0, %%acc2\n" | ||
2074 | "msac.l %%d3, %%d0, %%acc0\n" | ||
2075 | "msac.l %%d2, %%d0, %%acc1\n" | ||
2076 | "msac.l %%d1, %%d0, (12*4, %[X]), %%d0, %%acc2\n" | ||
2077 | "mac.l %%d1, %%d0, %%acc0\n" | ||
2078 | "msac.l %%d3, %%d0, %%acc1\n" | ||
2079 | "mac.l %%d2, %%d0, ( 2*4, %[X]), %%d0, %%acc2\n" | ||
2080 | "move.l #0x03768962, %%d1\n" | ||
2081 | "move.l #0x0f426cb5, %%d2\n" | ||
2082 | "move.l #0x0bcbe352, %%d3\n" | ||
2083 | "mac.l %%d1, %%d0, %%acc0\n" | ||
2084 | "mac.l %%d3, %%d0, %%acc1\n" | ||
2085 | "mac.l %%d2, %%d0, ( 9*4, %[X]), %%d0, %%acc2\n" | ||
2086 | "msac.l %%d3, %%d0, %%acc0\n" | ||
2087 | "mac.l %%d2, %%d0, %%acc1\n" | ||
2088 | "mac.l %%d1, %%d0, (14*4, %[X]), %%d0, %%acc2\n" | ||
2089 | "mac.l %%d2, %%d0, %%acc0\n" | ||
2090 | "msac.l %%d1, %%d0, %%acc1\n" | ||
2091 | "mac.l %%d3, %%d0, ( 3*4, %[X]), %%d0, %%acc2\n" | ||
2092 | "move.l #0x0acf37ad, %%d1\n" | ||
2093 | "move.l #0x0f9ee890, %%d2\n" | ||
2094 | "move.l #0x04cfb0e2, %%d3\n" | ||
2095 | "msac.l %%d3, %%d0, %%acc0\n" | ||
2096 | "mac.l %%d2, %%d0, %%acc1\n" | ||
2097 | "mac.l %%d1, %%d0, ( 8*4, %[X]), %%d0, %%acc2\n" | ||
2098 | "mac.l %%d1, %%d0, %%acc0\n" | ||
2099 | "mac.l %%d3, %%d0, %%acc1\n" | ||
2100 | "mac.l %%d2, %%d0, (15*4, %[X]), %%d0, %%acc2\n" | ||
2101 | "msac.l %%d2, %%d0, %%acc0\n" | ||
2102 | "mac.l %%d1, %%d0, %%acc1\n" | ||
2103 | "msac.l %%d3, %%d0, ( 5*4, %[X]), %%d0, %%acc2\n" | ||
2104 | "move.l #0x0ffc19fd, %%d1\n" | ||
2105 | "move.l #0x0898c779, %%d2\n" | ||
2106 | "move.l #0x07635284, %%d3\n" | ||
2107 | "msac.l %%d3, %%d0, %%acc0\n" | ||
2108 | "msac.l %%d2, %%d0, %%acc1\n" | ||
2109 | "msac.l %%d1, %%d0, ( 6*4, %[X]), %%d0, %%acc2\n" | ||
2110 | "mac.l %%d2, %%d0, %%acc0\n" | ||
2111 | "msac.l %%d1, %%d0, %%acc1\n" | ||
2112 | "msac.l %%d3, %%d0, (17*4, %[X]), %%d0, %%acc2\n" | ||
2113 | "msac.l %%d1, %%d0, %%acc0\n" | ||
2114 | "mac.l %%d3, %%d0, %%acc1\n" | ||
2115 | "msac.l %%d2, %%d0, (12*4, %[t]), %%d0, %%acc2\n" | ||
2116 | |||
2117 | "movclr.l %%acc0, %%d6\n" | ||
2118 | "asl.l #3, %%d6\n" | ||
2119 | "add.l %%d5, %%d6\n" | ||
2120 | "move.l %%d6, (8*4, %[x])\n" | ||
2121 | "neg.l %%d6\n" | ||
2122 | "move.l %%d6, (9*4, %[x])\n" | ||
2123 | |||
2124 | "movclr.l %%acc1, %%d6\n" | ||
2125 | "asl.l #3, %%d6\n" | ||
2126 | "add.l %%d5, %%d6\n" | ||
2127 | "move.l %%d6, (21*4, %[x])\n" | ||
2128 | "move.l %%d6, (32*4, %[x])\n" | ||
2129 | |||
2130 | "movclr.l %%acc2, %%d6\n" | ||
2131 | "asl.l #3, %%d6\n" | ||
2132 | "sub.l %%d5, %%d6\n" | ||
2133 | "move.l %%d6, (20*4, %[x])\n" | ||
2134 | "move.l %%d6, (33*4, %[x])\n" | ||
2135 | |||
2136 | /* MAD_F_ML0(hi, lo, t12, -MAD_F(0x0ec835e8)); */ | ||
2137 | /* MAD_F_MLA(hi, lo, t13, MAD_F(0x061f78aa)); */ | ||
2138 | /* x[22] = x[31] = MAD_F_MLZ(hi, lo) + t0; */ | ||
2139 | "move.l #0x0ec835e8, %%d1\n" | ||
2140 | "move.l #0x061f78aa, %%d2\n" | ||
2141 | "msac.l %%d1, %%d0, (13*4, %[t]), %%d3, %%acc0\n" | ||
2142 | "mac.l %%d2, %%d3, ( 1*4, %[x]), %%d4, %%acc0\n" | ||
2143 | "movclr.l %%acc0, %%d6\n" | ||
2144 | "asl.l #3, %%d6\n" | ||
2145 | "add.l (0*4, %[t]), %%d6\n" | ||
2146 | "move.l %%d6, (22*4, %[x])\n" | ||
2147 | "move.l %%d6, (31*4, %[x])\n" | ||
2148 | |||
2149 | /* MAD_F_ML0(hi, lo, t12, MAD_F(0x061f78aa)); */ | ||
2150 | /* MAD_F_MLA(hi, lo, t13, MAD_F(0x0ec835e8)); */ | ||
2151 | /* x[13] = -(x[4] = MAD_F_MLZ(hi, lo) + t4); */ | ||
2152 | /* x[16] = -(x[1] = x[1] + t4); */ | ||
2153 | /* x[25] = x[28] = x[25] + t4; */ | ||
2154 | "mac.l %%d2, %%d0, (4*4, %[t]), %%d2, %%acc0\n" | ||
2155 | "mac.l %%d1, %%d3, ( %[X]), %%d0, %%acc0\n" | ||
2156 | "movclr.l %%acc0, %%d6\n" | ||
2157 | "asl.l #3, %%d6\n" | ||
2158 | "add.l %%d2, %%d6\n" | ||
2159 | "move.l %%d6, ( 4*4, %[x])\n" | ||
2160 | "neg.l %%d6\n" | ||
2161 | "move.l %%d6, (13*4, %[x])\n" | ||
2162 | |||
2163 | "add.l %%d2, %%d4\n" | ||
2164 | "move.l %%d4, ( 1*4, %[x])\n" | ||
2165 | "neg.l %%d4\n" | ||
2166 | "move.l %%d4, (16*4, %[x])\n" | ||
2167 | |||
2168 | "move.l (25*4, %[x]), %%d4\n" | ||
2169 | "add.l %%d2, %%d4\n" | ||
2170 | "move.l %%d4, (25*4, %[x])\n" | ||
2171 | "move.l %%d4, (28*4, %[x])\n" | ||
2172 | |||
2173 | /* MAD_F_ML0(hi, lo, X[0], MAD_F(0x0898c779)); */ | ||
2174 | /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x04cfb0e2)); */ | ||
2175 | /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x0bcbe352)); */ | ||
2176 | /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x00b2aa3e)); */ | ||
2177 | /* MAD_F_MLA(hi, lo, X[6], MAD_F(0x0e313245)); */ | ||
2178 | /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x03768962)); */ | ||
2179 | /* MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f9ee890)); */ | ||
2180 | /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x07635284)); */ | ||
2181 | /* MAD_F_MLA(hi, lo, X[12], MAD_F(0x0ffc19fd)); */ | ||
2182 | /* MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0acf37ad)); */ | ||
2183 | /* MAD_F_MLA(hi, lo, X[15], MAD_F(0x0f426cb5)); */ | ||
2184 | /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0d7e8807)); */ | ||
2185 | /* x[15] = -(x[2] = MAD_F_MLZ(hi, lo) + t5); */ | ||
2186 | /* MAD_F_ML0(hi, lo, X[0], MAD_F(0x07635284)); */ | ||
2187 | /* MAD_F_MLA(hi, lo, X[2], MAD_F(0x0acf37ad)); */ | ||
2188 | /* MAD_F_MLA(hi, lo, X[3], MAD_F(0x03768962)); */ | ||
2189 | /* MAD_F_MLA(hi, lo, X[5], MAD_F(0x0d7e8807)); */ | ||
2190 | /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x00b2aa3e)); */ | ||
2191 | /* MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f426cb5)); */ | ||
2192 | /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x04cfb0e2)); */ | ||
2193 | /* MAD_F_MLA(hi, lo, X[11], MAD_F(0x0ffc19fd)); */ | ||
2194 | /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0898c779)); */ | ||
2195 | /* MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f9ee890)); */ | ||
2196 | /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0bcbe352)); */ | ||
2197 | /* MAD_F_MLA(hi, lo, X[17], MAD_F(0x0e313245)); */ | ||
2198 | /* x[14] = -(x[3] = MAD_F_MLZ(hi, lo) + t5); */ | ||
2199 | /* MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0ffc19fd)); */ | ||
2200 | /* MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0f9ee890)); */ | ||
2201 | /* MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0f426cb5)); */ | ||
2202 | /* MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0e313245)); */ | ||
2203 | /* MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0d7e8807)); */ | ||
2204 | /* MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0bcbe352)); */ | ||
2205 | /* MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0acf37ad)); */ | ||
2206 | /* MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0898c779)); */ | ||
2207 | /* MAD_F_MLA(hi, lo, X[12], -MAD_F(0x07635284)); */ | ||
2208 | /* MAD_F_MLA(hi, lo, X[14], -MAD_F(0x04cfb0e2)); */ | ||
2209 | /* MAD_F_MLA(hi, lo, X[15], -MAD_F(0x03768962)); */ | ||
2210 | /* MAD_F_MLA(hi, lo, X[17], -MAD_F(0x00b2aa3e)); */ | ||
2211 | /* x[26] = x[27] = MAD_F_MLZ(hi, lo) + t5; */ | ||
2212 | "move.l #0x0ffc19fd, %%d1\n" | ||
2213 | "move.l #0x0898c779, %%d2\n" | ||
2214 | "move.l #0x07635284, %%d3\n" | ||
2215 | "mac.l %%d2, %%d0, %%acc0\n" | ||
2216 | "mac.l %%d3, %%d0, %%acc1\n" | ||
2217 | "msac.l %%d1, %%d0, (11*4, %[X]), %%d0, %%acc2\n" | ||
2218 | "msac.l %%d3, %%d0, %%acc0\n" | ||
2219 | "mac.l %%d1, %%d0, %%acc1\n" | ||
2220 | "msac.l %%d2, %%d0, (12*4, %[X]), %%d0, %%acc2\n" | ||
2221 | "mac.l %%d1, %%d0, %%acc0\n" | ||
2222 | "msac.l %%d2, %%d0, %%acc1\n" | ||
2223 | "msac.l %%d3, %%d0, ( 2*4, %[X]), %%d0, %%acc2\n" | ||
2224 | "move.l #0x0acf37ad, %%d1\n" | ||
2225 | "move.l #0x0f9ee890, %%d2\n" | ||
2226 | "move.l #0x04cfb0e2, %%d3\n" | ||
2227 | "mac.l %%d3, %%d0, %%acc0\n" | ||
2228 | "mac.l %%d1, %%d0, %%acc1\n" | ||
2229 | "msac.l %%d2, %%d0, ( 9*4, %[X]), %%d0, %%acc2\n" | ||
2230 | "mac.l %%d2, %%d0, %%acc0\n" | ||
2231 | "msac.l %%d3, %%d0, %%acc1\n" | ||
2232 | "msac.l %%d1, %%d0, (14*4, %[X]), %%d0, %%acc2\n" | ||
2233 | "msac.l %%d1, %%d0, %%acc0\n" | ||
2234 | "mac.l %%d2, %%d0, %%acc1\n" | ||
2235 | "msac.l %%d3, %%d0, ( 3*4, %[X]), %%d0, %%acc2\n" | ||
2236 | "move.l #0x03768962, %%d1\n" | ||
2237 | "move.l #0x0f426cb5, %%d2\n" | ||
2238 | "move.l #0x0bcbe352, %%d3\n" | ||
2239 | "mac.l %%d3, %%d0, %%acc0\n" | ||
2240 | "mac.l %%d1, %%d0, %%acc1\n" | ||
2241 | "msac.l %%d2, %%d0, ( 8*4, %[X]), %%d0, %%acc2\n" | ||
2242 | "msac.l %%d1, %%d0, %%acc0\n" | ||
2243 | "mac.l %%d2, %%d0, %%acc1\n" | ||
2244 | "msac.l %%d3, %%d0, (15*4, %[X]), %%d0, %%acc2\n" | ||
2245 | "mac.l %%d2, %%d0, %%acc0\n" | ||
2246 | "msac.l %%d3, %%d0, %%acc1\n" | ||
2247 | "msac.l %%d1, %%d0, ( 5*4, %[X]), %%d0, %%acc2\n" | ||
2248 | "move.l #0x0e313245, %%d1\n" | ||
2249 | "move.l #0x00b2aa3e, %%d2\n" | ||
2250 | "move.l #0x0d7e8807, %%d3\n" | ||
2251 | "mac.l %%d2, %%d0, %%acc0\n" | ||
2252 | "mac.l %%d3, %%d0, %%acc1\n" | ||
2253 | "msac.l %%d1, %%d0, ( 6*4, %[X]), %%d0, %%acc2\n" | ||
2254 | "mac.l %%d1, %%d0, %%acc0\n" | ||
2255 | "msac.l %%d2, %%d0, %%acc1\n" | ||
2256 | "msac.l %%d3, %%d0, (17*4, %[X]), %%d0, %%acc2\n" | ||
2257 | "msac.l %%d3, %%d0, %%acc0\n" | ||
2258 | "mac.l %%d1, %%d0, %%acc1\n" | ||
2259 | "msac.l %%d2, %%d0, ( 5*4, %[t]), %%d6, %%acc2\n" | ||
2260 | "movclr.l %%acc0, %%d7\n" | ||
2261 | "asl.l #3, %%d7\n" | ||
2262 | "add.l %%d6, %%d7\n" | ||
2263 | "move.l %%d7, (2*4, %[x])\n" | ||
2264 | "neg.l %%d7\n" | ||
2265 | "move.l %%d7, (15*4, %[x])\n" | ||
2266 | |||
2267 | "movclr.l %%acc1, %%d7\n" | ||
2268 | "asl.l #3, %%d7\n" | ||
2269 | "add.l %%d6, %%d7\n" | ||
2270 | "move.l %%d7, (3*4, %[x])\n" | ||
2271 | "neg.l %%d7\n" | ||
2272 | "move.l %%d7, (14*4, %[x])\n" | ||
2273 | |||
2274 | "movclr.l %%acc2, %%d7\n" | ||
2275 | "asl.l #3, %%d7\n" | ||
2276 | "add.l %%d6, %%d7\n" | ||
2277 | "move.l %%d7, (26*4, %[x])\n" | ||
2278 | "move.l %%d7, (27*4, %[x])\n" | ||
2279 | |||
2280 | : : [X] "a" (X), [x] "a" (x), [t] "a" (t) | ||
2281 | : "d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7"); | ||
2282 | /* pfew */ | ||
2283 | } | ||
2284 | |||
2285 | # else /* if defined(CPU_COLDFIRE) */ | ||
2286 | |||
2287 | static inline | ||
2288 | void imdct36(mad_fixed_t const X[18], mad_fixed_t x[36]) | ||
2289 | { | ||
2290 | mad_fixed_t t0, t1, t2, t3, t4, t5, t6, t7; | ||
2291 | mad_fixed_t t8, t9, t10, t11, t12, t13, t14, t15; | ||
2292 | register mad_fixed64hi_t hi; | ||
2293 | register mad_fixed64lo_t lo; | ||
2294 | |||
2295 | MAD_F_ML0(hi, lo, (t14 = X[1] - X[10]), -MAD_F(0x0ec835e8)); | ||
2296 | MAD_F_MLA(hi, lo, (t15 = X[7] + X[16]), MAD_F(0x061f78aa)); | ||
2297 | t4 = MAD_F_MLZ(hi, lo); | ||
2298 | |||
2299 | MAD_F_ML0(hi, lo, X[4], MAD_F(0x0ec835e8)); | ||
2300 | MAD_F_MLA(hi, lo, X[13], MAD_F(0x061f78aa)); | ||
2301 | t6 = MAD_F_MLZ(hi, lo); | ||
2302 | |||
2303 | MAD_F_MLA(hi, lo, t14, -MAD_F(0x061f78aa)); | ||
2304 | MAD_F_MLA(hi, lo, t15, -MAD_F(0x0ec835e8)); | ||
2305 | t0 = MAD_F_MLZ(hi, lo); | ||
2306 | |||
2307 | MAD_F_MLA(hi, lo, (t8 =X[0]-X[11]-X[12]), MAD_F(0x0216a2a2)); | ||
2308 | MAD_F_MLA(hi, lo, (t9 =X[2]-X[ 9]-X[14]), MAD_F(0x09bd7ca0)); | ||
2309 | MAD_F_MLA(hi, lo, (t10=X[3]-X[ 8]-X[15]), -MAD_F(0x0cb19346)); | ||
2310 | MAD_F_MLA(hi, lo, (t11=X[5]-X[ 6]-X[17]), -MAD_F(0x0fdcf549)); | ||
2311 | x[10] = -(x[7] = MAD_F_MLZ(hi, lo)); | ||
2312 | |||
2313 | MAD_F_ML0(hi, lo, t8, -MAD_F(0x0cb19346)); | ||
2314 | MAD_F_MLA(hi, lo, t9, MAD_F(0x0fdcf549)); | ||
2315 | MAD_F_MLA(hi, lo, t10, MAD_F(0x0216a2a2)); | ||
2316 | MAD_F_MLA(hi, lo, t11, -MAD_F(0x09bd7ca0)); | ||
2317 | x[19] = x[34] = MAD_F_MLZ(hi, lo) - t0; | ||
2318 | |||
2319 | MAD_F_ML0(hi, lo, t8, MAD_F(0x09bd7ca0)); | ||
2320 | MAD_F_MLA(hi, lo, t9, -MAD_F(0x0216a2a2)); | ||
2321 | MAD_F_MLA(hi, lo, t10, MAD_F(0x0fdcf549)); | ||
2322 | MAD_F_MLA(hi, lo, t11, -MAD_F(0x0cb19346)); | ||
2323 | x[ 1] = MAD_F_MLZ(hi, lo); | ||
2324 | |||
2325 | MAD_F_ML0(hi, lo, t8, -MAD_F(0x0fdcf549)); | ||
2326 | MAD_F_MLA(hi, lo, t9, -MAD_F(0x0cb19346)); | ||
2327 | MAD_F_MLA(hi, lo, t10, -MAD_F(0x09bd7ca0)); | ||
2328 | MAD_F_MLA(hi, lo, t11, -MAD_F(0x0216a2a2)); | ||
2329 | x[25] = MAD_F_MLZ(hi, lo); | ||
2330 | |||
2331 | t12 = t8 - t10; | ||
2332 | t13 = t9 + t11; | ||
2333 | |||
2334 | MAD_F_ML0(hi, lo, X[1], -MAD_F(0x09bd7ca0)); | ||
2335 | MAD_F_MLA(hi, lo, X[7], MAD_F(0x0216a2a2)); | ||
2336 | MAD_F_MLA(hi, lo, X[10], -MAD_F(0x0fdcf549)); | ||
2337 | MAD_F_MLA(hi, lo, X[16], MAD_F(0x0cb19346)); | ||
2338 | t1 = MAD_F_MLZ(hi, lo) + t6; | ||
2339 | |||
2340 | MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0216a2a2)); | ||
2341 | MAD_F_MLA(hi, lo, X[7], -MAD_F(0x09bd7ca0)); | ||
2342 | MAD_F_MLA(hi, lo, X[10], MAD_F(0x0cb19346)); | ||
2343 | MAD_F_MLA(hi, lo, X[16], MAD_F(0x0fdcf549)); | ||
2344 | t3 = MAD_F_MLZ(hi, lo); | ||
2345 | |||
2346 | MAD_F_ML0(hi, lo, X[1], -MAD_F(0x0fdcf549)); | ||
2347 | MAD_F_MLA(hi, lo, X[7], -MAD_F(0x0cb19346)); | ||
2348 | MAD_F_MLA(hi, lo, X[10], -MAD_F(0x09bd7ca0)); | ||
2349 | MAD_F_MLA(hi, lo, X[16], -MAD_F(0x0216a2a2)); | ||
2350 | t5 = MAD_F_MLZ(hi, lo) - t6; | ||
2351 | |||
2352 | MAD_F_ML0(hi, lo, X[0], MAD_F(0x03768962)); | ||
2353 | MAD_F_MLA(hi, lo, X[2], MAD_F(0x0e313245)); | ||
2354 | MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0ffc19fd)); | ||
2355 | MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0acf37ad)); | ||
2356 | MAD_F_MLA(hi, lo, X[6], MAD_F(0x04cfb0e2)); | ||
2357 | MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0898c779)); | ||
2358 | MAD_F_MLA(hi, lo, X[9], MAD_F(0x0d7e8807)); | ||
2359 | MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f426cb5)); | ||
2360 | MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0bcbe352)); | ||
2361 | MAD_F_MLA(hi, lo, X[14], MAD_F(0x00b2aa3e)); | ||
2362 | MAD_F_MLA(hi, lo, X[15], -MAD_F(0x07635284)); | ||
2363 | MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0f9ee890)); | ||
2364 | x[11] = -(x[6] = MAD_F_MLZ(hi, lo) + t1); | ||
2365 | |||
2366 | MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f426cb5)); | ||
2367 | MAD_F_MLA(hi, lo, X[2], -MAD_F(0x00b2aa3e)); | ||
2368 | MAD_F_MLA(hi, lo, X[3], MAD_F(0x0898c779)); | ||
2369 | MAD_F_MLA(hi, lo, X[5], MAD_F(0x0f9ee890)); | ||
2370 | MAD_F_MLA(hi, lo, X[6], MAD_F(0x0acf37ad)); | ||
2371 | MAD_F_MLA(hi, lo, X[8], -MAD_F(0x07635284)); | ||
2372 | MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0e313245)); | ||
2373 | MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0bcbe352)); | ||
2374 | MAD_F_MLA(hi, lo, X[12], -MAD_F(0x03768962)); | ||
2375 | MAD_F_MLA(hi, lo, X[14], MAD_F(0x0d7e8807)); | ||
2376 | MAD_F_MLA(hi, lo, X[15], MAD_F(0x0ffc19fd)); | ||
2377 | MAD_F_MLA(hi, lo, X[17], MAD_F(0x04cfb0e2)); | ||
2378 | x[23] = x[30] = MAD_F_MLZ(hi, lo) + t1; | ||
2379 | |||
2380 | MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0bcbe352)); | ||
2381 | MAD_F_MLA(hi, lo, X[2], MAD_F(0x0d7e8807)); | ||
2382 | MAD_F_MLA(hi, lo, X[3], -MAD_F(0x07635284)); | ||
2383 | MAD_F_MLA(hi, lo, X[5], MAD_F(0x04cfb0e2)); | ||
2384 | MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f9ee890)); | ||
2385 | MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0ffc19fd)); | ||
2386 | MAD_F_MLA(hi, lo, X[9], -MAD_F(0x00b2aa3e)); | ||
2387 | MAD_F_MLA(hi, lo, X[11], MAD_F(0x03768962)); | ||
2388 | MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0f426cb5)); | ||
2389 | MAD_F_MLA(hi, lo, X[14], MAD_F(0x0e313245)); | ||
2390 | MAD_F_MLA(hi, lo, X[15], MAD_F(0x0898c779)); | ||
2391 | MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0acf37ad)); | ||
2392 | x[18] = x[35] = MAD_F_MLZ(hi, lo) - t1; | ||
2393 | |||
2394 | MAD_F_ML0(hi, lo, X[4], MAD_F(0x061f78aa)); | ||
2395 | MAD_F_MLA(hi, lo, X[13], -MAD_F(0x0ec835e8)); | ||
2396 | t3+= (t7 = MAD_F_MLZ(hi, lo)); | ||
2397 | t4-= t7; | ||
2398 | |||
2399 | MAD_F_MLA(hi, lo, X[1], -MAD_F(0x0cb19346)); | ||
2400 | MAD_F_MLA(hi, lo, X[7], MAD_F(0x0fdcf549)); | ||
2401 | MAD_F_MLA(hi, lo, X[10], MAD_F(0x0216a2a2)); | ||
2402 | MAD_F_MLA(hi, lo, X[16], -MAD_F(0x09bd7ca0)); | ||
2403 | t2 = MAD_F_MLZ(hi, lo); | ||
2404 | |||
2405 | MAD_F_MLA(hi, lo, X[0], MAD_F(0x04cfb0e2)); | ||
2406 | MAD_F_MLA(hi, lo, X[2], MAD_F(0x0ffc19fd)); | ||
2407 | MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0d7e8807)); | ||
2408 | MAD_F_MLA(hi, lo, X[5], MAD_F(0x03768962)); | ||
2409 | MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0bcbe352)); | ||
2410 | MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0e313245)); | ||
2411 | MAD_F_MLA(hi, lo, X[9], MAD_F(0x07635284)); | ||
2412 | MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0acf37ad)); | ||
2413 | MAD_F_MLA(hi, lo, X[12], MAD_F(0x0f9ee890)); | ||
2414 | MAD_F_MLA(hi, lo, X[14], MAD_F(0x0898c779)); | ||
2415 | MAD_F_MLA(hi, lo, X[15], MAD_F(0x00b2aa3e)); | ||
2416 | MAD_F_MLA(hi, lo, X[17], MAD_F(0x0f426cb5)); | ||
2417 | x[12] = -(x[5] = MAD_F_MLZ(hi, lo)); | ||
2418 | |||
2419 | MAD_F_ML0(hi, lo, X[0], MAD_F(0x0acf37ad)); | ||
2420 | MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0898c779)); | ||
2421 | MAD_F_MLA(hi, lo, X[3], MAD_F(0x0e313245)); | ||
2422 | MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0f426cb5)); | ||
2423 | MAD_F_MLA(hi, lo, X[6], -MAD_F(0x03768962)); | ||
2424 | MAD_F_MLA(hi, lo, X[8], MAD_F(0x00b2aa3e)); | ||
2425 | MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0ffc19fd)); | ||
2426 | MAD_F_MLA(hi, lo, X[11], MAD_F(0x0f9ee890)); | ||
2427 | MAD_F_MLA(hi, lo, X[12], -MAD_F(0x04cfb0e2)); | ||
2428 | MAD_F_MLA(hi, lo, X[14], MAD_F(0x07635284)); | ||
2429 | MAD_F_MLA(hi, lo, X[15], MAD_F(0x0d7e8807)); | ||
2430 | MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0bcbe352)); | ||
2431 | x[17] = -(x[0] = MAD_F_MLZ(hi, lo) + t2); | ||
2432 | |||
2433 | MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0f9ee890)); | ||
2434 | MAD_F_MLA(hi, lo, X[2], -MAD_F(0x07635284)); | ||
2435 | MAD_F_MLA(hi, lo, X[3], -MAD_F(0x00b2aa3e)); | ||
2436 | MAD_F_MLA(hi, lo, X[5], MAD_F(0x0bcbe352)); | ||
2437 | MAD_F_MLA(hi, lo, X[6], MAD_F(0x0f426cb5)); | ||
2438 | MAD_F_MLA(hi, lo, X[8], MAD_F(0x0d7e8807)); | ||
2439 | MAD_F_MLA(hi, lo, X[9], MAD_F(0x0898c779)); | ||
2440 | MAD_F_MLA(hi, lo, X[11], -MAD_F(0x04cfb0e2)); | ||
2441 | MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0acf37ad)); | ||
2442 | MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0ffc19fd)); | ||
2443 | MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0e313245)); | ||
2444 | MAD_F_MLA(hi, lo, X[17], -MAD_F(0x03768962)); | ||
2445 | x[24] = x[29] = MAD_F_MLZ(hi, lo) + t2; | ||
2446 | |||
2447 | MAD_F_ML0(hi, lo, X[0], MAD_F(0x00b2aa3e)); | ||
2448 | MAD_F_MLA(hi, lo, X[2], MAD_F(0x03768962)); | ||
2449 | MAD_F_MLA(hi, lo, X[3], -MAD_F(0x04cfb0e2)); | ||
2450 | MAD_F_MLA(hi, lo, X[5], -MAD_F(0x07635284)); | ||
2451 | MAD_F_MLA(hi, lo, X[6], MAD_F(0x0898c779)); | ||
2452 | MAD_F_MLA(hi, lo, X[8], MAD_F(0x0acf37ad)); | ||
2453 | MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0bcbe352)); | ||
2454 | MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0d7e8807)); | ||
2455 | MAD_F_MLA(hi, lo, X[12], MAD_F(0x0e313245)); | ||
2456 | MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f426cb5)); | ||
2457 | MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0f9ee890)); | ||
2458 | MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0ffc19fd)); | ||
2459 | x[9] = -(x[8] = MAD_F_MLZ(hi, lo) + t3); | ||
2460 | |||
2461 | MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0e313245)); | ||
2462 | MAD_F_MLA(hi, lo, X[2], MAD_F(0x0bcbe352)); | ||
2463 | MAD_F_MLA(hi, lo, X[3], MAD_F(0x0f9ee890)); | ||
2464 | MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0898c779)); | ||
2465 | MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0ffc19fd)); | ||
2466 | MAD_F_MLA(hi, lo, X[8], MAD_F(0x04cfb0e2)); | ||
2467 | MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f426cb5)); | ||
2468 | MAD_F_MLA(hi, lo, X[11], -MAD_F(0x00b2aa3e)); | ||
2469 | MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0d7e8807)); | ||
2470 | MAD_F_MLA(hi, lo, X[14], -MAD_F(0x03768962)); | ||
2471 | MAD_F_MLA(hi, lo, X[15], MAD_F(0x0acf37ad)); | ||
2472 | MAD_F_MLA(hi, lo, X[17], MAD_F(0x07635284)); | ||
2473 | x[21] = x[32] = MAD_F_MLZ(hi, lo) + t3; | ||
2474 | |||
2475 | MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0d7e8807)); | ||
2476 | MAD_F_MLA(hi, lo, X[2], MAD_F(0x0f426cb5)); | ||
2477 | MAD_F_MLA(hi, lo, X[3], MAD_F(0x0acf37ad)); | ||
2478 | MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0ffc19fd)); | ||
2479 | MAD_F_MLA(hi, lo, X[6], -MAD_F(0x07635284)); | ||
2480 | MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f9ee890)); | ||
2481 | MAD_F_MLA(hi, lo, X[9], MAD_F(0x03768962)); | ||
2482 | MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0e313245)); | ||
2483 | MAD_F_MLA(hi, lo, X[12], MAD_F(0x00b2aa3e)); | ||
2484 | MAD_F_MLA(hi, lo, X[14], MAD_F(0x0bcbe352)); | ||
2485 | MAD_F_MLA(hi, lo, X[15], -MAD_F(0x04cfb0e2)); | ||
2486 | MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0898c779)); | ||
2487 | x[20] = x[33] = MAD_F_MLZ(hi, lo) - t3; | ||
2488 | |||
2489 | MAD_F_ML0(hi, lo, t12, -MAD_F(0x0ec835e8)); | ||
2490 | MAD_F_MLA(hi, lo, t13, MAD_F(0x061f78aa)); | ||
2491 | x[22] = x[31] = MAD_F_MLZ(hi, lo) + t0; | ||
2492 | |||
2493 | MAD_F_ML0(hi, lo, t12, MAD_F(0x061f78aa)); | ||
2494 | MAD_F_MLA(hi, lo, t13, MAD_F(0x0ec835e8)); | ||
2495 | x[13] = -(x[4] = MAD_F_MLZ(hi, lo) + t4); | ||
2496 | x[16] = -(x[1] = x[1] + t4); | ||
2497 | x[25] = x[28] = x[25] + t4; | ||
2498 | |||
2499 | MAD_F_ML0(hi, lo, X[0], MAD_F(0x0898c779)); | ||
2500 | MAD_F_MLA(hi, lo, X[2], MAD_F(0x04cfb0e2)); | ||
2501 | MAD_F_MLA(hi, lo, X[3], MAD_F(0x0bcbe352)); | ||
2502 | MAD_F_MLA(hi, lo, X[5], MAD_F(0x00b2aa3e)); | ||
2503 | MAD_F_MLA(hi, lo, X[6], MAD_F(0x0e313245)); | ||
2504 | MAD_F_MLA(hi, lo, X[8], -MAD_F(0x03768962)); | ||
2505 | MAD_F_MLA(hi, lo, X[9], MAD_F(0x0f9ee890)); | ||
2506 | MAD_F_MLA(hi, lo, X[11], -MAD_F(0x07635284)); | ||
2507 | MAD_F_MLA(hi, lo, X[12], MAD_F(0x0ffc19fd)); | ||
2508 | MAD_F_MLA(hi, lo, X[14], -MAD_F(0x0acf37ad)); | ||
2509 | MAD_F_MLA(hi, lo, X[15], MAD_F(0x0f426cb5)); | ||
2510 | MAD_F_MLA(hi, lo, X[17], -MAD_F(0x0d7e8807)); | ||
2511 | x[15] = -(x[2] = MAD_F_MLZ(hi, lo) + t5); | ||
2512 | |||
2513 | MAD_F_ML0(hi, lo, X[0], MAD_F(0x07635284)); | ||
2514 | MAD_F_MLA(hi, lo, X[2], MAD_F(0x0acf37ad)); | ||
2515 | MAD_F_MLA(hi, lo, X[3], MAD_F(0x03768962)); | ||
2516 | MAD_F_MLA(hi, lo, X[5], MAD_F(0x0d7e8807)); | ||
2517 | MAD_F_MLA(hi, lo, X[6], -MAD_F(0x00b2aa3e)); | ||
2518 | MAD_F_MLA(hi, lo, X[8], MAD_F(0x0f426cb5)); | ||
2519 | MAD_F_MLA(hi, lo, X[9], -MAD_F(0x04cfb0e2)); | ||
2520 | MAD_F_MLA(hi, lo, X[11], MAD_F(0x0ffc19fd)); | ||
2521 | MAD_F_MLA(hi, lo, X[12], -MAD_F(0x0898c779)); | ||
2522 | MAD_F_MLA(hi, lo, X[14], MAD_F(0x0f9ee890)); | ||
2523 | MAD_F_MLA(hi, lo, X[15], -MAD_F(0x0bcbe352)); | ||
2524 | MAD_F_MLA(hi, lo, X[17], MAD_F(0x0e313245)); | ||
2525 | x[14] = -(x[3] = MAD_F_MLZ(hi, lo) + t5); | ||
2526 | |||
2527 | MAD_F_ML0(hi, lo, X[0], -MAD_F(0x0ffc19fd)); | ||
2528 | MAD_F_MLA(hi, lo, X[2], -MAD_F(0x0f9ee890)); | ||
2529 | MAD_F_MLA(hi, lo, X[3], -MAD_F(0x0f426cb5)); | ||
2530 | MAD_F_MLA(hi, lo, X[5], -MAD_F(0x0e313245)); | ||
2531 | MAD_F_MLA(hi, lo, X[6], -MAD_F(0x0d7e8807)); | ||
2532 | MAD_F_MLA(hi, lo, X[8], -MAD_F(0x0bcbe352)); | ||
2533 | MAD_F_MLA(hi, lo, X[9], -MAD_F(0x0acf37ad)); | ||
2534 | MAD_F_MLA(hi, lo, X[11], -MAD_F(0x0898c779)); | ||
2535 | MAD_F_MLA(hi, lo, X[12], -MAD_F(0x07635284)); | ||
2536 | MAD_F_MLA(hi, lo, X[14], -MAD_F(0x04cfb0e2)); | ||
2537 | MAD_F_MLA(hi, lo, X[15], -MAD_F(0x03768962)); | ||
2538 | MAD_F_MLA(hi, lo, X[17], -MAD_F(0x00b2aa3e)); | ||
2539 | x[26] = x[27] = MAD_F_MLZ(hi, lo) + t5; | ||
2540 | } | ||
2541 | # endif /* CPU_COLDFIRE */ | ||
2542 | |||
2543 | /* | ||
2544 | * NAME: III_imdct_l() | ||
2545 | * DESCRIPTION: perform IMDCT and windowing for long blocks | ||
2546 | */ | ||
2547 | static | ||
2548 | void III_imdct_l(mad_fixed_t const X[18], mad_fixed_t z[36], | ||
2549 | unsigned int block_type) | ||
2550 | { | ||
2551 | unsigned int i; | ||
2552 | |||
2553 | /* IMDCT */ | ||
2554 | |||
2555 | imdct36(X, z); | ||
2556 | |||
2557 | /* windowing */ | ||
2558 | |||
2559 | switch (block_type) { | ||
2560 | case 0: /* normal window */ | ||
2561 | # if 1 | ||
2562 | /* loop unrolled implementation */ | ||
2563 | for (i = 0; i < 36; i += 4) { | ||
2564 | z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]); | ||
2565 | z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]); | ||
2566 | z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]); | ||
2567 | z[i + 3] = mad_f_mul(z[i + 3], window_l[i + 3]); | ||
2568 | } | ||
2569 | # else | ||
2570 | /* reference implementation */ | ||
2571 | for (i = 0; i < 36; ++i) z[i] = mad_f_mul(z[i], window_l[i]); | ||
2572 | # endif | ||
2573 | break; | ||
2574 | |||
2575 | case 1: /* start block */ | ||
2576 | for (i = 0; i < 18; i += 3) { | ||
2577 | z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]); | ||
2578 | z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]); | ||
2579 | z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]); | ||
2580 | } | ||
2581 | /* (i = 18; i < 24; ++i) z[i] unchanged */ | ||
2582 | for (i = 24; i < 30; ++i) z[i] = mad_f_mul(z[i], window_s[i - 18]); | ||
2583 | for (i = 30; i < 36; ++i) z[i] = 0; | ||
2584 | break; | ||
2585 | |||
2586 | case 3: /* stop block */ | ||
2587 | for (i = 0; i < 6; ++i) z[i] = 0; | ||
2588 | for (i = 6; i < 12; ++i) z[i] = mad_f_mul(z[i], window_s[i - 6]); | ||
2589 | /* (i = 12; i < 18; ++i) z[i] unchanged */ | ||
2590 | for (i = 18; i < 36; i += 3) { | ||
2591 | z[i + 0] = mad_f_mul(z[i + 0], window_l[i + 0]); | ||
2592 | z[i + 1] = mad_f_mul(z[i + 1], window_l[i + 1]); | ||
2593 | z[i + 2] = mad_f_mul(z[i + 2], window_l[i + 2]); | ||
2594 | } | ||
2595 | break; | ||
2596 | } | ||
2597 | } | ||
2598 | # endif /* FPM_ARM */ | ||
2599 | |||
2600 | /* | ||
2601 | * NAME: III_imdct_s() | ||
2602 | * DESCRIPTION: perform IMDCT and windowing for short blocks | ||
2603 | */ | ||
2604 | |||
2605 | # if defined(CPU_COLDFIRE) | ||
2606 | void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36]); | ||
2607 | #else | ||
2608 | |||
2609 | static | ||
2610 | void III_imdct_s(mad_fixed_t const X[18], mad_fixed_t z[36]) | ||
2611 | { | ||
2612 | mad_fixed_t y[36], *yptr; | ||
2613 | mad_fixed_t const *wptr; | ||
2614 | int w, i; | ||
2615 | register mad_fixed64hi_t hi; | ||
2616 | register mad_fixed64lo_t lo; | ||
2617 | |||
2618 | /* IMDCT */ | ||
2619 | |||
2620 | yptr = &y[0]; | ||
2621 | |||
2622 | for (w = 0; w < 3; ++w) { | ||
2623 | register mad_fixed_t const (*s)[6]; | ||
2624 | |||
2625 | s = imdct_s; | ||
2626 | |||
2627 | for (i = 0; i < 3; ++i) { | ||
2628 | MAD_F_ML0(hi, lo, X[0], (*s)[0]); | ||
2629 | MAD_F_MLA(hi, lo, X[1], (*s)[1]); | ||
2630 | MAD_F_MLA(hi, lo, X[2], (*s)[2]); | ||
2631 | MAD_F_MLA(hi, lo, X[3], (*s)[3]); | ||
2632 | MAD_F_MLA(hi, lo, X[4], (*s)[4]); | ||
2633 | MAD_F_MLA(hi, lo, X[5], (*s)[5]); | ||
2634 | |||
2635 | yptr[i + 0] = MAD_F_MLZ(hi, lo); | ||
2636 | yptr[5 - i] = -yptr[i + 0]; | ||
2637 | |||
2638 | ++s; | ||
2639 | |||
2640 | MAD_F_ML0(hi, lo, X[0], (*s)[0]); | ||
2641 | MAD_F_MLA(hi, lo, X[1], (*s)[1]); | ||
2642 | MAD_F_MLA(hi, lo, X[2], (*s)[2]); | ||
2643 | MAD_F_MLA(hi, lo, X[3], (*s)[3]); | ||
2644 | MAD_F_MLA(hi, lo, X[4], (*s)[4]); | ||
2645 | MAD_F_MLA(hi, lo, X[5], (*s)[5]); | ||
2646 | |||
2647 | yptr[ i + 6] = MAD_F_MLZ(hi, lo); | ||
2648 | yptr[11 - i] = yptr[i + 6]; | ||
2649 | |||
2650 | ++s; | ||
2651 | } | ||
2652 | |||
2653 | yptr += 12; | ||
2654 | X += 6; | ||
2655 | } | ||
2656 | |||
2657 | /* windowing, overlapping and concatenation */ | ||
2658 | |||
2659 | yptr = &y[0]; | ||
2660 | wptr = &window_s[0]; | ||
2661 | |||
2662 | for (i = 0; i < 6; ++i) { | ||
2663 | z[i + 0] = 0; | ||
2664 | z[i + 6] = mad_f_mul(yptr[ 0 + 0], wptr[0]); | ||
2665 | |||
2666 | MAD_F_ML0(hi, lo, yptr[ 0 + 6], wptr[6]); | ||
2667 | MAD_F_MLA(hi, lo, yptr[12 + 0], wptr[0]); | ||
2668 | |||
2669 | z[i + 12] = MAD_F_MLZ(hi, lo); | ||
2670 | |||
2671 | MAD_F_ML0(hi, lo, yptr[12 + 6], wptr[6]); | ||
2672 | MAD_F_MLA(hi, lo, yptr[24 + 0], wptr[0]); | ||
2673 | |||
2674 | z[i + 18] = MAD_F_MLZ(hi, lo); | ||
2675 | |||
2676 | z[i + 24] = mad_f_mul(yptr[24 + 6], wptr[6]); | ||
2677 | z[i + 30] = 0; | ||
2678 | |||
2679 | ++yptr; | ||
2680 | ++wptr; | ||
2681 | } | ||
2682 | } | ||
2683 | |||
2684 | #endif | ||
2685 | |||
2686 | #ifdef CPU_ARM | ||
2687 | void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18], | ||
2688 | mad_fixed_t sample[18][32], unsigned int sb); | ||
2689 | #else | ||
2690 | |||
2691 | /* | ||
2692 | * NAME: III_overlap() | ||
2693 | * DESCRIPTION: perform overlap-add of windowed IMDCT outputs | ||
2694 | */ | ||
2695 | static | ||
2696 | void III_overlap(mad_fixed_t const output[36], mad_fixed_t overlap[18], | ||
2697 | mad_fixed_t sample[18][32], unsigned int sb) | ||
2698 | { | ||
2699 | unsigned int i; | ||
2700 | for (i = 0; i < 18; ++i) { | ||
2701 | sample[i][sb] = output[i + 0] + overlap[i]; | ||
2702 | overlap[i] = output[i + 18]; | ||
2703 | } | ||
2704 | } | ||
2705 | #endif | ||
2706 | |||
2707 | /* | ||
2708 | * NAME: III_overlap_z() | ||
2709 | * DESCRIPTION: perform "overlap-add" of zero IMDCT outputs | ||
2710 | */ | ||
2711 | static inline | ||
2712 | void III_overlap_z(mad_fixed_t overlap[18], | ||
2713 | mad_fixed_t sample[18][32], unsigned int sb) | ||
2714 | { | ||
2715 | unsigned int i; | ||
2716 | for (i = 0; i < 18; ++i) { | ||
2717 | sample[i][sb] = overlap[i]; | ||
2718 | overlap[i] = 0; | ||
2719 | } | ||
2720 | } | ||
2721 | |||
2722 | /* | ||
2723 | * NAME: III_freqinver() | ||
2724 | * DESCRIPTION: perform subband frequency inversion for odd sample lines | ||
2725 | */ | ||
2726 | static | ||
2727 | void III_freqinver(mad_fixed_t sample[18][32], unsigned int sb) | ||
2728 | { | ||
2729 | unsigned int i; | ||
2730 | for (i = 1; i < 18; i += 2) | ||
2731 | sample[i][sb] = -sample[i][sb]; | ||
2732 | } | ||
2733 | |||
2734 | /* | ||
2735 | * NAME: III_decode() | ||
2736 | * DESCRIPTION: decode frame main_data | ||
2737 | */ | ||
2738 | static | ||
2739 | enum mad_error III_decode(struct mad_bitptr *ptr, struct mad_frame *frame, | ||
2740 | struct sideinfo *si, unsigned int nch) | ||
2741 | { | ||
2742 | struct mad_header *header = &frame->header; | ||
2743 | unsigned int sfreqi, ngr, gr; | ||
2744 | |||
2745 | { | ||
2746 | unsigned int sfreq; | ||
2747 | |||
2748 | sfreq = header->samplerate; | ||
2749 | if (header->flags & MAD_FLAG_MPEG_2_5_EXT) | ||
2750 | sfreq *= 2; | ||
2751 | |||
2752 | /* 48000 => 0, 44100 => 1, 32000 => 2, | ||
2753 | 24000 => 3, 22050 => 4, 16000 => 5 */ | ||
2754 | sfreqi = ((sfreq >> 7) & 0x000f) + | ||
2755 | ((sfreq >> 15) & 0x0001) - 8; | ||
2756 | |||
2757 | if (header->flags & MAD_FLAG_MPEG_2_5_EXT) | ||
2758 | sfreqi += 3; | ||
2759 | } | ||
2760 | |||
2761 | /* scalefactors, Huffman decoding, requantization */ | ||
2762 | |||
2763 | ngr = (header->flags & MAD_FLAG_LSF_EXT) ? 1 : 2; | ||
2764 | |||
2765 | for (gr = 0; gr < ngr; ++gr) { | ||
2766 | struct granule *granule = &si->gr[gr]; | ||
2767 | unsigned char const *sfbwidth[2]; | ||
2768 | mad_fixed_t xr[2][576]; | ||
2769 | unsigned int ch; | ||
2770 | enum mad_error error; | ||
2771 | |||
2772 | for (ch = 0; ch < nch; ++ch) { | ||
2773 | struct channel *channel = &granule->ch[ch]; | ||
2774 | unsigned int part2_length; | ||
2775 | |||
2776 | sfbwidth[ch] = sfbwidth_table[sfreqi].l; | ||
2777 | if (channel->block_type == 2) { | ||
2778 | sfbwidth[ch] = (channel->flags & mixed_block_flag) ? | ||
2779 | sfbwidth_table[sfreqi].m : sfbwidth_table[sfreqi].s; | ||
2780 | } | ||
2781 | |||
2782 | if (header->flags & MAD_FLAG_LSF_EXT) { | ||
2783 | part2_length = III_scalefactors_lsf(ptr, channel, | ||
2784 | ch == 0 ? 0 : &si->gr[1].ch[1], | ||
2785 | header->mode_extension); | ||
2786 | } | ||
2787 | else { | ||
2788 | part2_length = III_scalefactors(ptr, channel, &si->gr[0].ch[ch], | ||
2789 | gr == 0 ? 0 : si->scfsi[ch]); | ||
2790 | } | ||
2791 | |||
2792 | error = III_huffdecode(ptr, xr[ch], channel, sfbwidth[ch], part2_length); | ||
2793 | if (error) | ||
2794 | return error; | ||
2795 | } | ||
2796 | |||
2797 | /* joint stereo processing */ | ||
2798 | |||
2799 | if (header->mode == MAD_MODE_JOINT_STEREO && header->mode_extension) { | ||
2800 | error = III_stereo(xr, granule, header, sfbwidth[0]); | ||
2801 | if (error) | ||
2802 | return error; | ||
2803 | } | ||
2804 | |||
2805 | /* reordering, alias reduction, IMDCT, overlap-add, frequency inversion */ | ||
2806 | |||
2807 | for (ch = 0; ch < nch; ++ch) { | ||
2808 | struct channel const *channel = &granule->ch[ch]; | ||
2809 | mad_fixed_t (*sample)[32] = &((*frame->sbsample)[ch][18 * gr]); | ||
2810 | unsigned int sb, l, i, sblimit; | ||
2811 | mad_fixed_t output[36]; | ||
2812 | |||
2813 | if (channel->block_type == 2) { | ||
2814 | III_reorder(xr[ch], channel, sfbwidth[ch]); | ||
2815 | |||
2816 | # if !defined(OPT_STRICT) | ||
2817 | /* | ||
2818 | * According to ISO/IEC 11172-3, "Alias reduction is not applied for | ||
2819 | * granules with block_type == 2 (short block)." However, other | ||
2820 | * sources suggest alias reduction should indeed be performed on the | ||
2821 | * lower two subbands of mixed blocks. Most other implementations do | ||
2822 | * this, so by default we will too. | ||
2823 | */ | ||
2824 | if (channel->flags & mixed_block_flag) | ||
2825 | III_aliasreduce(xr[ch], 36); | ||
2826 | # endif | ||
2827 | } | ||
2828 | else | ||
2829 | III_aliasreduce(xr[ch], 576); | ||
2830 | |||
2831 | l = 0; | ||
2832 | |||
2833 | /* subbands 0-1 */ | ||
2834 | |||
2835 | if (channel->block_type != 2 || (channel->flags & mixed_block_flag)) { | ||
2836 | unsigned int block_type; | ||
2837 | |||
2838 | block_type = channel->block_type; | ||
2839 | if (channel->flags & mixed_block_flag) | ||
2840 | block_type = 0; | ||
2841 | |||
2842 | /* long blocks */ | ||
2843 | for (sb = 0; sb < 2; ++sb, l += 18) { | ||
2844 | III_imdct_l(&xr[ch][l], output, block_type); | ||
2845 | III_overlap(output, (*frame->overlap)[ch][sb], sample, sb); | ||
2846 | } | ||
2847 | } | ||
2848 | else { | ||
2849 | /* short blocks */ | ||
2850 | for (sb = 0; sb < 2; ++sb, l += 18) { | ||
2851 | III_imdct_s(&xr[ch][l], output); | ||
2852 | III_overlap(output, (*frame->overlap)[ch][sb], sample, sb); | ||
2853 | } | ||
2854 | } | ||
2855 | |||
2856 | III_freqinver(sample, 1); | ||
2857 | |||
2858 | /* (nonzero) subbands 2-31 */ | ||
2859 | |||
2860 | /* | ||
2861 | i = 576; | ||
2862 | while (i > 36 && xr[ch][i - 1] == 0) | ||
2863 | --i; | ||
2864 | */ | ||
2865 | |||
2866 | { | ||
2867 | /* saves ~600k cycles */ | ||
2868 | mad_fixed_t *p = &xr[ch][576]; | ||
2869 | mad_fixed_t tmp = xr[ch][35]; | ||
2870 | xr[ch][35] = 1; | ||
2871 | while (!*--p); | ||
2872 | xr[ch][35] = tmp; | ||
2873 | i = p - &xr[ch][0] + 1; | ||
2874 | } | ||
2875 | sblimit = 32 - (576 - i) / 18; | ||
2876 | |||
2877 | if (channel->block_type != 2) { | ||
2878 | /* long blocks */ | ||
2879 | for (sb = 2; sb < sblimit; ++sb, l += 18) { | ||
2880 | III_imdct_l(&xr[ch][l], output, channel->block_type); | ||
2881 | III_overlap(output, (*frame->overlap)[ch][sb], sample, sb); | ||
2882 | |||
2883 | if (sb & 1) | ||
2884 | III_freqinver(sample, sb); | ||
2885 | } | ||
2886 | } | ||
2887 | else { | ||
2888 | /* short blocks */ | ||
2889 | for (sb = 2; sb < sblimit; ++sb, l += 18) { | ||
2890 | III_imdct_s(&xr[ch][l], output); | ||
2891 | III_overlap(output, (*frame->overlap)[ch][sb], sample, sb); | ||
2892 | |||
2893 | if (sb & 1) | ||
2894 | III_freqinver(sample, sb); | ||
2895 | } | ||
2896 | } | ||
2897 | |||
2898 | /* remaining (zero) subbands */ | ||
2899 | |||
2900 | for (sb = sblimit; sb < 32; ++sb) { | ||
2901 | III_overlap_z((*frame->overlap)[ch][sb], sample, sb); | ||
2902 | |||
2903 | if (sb & 1) | ||
2904 | III_freqinver(sample, sb); | ||
2905 | } | ||
2906 | } | ||
2907 | } | ||
2908 | |||
2909 | return MAD_ERROR_NONE; | ||
2910 | } | ||
2911 | |||
2912 | /* | ||
2913 | * NAME: layer->III() | ||
2914 | * DESCRIPTION: decode a single Layer III frame | ||
2915 | */ | ||
2916 | int mad_layer_III(struct mad_stream *stream, struct mad_frame *frame) | ||
2917 | { | ||
2918 | struct mad_header *header = &frame->header; | ||
2919 | unsigned int nch, priv_bitlen, next_md_begin = 0; | ||
2920 | unsigned int si_len, data_bitlen, md_len; | ||
2921 | unsigned int frame_space, frame_used, frame_free; | ||
2922 | struct mad_bitptr ptr; | ||
2923 | struct sideinfo si; | ||
2924 | enum mad_error error; | ||
2925 | int result = 0; | ||
2926 | |||
2927 | #if 0 /* rockbox: do not allocate */ | ||
2928 | /* allocate Layer III dynamic structures */ | ||
2929 | /* rockbox: not used. Both pointers are linked to an array in | ||
2930 | * ../mpa.c before calling this. */ | ||
2931 | if (stream->main_data == 0) { | ||
2932 | stream->main_data = malloc(MAD_BUFFER_MDLEN); | ||
2933 | if (stream->main_data == 0) { | ||
2934 | stream->error = MAD_ERROR_NOMEM; | ||
2935 | return -1; | ||
2936 | } | ||
2937 | } | ||
2938 | |||
2939 | if (frame->overlap == 0) { | ||
2940 | frame->overlap = calloc(2 * 32 * 18, sizeof(mad_fixed_t)); | ||
2941 | if (frame->overlap == 0) { | ||
2942 | stream->error = MAD_ERROR_NOMEM; | ||
2943 | return -1; | ||
2944 | } | ||
2945 | } | ||
2946 | #else | ||
2947 | /* rockbox: This should not happen. Return with error. */ | ||
2948 | if ((stream->main_data == 0) || (frame->overlap == 0)) { | ||
2949 | stream->error = MAD_ERROR_NOMEM; | ||
2950 | return -1; | ||
2951 | } | ||
2952 | #endif /* rockbox */ | ||
2953 | |||
2954 | nch = MAD_NCHANNELS(header); | ||
2955 | si_len = (header->flags & MAD_FLAG_LSF_EXT) ? | ||
2956 | (nch == 1 ? 9 : 17) : (nch == 1 ? 17 : 32); | ||
2957 | |||
2958 | /* check frame sanity */ | ||
2959 | |||
2960 | if (stream->next_frame - mad_bit_nextbyte(&stream->ptr) < | ||
2961 | (signed int) si_len) { | ||
2962 | stream->error = MAD_ERROR_BADFRAMELEN; | ||
2963 | stream->md_len = 0; | ||
2964 | return -1; | ||
2965 | } | ||
2966 | |||
2967 | /* check CRC word */ | ||
2968 | |||
2969 | if (header->flags & MAD_FLAG_PROTECTION) { | ||
2970 | header->crc_check = | ||
2971 | mad_bit_crc(stream->ptr, si_len * CHAR_BIT, header->crc_check); | ||
2972 | |||
2973 | if (header->crc_check != header->crc_target && | ||
2974 | !(frame->options & MAD_OPTION_IGNORECRC)) { | ||
2975 | stream->error = MAD_ERROR_BADCRC; | ||
2976 | result = -1; | ||
2977 | } | ||
2978 | } | ||
2979 | |||
2980 | /* decode frame side information */ | ||
2981 | |||
2982 | error = III_sideinfo(&stream->ptr, nch, header->flags & MAD_FLAG_LSF_EXT, | ||
2983 | &si, &data_bitlen, &priv_bitlen); | ||
2984 | if (error && result == 0) { | ||
2985 | stream->error = error; | ||
2986 | result = -1; | ||
2987 | } | ||
2988 | |||
2989 | header->flags |= priv_bitlen; | ||
2990 | header->private_bits |= si.private_bits; | ||
2991 | |||
2992 | /* find main_data of next frame */ | ||
2993 | |||
2994 | { | ||
2995 | struct mad_bitptr peek; | ||
2996 | unsigned long header; | ||
2997 | |||
2998 | mad_bit_init(&peek, stream->next_frame); | ||
2999 | |||
3000 | header = mad_bit_read(&peek, 32); | ||
3001 | if ((header & 0xffe60000L) /* syncword | layer */ == 0xffe20000L) { | ||
3002 | if (!(header & 0x00010000L)) /* protection_bit */ | ||
3003 | mad_bit_skip(&peek, 16); /* crc_check */ | ||
3004 | |||
3005 | next_md_begin = | ||
3006 | mad_bit_read(&peek, (header & 0x00080000L) /* ID */ ? 9 : 8); | ||
3007 | } | ||
3008 | |||
3009 | mad_bit_finish(&peek); | ||
3010 | } | ||
3011 | |||
3012 | /* find main_data of this frame */ | ||
3013 | |||
3014 | frame_space = stream->next_frame - mad_bit_nextbyte(&stream->ptr); | ||
3015 | |||
3016 | if (next_md_begin > si.main_data_begin + frame_space) | ||
3017 | next_md_begin = 0; | ||
3018 | |||
3019 | md_len = si.main_data_begin + frame_space - next_md_begin; | ||
3020 | |||
3021 | frame_used = 0; | ||
3022 | |||
3023 | if (si.main_data_begin == 0) { | ||
3024 | ptr = stream->ptr; | ||
3025 | stream->md_len = 0; | ||
3026 | |||
3027 | frame_used = md_len; | ||
3028 | } | ||
3029 | else { | ||
3030 | if (si.main_data_begin > stream->md_len) { | ||
3031 | if (result == 0) { | ||
3032 | stream->error = MAD_ERROR_BADDATAPTR; | ||
3033 | result = -1; | ||
3034 | } | ||
3035 | } | ||
3036 | else { | ||
3037 | mad_bit_init(&ptr, | ||
3038 | *stream->main_data + stream->md_len - si.main_data_begin); | ||
3039 | |||
3040 | if (md_len > si.main_data_begin) { | ||
3041 | assert(stream->md_len + md_len - | ||
3042 | si.main_data_begin <= MAD_BUFFER_MDLEN); | ||
3043 | |||
3044 | memcpy(*stream->main_data + stream->md_len, | ||
3045 | mad_bit_nextbyte(&stream->ptr), | ||
3046 | frame_used = md_len - si.main_data_begin); | ||
3047 | stream->md_len += frame_used; | ||
3048 | } | ||
3049 | } | ||
3050 | } | ||
3051 | |||
3052 | frame_free = frame_space - frame_used; | ||
3053 | |||
3054 | /* decode main_data */ | ||
3055 | |||
3056 | if (result == 0) { | ||
3057 | error = III_decode(&ptr, frame, &si, nch); | ||
3058 | if (error) { | ||
3059 | stream->error = error; | ||
3060 | result = -1; | ||
3061 | } | ||
3062 | |||
3063 | /* designate ancillary bits */ | ||
3064 | |||
3065 | stream->anc_ptr = ptr; | ||
3066 | stream->anc_bitlen = md_len * CHAR_BIT - data_bitlen; | ||
3067 | } | ||
3068 | |||
3069 | # if 0 && defined(DEBUG) | ||
3070 | fprintf(stderr, | ||
3071 | "main_data_begin:%u, md_len:%u, frame_free:%u, " | ||
3072 | "data_bitlen:%u, anc_bitlen: %u\n", | ||
3073 | si.main_data_begin, md_len, frame_free, | ||
3074 | data_bitlen, stream->anc_bitlen); | ||
3075 | # endif | ||
3076 | |||
3077 | /* preload main_data buffer with up to 511 bytes for next frame(s) */ | ||
3078 | |||
3079 | if (frame_free >= next_md_begin) { | ||
3080 | memcpy(*stream->main_data, | ||
3081 | stream->next_frame - next_md_begin, next_md_begin); | ||
3082 | stream->md_len = next_md_begin; | ||
3083 | } | ||
3084 | else { | ||
3085 | if (md_len < si.main_data_begin) { | ||
3086 | unsigned int extra; | ||
3087 | |||
3088 | extra = si.main_data_begin - md_len; | ||
3089 | if (extra + frame_free > next_md_begin) | ||
3090 | extra = next_md_begin - frame_free; | ||
3091 | |||
3092 | if (extra < stream->md_len) { | ||
3093 | memmove(*stream->main_data, | ||
3094 | *stream->main_data + stream->md_len - extra, extra); | ||
3095 | stream->md_len = extra; | ||
3096 | } | ||
3097 | } | ||
3098 | else | ||
3099 | stream->md_len = 0; | ||
3100 | |||
3101 | memcpy(*stream->main_data + stream->md_len, | ||
3102 | stream->next_frame - frame_free, frame_free); | ||
3103 | stream->md_len += frame_free; | ||
3104 | } | ||
3105 | |||
3106 | return result; | ||
3107 | } | ||