?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add gigabeat F/S volume limits to the manual, and a few minor formatting changes.
[kugel-rb.git] / apps / codecs / libfaad / specrec.c
blob4998828eff5e02f2dab5ea3a3a3823c1ff875b2f
1 /*
2 ** FAAD2 - Freeware Advanced Audio (AAC) Decoder including SBR decoding
3 ** Copyright (C) 2003-2004 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 ** Commercial non-GPL licensing of this software is possible.
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
24 **
25 ** $Id$
26 **/
27
28 /*
29 Spectral reconstruction:
30 - grouping/sectioning
31 - inverse quantization
32 - applying scalefactors
33 */
34
35 #include "common.h"
36 #include "structs.h"
37
38 #include <string.h>
39 #include <stdlib.h>
40 #include "specrec.h"
41 #include "filtbank.h"
42 #include "syntax.h"
43 #include "iq_table.h"
44 #include "ms.h"
45 #include "is.h"
46 #include "pns.h"
47 #include "tns.h"
48 #include "drc.h"
49 #include "lt_predict.h"
50 #include "ic_predict.h"
51 #ifdef SSR_DEC
52 #include "ssr.h"
53 #include "ssr_fb.h"
54 #endif
55
56
57 /* static function declarations */
58 static uint8_t quant_to_spec(NeAACDecHandle hDecoder,
59 ic_stream *ics, int16_t *quant_data,
60 real_t *spec_data, uint16_t frame_len);
61
62
63 #ifdef LD_DEC
64 ALIGN static const uint8_t num_swb_512_window[] =
65 {
66 0, 0, 0, 36, 36, 37, 31, 31, 0, 0, 0, 0
67 };
68 ALIGN static const uint8_t num_swb_480_window[] =
69 {
70 0, 0, 0, 35, 35, 37, 30, 30, 0, 0, 0, 0
71 };
72 #endif
73
74 ALIGN static const uint8_t num_swb_960_window[] ICONST_ATTR =
75 {
76 40, 40, 45, 49, 49, 49, 46, 46, 42, 42, 42, 40
77 };
78
79 ALIGN static const uint8_t num_swb_1024_window[] ICONST_ATTR =
80 {
81 41, 41, 47, 49, 49, 51, 47, 47, 43, 43, 43, 40
82 };
83
84 ALIGN static const uint8_t num_swb_128_window[] ICONST_ATTR =
85 {
86 12, 12, 12, 14, 14, 14, 15, 15, 15, 15, 15, 15
87 };
88
89 ALIGN static const uint16_t swb_offset_1024_96[] =
90 {
91 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56,
92 64, 72, 80, 88, 96, 108, 120, 132, 144, 156, 172, 188, 212, 240,
93 276, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024
94 };
95
96 ALIGN static const uint16_t swb_offset_128_96[] =
97 {
98 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
99 };
100
101 ALIGN static const uint16_t swb_offset_1024_64[] =
102 {
103 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56,
104 64, 72, 80, 88, 100, 112, 124, 140, 156, 172, 192, 216, 240, 268,
105 304, 344, 384, 424, 464, 504, 544, 584, 624, 664, 704, 744, 784, 824,
106 864, 904, 944, 984, 1024
107 };
108
109 ALIGN static const uint16_t swb_offset_128_64[] =
110 {
111 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
112 };
113
114 ALIGN static const uint16_t swb_offset_1024_48[] ICONST_ATTR =
115 {
116 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72,
117 80, 88, 96, 108, 120, 132, 144, 160, 176, 196, 216, 240, 264, 292,
118 320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736,
119 768, 800, 832, 864, 896, 928, 1024
120 };
121
122 #ifdef LD_DEC
123 ALIGN static const uint16_t swb_offset_512_48[] =
124 {
125 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 68, 76, 84,
126 92, 100, 112, 124, 136, 148, 164, 184, 208, 236, 268, 300, 332, 364, 396,
127 428, 460, 512
128 };
129
130 ALIGN static const uint16_t swb_offset_480_48[] =
131 {
132 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72 ,80 ,88,
133 96, 108, 120, 132, 144, 156, 172, 188, 212, 240, 272, 304, 336, 368, 400,
134 432, 480
135 };
136 #endif
137
138 ALIGN static const uint16_t swb_offset_128_48[] ICONST_ATTR =
139 {
140 0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128
141 };
142
143 ALIGN static const uint16_t swb_offset_1024_32[] ICONST_ATTR =
144 {
145 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72,
146 80, 88, 96, 108, 120, 132, 144, 160, 176, 196, 216, 240, 264, 292,
147 320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736,
148 768, 800, 832, 864, 896, 928, 960, 992, 1024
149 };
150
151 #ifdef LD_DEC
152 ALIGN static const uint16_t swb_offset_512_32[] =
153 {
154 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80,
155 88, 96, 108, 120, 132, 144, 160, 176, 192, 212, 236, 260, 288, 320, 352,
156 384, 416, 448, 480, 512
157 };
158
159 ALIGN static const uint16_t swb_offset_480_32[] =
160 {
161 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 72, 80,
162 88, 96, 104, 112, 124, 136, 148, 164, 180, 200, 224, 256, 288, 320, 352,
163 384, 416, 448, 480
164 };
165 #endif
166
167 ALIGN static const uint16_t swb_offset_1024_24[] ICONST_ATTR =
168 {
169 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68,
170 76, 84, 92, 100, 108, 116, 124, 136, 148, 160, 172, 188, 204, 220,
171 240, 260, 284, 308, 336, 364, 396, 432, 468, 508, 552, 600, 652, 704,
172 768, 832, 896, 960, 1024
173 };
174
175 #ifdef LD_DEC
176 ALIGN static const uint16_t swb_offset_512_24[] =
177 {
178 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68,
179 80, 92, 104, 120, 140, 164, 192, 224, 256, 288, 320, 352, 384, 416,
180 448, 480, 512
181 };
182
183 ALIGN static const uint16_t swb_offset_480_24[] =
184 {
185 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68, 80, 92, 104, 120,
186 140, 164, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480
187 };
188 #endif
189
190 ALIGN static const uint16_t swb_offset_128_24[] ICONST_ATTR =
191 {
192 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128
193 };
194
195 ALIGN static const uint16_t swb_offset_1024_16[] ICONST_ATTR =
196 {
197 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 100, 112, 124,
198 136, 148, 160, 172, 184, 196, 212, 228, 244, 260, 280, 300, 320, 344,
199 368, 396, 424, 456, 492, 532, 572, 616, 664, 716, 772, 832, 896, 960, 1024
200 };
201
202 ALIGN static const uint16_t swb_offset_128_16[] ICONST_ATTR =
203 {
204 0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128
205 };
206
207 ALIGN static const uint16_t swb_offset_1024_8[] ICONST_ATTR =
208 {
209 0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 172,
210 188, 204, 220, 236, 252, 268, 288, 308, 328, 348, 372, 396, 420, 448,
211 476, 508, 544, 580, 620, 664, 712, 764, 820, 880, 944, 1024
212 };
213
214 ALIGN static const uint16_t swb_offset_128_8[] ICONST_ATTR =
215 {
216 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128
217 };
218
219 ALIGN static const uint16_t *const swb_offset_1024_window[] ICONST_ATTR =
220 {
221 swb_offset_1024_96, /* 96000 */
222 swb_offset_1024_96, /* 88200 */
223 swb_offset_1024_64, /* 64000 */
224 swb_offset_1024_48, /* 48000 */
225 swb_offset_1024_48, /* 44100 */
226 swb_offset_1024_32, /* 32000 */
227 swb_offset_1024_24, /* 24000 */
228 swb_offset_1024_24, /* 22050 */
229 swb_offset_1024_16, /* 16000 */
230 swb_offset_1024_16, /* 12000 */
231 swb_offset_1024_16, /* 11025 */
232 swb_offset_1024_8 /* 8000 */
233 };
234
235 #ifdef LD_DEC
236 ALIGN static const uint16_t *swb_offset_512_window[] =
237 {
238 0, /* 96000 */
239 0, /* 88200 */
240 0, /* 64000 */
241 swb_offset_512_48, /* 48000 */
242 swb_offset_512_48, /* 44100 */
243 swb_offset_512_32, /* 32000 */
244 swb_offset_512_24, /* 24000 */
245 swb_offset_512_24, /* 22050 */
246 0, /* 16000 */
247 0, /* 12000 */
248 0, /* 11025 */
249 0 /* 8000 */
250 };
251
252 ALIGN static const uint16_t *swb_offset_480_window[] =
253 {
254 0, /* 96000 */
255 0, /* 88200 */
256 0, /* 64000 */
257 swb_offset_480_48, /* 48000 */
258 swb_offset_480_48, /* 44100 */
259 swb_offset_480_32, /* 32000 */
260 swb_offset_480_24, /* 24000 */
261 swb_offset_480_24, /* 22050 */
262 0, /* 16000 */
263 0, /* 12000 */
264 0, /* 11025 */
265 0 /* 8000 */
266 };
267 #endif
268
269 ALIGN static const uint16_t *const swb_offset_128_window[] ICONST_ATTR =
270 {
271 swb_offset_128_96, /* 96000 */
272 swb_offset_128_96, /* 88200 */
273 swb_offset_128_64, /* 64000 */
274 swb_offset_128_48, /* 48000 */
275 swb_offset_128_48, /* 44100 */
276 swb_offset_128_48, /* 32000 */
277 swb_offset_128_24, /* 24000 */
278 swb_offset_128_24, /* 22050 */
279 swb_offset_128_16, /* 16000 */
280 swb_offset_128_16, /* 12000 */
281 swb_offset_128_16, /* 11025 */
282 swb_offset_128_8 /* 8000 */
283 };
284
285 #define bit_set(A, B) ((A) & (1<<(B)))
286
287 /* 4.5.2.3.4 */
288 /*
289 - determine the number of windows in a window_sequence named num_windows
290 - determine the number of window_groups named num_window_groups
291 - determine the number of windows in each group named window_group_length[g]
292 - determine the total number of scalefactor window bands named num_swb for
293 the actual window type
294 - determine swb_offset[swb], the offset of the first coefficient in
295 scalefactor window band named swb of the window actually used
296 - determine sect_sfb_offset[g][section],the offset of the first coefficient
297 in section named section. This offset depends on window_sequence and
298 scale_factor_grouping and is needed to decode the spectral_data().
299 */
300 uint8_t window_grouping_info(NeAACDecHandle hDecoder, ic_stream *ics)
301 {
302 uint8_t i, g;
303
304 uint8_t sf_index = hDecoder->sf_index;
305
306 switch (ics->window_sequence) {
307 case ONLY_LONG_SEQUENCE:
308 case LONG_START_SEQUENCE:
309 case LONG_STOP_SEQUENCE:
310 ics->num_windows = 1;
311 ics->num_window_groups = 1;
312 ics->window_group_length[ics->num_window_groups-1] = 1;
313 #ifdef LD_DEC
314 if (hDecoder->object_type == LD)
315 {
316 if (hDecoder->frameLength == 512)
317 ics->num_swb = num_swb_512_window[sf_index];
318 else /* if (hDecoder->frameLength == 480) */
319 ics->num_swb = num_swb_480_window[sf_index];
320 } else {
321 #endif
322 if (hDecoder->frameLength == 1024)
323 ics->num_swb = num_swb_1024_window[sf_index];
324 else /* if (hDecoder->frameLength == 960) */
325 ics->num_swb = num_swb_960_window[sf_index];
326 #ifdef LD_DEC
327 }
328 #endif
329
330 /* preparation of sect_sfb_offset for long blocks */
331 /* also copy the last value! */
332 #ifdef LD_DEC
333 if (hDecoder->object_type == LD)
334 {
335 if (hDecoder->frameLength == 512)
336 {
337 for (i = 0; i < ics->num_swb; i++)
338 {
339 ics->sect_sfb_offset[0][i] = swb_offset_512_window[sf_index][i];
340 ics->swb_offset[i] = swb_offset_512_window[sf_index][i];
341 }
342 } else /* if (hDecoder->frameLength == 480) */ {
343 for (i = 0; i < ics->num_swb; i++)
344 {
345 ics->sect_sfb_offset[0][i] = swb_offset_480_window[sf_index][i];
346 ics->swb_offset[i] = swb_offset_480_window[sf_index][i];
347 }
348 }
349 ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
350 ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
351 } else {
352 #endif
353 for (i = 0; i < ics->num_swb; i++)
354 {
355 ics->sect_sfb_offset[0][i] = swb_offset_1024_window[sf_index][i];
356 ics->swb_offset[i] = swb_offset_1024_window[sf_index][i];
357 }
358 ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
359 ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
360 #ifdef LD_DEC
361 }
362 #endif
363 return 0;
364 case EIGHT_SHORT_SEQUENCE:
365 ics->num_windows = 8;
366 ics->num_window_groups = 1;
367 ics->window_group_length[ics->num_window_groups-1] = 1;
368 ics->num_swb = num_swb_128_window[sf_index];
369
370 for (i = 0; i < ics->num_swb; i++)
371 ics->swb_offset[i] = swb_offset_128_window[sf_index][i];
372 ics->swb_offset[ics->num_swb] = hDecoder->frameLength/8;
373
374 for (i = 0; i < ics->num_windows-1; i++) {
375 if (bit_set(ics->scale_factor_grouping, 6-i) == 0)
376 {
377 ics->num_window_groups += 1;
378 ics->window_group_length[ics->num_window_groups-1] = 1;
379 } else {
380 ics->window_group_length[ics->num_window_groups-1] += 1;
381 }
382 }
383
384 /* preparation of sect_sfb_offset for short blocks */
385 for (g = 0; g < ics->num_window_groups; g++)
386 {
387 uint16_t width;
388 uint8_t sect_sfb = 0;
389 uint16_t offset = 0;
390
391 for (i = 0; i < ics->num_swb; i++)
392 {
393 if (i+1 == ics->num_swb)
394 {
395 width = (hDecoder->frameLength/8) - swb_offset_128_window[sf_index][i];
396 } else {
397 width = swb_offset_128_window[sf_index][i+1] -
398 swb_offset_128_window[sf_index][i];
399 }
400 width *= ics->window_group_length[g];
401 ics->sect_sfb_offset[g][sect_sfb++] = offset;
402 offset += width;
403 }
404 ics->sect_sfb_offset[g][sect_sfb] = offset;
405 }
406 return 0;
407 default:
408 return 1;
409 }
410 }
411
412 /* iquant() */
413 /* output = sign(input)*abs(input)^(4/3) */
414 /**/
415 static INLINE real_t iquant(int16_t q, const real_t *tab, uint8_t *error)
416 {
417 #ifdef FIXED_POINT
418 /* For FIXED_POINT the iq_table is prescaled by 3 bits (iq_table[]/8) */
419 /* BIG_IQ_TABLE allows you to use the full 8192 value table, if this is not
420 * defined a 1026 value table and interpolation will be used
421 */
422 #ifndef BIG_IQ_TABLE
423 static const real_t errcorr[] = {
424 REAL_CONST(0), REAL_CONST(1.0/8.0), REAL_CONST(2.0/8.0), REAL_CONST(3.0/8.0),
425 REAL_CONST(4.0/8.0), REAL_CONST(5.0/8.0), REAL_CONST(6.0/8.0), REAL_CONST(7.0/8.0),
426 REAL_CONST(0)
427 };
428 real_t x1, x2;
429 #endif
430 int16_t sgn = 1;
431
432 if (q < 0)
433 {
434 q = -q;
435 sgn = -1;
436 }
437
438 if (q < IQ_TABLE_SIZE)
439 {
440 //#define IQUANT_PRINT
441 #ifdef IQUANT_PRINT
442 //printf("0x%.8X\n", sgn * tab[q]);
443 printf("%d\n", sgn * tab[q]);
444 #endif
445 return sgn * tab[q];
446 }
447
448 #ifndef BIG_IQ_TABLE
449 if (q >= 8192)
450 {
451 *error = 17;
452 return 0;
453 }
454
455 /* linear interpolation */
456 x1 = tab[q>>3];
457 x2 = tab[(q>>3) + 1];
458 return sgn * 16 * (MUL_R(errcorr[q&7],(x2-x1)) + x1);
459 #else
460 *error = 17;
461 return 0;
462 #endif
463
464 #else
465 if (q < 0)
466 {
467 /* tab contains a value for all possible q [0,8192] */
468 if (-q < IQ_TABLE_SIZE)
469 return -tab[-q];
470
471 *error = 17;
472 return 0;
473 } else {
474 /* tab contains a value for all possible q [0,8192] */
475 if (q < IQ_TABLE_SIZE)
476 return tab[q];
477
478 *error = 17;
479 return 0;
480 }
481 #endif
482 }
483
484 #ifndef FIXED_POINT
485 ALIGN static const real_t pow2sf_tab[] = {
486 2.9802322387695313E-008, 5.9604644775390625E-008, 1.1920928955078125E-007,
487 2.384185791015625E-007, 4.76837158203125E-007, 9.5367431640625E-007,
488 1.9073486328125E-006, 3.814697265625E-006, 7.62939453125E-006,
489 1.52587890625E-005, 3.0517578125E-005, 6.103515625E-005,
490 0.0001220703125, 0.000244140625, 0.00048828125,
491 0.0009765625, 0.001953125, 0.00390625,
492 0.0078125, 0.015625, 0.03125,
493 0.0625, 0.125, 0.25,
494 0.5, 1.0, 2.0,
495 4.0, 8.0, 16.0, 32.0,
496 64.0, 128.0, 256.0,
497 512.0, 1024.0, 2048.0,
498 4096.0, 8192.0, 16384.0,
499 32768.0, 65536.0, 131072.0,
500 262144.0, 524288.0, 1048576.0,
501 2097152.0, 4194304.0, 8388608.0,
502 16777216.0, 33554432.0, 67108864.0,
503 134217728.0, 268435456.0, 536870912.0,
504 1073741824.0, 2147483648.0, 4294967296.0,
505 8589934592.0, 17179869184.0, 34359738368.0,
506 68719476736.0, 137438953472.0, 274877906944.0
507 };
508 #endif
509
510 /* quant_to_spec: perform dequantisation and scaling
511 * and in case of short block it also does the deinterleaving
512 */
513 /*
514 For ONLY_LONG_SEQUENCE windows (num_window_groups = 1,
515 window_group_length[0] = 1) the spectral data is in ascending spectral
516 order.
517 For the EIGHT_SHORT_SEQUENCE window, the spectral order depends on the
518 grouping in the following manner:
519 - Groups are ordered sequentially
520 - Within a group, a scalefactor band consists of the spectral data of all
521 grouped SHORT_WINDOWs for the associated scalefactor window band. To
522 clarify via example, the length of a group is in the range of one to eight
523 SHORT_WINDOWs.
524 - If there are eight groups each with length one (num_window_groups = 8,
525 window_group_length[0..7] = 1), the result is a sequence of eight spectra,
526 each in ascending spectral order.
527 - If there is only one group with length eight (num_window_groups = 1,
528 window_group_length[0] = 8), the result is that spectral data of all eight
529 SHORT_WINDOWs is interleaved by scalefactor window bands.
530 - Within a scalefactor window band, the coefficients are in ascending
531 spectral order.
532 */
533 static uint8_t quant_to_spec(NeAACDecHandle hDecoder,
534 ic_stream *ics, int16_t *quant_data,
535 real_t *spec_data, uint16_t frame_len)
536 {
537 ALIGN static const real_t pow2_table[] ICONST_ATTR =
538 {
539 COEF_CONST(1.0),
540 COEF_CONST(1.1892071150027210667174999705605), /* 2^0.25 */
541 COEF_CONST(1.4142135623730950488016887242097), /* 2^0.5 */
542 COEF_CONST(1.6817928305074290860622509524664) /* 2^0.75 */
543 };
544 const real_t *tab = iq_table;
545
546 (void)frame_len;
547 uint8_t g, sfb, win;
548 uint16_t width, bin, k, gindex, wa, wb;
549 uint8_t error = 0; /* Init error flag */
550 #ifndef FIXED_POINT
551 real_t scf;
552 #endif
553
554 k = 0;
555 gindex = 0;
556
557 for (g = 0; g < ics->num_window_groups; g++)
558 {
559 uint16_t j = 0;
560 uint16_t gincrease = 0;
561 uint16_t win_inc = ics->swb_offset[ics->num_swb];
562
563 for (sfb = 0; sfb < ics->num_swb; sfb++)
564 {
565 int32_t exp, frac;
566
567 width = ics->swb_offset[sfb+1] - ics->swb_offset[sfb];
568
569 /* this could be scalefactor for IS or PNS, those can be negative or bigger then 255 */
570 /* just ignore them */
571 if (ics->scale_factors[g][sfb] < 0 || ics->scale_factors[g][sfb] > 255)
572 {
573 exp = 0;
574 frac = 0;
575 } else {
576 /* ics->scale_factors[g][sfb] must be between 0 and 255 */
577 exp = (ics->scale_factors[g][sfb] /* - 100 */) >> 2;
578 /* frac must always be > 0 */
579 frac = (ics->scale_factors[g][sfb] /* - 100 */) & 3;
580 }
581
582 #ifdef FIXED_POINT
583 exp -= 25;
584 /* IMDCT pre-scaling */
585 if (hDecoder->object_type == LD)
586 {
587 exp -= 6 /*9*/;
588 } else {
589 if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
590 exp -= 4 /*7*/;
591 else
592 exp -= 7 /*10*/;
593 }
594 #endif
595
596 wa = gindex + j;
597
598 #ifndef FIXED_POINT
599 scf = pow2sf_tab[exp/*+25*/] * pow2_table[frac];
600 #endif
601
602 for (win = 0; win < ics->window_group_length[g]; win++)
603 {
604 for (bin = 0; bin < width; bin += 4)
605 {
606 #ifndef FIXED_POINT
607 wb = wa + bin;
608
609 spec_data[wb+0] = iquant(quant_data[k+0], tab, &error) * scf;
610 spec_data[wb+1] = iquant(quant_data[k+1], tab, &error) * scf;
611 spec_data[wb+2] = iquant(quant_data[k+2], tab, &error) * scf;
612 spec_data[wb+3] = iquant(quant_data[k+3], tab, &error) * scf;
613
614 #else
615 real_t iq0 = iquant(quant_data[k+0], tab, &error);
616 real_t iq1 = iquant(quant_data[k+1], tab, &error);
617 real_t iq2 = iquant(quant_data[k+2], tab, &error);
618 real_t iq3 = iquant(quant_data[k+3], tab, &error);
619
620 wb = wa + bin;
621
622 if (exp < 0)
623 {
624 spec_data[wb+0] = iq0 >>= -exp;
625 spec_data[wb+1] = iq1 >>= -exp;
626 spec_data[wb+2] = iq2 >>= -exp;
627 spec_data[wb+3] = iq3 >>= -exp;
628 } else {
629 spec_data[wb+0] = iq0 <<= exp;
630 spec_data[wb+1] = iq1 <<= exp;
631 spec_data[wb+2] = iq2 <<= exp;
632 spec_data[wb+3] = iq3 <<= exp;
633 }
634 if (frac != 0)
635 {
636 spec_data[wb+0] = MUL_C(spec_data[wb+0],pow2_table[frac]);
637 spec_data[wb+1] = MUL_C(spec_data[wb+1],pow2_table[frac]);
638 spec_data[wb+2] = MUL_C(spec_data[wb+2],pow2_table[frac]);
639 spec_data[wb+3] = MUL_C(spec_data[wb+3],pow2_table[frac]);
640 }
641
642 //#define SCFS_PRINT
643 #ifdef SCFS_PRINT
644 printf("%d\n", spec_data[gindex+(win*win_inc)+j+bin+0]);
645 printf("%d\n", spec_data[gindex+(win*win_inc)+j+bin+1]);
646 printf("%d\n", spec_data[gindex+(win*win_inc)+j+bin+2]);
647 printf("%d\n", spec_data[gindex+(win*win_inc)+j+bin+3]);
648 //printf("0x%.8X\n", spec_data[gindex+(win*win_inc)+j+bin+0]);
649 //printf("0x%.8X\n", spec_data[gindex+(win*win_inc)+j+bin+1]);
650 //printf("0x%.8X\n", spec_data[gindex+(win*win_inc)+j+bin+2]);
651 //printf("0x%.8X\n", spec_data[gindex+(win*win_inc)+j+bin+3]);
652 #endif
653 #endif
654
655 gincrease += 4;
656 k += 4;
657 }
658 wa += win_inc;
659 }
660 j += width;
661 }
662 gindex += gincrease;
663 }
664
665 return error;
666 }
667
668 static uint8_t allocate_single_channel(NeAACDecHandle hDecoder, uint8_t channel,
669 uint8_t output_channels)
670 {
671 uint8_t mul = 1;
672
673 #ifdef MAIN_DEC
674 /* MAIN object type prediction */
675 if (hDecoder->object_type == MAIN)
676 {
677 /* allocate the state only when needed */
678 if (hDecoder->pred_stat[channel] == NULL)
679 {
680 hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
681 reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
682 }
683 }
684 #endif
685
686 #ifdef LTP_DEC
687 if (is_ltp_ot(hDecoder->object_type))
688 {
689 /* allocate the state only when needed */
690 if (hDecoder->lt_pred_stat[channel] == NULL)
691 {
692 hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
693 memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
694 }
695 }
696 #endif
697
698 if (hDecoder->time_out[channel] == NULL)
699 {
700 mul = 1;
701 #ifdef SBR_DEC
702 hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
703 if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
704 {
705 /* SBR requires 2 times as much output data */
706 mul = 2;
707 hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
708 }
709 #endif
710 hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
711 memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
712 }
713 #if (defined(PS_DEC) || defined(DRM_PS))
714 if (output_channels == 2)
715 {
716 if (hDecoder->time_out[channel+1] == NULL)
717 {
718 hDecoder->time_out[channel+1] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
719 memset(hDecoder->time_out[channel+1], 0, mul*hDecoder->frameLength*sizeof(real_t));
720 }
721 }
722 #else
723 (void)output_channels; /*silence warning when PS disabled*/
724 #endif
725
726 if (hDecoder->fb_intermed[channel] == NULL)
727 {
728 hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
729 memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t));
730 }
731
732 #ifdef SSR_DEC
733 if (hDecoder->object_type == SSR)
734 {
735 if (hDecoder->ssr_overlap[channel] == NULL)
736 {
737 hDecoder->ssr_overlap[channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
738 memset(hDecoder->ssr_overlap[channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
739 }
740 if (hDecoder->prev_fmd[channel] == NULL)
741 {
742 uint16_t k;
743 hDecoder->prev_fmd[channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
744 for (k = 0; k < 2*hDecoder->frameLength; k++)
745 hDecoder->prev_fmd[channel][k] = REAL_CONST(-1);
746 }
747 }
748 #endif
749
750 return 0;
751 }
752
753 static uint8_t allocate_channel_pair(NeAACDecHandle hDecoder,
754 uint8_t channel, uint8_t paired_channel)
755 {
756 uint8_t mul = 1;
757
758 #ifdef MAIN_DEC
759 /* MAIN object type prediction */
760 if (hDecoder->object_type == MAIN)
761 {
762 /* allocate the state only when needed */
763 if (hDecoder->pred_stat[channel] == NULL)
764 {
765 hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
766 reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
767 }
768 if (hDecoder->pred_stat[paired_channel] == NULL)
769 {
770 hDecoder->pred_stat[paired_channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
771 reset_all_predictors(hDecoder->pred_stat[paired_channel], hDecoder->frameLength);
772 }
773 }
774 #endif
775
776 #ifdef LTP_DEC
777 if (is_ltp_ot(hDecoder->object_type))
778 {
779 /* allocate the state only when needed */
780 if (hDecoder->lt_pred_stat[channel] == NULL)
781 {
782 hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
783 memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
784 }
785 if (hDecoder->lt_pred_stat[paired_channel] == NULL)
786 {
787 hDecoder->lt_pred_stat[paired_channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
788 memset(hDecoder->lt_pred_stat[paired_channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
789 }
790 }
791 #endif
792
793 if (hDecoder->time_out[channel] == NULL)
794 {
795 mul = 1;
796 #ifdef SBR_DEC
797 hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
798 if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
799 {
800 /* SBR requires 2 times as much output data */
801 mul = 2;
802 hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
803 }
804 #endif
805 hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
806 memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
807 }
808 if (hDecoder->time_out[paired_channel] == NULL)
809 {
810 hDecoder->time_out[paired_channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
811 memset(hDecoder->time_out[paired_channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
812 }
813
814 if (hDecoder->fb_intermed[channel] == NULL)
815 {
816 hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
817 memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t));
818 }
819 if (hDecoder->fb_intermed[paired_channel] == NULL)
820 {
821 hDecoder->fb_intermed[paired_channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
822 memset(hDecoder->fb_intermed[paired_channel], 0, hDecoder->frameLength*sizeof(real_t));
823 }
824
825 #ifdef SSR_DEC
826 if (hDecoder->object_type == SSR)
827 {
828 if (hDecoder->ssr_overlap[cpe->channel] == NULL)
829 {
830 hDecoder->ssr_overlap[cpe->channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
831 memset(hDecoder->ssr_overlap[cpe->channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
832 }
833 if (hDecoder->ssr_overlap[cpe->paired_channel] == NULL)
834 {
835 hDecoder->ssr_overlap[cpe->paired_channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
836 memset(hDecoder->ssr_overlap[cpe->paired_channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
837 }
838 if (hDecoder->prev_fmd[cpe->channel] == NULL)
839 {
840 uint16_t k;
841 hDecoder->prev_fmd[cpe->channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
842 for (k = 0; k < 2*hDecoder->frameLength; k++)
843 hDecoder->prev_fmd[cpe->channel][k] = REAL_CONST(-1);
844 }
845 if (hDecoder->prev_fmd[cpe->paired_channel] == NULL)
846 {
847 uint16_t k;
848 hDecoder->prev_fmd[cpe->paired_channel] = (real_t*)faad_malloc(2*hDecoder->frameLength*sizeof(real_t));
849 for (k = 0; k < 2*hDecoder->frameLength; k++)
850 hDecoder->prev_fmd[cpe->paired_channel][k] = REAL_CONST(-1);
851 }
852 }
853 #endif
854
855 return 0;
856 }
857
858 uint8_t reconstruct_single_channel(NeAACDecHandle hDecoder, ic_stream *ics,
859 element *sce, int16_t *spec_data)
860 {
861 uint8_t retval, output_channels;
862 ALIGN static real_t spec_coef[1024];
863
864 #ifdef PROFILE
865 int64_t count = faad_get_ts();
866 #endif
867
868
869 /* always allocate 2 channels, PS can always "suddenly" turn up */
870 #if (defined(PS_DEC) || defined(DRM_PS))
871 output_channels = 2;
872 #else
873 output_channels = 1;
874 #endif
875
876 if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
877 {
878 /* element_output_channels not set yet */
879 hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
880 } else if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] != output_channels) {
881 /* element inconsistency */
882 return 21;
883 }
884
885 if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0)
886 {
887 retval = allocate_single_channel(hDecoder, sce->channel, output_channels);
888 if (retval > 0)
889 return retval;
890
891 hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1;
892 }
893
894
895 /* dequantisation and scaling */
896 retval = quant_to_spec(hDecoder, ics, spec_data, spec_coef, hDecoder->frameLength);
897 if (retval > 0)
898 return retval;
899
900 #ifdef PROFILE
901 count = faad_get_ts() - count;
902 hDecoder->requant_cycles += count;
903 #endif
904
905
906 /* pns decoding */
907 pns_decode(ics, NULL, spec_coef, NULL, hDecoder->frameLength, 0, hDecoder->object_type);
908
909 #ifdef MAIN_DEC
910 /* MAIN object type prediction */
911 if (hDecoder->object_type == MAIN)
912 {
913 /* intra channel prediction */
914 ic_prediction(ics, spec_coef, hDecoder->pred_stat[sce->channel], hDecoder->frameLength,
915 hDecoder->sf_index);
916
917 /* In addition, for scalefactor bands coded by perceptual
918 noise substitution the predictors belonging to the
919 corresponding spectral coefficients are reset.
920 */
921 pns_reset_pred_state(ics, hDecoder->pred_stat[sce->channel]);
922 }
923 #endif
924
925 #ifdef LTP_DEC
926 if (is_ltp_ot(hDecoder->object_type))
927 {
928 #ifdef LD_DEC
929 if (hDecoder->object_type == LD)
930 {
931 if (ics->ltp.data_present)
932 {
933 if (ics->ltp.lag_update)
934 hDecoder->ltp_lag[sce->channel] = ics->ltp.lag;
935 }
936 ics->ltp.lag = hDecoder->ltp_lag[sce->channel];
937 }
938 #endif
939
940 /* long term prediction */
941 lt_prediction(ics, &(ics->ltp), spec_coef, hDecoder->lt_pred_stat[sce->channel], hDecoder->fb,
942 ics->window_shape, hDecoder->window_shape_prev[sce->channel],
943 hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
944 }
945 #endif
946
947 /* tns decoding */
948 tns_decode_frame(ics, &(ics->tns), hDecoder->sf_index, hDecoder->object_type,
949 spec_coef, hDecoder->frameLength);
950
951 /* drc decoding */
952 if (hDecoder->drc->present)
953 {
954 if (!hDecoder->drc->exclude_mask[sce->channel] || !hDecoder->drc->excluded_chns_present)
955 drc_decode(hDecoder->drc, spec_coef);
956 }
957
958 /* filter bank */
959 #ifdef SSR_DEC
960 if (hDecoder->object_type != SSR)
961 {
962 #endif
963 ifilter_bank(ics->window_sequence,ics->window_shape,
964 hDecoder->window_shape_prev[sce->channel],spec_coef,
965 hDecoder->time_out[sce->channel], hDecoder->fb_intermed[sce->channel],
966 hDecoder->object_type, hDecoder->frameLength);
967 #ifdef SSR_DEC
968 } else {
969 ssr_decode(&(ics->ssr), hDecoder->fb, ics->window_sequence, ics->window_shape,
970 hDecoder->window_shape_prev[sce->channel], spec_coef, hDecoder->time_out[sce->channel],
971 hDecoder->ssr_overlap[sce->channel], hDecoder->ipqf_buffer[sce->channel], hDecoder->prev_fmd[sce->channel],
972 hDecoder->frameLength);
973 }
974 #endif
975
976 /* save window shape for next frame */
977 hDecoder->window_shape_prev[sce->channel] = ics->window_shape;
978
979 #ifdef LTP_DEC
980 if (is_ltp_ot(hDecoder->object_type))
981 {
982 lt_update_state(hDecoder->lt_pred_stat[sce->channel], hDecoder->time_out[sce->channel],
983 hDecoder->fb_intermed[sce->channel], hDecoder->frameLength, hDecoder->object_type);
984 }
985 #endif
986
987 #ifdef SBR_DEC
988 if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
989 && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
990 {
991 uint8_t ele = hDecoder->fr_ch_ele;
992 uint8_t ch = sce->channel;
993
994 /* following case can happen when forceUpSampling == 1 */
995 if (hDecoder->sbr[ele] == NULL)
996 {
997 hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
998 hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
999 hDecoder->downSampledSBR
1000 #ifdef DRM
1001 , 0
1002 #endif
1003 );
1004 }
1005
1006 if (sce->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
1007 hDecoder->sbr[ele]->maxAACLine = 8*sce->ics1.swb_offset[max(sce->ics1.max_sfb-1, 0)];
1008 else
1009 hDecoder->sbr[ele]->maxAACLine = sce->ics1.swb_offset[max(sce->ics1.max_sfb-1, 0)];
1010
1011 /* check if any of the PS tools is used */
1012 #if (defined(PS_DEC) || defined(DRM_PS))
1013 if (hDecoder->ps_used[ele] == 0)
1014 {
1015 #endif
1016 retval = sbrDecodeSingleFrame(hDecoder->sbr[ele], hDecoder->time_out[ch],
1017 hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
1018 #if (defined(PS_DEC) || defined(DRM_PS))
1019 } else {
1020 retval = sbrDecodeSingleFramePS(hDecoder->sbr[ele], hDecoder->time_out[ch],
1021 hDecoder->time_out[ch+1], hDecoder->postSeekResetFlag,
1022 hDecoder->downSampledSBR);
1023 }
1024 #endif
1025 if (retval > 0)
1026 return retval;
1027 } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1028 && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1029 {
1030 return 23;
1031 }
1032 #endif
1033
1034 /* copy L to R when no PS is used */
1035 #if (defined(PS_DEC) || defined(DRM_PS))
1036 if ((hDecoder->ps_used[hDecoder->fr_ch_ele] == 0))
1037 {
1038 uint8_t ele = hDecoder->fr_ch_ele;
1039 uint8_t ch = sce->channel;
1040 uint16_t frame_size = (hDecoder->sbr_alloced[ele]) ? 2 : 1;
1041 frame_size *= hDecoder->frameLength*sizeof(real_t);
1042
1043 memcpy(hDecoder->time_out[ch+1], hDecoder->time_out[ch], frame_size);
1044 }
1045 #endif
1046
1047 return 0;
1048 }
1049
1050 uint8_t reconstruct_channel_pair(NeAACDecHandle hDecoder, ic_stream *ics1, ic_stream *ics2,
1051 element *cpe, int16_t *spec_data1, int16_t *spec_data2)
1052 {
1053 uint8_t retval;
1054 ALIGN static real_t spec_coef1[1024] IBSS_ATTR;
1055 ALIGN static real_t spec_coef2[1024] IBSS_ATTR;
1056
1057 #ifdef PROFILE
1058 int64_t count = faad_get_ts();
1059 #endif
1060 if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0)
1061 {
1062 retval = allocate_channel_pair(hDecoder, cpe->channel, (uint8_t)cpe->paired_channel);
1063 if (retval > 0)
1064 return retval;
1065
1066 hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1;
1067 }
1068
1069 /* dequantisation and scaling */
1070 retval = quant_to_spec(hDecoder, ics1, spec_data1, spec_coef1, hDecoder->frameLength);
1071 if (retval > 0)
1072 return retval;
1073 retval = quant_to_spec(hDecoder, ics2, spec_data2, spec_coef2, hDecoder->frameLength);
1074 if (retval > 0)
1075 return retval;
1076
1077 #ifdef PROFILE
1078 count = faad_get_ts() - count;
1079 hDecoder->requant_cycles += count;
1080 #endif
1081
1082
1083 /* pns decoding */
1084 if (ics1->ms_mask_present)
1085 {
1086 pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 1, hDecoder->object_type);
1087 } else {
1088 pns_decode(ics1, NULL, spec_coef1, NULL, hDecoder->frameLength, 0, hDecoder->object_type);
1089 pns_decode(ics2, NULL, spec_coef2, NULL, hDecoder->frameLength, 0, hDecoder->object_type);
1090 }
1091
1092 /* mid/side decoding */
1093 ms_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength);
1094
1095 #if 0
1096 {
1097 int i;
1098 for (i = 0; i < 1024; i++)
1099 {
1100 //printf("%d\n", spec_coef1[i]);
1101 printf("0x%.8X\n", spec_coef1[i]);
1102 }
1103 for (i = 0; i < 1024; i++)
1104 {
1105 //printf("%d\n", spec_coef2[i]);
1106 printf("0x%.8X\n", spec_coef2[i]);
1107 }
1108 }
1109 #endif
1110
1111 /* intensity stereo decoding */
1112 is_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength);
1113
1114 #if 0
1115 {
1116 int i;
1117 for (i = 0; i < 1024; i++)
1118 {
1119 printf("%d\n", spec_coef1[i]);
1120 //printf("0x%.8X\n", spec_coef1[i]);
1121 }
1122 for (i = 0; i < 1024; i++)
1123 {
1124 printf("%d\n", spec_coef2[i]);
1125 //printf("0x%.8X\n", spec_coef2[i]);
1126 }
1127 }
1128 #endif
1129
1130 #ifdef MAIN_DEC
1131 /* MAIN object type prediction */
1132 if (hDecoder->object_type == MAIN)
1133 {
1134 /* intra channel prediction */
1135 ic_prediction(ics1, spec_coef1, hDecoder->pred_stat[cpe->channel], hDecoder->frameLength,
1136 hDecoder->sf_index);
1137 ic_prediction(ics2, spec_coef2, hDecoder->pred_stat[cpe->paired_channel], hDecoder->frameLength,
1138 hDecoder->sf_index);
1139
1140 /* In addition, for scalefactor bands coded by perceptual
1141 noise substitution the predictors belonging to the
1142 corresponding spectral coefficients are reset.
1143 */
1144 pns_reset_pred_state(ics1, hDecoder->pred_stat[cpe->channel]);
1145 pns_reset_pred_state(ics2, hDecoder->pred_stat[cpe->paired_channel]);
1146 }
1147 #endif
1148
1149 #ifdef LTP_DEC
1150 if (is_ltp_ot(hDecoder->object_type))
1151 {
1152 ltp_info *ltp1 = &(ics1->ltp);
1153 ltp_info *ltp2 = (cpe->common_window) ? &(ics2->ltp2) : &(ics2->ltp);
1154 #ifdef LD_DEC
1155 if (hDecoder->object_type == LD)
1156 {
1157 if (ltp1->data_present)
1158 {
1159 if (ltp1->lag_update)
1160 hDecoder->ltp_lag[cpe->channel] = ltp1->lag;
1161 }
1162 ltp1->lag = hDecoder->ltp_lag[cpe->channel];
1163 if (ltp2->data_present)
1164 {
1165 if (ltp2->lag_update)
1166 hDecoder->ltp_lag[cpe->paired_channel] = ltp2->lag;
1167 }
1168 ltp2->lag = hDecoder->ltp_lag[cpe->paired_channel];
1169 }
1170 #endif
1171
1172 /* long term prediction */
1173 lt_prediction(ics1, ltp1, spec_coef1, hDecoder->lt_pred_stat[cpe->channel], hDecoder->fb,
1174 ics1->window_shape, hDecoder->window_shape_prev[cpe->channel],
1175 hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1176 lt_prediction(ics2, ltp2, spec_coef2, hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->fb,
1177 ics2->window_shape, hDecoder->window_shape_prev[cpe->paired_channel],
1178 hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1179 }
1180 #endif
1181
1182 /* tns decoding */
1183 tns_decode_frame(ics1, &(ics1->tns), hDecoder->sf_index, hDecoder->object_type,
1184 spec_coef1, hDecoder->frameLength);
1185 tns_decode_frame(ics2, &(ics2->tns), hDecoder->sf_index, hDecoder->object_type,
1186 spec_coef2, hDecoder->frameLength);
1187
1188 /* drc decoding */
1189 if (hDecoder->drc->present)
1190 {
1191 if (!hDecoder->drc->exclude_mask[cpe->channel] || !hDecoder->drc->excluded_chns_present)
1192 drc_decode(hDecoder->drc, spec_coef1);
1193 if (!hDecoder->drc->exclude_mask[cpe->paired_channel] || !hDecoder->drc->excluded_chns_present)
1194 drc_decode(hDecoder->drc, spec_coef2);
1195 }
1196
1197 /* filter bank */
1198 #ifdef SSR_DEC
1199 if (hDecoder->object_type != SSR)
1200 {
1201 #endif
1202 ifilter_bank(ics1->window_sequence,ics1->window_shape,
1203 hDecoder->window_shape_prev[cpe->channel],spec_coef1,
1204 hDecoder->time_out[cpe->channel], hDecoder->fb_intermed[cpe->channel],
1205 hDecoder->object_type, hDecoder->frameLength);
1206 ifilter_bank(ics2->window_sequence,ics2->window_shape,
1207 hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2,
1208 hDecoder->time_out[cpe->paired_channel], hDecoder->fb_intermed[cpe->paired_channel],
1209 hDecoder->object_type, hDecoder->frameLength);
1210 #ifdef SSR_DEC
1211 } else {
1212 ssr_decode(&(ics1->ssr), hDecoder->fb, ics1->window_sequence, ics1->window_shape,
1213 hDecoder->window_shape_prev[cpe->channel], spec_coef1, hDecoder->time_out[cpe->channel],
1214 hDecoder->ssr_overlap[cpe->channel], hDecoder->ipqf_buffer[cpe->channel],
1215 hDecoder->prev_fmd[cpe->channel], hDecoder->frameLength);
1216 ssr_decode(&(ics2->ssr), hDecoder->fb, ics2->window_sequence, ics2->window_shape,
1217 hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2, hDecoder->time_out[cpe->paired_channel],
1218 hDecoder->ssr_overlap[cpe->paired_channel], hDecoder->ipqf_buffer[cpe->paired_channel],
1219 hDecoder->prev_fmd[cpe->paired_channel], hDecoder->frameLength);
1220 }
1221 #endif
1222
1223 /* save window shape for next frame */
1224 hDecoder->window_shape_prev[cpe->channel] = ics1->window_shape;
1225 hDecoder->window_shape_prev[cpe->paired_channel] = ics2->window_shape;
1226
1227 #ifdef LTP_DEC
1228 if (is_ltp_ot(hDecoder->object_type))
1229 {
1230 lt_update_state(hDecoder->lt_pred_stat[cpe->channel], hDecoder->time_out[cpe->channel],
1231 hDecoder->fb_intermed[cpe->channel], hDecoder->frameLength, hDecoder->object_type);
1232 lt_update_state(hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->time_out[cpe->paired_channel],
1233 hDecoder->fb_intermed[cpe->paired_channel], hDecoder->frameLength, hDecoder->object_type);
1234 }
1235 #endif
1236
1237 #ifdef SBR_DEC
1238 if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1239 && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1240 {
1241 uint8_t ele = hDecoder->fr_ch_ele;
1242 uint8_t ch0 = cpe->channel;
1243 uint8_t ch1 = cpe->paired_channel;
1244
1245 /* following case can happen when forceUpSampling == 1 */
1246 if (hDecoder->sbr[ele] == NULL)
1247 {
1248 hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
1249 hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
1250 hDecoder->downSampledSBR
1251 #ifdef DRM
1252 , 0
1253 #endif
1254 );
1255 }
1256
1257 if (cpe->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
1258 hDecoder->sbr[ele]->maxAACLine = 8*cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)];
1259 else
1260 hDecoder->sbr[ele]->maxAACLine = cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)];
1261
1262 retval = sbrDecodeCoupleFrame(hDecoder->sbr[ele],
1263 hDecoder->time_out[ch0], hDecoder->time_out[ch1],
1264 hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
1265 if (retval > 0)
1266 return retval;
1267 } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1268 && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1269 {
1270 return 23;
1271 }
1272 #endif
1273
1274 return 0;
1275 }
My public Rockbox git repo