?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Give better name to Inverse_Table_6_9
[mplayer/glamo.git] / libfaad2 / output.c
bloba8c41b894119418ccad2554aef3d2b517a68ea8b
1 /*
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3 ** Copyright (C) 2003 M. Bakker, Ahead Software AG, http://www.nero.com
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 ** Any non-GPL usage of this software or parts of this software is strictly
20 ** forbidden.
21 **
22 ** Initially modified for use with MPlayer by Rich Felker on 2005/03/29
23 ** $Id$
24 ** detailed changelog at http://svn.mplayerhq.hu/mplayer/trunk/
25 **/
26
27 #include "common.h"
28 #include "structs.h"
29
30 #include "output.h"
31 #include "decoder.h"
32
33 #ifndef FIXED_POINT
34
35
36 #define FLOAT_SCALE (1.0f/(1<<15))
37
38 #define DM_MUL REAL_CONST(0.3203772410170407) // 1/(1+sqrt(2) + 1/sqrt(2))
39 #define RSQRT2 REAL_CONST(0.7071067811865475244) // 1/sqrt(2)
40
41
42 static INLINE real_t get_sample(real_t **input, uint8_t channel, uint16_t sample,
43 uint8_t down_matrix, uint8_t *internal_channel)
44 {
45 if (!down_matrix)
46 return input[internal_channel[channel]][sample];
47
48 if (channel == 0)
49 {
50 return DM_MUL * (input[internal_channel[1]][sample] +
51 input[internal_channel[0]][sample] * RSQRT2 +
52 input[internal_channel[3]][sample] * RSQRT2);
53 } else {
54 return DM_MUL * (input[internal_channel[2]][sample] +
55 input[internal_channel[0]][sample] * RSQRT2 +
56 input[internal_channel[4]][sample] * RSQRT2);
57 }
58 }
59
60 #ifndef HAS_LRINTF
61 #define CLIP(sample, max, min) \
62 if (sample >= 0.0f) \
63 { \
64 sample += 0.5f; \
65 if (sample >= max) \
66 sample = max; \
67 } else { \
68 sample += -0.5f; \
69 if (sample <= min) \
70 sample = min; \
71 }
72 #else
73 #define CLIP(sample, max, min) \
74 if (sample >= 0.0f) \
75 { \
76 if (sample >= max) \
77 sample = max; \
78 } else { \
79 if (sample <= min) \
80 sample = min; \
81 }
82 #endif
83
84 #define CONV(a,b) ((a<<1)|(b&0x1))
85
86 static void to_PCM_16bit(NeAACDecHandle hDecoder, real_t **input,
87 uint8_t channels, uint16_t frame_len,
88 int16_t **sample_buffer)
89 {
90 uint8_t ch, ch1;
91 uint16_t i;
92
93 switch (CONV(channels,hDecoder->downMatrix))
94 {
95 case CONV(1,0):
96 case CONV(1,1):
97 for(i = 0; i < frame_len; i++)
98 {
99 real_t inp = input[hDecoder->internal_channel[0]][i];
100
101 CLIP(inp, 32767.0f, -32768.0f);
102
103 (*sample_buffer)[i] = (int16_t)lrintf(inp);
104 }
105 break;
106 case CONV(2,0):
107 if (hDecoder->upMatrix)
108 {
109 ch = hDecoder->internal_channel[0];
110 for(i = 0; i < frame_len; i++)
111 {
112 real_t inp0 = input[ch][i];
113
114 CLIP(inp0, 32767.0f, -32768.0f);
115
116 (*sample_buffer)[(i*2)+0] = (int16_t)lrintf(inp0);
117 (*sample_buffer)[(i*2)+1] = (int16_t)lrintf(inp0);
118 }
119 } else {
120 ch = hDecoder->internal_channel[0];
121 ch1 = hDecoder->internal_channel[1];
122 for(i = 0; i < frame_len; i++)
123 {
124 real_t inp0 = input[ch ][i];
125 real_t inp1 = input[ch1][i];
126
127 CLIP(inp0, 32767.0f, -32768.0f);
128 CLIP(inp1, 32767.0f, -32768.0f);
129
130 (*sample_buffer)[(i*2)+0] = (int16_t)lrintf(inp0);
131 (*sample_buffer)[(i*2)+1] = (int16_t)lrintf(inp1);
132 }
133 }
134 break;
135 default:
136 for (ch = 0; ch < channels; ch++)
137 {
138 for(i = 0; i < frame_len; i++)
139 {
140 real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
141
142 CLIP(inp, 32767.0f, -32768.0f);
143
144 (*sample_buffer)[(i*channels)+ch] = (int16_t)lrintf(inp);
145 }
146 }
147 break;
148 }
149 }
150
151 static void to_PCM_24bit(NeAACDecHandle hDecoder, real_t **input,
152 uint8_t channels, uint16_t frame_len,
153 int32_t **sample_buffer)
154 {
155 uint8_t ch, ch1;
156 uint16_t i;
157
158 switch (CONV(channels,hDecoder->downMatrix))
159 {
160 case CONV(1,0):
161 case CONV(1,1):
162 for(i = 0; i < frame_len; i++)
163 {
164 real_t inp = input[hDecoder->internal_channel[0]][i];
165
166 inp *= 256.0f;
167 CLIP(inp, 8388607.0f, -8388608.0f);
168
169 (*sample_buffer)[i] = (int32_t)lrintf(inp);
170 }
171 break;
172 case CONV(2,0):
173 if (hDecoder->upMatrix)
174 {
175 ch = hDecoder->internal_channel[0];
176 for(i = 0; i < frame_len; i++)
177 {
178 real_t inp0 = input[ch][i];
179
180 inp0 *= 256.0f;
181 CLIP(inp0, 8388607.0f, -8388608.0f);
182
183 (*sample_buffer)[(i*2)+0] = (int32_t)lrintf(inp0);
184 (*sample_buffer)[(i*2)+1] = (int32_t)lrintf(inp0);
185 }
186 } else {
187 ch = hDecoder->internal_channel[0];
188 ch1 = hDecoder->internal_channel[1];
189 for(i = 0; i < frame_len; i++)
190 {
191 real_t inp0 = input[ch ][i];
192 real_t inp1 = input[ch1][i];
193
194 inp0 *= 256.0f;
195 inp1 *= 256.0f;
196 CLIP(inp0, 8388607.0f, -8388608.0f);
197 CLIP(inp1, 8388607.0f, -8388608.0f);
198
199 (*sample_buffer)[(i*2)+0] = (int32_t)lrintf(inp0);
200 (*sample_buffer)[(i*2)+1] = (int32_t)lrintf(inp1);
201 }
202 }
203 break;
204 default:
205 for (ch = 0; ch < channels; ch++)
206 {
207 for(i = 0; i < frame_len; i++)
208 {
209 real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
210
211 inp *= 256.0f;
212 CLIP(inp, 8388607.0f, -8388608.0f);
213
214 (*sample_buffer)[(i*channels)+ch] = (int32_t)lrintf(inp);
215 }
216 }
217 break;
218 }
219 }
220
221 static void to_PCM_32bit(NeAACDecHandle hDecoder, real_t **input,
222 uint8_t channels, uint16_t frame_len,
223 int32_t **sample_buffer)
224 {
225 uint8_t ch, ch1;
226 uint16_t i;
227
228 switch (CONV(channels,hDecoder->downMatrix))
229 {
230 case CONV(1,0):
231 case CONV(1,1):
232 for(i = 0; i < frame_len; i++)
233 {
234 real_t inp = input[hDecoder->internal_channel[0]][i];
235
236 inp *= 65536.0f;
237 CLIP(inp, 2147483647.0f, -2147483648.0f);
238
239 (*sample_buffer)[i] = (int32_t)lrintf(inp);
240 }
241 break;
242 case CONV(2,0):
243 if (hDecoder->upMatrix)
244 {
245 ch = hDecoder->internal_channel[0];
246 for(i = 0; i < frame_len; i++)
247 {
248 real_t inp0 = input[ch][i];
249
250 inp0 *= 65536.0f;
251 CLIP(inp0, 2147483647.0f, -2147483648.0f);
252
253 (*sample_buffer)[(i*2)+0] = (int32_t)lrintf(inp0);
254 (*sample_buffer)[(i*2)+1] = (int32_t)lrintf(inp0);
255 }
256 } else {
257 ch = hDecoder->internal_channel[0];
258 ch1 = hDecoder->internal_channel[1];
259 for(i = 0; i < frame_len; i++)
260 {
261 real_t inp0 = input[ch ][i];
262 real_t inp1 = input[ch1][i];
263
264 inp0 *= 65536.0f;
265 inp1 *= 65536.0f;
266 CLIP(inp0, 2147483647.0f, -2147483648.0f);
267 CLIP(inp1, 2147483647.0f, -2147483648.0f);
268
269 (*sample_buffer)[(i*2)+0] = (int32_t)lrintf(inp0);
270 (*sample_buffer)[(i*2)+1] = (int32_t)lrintf(inp1);
271 }
272 }
273 break;
274 default:
275 for (ch = 0; ch < channels; ch++)
276 {
277 for(i = 0; i < frame_len; i++)
278 {
279 real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
280
281 inp *= 65536.0f;
282 CLIP(inp, 2147483647.0f, -2147483648.0f);
283
284 (*sample_buffer)[(i*channels)+ch] = (int32_t)lrintf(inp);
285 }
286 }
287 break;
288 }
289 }
290
291 static void to_PCM_float(NeAACDecHandle hDecoder, real_t **input,
292 uint8_t channels, uint16_t frame_len,
293 float32_t **sample_buffer)
294 {
295 uint8_t ch, ch1;
296 uint16_t i;
297
298 switch (CONV(channels,hDecoder->downMatrix))
299 {
300 case CONV(1,0):
301 case CONV(1,1):
302 for(i = 0; i < frame_len; i++)
303 {
304 real_t inp = input[hDecoder->internal_channel[0]][i];
305 (*sample_buffer)[i] = inp*FLOAT_SCALE;
306 }
307 break;
308 case CONV(2,0):
309 if (hDecoder->upMatrix)
310 {
311 ch = hDecoder->internal_channel[0];
312 for(i = 0; i < frame_len; i++)
313 {
314 real_t inp0 = input[ch][i];
315 (*sample_buffer)[(i*2)+0] = inp0*FLOAT_SCALE;
316 (*sample_buffer)[(i*2)+1] = inp0*FLOAT_SCALE;
317 }
318 } else {
319 ch = hDecoder->internal_channel[0];
320 ch1 = hDecoder->internal_channel[1];
321 for(i = 0; i < frame_len; i++)
322 {
323 real_t inp0 = input[ch ][i];
324 real_t inp1 = input[ch1][i];
325 (*sample_buffer)[(i*2)+0] = inp0*FLOAT_SCALE;
326 (*sample_buffer)[(i*2)+1] = inp1*FLOAT_SCALE;
327 }
328 }
329 break;
330 default:
331 for (ch = 0; ch < channels; ch++)
332 {
333 for(i = 0; i < frame_len; i++)
334 {
335 real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
336 (*sample_buffer)[(i*channels)+ch] = inp*FLOAT_SCALE;
337 }
338 }
339 break;
340 }
341 }
342
343 static void to_PCM_double(NeAACDecHandle hDecoder, real_t **input,
344 uint8_t channels, uint16_t frame_len,
345 double **sample_buffer)
346 {
347 uint8_t ch, ch1;
348 uint16_t i;
349
350 switch (CONV(channels,hDecoder->downMatrix))
351 {
352 case CONV(1,0):
353 case CONV(1,1):
354 for(i = 0; i < frame_len; i++)
355 {
356 real_t inp = input[hDecoder->internal_channel[0]][i];
357 (*sample_buffer)[i] = (double)inp*FLOAT_SCALE;
358 }
359 break;
360 case CONV(2,0):
361 if (hDecoder->upMatrix)
362 {
363 ch = hDecoder->internal_channel[0];
364 for(i = 0; i < frame_len; i++)
365 {
366 real_t inp0 = input[ch][i];
367 (*sample_buffer)[(i*2)+0] = (double)inp0*FLOAT_SCALE;
368 (*sample_buffer)[(i*2)+1] = (double)inp0*FLOAT_SCALE;
369 }
370 } else {
371 ch = hDecoder->internal_channel[0];
372 ch1 = hDecoder->internal_channel[1];
373 for(i = 0; i < frame_len; i++)
374 {
375 real_t inp0 = input[ch ][i];
376 real_t inp1 = input[ch1][i];
377 (*sample_buffer)[(i*2)+0] = (double)inp0*FLOAT_SCALE;
378 (*sample_buffer)[(i*2)+1] = (double)inp1*FLOAT_SCALE;
379 }
380 }
381 break;
382 default:
383 for (ch = 0; ch < channels; ch++)
384 {
385 for(i = 0; i < frame_len; i++)
386 {
387 real_t inp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->internal_channel);
388 (*sample_buffer)[(i*channels)+ch] = (double)inp*FLOAT_SCALE;
389 }
390 }
391 break;
392 }
393 }
394
395 void *output_to_PCM(NeAACDecHandle hDecoder,
396 real_t **input, void *sample_buffer, uint8_t channels,
397 uint16_t frame_len, uint8_t format)
398 {
399 int16_t *short_sample_buffer = (int16_t*)sample_buffer;
400 int32_t *int_sample_buffer = (int32_t*)sample_buffer;
401 float32_t *float_sample_buffer = (float32_t*)sample_buffer;
402 double *double_sample_buffer = (double*)sample_buffer;
403
404 #ifdef PROFILE
405 int64_t count = faad_get_ts();
406 #endif
407
408 /* Copy output to a standard PCM buffer */
409 switch (format)
410 {
411 case FAAD_FMT_16BIT:
412 to_PCM_16bit(hDecoder, input, channels, frame_len, &short_sample_buffer);
413 break;
414 case FAAD_FMT_24BIT:
415 to_PCM_24bit(hDecoder, input, channels, frame_len, &int_sample_buffer);
416 break;
417 case FAAD_FMT_32BIT:
418 to_PCM_32bit(hDecoder, input, channels, frame_len, &int_sample_buffer);
419 break;
420 case FAAD_FMT_FLOAT:
421 to_PCM_float(hDecoder, input, channels, frame_len, &float_sample_buffer);
422 break;
423 case FAAD_FMT_DOUBLE:
424 to_PCM_double(hDecoder, input, channels, frame_len, &double_sample_buffer);
425 break;
426 }
427
428 #ifdef PROFILE
429 count = faad_get_ts() - count;
430 hDecoder->output_cycles += count;
431 #endif
432
433 return sample_buffer;
434 }
435
436 #else
437
438 #define DM_MUL FRAC_CONST(0.3203772410170407) // 1/(1+sqrt(2) + 1/sqrt(2))
439 #define RSQRT2 FRAC_CONST(0.7071067811865475244) // 1/sqrt(2)
440
441 static INLINE real_t get_sample(real_t **input, uint8_t channel, uint16_t sample,
442 uint8_t down_matrix, uint8_t up_matrix,
443 uint8_t *internal_channel)
444 {
445 if (up_matrix == 1)
446 return input[internal_channel[0]][sample];
447
448 if (!down_matrix)
449 return input[internal_channel[channel]][sample];
450
451 if (channel == 0)
452 {
453 real_t C = MUL_F(input[internal_channel[0]][sample], RSQRT2);
454 real_t L_S = MUL_F(input[internal_channel[3]][sample], RSQRT2);
455 real_t cum = input[internal_channel[1]][sample] + C + L_S;
456 return MUL_F(cum, DM_MUL);
457 } else {
458 real_t C = MUL_F(input[internal_channel[0]][sample], RSQRT2);
459 real_t R_S = MUL_F(input[internal_channel[4]][sample], RSQRT2);
460 real_t cum = input[internal_channel[2]][sample] + C + R_S;
461 return MUL_F(cum, DM_MUL);
462 }
463 }
464
465 void* output_to_PCM_sux(NeAACDecHandle hDecoder,
466 real_t **input, void *sample_buffer, uint8_t channels,
467 uint16_t frame_len, uint8_t format)
468 {
469 uint8_t ch;
470 uint16_t i;
471 int16_t *short_sample_buffer = (int16_t*)sample_buffer;
472 int32_t *int_sample_buffer = (int32_t*)sample_buffer;
473
474 /* Copy output to a standard PCM buffer */
475 for (ch = 0; ch < channels; ch++)
476 {
477 switch (format)
478 {
479 case FAAD_FMT_16BIT:
480 for(i = 0; i < frame_len; i++)
481 {
482 int32_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix,
483 hDecoder->internal_channel);
484 if (tmp >= 0)
485 {
486 tmp += (1 << (REAL_BITS-1));
487 if (tmp >= REAL_CONST(32767))
488 {
489 tmp = REAL_CONST(32767);
490 }
491 } else {
492 tmp += -(1 << (REAL_BITS-1));
493 if (tmp <= REAL_CONST(-32768))
494 {
495 tmp = REAL_CONST(-32768);
496 }
497 }
498 tmp >>= REAL_BITS;
499 short_sample_buffer[(i*channels)+ch] = (int16_t)tmp;
500 }
501 break;
502 case FAAD_FMT_24BIT:
503 for(i = 0; i < frame_len; i++)
504 {
505 int32_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix,
506 hDecoder->internal_channel);
507 if (tmp >= 0)
508 {
509 tmp += (1 << (REAL_BITS-9));
510 tmp >>= (REAL_BITS-8);
511 if (tmp >= 8388607)
512 {
513 tmp = 8388607;
514 }
515 } else {
516 tmp += -(1 << (REAL_BITS-9));
517 tmp >>= (REAL_BITS-8);
518 if (tmp <= -8388608)
519 {
520 tmp = -8388608;
521 }
522 }
523 int_sample_buffer[(i*channels)+ch] = (int32_t)tmp;
524 }
525 break;
526 case FAAD_FMT_32BIT:
527 for(i = 0; i < frame_len; i++)
528 {
529 int32_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix,
530 hDecoder->internal_channel);
531 if (tmp >= 0)
532 {
533 tmp += (1 << (16-REAL_BITS-1));
534 tmp <<= (16-REAL_BITS);
535 } else {
536 tmp += -(1 << (16-REAL_BITS-1));
537 tmp <<= (16-REAL_BITS);
538 }
539 int_sample_buffer[(i*channels)+ch] = (int32_t)tmp;
540 }
541 break;
542 case FAAD_FMT_FIXED:
543 for(i = 0; i < frame_len; i++)
544 {
545 real_t tmp = get_sample(input, ch, i, hDecoder->downMatrix, hDecoder->upMatrix,
546 hDecoder->internal_channel);
547 int_sample_buffer[(i*channels)+ch] = (int32_t)tmp;
548 }
549 break;
550 }
551 }
552
553 return sample_buffer;
554 }
555
556 void* output_to_PCM(NeAACDecHandle hDecoder,
557 real_t **input, void *sample_buffer, uint8_t channels,
558 uint16_t frame_len, uint8_t format)
559 {
560 int ch;
561 int i;
562 int16_t *short_sample_buffer = (int16_t*)sample_buffer;
563 real_t *ch0 = input[hDecoder->internal_channel[0]];
564 real_t *ch1 = input[hDecoder->internal_channel[1]];
565 real_t *ch2 = input[hDecoder->internal_channel[2]];
566 real_t *ch3 = input[hDecoder->internal_channel[3]];
567 real_t *ch4 = input[hDecoder->internal_channel[4]];
568
569 if (format != FAAD_FMT_16BIT)
570 return output_to_PCM_sux(hDecoder, input, sample_buffer, channels, frame_len, format);
571
572 if (hDecoder->downMatrix) {
573 for(i = 0; i < frame_len; i++)
574 {
575 int32_t tmp;
576 tmp = (ch1[i] + ((ch0[i]+ch3[i])>>1) + ((ch0[i]+ch3[i])>>2) + (1<<(REAL_BITS))) >> (REAL_BITS+1);
577 if ((tmp+0x8000) & ~0xffff) tmp = ~(tmp>>31)-0x8000;
578 short_sample_buffer[0] = tmp;
579 tmp = (ch2[i] + ((ch0[i]+ch4[i])>>1) + ((ch0[i]+ch4[i])>>2) + (1<<(REAL_BITS))) >> (REAL_BITS+1);
580 if ((tmp+0x8000) & ~0xffff) tmp = ~(tmp>>31)-0x8000;
581 short_sample_buffer[1] = tmp;
582 short_sample_buffer += channels;
583 }
584 return sample_buffer;
585 }
586
587 /* Copy output to a standard PCM buffer */
588 for(i = 0; i < frame_len; i++)
589 {
590 for (ch = 0; ch < channels; ch++)
591 {
592 int32_t tmp = input[hDecoder->internal_channel[ch]][i];
593 tmp += (1 << (REAL_BITS-1));
594 tmp >>= REAL_BITS;
595 if ((tmp+0x8000) & ~0xffff) tmp = ~(tmp>>31)-0x8000;
596 *(short_sample_buffer++) = tmp;
597 }
598 }
599
600 return sample_buffer;
601 }
602
603 #endif
mplayer with SMedia Glamo drivers