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