diff options
Diffstat (limited to 'uisimulator/common/libmad/layer12.c')
-rw-r--r-- | uisimulator/common/libmad/layer12.c | 496 |
1 files changed, 0 insertions, 496 deletions
diff --git a/uisimulator/common/libmad/layer12.c b/uisimulator/common/libmad/layer12.c deleted file mode 100644 index 4e0870c8dc..0000000000 --- a/uisimulator/common/libmad/layer12.c +++ /dev/null | |||
@@ -1,496 +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 | # ifdef HAVE_LIMITS_H | ||
29 | # include <limits.h> | ||
30 | # else | ||
31 | # define CHAR_BIT 8 | ||
32 | # endif | ||
33 | |||
34 | # include "fixed.h" | ||
35 | # include "bit.h" | ||
36 | # include "stream.h" | ||
37 | # include "frame.h" | ||
38 | # include "layer12.h" | ||
39 | |||
40 | /* | ||
41 | * scalefactor table | ||
42 | * used in both Layer I and Layer II decoding | ||
43 | */ | ||
44 | static | ||
45 | mad_fixed_t const sf_table[63] = { | ||
46 | # include "sf_table.dat" | ||
47 | }; | ||
48 | |||
49 | /* --- Layer I ------------------------------------------------------------- */ | ||
50 | |||
51 | /* linear scaling table */ | ||
52 | static | ||
53 | mad_fixed_t const linear_table[14] = { | ||
54 | MAD_F(0x15555555), /* 2^2 / (2^2 - 1) == 1.33333333333333 */ | ||
55 | MAD_F(0x12492492), /* 2^3 / (2^3 - 1) == 1.14285714285714 */ | ||
56 | MAD_F(0x11111111), /* 2^4 / (2^4 - 1) == 1.06666666666667 */ | ||
57 | MAD_F(0x10842108), /* 2^5 / (2^5 - 1) == 1.03225806451613 */ | ||
58 | MAD_F(0x10410410), /* 2^6 / (2^6 - 1) == 1.01587301587302 */ | ||
59 | MAD_F(0x10204081), /* 2^7 / (2^7 - 1) == 1.00787401574803 */ | ||
60 | MAD_F(0x10101010), /* 2^8 / (2^8 - 1) == 1.00392156862745 */ | ||
61 | MAD_F(0x10080402), /* 2^9 / (2^9 - 1) == 1.00195694716243 */ | ||
62 | MAD_F(0x10040100), /* 2^10 / (2^10 - 1) == 1.00097751710655 */ | ||
63 | MAD_F(0x10020040), /* 2^11 / (2^11 - 1) == 1.00048851978505 */ | ||
64 | MAD_F(0x10010010), /* 2^12 / (2^12 - 1) == 1.00024420024420 */ | ||
65 | MAD_F(0x10008004), /* 2^13 / (2^13 - 1) == 1.00012208521548 */ | ||
66 | MAD_F(0x10004001), /* 2^14 / (2^14 - 1) == 1.00006103888177 */ | ||
67 | MAD_F(0x10002000) /* 2^15 / (2^15 - 1) == 1.00003051850948 */ | ||
68 | }; | ||
69 | |||
70 | /* | ||
71 | * NAME: I_sample() | ||
72 | * DESCRIPTION: decode one requantized Layer I sample from a bitstream | ||
73 | */ | ||
74 | static | ||
75 | mad_fixed_t I_sample(struct mad_bitptr *ptr, unsigned int nb) | ||
76 | { | ||
77 | mad_fixed_t sample; | ||
78 | |||
79 | sample = mad_bit_read(ptr, nb); | ||
80 | |||
81 | /* invert most significant bit, extend sign, then scale to fixed format */ | ||
82 | |||
83 | sample ^= 1 << (nb - 1); | ||
84 | sample |= -(sample & (1 << (nb - 1))); | ||
85 | |||
86 | sample <<= MAD_F_FRACBITS - (nb - 1); | ||
87 | |||
88 | /* requantize the sample */ | ||
89 | |||
90 | /* s'' = (2^nb / (2^nb - 1)) * (s''' + 2^(-nb + 1)) */ | ||
91 | |||
92 | sample += MAD_F_ONE >> (nb - 1); | ||
93 | |||
94 | return mad_f_mul(sample, linear_table[nb - 2]); | ||
95 | |||
96 | /* s' = factor * s'' */ | ||
97 | /* (to be performed by caller) */ | ||
98 | } | ||
99 | |||
100 | /* | ||
101 | * NAME: layer->I() | ||
102 | * DESCRIPTION: decode a single Layer I frame | ||
103 | */ | ||
104 | int mad_layer_I(struct mad_stream *stream, struct mad_frame *frame) | ||
105 | { | ||
106 | struct mad_header *header = &frame->header; | ||
107 | unsigned int nch, bound, ch, s, sb, nb; | ||
108 | unsigned char allocation[2][32], scalefactor[2][32]; | ||
109 | |||
110 | nch = MAD_NCHANNELS(header); | ||
111 | |||
112 | bound = 32; | ||
113 | if (header->mode == MAD_MODE_JOINT_STEREO) { | ||
114 | header->flags |= MAD_FLAG_I_STEREO; | ||
115 | bound = 4 + header->mode_extension * 4; | ||
116 | } | ||
117 | |||
118 | /* check CRC word */ | ||
119 | |||
120 | if (header->flags & MAD_FLAG_PROTECTION) { | ||
121 | header->crc_check = | ||
122 | mad_bit_crc(stream->ptr, 4 * (bound * nch + (32 - bound)), | ||
123 | header->crc_check); | ||
124 | |||
125 | if (header->crc_check != header->crc_target && | ||
126 | !(frame->options & MAD_OPTION_IGNORECRC)) { | ||
127 | stream->error = MAD_ERROR_BADCRC; | ||
128 | return -1; | ||
129 | } | ||
130 | } | ||
131 | |||
132 | /* decode bit allocations */ | ||
133 | |||
134 | for (sb = 0; sb < bound; ++sb) { | ||
135 | for (ch = 0; ch < nch; ++ch) { | ||
136 | nb = mad_bit_read(&stream->ptr, 4); | ||
137 | |||
138 | if (nb == 15) { | ||
139 | stream->error = MAD_ERROR_BADBITALLOC; | ||
140 | return -1; | ||
141 | } | ||
142 | |||
143 | allocation[ch][sb] = nb ? nb + 1 : 0; | ||
144 | } | ||
145 | } | ||
146 | |||
147 | for (sb = bound; sb < 32; ++sb) { | ||
148 | nb = mad_bit_read(&stream->ptr, 4); | ||
149 | |||
150 | if (nb == 15) { | ||
151 | stream->error = MAD_ERROR_BADBITALLOC; | ||
152 | return -1; | ||
153 | } | ||
154 | |||
155 | allocation[0][sb] = | ||
156 | allocation[1][sb] = nb ? nb + 1 : 0; | ||
157 | } | ||
158 | |||
159 | /* decode scalefactors */ | ||
160 | |||
161 | for (sb = 0; sb < 32; ++sb) { | ||
162 | for (ch = 0; ch < nch; ++ch) { | ||
163 | if (allocation[ch][sb]) { | ||
164 | scalefactor[ch][sb] = mad_bit_read(&stream->ptr, 6); | ||
165 | |||
166 | if (scalefactor[ch][sb] == 63) { | ||
167 | stream->error = MAD_ERROR_BADSCALEFACTOR; | ||
168 | return -1; | ||
169 | } | ||
170 | } | ||
171 | } | ||
172 | } | ||
173 | |||
174 | /* decode samples */ | ||
175 | |||
176 | for (s = 0; s < 12; ++s) { | ||
177 | for (sb = 0; sb < bound; ++sb) { | ||
178 | for (ch = 0; ch < nch; ++ch) { | ||
179 | nb = allocation[ch][sb]; | ||
180 | frame->sbsample[ch][s][sb] = nb ? | ||
181 | mad_f_mul(I_sample(&stream->ptr, nb), | ||
182 | sf_table[scalefactor[ch][sb]]) : 0; | ||
183 | } | ||
184 | } | ||
185 | |||
186 | for (sb = bound; sb < 32; ++sb) { | ||
187 | if ((nb = allocation[0][sb])) { | ||
188 | mad_fixed_t sample; | ||
189 | |||
190 | sample = I_sample(&stream->ptr, nb); | ||
191 | |||
192 | for (ch = 0; ch < nch; ++ch) { | ||
193 | frame->sbsample[ch][s][sb] = | ||
194 | mad_f_mul(sample, sf_table[scalefactor[ch][sb]]); | ||
195 | } | ||
196 | } | ||
197 | else { | ||
198 | for (ch = 0; ch < nch; ++ch) | ||
199 | frame->sbsample[ch][s][sb] = 0; | ||
200 | } | ||
201 | } | ||
202 | } | ||
203 | |||
204 | return 0; | ||
205 | } | ||
206 | |||
207 | /* --- Layer II ------------------------------------------------------------ */ | ||
208 | |||
209 | /* possible quantization per subband table */ | ||
210 | static | ||
211 | struct { | ||
212 | unsigned int sblimit; | ||
213 | unsigned char const offsets[30]; | ||
214 | } const sbquant_table[5] = { | ||
215 | /* ISO/IEC 11172-3 Table B.2a */ | ||
216 | { 27, { 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 3, 3, 3, 3, 3, /* 0 */ | ||
217 | 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0 } }, | ||
218 | /* ISO/IEC 11172-3 Table B.2b */ | ||
219 | { 30, { 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 3, 3, 3, 3, 3, /* 1 */ | ||
220 | 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0 } }, | ||
221 | /* ISO/IEC 11172-3 Table B.2c */ | ||
222 | { 8, { 5, 5, 2, 2, 2, 2, 2, 2 } }, /* 2 */ | ||
223 | /* ISO/IEC 11172-3 Table B.2d */ | ||
224 | { 12, { 5, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 } }, /* 3 */ | ||
225 | /* ISO/IEC 13818-3 Table B.1 */ | ||
226 | { 30, { 4, 4, 4, 4, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, /* 4 */ | ||
227 | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } } | ||
228 | }; | ||
229 | |||
230 | /* bit allocation table */ | ||
231 | static | ||
232 | struct { | ||
233 | unsigned short nbal; | ||
234 | unsigned short offset; | ||
235 | } const bitalloc_table[8] = { | ||
236 | { 2, 0 }, /* 0 */ | ||
237 | { 2, 3 }, /* 1 */ | ||
238 | { 3, 3 }, /* 2 */ | ||
239 | { 3, 1 }, /* 3 */ | ||
240 | { 4, 2 }, /* 4 */ | ||
241 | { 4, 3 }, /* 5 */ | ||
242 | { 4, 4 }, /* 6 */ | ||
243 | { 4, 5 } /* 7 */ | ||
244 | }; | ||
245 | |||
246 | /* offsets into quantization class table */ | ||
247 | static | ||
248 | unsigned char const offset_table[6][15] = { | ||
249 | { 0, 1, 16 }, /* 0 */ | ||
250 | { 0, 1, 2, 3, 4, 5, 16 }, /* 1 */ | ||
251 | { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 }, /* 2 */ | ||
252 | { 0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 }, /* 3 */ | ||
253 | { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 16 }, /* 4 */ | ||
254 | { 0, 2, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 } /* 5 */ | ||
255 | }; | ||
256 | |||
257 | /* quantization class table */ | ||
258 | static | ||
259 | struct quantclass { | ||
260 | unsigned short nlevels; | ||
261 | unsigned char group; | ||
262 | unsigned char bits; | ||
263 | mad_fixed_t C; | ||
264 | mad_fixed_t D; | ||
265 | } const qc_table[17] = { | ||
266 | # include "qc_table.dat" | ||
267 | }; | ||
268 | |||
269 | /* | ||
270 | * NAME: II_samples() | ||
271 | * DESCRIPTION: decode three requantized Layer II samples from a bitstream | ||
272 | */ | ||
273 | static | ||
274 | void II_samples(struct mad_bitptr *ptr, | ||
275 | struct quantclass const *quantclass, | ||
276 | mad_fixed_t output[3]) | ||
277 | { | ||
278 | unsigned int nb, s, sample[3]; | ||
279 | |||
280 | if ((nb = quantclass->group)) { | ||
281 | unsigned int c, nlevels; | ||
282 | |||
283 | /* degrouping */ | ||
284 | c = mad_bit_read(ptr, quantclass->bits); | ||
285 | nlevels = quantclass->nlevels; | ||
286 | |||
287 | for (s = 0; s < 3; ++s) { | ||
288 | sample[s] = c % nlevels; | ||
289 | c /= nlevels; | ||
290 | } | ||
291 | } | ||
292 | else { | ||
293 | nb = quantclass->bits; | ||
294 | |||
295 | for (s = 0; s < 3; ++s) | ||
296 | sample[s] = mad_bit_read(ptr, nb); | ||
297 | } | ||
298 | |||
299 | for (s = 0; s < 3; ++s) { | ||
300 | mad_fixed_t requantized; | ||
301 | |||
302 | /* invert most significant bit, extend sign, then scale to fixed format */ | ||
303 | |||
304 | requantized = sample[s] ^ (1 << (nb - 1)); | ||
305 | requantized |= -(requantized & (1 << (nb - 1))); | ||
306 | |||
307 | requantized <<= MAD_F_FRACBITS - (nb - 1); | ||
308 | |||
309 | /* requantize the sample */ | ||
310 | |||
311 | /* s'' = C * (s''' + D) */ | ||
312 | |||
313 | output[s] = mad_f_mul(requantized + quantclass->D, quantclass->C); | ||
314 | |||
315 | /* s' = factor * s'' */ | ||
316 | /* (to be performed by caller) */ | ||
317 | } | ||
318 | } | ||
319 | |||
320 | /* | ||
321 | * NAME: layer->II() | ||
322 | * DESCRIPTION: decode a single Layer II frame | ||
323 | */ | ||
324 | int mad_layer_II(struct mad_stream *stream, struct mad_frame *frame) | ||
325 | { | ||
326 | struct mad_header *header = &frame->header; | ||
327 | struct mad_bitptr start; | ||
328 | unsigned int index, sblimit, nbal, nch, bound, gr, ch, s, sb; | ||
329 | unsigned char const *offsets; | ||
330 | unsigned char allocation[2][32], scfsi[2][32], scalefactor[2][32][3]; | ||
331 | mad_fixed_t samples[3]; | ||
332 | |||
333 | nch = MAD_NCHANNELS(header); | ||
334 | |||
335 | if (header->flags & MAD_FLAG_LSF_EXT) | ||
336 | index = 4; | ||
337 | else { | ||
338 | switch (nch == 2 ? header->bitrate / 2 : header->bitrate) { | ||
339 | case 32000: | ||
340 | case 48000: | ||
341 | index = (header->samplerate == 32000) ? 3 : 2; | ||
342 | break; | ||
343 | |||
344 | case 56000: | ||
345 | case 64000: | ||
346 | case 80000: | ||
347 | index = 0; | ||
348 | break; | ||
349 | |||
350 | default: | ||
351 | index = (header->samplerate == 48000) ? 0 : 1; | ||
352 | } | ||
353 | } | ||
354 | |||
355 | sblimit = sbquant_table[index].sblimit; | ||
356 | offsets = sbquant_table[index].offsets; | ||
357 | |||
358 | bound = 32; | ||
359 | if (header->mode == MAD_MODE_JOINT_STEREO) { | ||
360 | header->flags |= MAD_FLAG_I_STEREO; | ||
361 | bound = 4 + header->mode_extension * 4; | ||
362 | } | ||
363 | |||
364 | if (bound > sblimit) | ||
365 | bound = sblimit; | ||
366 | |||
367 | start = stream->ptr; | ||
368 | |||
369 | /* decode bit allocations */ | ||
370 | |||
371 | for (sb = 0; sb < bound; ++sb) { | ||
372 | nbal = bitalloc_table[offsets[sb]].nbal; | ||
373 | |||
374 | for (ch = 0; ch < nch; ++ch) | ||
375 | allocation[ch][sb] = mad_bit_read(&stream->ptr, nbal); | ||
376 | } | ||
377 | |||
378 | for (sb = bound; sb < sblimit; ++sb) { | ||
379 | nbal = bitalloc_table[offsets[sb]].nbal; | ||
380 | |||
381 | allocation[0][sb] = | ||
382 | allocation[1][sb] = mad_bit_read(&stream->ptr, nbal); | ||
383 | } | ||
384 | |||
385 | /* decode scalefactor selection info */ | ||
386 | |||
387 | for (sb = 0; sb < sblimit; ++sb) { | ||
388 | for (ch = 0; ch < nch; ++ch) { | ||
389 | if (allocation[ch][sb]) | ||
390 | scfsi[ch][sb] = mad_bit_read(&stream->ptr, 2); | ||
391 | } | ||
392 | } | ||
393 | |||
394 | /* check CRC word */ | ||
395 | |||
396 | if (header->flags & MAD_FLAG_PROTECTION) { | ||
397 | header->crc_check = | ||
398 | mad_bit_crc(start, mad_bit_length(&start, &stream->ptr), | ||
399 | header->crc_check); | ||
400 | |||
401 | if (header->crc_check != header->crc_target && | ||
402 | !(frame->options & MAD_OPTION_IGNORECRC)) { | ||
403 | stream->error = MAD_ERROR_BADCRC; | ||
404 | return -1; | ||
405 | } | ||
406 | } | ||
407 | |||
408 | /* decode scalefactors */ | ||
409 | |||
410 | for (sb = 0; sb < sblimit; ++sb) { | ||
411 | for (ch = 0; ch < nch; ++ch) { | ||
412 | if (allocation[ch][sb]) { | ||
413 | scalefactor[ch][sb][0] = mad_bit_read(&stream->ptr, 6); | ||
414 | |||
415 | switch (scfsi[ch][sb]) { | ||
416 | case 2: | ||
417 | scalefactor[ch][sb][2] = | ||
418 | scalefactor[ch][sb][1] = | ||
419 | scalefactor[ch][sb][0]; | ||
420 | break; | ||
421 | |||
422 | case 0: | ||
423 | scalefactor[ch][sb][1] = mad_bit_read(&stream->ptr, 6); | ||
424 | /* fall through */ | ||
425 | |||
426 | case 1: | ||
427 | case 3: | ||
428 | scalefactor[ch][sb][2] = mad_bit_read(&stream->ptr, 6); | ||
429 | } | ||
430 | |||
431 | if (scfsi[ch][sb] & 1) | ||
432 | scalefactor[ch][sb][1] = scalefactor[ch][sb][scfsi[ch][sb] - 1]; | ||
433 | |||
434 | if (scalefactor[ch][sb][0] == 63 || | ||
435 | scalefactor[ch][sb][1] == 63 || | ||
436 | scalefactor[ch][sb][2] == 63) { | ||
437 | stream->error = MAD_ERROR_BADSCALEFACTOR; | ||
438 | return -1; | ||
439 | } | ||
440 | } | ||
441 | } | ||
442 | } | ||
443 | |||
444 | /* decode samples */ | ||
445 | |||
446 | for (gr = 0; gr < 12; ++gr) { | ||
447 | for (sb = 0; sb < bound; ++sb) { | ||
448 | for (ch = 0; ch < nch; ++ch) { | ||
449 | if ((index = allocation[ch][sb])) { | ||
450 | index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1]; | ||
451 | |||
452 | II_samples(&stream->ptr, &qc_table[index], samples); | ||
453 | |||
454 | for (s = 0; s < 3; ++s) { | ||
455 | frame->sbsample[ch][3 * gr + s][sb] = | ||
456 | mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]); | ||
457 | } | ||
458 | } | ||
459 | else { | ||
460 | for (s = 0; s < 3; ++s) | ||
461 | frame->sbsample[ch][3 * gr + s][sb] = 0; | ||
462 | } | ||
463 | } | ||
464 | } | ||
465 | |||
466 | for (sb = bound; sb < sblimit; ++sb) { | ||
467 | if ((index = allocation[0][sb])) { | ||
468 | index = offset_table[bitalloc_table[offsets[sb]].offset][index - 1]; | ||
469 | |||
470 | II_samples(&stream->ptr, &qc_table[index], samples); | ||
471 | |||
472 | for (ch = 0; ch < nch; ++ch) { | ||
473 | for (s = 0; s < 3; ++s) { | ||
474 | frame->sbsample[ch][3 * gr + s][sb] = | ||
475 | mad_f_mul(samples[s], sf_table[scalefactor[ch][sb][gr / 4]]); | ||
476 | } | ||
477 | } | ||
478 | } | ||
479 | else { | ||
480 | for (ch = 0; ch < nch; ++ch) { | ||
481 | for (s = 0; s < 3; ++s) | ||
482 | frame->sbsample[ch][3 * gr + s][sb] = 0; | ||
483 | } | ||
484 | } | ||
485 | } | ||
486 | |||
487 | for (ch = 0; ch < nch; ++ch) { | ||
488 | for (s = 0; s < 3; ++s) { | ||
489 | for (sb = sblimit; sb < 32; ++sb) | ||
490 | frame->sbsample[ch][3 * gr + s][sb] = 0; | ||
491 | } | ||
492 | } | ||
493 | } | ||
494 | |||
495 | return 0; | ||
496 | } | ||