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