61
|
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 ** Commercial non-GPL licensing of this software is possible.
|
|
23 ** For more info contact Ahead Software through Mpeg4AAClicense@nero.com.
|
|
24 **
|
|
25 ** $Id: specrec.c,v 1.33 2003/11/12 20:47:59 menno Exp $
|
|
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 "specrec.h"
|
|
40 #include "syntax.h"
|
|
41 #include "iq_table.h"
|
|
42 #include "ms.h"
|
|
43 #include "is.h"
|
|
44 #include "pns.h"
|
|
45 #include "tns.h"
|
|
46 #include "lt_predict.h"
|
|
47 #include "ic_predict.h"
|
|
48 #ifdef SSR_DEC
|
|
49 #include "ssr.h"
|
|
50 #include "ssr_fb.h"
|
|
51 #endif
|
|
52
|
|
53 #ifdef LD_DEC
|
|
54 static uint8_t num_swb_512_window[] =
|
|
55 {
|
|
56 0, 0, 0, 36, 36, 37, 31, 31, 0, 0, 0, 0
|
|
57 };
|
|
58 static uint8_t num_swb_480_window[] =
|
|
59 {
|
|
60 0, 0, 0, 35, 35, 37, 30, 30, 0, 0, 0, 0
|
|
61 };
|
|
62 #endif
|
|
63
|
|
64 static uint8_t num_swb_960_window[] =
|
|
65 {
|
|
66 40, 40, 45, 49, 49, 49, 46, 46, 42, 42, 42, 40
|
|
67 };
|
|
68
|
|
69 static uint8_t num_swb_1024_window[] =
|
|
70 {
|
|
71 41, 41, 47, 49, 49, 51, 47, 47, 43, 43, 43, 40
|
|
72 };
|
|
73
|
|
74 static uint8_t num_swb_128_window[] =
|
|
75 {
|
|
76 12, 12, 12, 14, 14, 14, 15, 15, 15, 15, 15, 15
|
|
77 };
|
|
78
|
|
79 static uint16_t swb_offset_1024_96[] =
|
|
80 {
|
|
81 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56,
|
|
82 64, 72, 80, 88, 96, 108, 120, 132, 144, 156, 172, 188, 212, 240,
|
|
83 276, 320, 384, 448, 512, 576, 640, 704, 768, 832, 896, 960, 1024
|
|
84 };
|
|
85
|
|
86 static uint16_t swb_offset_128_96[] =
|
|
87 {
|
|
88 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
|
|
89 };
|
|
90
|
|
91 static uint16_t swb_offset_1024_64[] =
|
|
92 {
|
|
93 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56,
|
|
94 64, 72, 80, 88, 100, 112, 124, 140, 156, 172, 192, 216, 240, 268,
|
|
95 304, 344, 384, 424, 464, 504, 544, 584, 624, 664, 704, 744, 784, 824,
|
|
96 864, 904, 944, 984, 1024
|
|
97 };
|
|
98
|
|
99 static uint16_t swb_offset_128_64[] =
|
|
100 {
|
|
101 0, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 92, 128
|
|
102 };
|
|
103
|
|
104
|
|
105 static uint16_t swb_offset_1024_48[] =
|
|
106 {
|
|
107 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72,
|
|
108 80, 88, 96, 108, 120, 132, 144, 160, 176, 196, 216, 240, 264, 292,
|
|
109 320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736,
|
|
110 768, 800, 832, 864, 896, 928, 1024
|
|
111 };
|
|
112
|
|
113 #ifdef LD_DEC
|
|
114 static uint16_t swb_offset_512_48[] =
|
|
115 {
|
|
116 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 68, 76, 84,
|
|
117 92, 100, 112, 124, 136, 148, 164, 184, 208, 236, 268, 300, 332, 364, 396,
|
|
118 428, 460, 512
|
|
119 };
|
|
120
|
|
121 static uint16_t swb_offset_480_48[] =
|
|
122 {
|
|
123 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72 ,80 ,88,
|
|
124 96, 108, 120, 132, 144, 156, 172, 188, 212, 240, 272, 304, 336, 368, 400,
|
|
125 432, 480
|
|
126 };
|
|
127 #endif
|
|
128
|
|
129 static uint16_t swb_offset_128_48[] =
|
|
130 {
|
|
131 0, 4, 8, 12, 16, 20, 28, 36, 44, 56, 68, 80, 96, 112, 128
|
|
132 };
|
|
133
|
|
134 static uint16_t swb_offset_1024_32[] =
|
|
135 {
|
|
136 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 48, 56, 64, 72,
|
|
137 80, 88, 96, 108, 120, 132, 144, 160, 176, 196, 216, 240, 264, 292,
|
|
138 320, 352, 384, 416, 448, 480, 512, 544, 576, 608, 640, 672, 704, 736,
|
|
139 768, 800, 832, 864, 896, 928, 960, 992, 1024
|
|
140 };
|
|
141
|
|
142 #ifdef LD_DEC
|
|
143 static uint16_t swb_offset_512_32[] =
|
|
144 {
|
|
145 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 64, 72, 80,
|
|
146 88, 96, 108, 120, 132, 144, 160, 176, 192, 212, 236, 260, 288, 320, 352,
|
|
147 384, 416, 448, 480, 512
|
|
148 };
|
|
149
|
|
150 static uint16_t swb_offset_480_32[] =
|
|
151 {
|
|
152 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 72, 80,
|
|
153 88, 96, 104, 112, 124, 136, 148, 164, 180, 200, 224, 256, 288, 320, 352,
|
|
154 384, 416, 448, 480
|
|
155 };
|
|
156 #endif
|
|
157
|
|
158 static uint16_t swb_offset_1024_24[] =
|
|
159 {
|
|
160 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68,
|
|
161 76, 84, 92, 100, 108, 116, 124, 136, 148, 160, 172, 188, 204, 220,
|
|
162 240, 260, 284, 308, 336, 364, 396, 432, 468, 508, 552, 600, 652, 704,
|
|
163 768, 832, 896, 960, 1024
|
|
164 };
|
|
165
|
|
166 #ifdef LD_DEC
|
|
167 static uint16_t swb_offset_512_24[] =
|
|
168 {
|
|
169 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68,
|
|
170 80, 92, 104, 120, 140, 164, 192, 224, 256, 288, 320, 352, 384, 416,
|
|
171 448, 480, 512
|
|
172 };
|
|
173
|
|
174 static uint16_t swb_offset_480_24[] =
|
|
175 {
|
|
176 0, 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 52, 60, 68, 80, 92, 104, 120,
|
|
177 140, 164, 192, 224, 256, 288, 320, 352, 384, 416, 448, 480
|
|
178 };
|
|
179 #endif
|
|
180
|
|
181 static uint16_t swb_offset_128_24[] =
|
|
182 {
|
|
183 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 64, 76, 92, 108, 128
|
|
184 };
|
|
185
|
|
186 static uint16_t swb_offset_1024_16[] =
|
|
187 {
|
|
188 0, 8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 100, 112, 124,
|
|
189 136, 148, 160, 172, 184, 196, 212, 228, 244, 260, 280, 300, 320, 344,
|
|
190 368, 396, 424, 456, 492, 532, 572, 616, 664, 716, 772, 832, 896, 960, 1024
|
|
191 };
|
|
192
|
|
193 static uint16_t swb_offset_128_16[] =
|
|
194 {
|
|
195 0, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 60, 72, 88, 108, 128
|
|
196 };
|
|
197
|
|
198 static uint16_t swb_offset_1024_8[] =
|
|
199 {
|
|
200 0, 12, 24, 36, 48, 60, 72, 84, 96, 108, 120, 132, 144, 156, 172,
|
|
201 188, 204, 220, 236, 252, 268, 288, 308, 328, 348, 372, 396, 420, 448,
|
|
202 476, 508, 544, 580, 620, 664, 712, 764, 820, 880, 944, 1024
|
|
203 };
|
|
204
|
|
205 static uint16_t swb_offset_128_8[] =
|
|
206 {
|
|
207 0, 4, 8, 12, 16, 20, 24, 28, 36, 44, 52, 60, 72, 88, 108, 128
|
|
208 };
|
|
209
|
|
210 static uint16_t *swb_offset_1024_window[] =
|
|
211 {
|
|
212 swb_offset_1024_96, /* 96000 */
|
|
213 swb_offset_1024_96, /* 88200 */
|
|
214 swb_offset_1024_64, /* 64000 */
|
|
215 swb_offset_1024_48, /* 48000 */
|
|
216 swb_offset_1024_48, /* 44100 */
|
|
217 swb_offset_1024_32, /* 32000 */
|
|
218 swb_offset_1024_24, /* 24000 */
|
|
219 swb_offset_1024_24, /* 22050 */
|
|
220 swb_offset_1024_16, /* 16000 */
|
|
221 swb_offset_1024_16, /* 12000 */
|
|
222 swb_offset_1024_16, /* 11025 */
|
|
223 swb_offset_1024_8 /* 8000 */
|
|
224 };
|
|
225
|
|
226 #ifdef LD_DEC
|
|
227 static uint16_t *swb_offset_512_window[] =
|
|
228 {
|
|
229 0, /* 96000 */
|
|
230 0, /* 88200 */
|
|
231 0, /* 64000 */
|
|
232 swb_offset_512_48, /* 48000 */
|
|
233 swb_offset_512_48, /* 44100 */
|
|
234 swb_offset_512_32, /* 32000 */
|
|
235 swb_offset_512_24, /* 24000 */
|
|
236 swb_offset_512_24, /* 22050 */
|
|
237 0, /* 16000 */
|
|
238 0, /* 12000 */
|
|
239 0, /* 11025 */
|
|
240 0 /* 8000 */
|
|
241 };
|
|
242
|
|
243 static uint16_t *swb_offset_480_window[] =
|
|
244 {
|
|
245 0, /* 96000 */
|
|
246 0, /* 88200 */
|
|
247 0, /* 64000 */
|
|
248 swb_offset_480_48, /* 48000 */
|
|
249 swb_offset_480_48, /* 44100 */
|
|
250 swb_offset_480_32, /* 32000 */
|
|
251 swb_offset_480_24, /* 24000 */
|
|
252 swb_offset_480_24, /* 22050 */
|
|
253 0, /* 16000 */
|
|
254 0, /* 12000 */
|
|
255 0, /* 11025 */
|
|
256 0 /* 8000 */
|
|
257 };
|
|
258 #endif
|
|
259
|
|
260 static uint16_t *swb_offset_128_window[] =
|
|
261 {
|
|
262 swb_offset_128_96, /* 96000 */
|
|
263 swb_offset_128_96, /* 88200 */
|
|
264 swb_offset_128_64, /* 64000 */
|
|
265 swb_offset_128_48, /* 48000 */
|
|
266 swb_offset_128_48, /* 44100 */
|
|
267 swb_offset_128_48, /* 32000 */
|
|
268 swb_offset_128_24, /* 24000 */
|
|
269 swb_offset_128_24, /* 22050 */
|
|
270 swb_offset_128_16, /* 16000 */
|
|
271 swb_offset_128_16, /* 12000 */
|
|
272 swb_offset_128_16, /* 11025 */
|
|
273 swb_offset_128_8 /* 8000 */
|
|
274 };
|
|
275
|
|
276 #define bit_set(A, B) ((A) & (1<<(B)))
|
|
277
|
|
278 /* 4.5.2.3.4 */
|
|
279 /*
|
|
280 - determine the number of windows in a window_sequence named num_windows
|
|
281 - determine the number of window_groups named num_window_groups
|
|
282 - determine the number of windows in each group named window_group_length[g]
|
|
283 - determine the total number of scalefactor window bands named num_swb for
|
|
284 the actual window type
|
|
285 - determine swb_offset[swb], the offset of the first coefficient in
|
|
286 scalefactor window band named swb of the window actually used
|
|
287 - determine sect_sfb_offset[g][section],the offset of the first coefficient
|
|
288 in section named section. This offset depends on window_sequence and
|
|
289 scale_factor_grouping and is needed to decode the spectral_data().
|
|
290 */
|
|
291 uint8_t window_grouping_info(faacDecHandle hDecoder, ic_stream *ics)
|
|
292 {
|
|
293 uint8_t i, g;
|
|
294
|
|
295 uint8_t sf_index = hDecoder->sf_index;
|
|
296
|
|
297 switch (ics->window_sequence) {
|
|
298 case ONLY_LONG_SEQUENCE:
|
|
299 case LONG_START_SEQUENCE:
|
|
300 case LONG_STOP_SEQUENCE:
|
|
301 ics->num_windows = 1;
|
|
302 ics->num_window_groups = 1;
|
|
303 ics->window_group_length[ics->num_window_groups-1] = 1;
|
|
304 #ifdef LD_DEC
|
|
305 if (hDecoder->object_type == LD)
|
|
306 {
|
|
307 if (hDecoder->frameLength == 512)
|
|
308 ics->num_swb = num_swb_512_window[sf_index];
|
|
309 else /* if (hDecoder->frameLength == 480) */
|
|
310 ics->num_swb = num_swb_480_window[sf_index];
|
|
311 } else {
|
|
312 #endif
|
|
313 if (hDecoder->frameLength == 1024)
|
|
314 ics->num_swb = num_swb_1024_window[sf_index];
|
|
315 else /* if (hDecoder->frameLength == 960) */
|
|
316 ics->num_swb = num_swb_960_window[sf_index];
|
|
317 #ifdef LD_DEC
|
|
318 }
|
|
319 #endif
|
|
320
|
|
321 /* preparation of sect_sfb_offset for long blocks */
|
|
322 /* also copy the last value! */
|
|
323 #ifdef LD_DEC
|
|
324 if (hDecoder->object_type == LD)
|
|
325 {
|
|
326 if (hDecoder->frameLength == 512)
|
|
327 {
|
|
328 for (i = 0; i < ics->num_swb; i++)
|
|
329 {
|
|
330 ics->sect_sfb_offset[0][i] = swb_offset_512_window[sf_index][i];
|
|
331 ics->swb_offset[i] = swb_offset_512_window[sf_index][i];
|
|
332 }
|
|
333 } else /* if (hDecoder->frameLength == 480) */ {
|
|
334 for (i = 0; i < ics->num_swb; i++)
|
|
335 {
|
|
336 ics->sect_sfb_offset[0][i] = swb_offset_480_window[sf_index][i];
|
|
337 ics->swb_offset[i] = swb_offset_480_window[sf_index][i];
|
|
338 }
|
|
339 }
|
|
340 ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
|
|
341 ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
|
|
342 } else {
|
|
343 #endif
|
|
344 for (i = 0; i < ics->num_swb; i++)
|
|
345 {
|
|
346 ics->sect_sfb_offset[0][i] = swb_offset_1024_window[sf_index][i];
|
|
347 ics->swb_offset[i] = swb_offset_1024_window[sf_index][i];
|
|
348 }
|
|
349 ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
|
|
350 ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
|
|
351 #ifdef LD_DEC
|
|
352 }
|
|
353 #endif
|
|
354 return 0;
|
|
355 case EIGHT_SHORT_SEQUENCE:
|
|
356 ics->num_windows = 8;
|
|
357 ics->num_window_groups = 1;
|
|
358 ics->window_group_length[ics->num_window_groups-1] = 1;
|
|
359 ics->num_swb = num_swb_128_window[sf_index];
|
|
360
|
|
361 for (i = 0; i < ics->num_swb; i++)
|
|
362 ics->swb_offset[i] = swb_offset_128_window[sf_index][i];
|
|
363 ics->swb_offset[ics->num_swb] = hDecoder->frameLength/8;
|
|
364
|
|
365 for (i = 0; i < ics->num_windows-1; i++) {
|
|
366 if (bit_set(ics->scale_factor_grouping, 6-i) == 0)
|
|
367 {
|
|
368 ics->num_window_groups += 1;
|
|
369 ics->window_group_length[ics->num_window_groups-1] = 1;
|
|
370 } else {
|
|
371 ics->window_group_length[ics->num_window_groups-1] += 1;
|
|
372 }
|
|
373 }
|
|
374
|
|
375 /* preparation of sect_sfb_offset for short blocks */
|
|
376 for (g = 0; g < ics->num_window_groups; g++)
|
|
377 {
|
|
378 uint16_t width;
|
|
379 uint8_t sect_sfb = 0;
|
|
380 uint16_t offset = 0;
|
|
381
|
|
382 for (i = 0; i < ics->num_swb; i++)
|
|
383 {
|
|
384 if (i+1 == ics->num_swb)
|
|
385 {
|
|
386 width = (hDecoder->frameLength/8) - swb_offset_128_window[sf_index][i];
|
|
387 } else {
|
|
388 width = swb_offset_128_window[sf_index][i+1] -
|
|
389 swb_offset_128_window[sf_index][i];
|
|
390 }
|
|
391 width *= ics->window_group_length[g];
|
|
392 ics->sect_sfb_offset[g][sect_sfb++] = offset;
|
|
393 offset += width;
|
|
394 }
|
|
395 ics->sect_sfb_offset[g][sect_sfb] = offset;
|
|
396 }
|
|
397 return 0;
|
|
398 default:
|
|
399 return 1;
|
|
400 }
|
|
401 }
|
|
402
|
|
403 /*
|
|
404 For ONLY_LONG_SEQUENCE windows (num_window_groups = 1,
|
|
405 window_group_length[0] = 1) the spectral data is in ascending spectral
|
|
406 order.
|
|
407 For the EIGHT_SHORT_SEQUENCE window, the spectral order depends on the
|
|
408 grouping in the following manner:
|
|
409 - Groups are ordered sequentially
|
|
410 - Within a group, a scalefactor band consists of the spectral data of all
|
|
411 grouped SHORT_WINDOWs for the associated scalefactor window band. To
|
|
412 clarify via example, the length of a group is in the range of one to eight
|
|
413 SHORT_WINDOWs.
|
|
414 - If there are eight groups each with length one (num_window_groups = 8,
|
|
415 window_group_length[0..7] = 1), the result is a sequence of eight spectra,
|
|
416 each in ascending spectral order.
|
|
417 - If there is only one group with length eight (num_window_groups = 1,
|
|
418 window_group_length[0] = 8), the result is that spectral data of all eight
|
|
419 SHORT_WINDOWs is interleaved by scalefactor window bands.
|
|
420 - Within a scalefactor window band, the coefficients are in ascending
|
|
421 spectral order.
|
|
422 */
|
|
423 static void quant_to_spec(ic_stream *ics, real_t *spec_data, uint16_t frame_len)
|
|
424 {
|
|
425 uint8_t g, sfb, win;
|
|
426 uint16_t width, bin, k, gindex;
|
|
427
|
|
428 real_t tmp_spec[1024] = {0};
|
|
429
|
|
430 k = 0;
|
|
431 gindex = 0;
|
|
432
|
|
433 for (g = 0; g < ics->num_window_groups; g++)
|
|
434 {
|
|
435 uint16_t j = 0;
|
|
436 uint16_t gincrease = 0;
|
|
437 uint16_t win_inc = ics->swb_offset[ics->num_swb];
|
|
438
|
|
439 for (sfb = 0; sfb < ics->num_swb; sfb++)
|
|
440 {
|
|
441 width = ics->swb_offset[sfb+1] - ics->swb_offset[sfb];
|
|
442
|
|
443 for (win = 0; win < ics->window_group_length[g]; win++)
|
|
444 {
|
|
445 for (bin = 0; bin < width; bin += 4)
|
|
446 {
|
|
447 tmp_spec[gindex+(win*win_inc)+j+bin+0] = spec_data[k+0];
|
|
448 tmp_spec[gindex+(win*win_inc)+j+bin+1] = spec_data[k+1];
|
|
449 tmp_spec[gindex+(win*win_inc)+j+bin+2] = spec_data[k+2];
|
|
450 tmp_spec[gindex+(win*win_inc)+j+bin+3] = spec_data[k+3];
|
|
451 gincrease += 4;
|
|
452 k += 4;
|
|
453 }
|
|
454 }
|
|
455 j += width;
|
|
456 }
|
|
457 gindex += gincrease;
|
|
458 }
|
|
459
|
|
460 memcpy(spec_data, tmp_spec, frame_len*sizeof(real_t));
|
|
461 }
|
|
462
|
|
463 #ifndef FIXED_POINT
|
|
464 void build_tables(real_t *pow2_table)
|
|
465 {
|
|
466 uint16_t i;
|
|
467
|
|
468 /* build pow(2, 0.25*x) table for scalefactors */
|
|
469 for(i = 0; i < POW_TABLE_SIZE; i++)
|
|
470 {
|
|
471 pow2_table[i] = REAL_CONST(pow(2.0, 0.25 * (i-100)));
|
|
472 }
|
|
473 }
|
|
474 #endif
|
|
475
|
|
476 static INLINE real_t iquant(int16_t q, real_t *tab)
|
|
477 {
|
|
478 #ifdef FIXED_POINT
|
|
479 static const real_t errcorr[] = {
|
|
480 REAL_CONST(0), REAL_CONST(1.0/8.0), REAL_CONST(2.0/8.0), REAL_CONST(3.0/8.0),
|
|
481 REAL_CONST(4.0/8.0), REAL_CONST(5.0/8.0), REAL_CONST(6.0/8.0), REAL_CONST(7.0/8.0),
|
|
482 REAL_CONST(0)
|
|
483 };
|
|
484 real_t x1, x2;
|
|
485 int16_t sgn = 1;
|
|
486
|
|
487 if (q < 0)
|
|
488 {
|
|
489 q = -q;
|
|
490 sgn = -1;
|
|
491 }
|
|
492
|
|
493 if (q < IQ_TABLE_SIZE)
|
|
494 return sgn * tab[q];
|
|
495
|
|
496 /* linear interpolation */
|
|
497 x1 = tab[q>>3];
|
|
498 x2 = tab[(q>>3) + 1];
|
|
499 return sgn * 16 * (MUL_R(errcorr[q&7],(x2-x1)) + x1);
|
|
500 #else
|
|
501 real_t sgn = REAL_CONST(1.0);
|
|
502
|
|
503 if (q < 0)
|
|
504 {
|
|
505 q = -q;
|
|
506 sgn = REAL_CONST(-1.0);
|
|
507 }
|
|
508
|
|
509 if (q < IQ_TABLE_SIZE)
|
|
510 return sgn * tab[q];
|
|
511
|
|
512 return sgn * (real_t)pow(q, 4.0/3.0);
|
|
513 #endif
|
|
514 }
|
|
515
|
|
516 static void inverse_quantization(real_t *x_invquant, int16_t *x_quant, uint16_t frame_len)
|
|
517 {
|
|
518 int16_t i;
|
|
519 real_t *tab = iq_table;
|
|
520
|
|
521 for(i = 0; i < frame_len; i+=4)
|
|
522 {
|
|
523 x_invquant[i] = iquant(x_quant[i], tab);
|
|
524 x_invquant[i+1] = iquant(x_quant[i+1], tab);
|
|
525 x_invquant[i+2] = iquant(x_quant[i+2], tab);
|
|
526 x_invquant[i+3] = iquant(x_quant[i+3], tab);
|
|
527 }
|
|
528 }
|
|
529
|
|
530 #ifndef FIXED_POINT
|
|
531 static INLINE real_t get_scale_factor_gain(uint16_t scale_factor, real_t *pow2_table)
|
|
532 {
|
|
533 if (scale_factor < POW_TABLE_SIZE)
|
|
534 return pow2_table[scale_factor];
|
|
535 else
|
|
536 return REAL_CONST(pow(2.0, 0.25 * (scale_factor - 100)));
|
|
537 }
|
|
538 #else
|
|
539 static real_t pow2_table[] =
|
|
540 {
|
|
541 COEF_CONST(0.59460355750136053335874998528024), /* 2^-0.75 */
|
|
542 COEF_CONST(0.70710678118654752440084436210485), /* 2^-0.5 */
|
|
543 COEF_CONST(0.84089641525371454303112547623321), /* 2^-0.25 */
|
|
544 COEF_CONST(1.0),
|
|
545 COEF_CONST(1.1892071150027210667174999705605), /* 2^0.25 */
|
|
546 COEF_CONST(1.4142135623730950488016887242097), /* 2^0.5 */
|
|
547 COEF_CONST(1.6817928305074290860622509524664) /* 2^0.75 */
|
|
548 };
|
|
549 #endif
|
|
550
|
|
551 static void apply_scalefactors(faacDecHandle hDecoder, ic_stream *ics,
|
|
552 real_t *x_invquant, uint16_t frame_len)
|
|
553 {
|
|
554 uint8_t g, sfb;
|
|
555 uint16_t top;
|
|
556 #ifndef FIXED_POINT
|
|
557 real_t scale;
|
|
558 #else
|
|
559 int32_t exp, frac;
|
|
560 #endif
|
|
561 uint8_t groups = 0;
|
|
562 uint16_t nshort = frame_len/8;
|
|
563
|
|
564 for (g = 0; g < ics->num_window_groups; g++)
|
|
565 {
|
|
566 uint16_t k = 0;
|
|
567
|
|
568 /* using this nshort*groups doesn't hurt long blocks, because
|
|
569 long blocks only have 1 group, so that means 'groups' is
|
|
570 always 0 for long blocks
|
|
571 */
|
|
572 for (sfb = 0; sfb < ics->max_sfb; sfb++)
|
|
573 {
|
|
574 top = ics->sect_sfb_offset[g][sfb+1];
|
|
575
|
|
576 #ifndef FIXED_POINT
|
|
577 scale = get_scale_factor_gain(ics->scale_factors[g][sfb], hDecoder->pow2_table);
|
|
578 #else
|
|
579 exp = (ics->scale_factors[g][sfb] - 100) / 4;
|
|
580 frac = (ics->scale_factors[g][sfb] - 100) % 4;
|
|
581
|
|
582 /* IMDCT pre-scaling */
|
|
583 if (hDecoder->object_type == LD)
|
|
584 {
|
|
585 exp -= 6 /*9*/;
|
|
586 } else {
|
|
587 if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
|
|
588 exp -= 4 /*7*/;
|
|
589 else
|
|
590 exp -= 7 /*10*/;
|
|
591 }
|
|
592 #if (REAL_BITS == 16)
|
|
593 exp--;
|
|
594 #endif
|
|
595 #endif
|
|
596
|
|
597 /* minimum size of a sf band is 4 and always a multiple of 4 */
|
|
598 for ( ; k < top; k += 4)
|
|
599 {
|
|
600 #ifndef FIXED_POINT
|
|
601 x_invquant[k+(groups*nshort)] = x_invquant[k+(groups*nshort)] * scale;
|
|
602 x_invquant[k+(groups*nshort)+1] = x_invquant[k+(groups*nshort)+1] * scale;
|
|
603 x_invquant[k+(groups*nshort)+2] = x_invquant[k+(groups*nshort)+2] * scale;
|
|
604 x_invquant[k+(groups*nshort)+3] = x_invquant[k+(groups*nshort)+3] * scale;
|
|
605 #else
|
|
606 if (exp < 0)
|
|
607 {
|
|
608 x_invquant[k+(groups*nshort)] >>= -exp;
|
|
609 x_invquant[k+(groups*nshort)+1] >>= -exp;
|
|
610 x_invquant[k+(groups*nshort)+2] >>= -exp;
|
|
611 x_invquant[k+(groups*nshort)+3] >>= -exp;
|
|
612 } else {
|
|
613 x_invquant[k+(groups*nshort)] <<= exp;
|
|
614 x_invquant[k+(groups*nshort)+1] <<= exp;
|
|
615 x_invquant[k+(groups*nshort)+2] <<= exp;
|
|
616 x_invquant[k+(groups*nshort)+3] <<= exp;
|
|
617 }
|
|
618
|
|
619 if (frac)
|
|
620 {
|
|
621 x_invquant[k+(groups*nshort)] = MUL_C(x_invquant[k+(groups*nshort)],pow2_table[frac + 3]);
|
|
622 x_invquant[k+(groups*nshort)+1] = MUL_C(x_invquant[k+(groups*nshort)+1],pow2_table[frac + 3]);
|
|
623 x_invquant[k+(groups*nshort)+2] = MUL_C(x_invquant[k+(groups*nshort)+2],pow2_table[frac + 3]);
|
|
624 x_invquant[k+(groups*nshort)+3] = MUL_C(x_invquant[k+(groups*nshort)+3],pow2_table[frac + 3]);
|
|
625 }
|
|
626 #endif
|
|
627 }
|
|
628 }
|
|
629 groups += ics->window_group_length[g];
|
|
630 }
|
|
631 }
|
|
632
|
|
633 void reconstruct_single_channel(faacDecHandle hDecoder, ic_stream *ics,
|
|
634 element *sce, int16_t *spec_data)
|
|
635 {
|
|
636 real_t spec_coef[1024];
|
|
637
|
|
638 /* inverse quantization */
|
|
639 inverse_quantization(spec_coef, spec_data, hDecoder->frameLength);
|
|
640
|
|
641 /* apply scalefactors */
|
|
642 apply_scalefactors(hDecoder, ics, spec_coef, hDecoder->frameLength);
|
|
643
|
|
644 /* deinterleave short block grouping */
|
|
645 if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
|
|
646 quant_to_spec(ics, spec_coef, hDecoder->frameLength);
|
|
647
|
|
648
|
|
649 /* pns decoding */
|
|
650 pns_decode(ics, NULL, spec_coef, NULL, hDecoder->frameLength, 0, hDecoder->object_type);
|
|
651
|
|
652 #ifdef MAIN_DEC
|
|
653 /* MAIN object type prediction */
|
|
654 if (hDecoder->object_type == MAIN)
|
|
655 {
|
|
656 /* allocate the state only when needed */
|
|
657 if (hDecoder->pred_stat[sce->channel] == NULL)
|
|
658 {
|
|
659 hDecoder->pred_stat[sce->channel] = (pred_state*)malloc(hDecoder->frameLength * sizeof(pred_state));
|
|
660 reset_all_predictors(hDecoder->pred_stat[sce->channel], hDecoder->frameLength);
|
|
661 }
|
|
662
|
|
663 /* intra channel prediction */
|
|
664 ic_prediction(ics, spec_coef, hDecoder->pred_stat[sce->channel], hDecoder->frameLength,
|
|
665 hDecoder->sf_index);
|
|
666
|
|
667 /* In addition, for scalefactor bands coded by perceptual
|
|
668 noise substitution the predictors belonging to the
|
|
669 corresponding spectral coefficients are reset.
|
|
670 */
|
|
671 pns_reset_pred_state(ics, hDecoder->pred_stat[sce->channel]);
|
|
672 }
|
|
673 #endif
|
|
674
|
|
675 #ifdef LTP_DEC
|
|
676 if (is_ltp_ot(hDecoder->object_type))
|
|
677 {
|
|
678 #ifdef LD_DEC
|
|
679 if (hDecoder->object_type == LD)
|
|
680 {
|
|
681 if (ics->ltp.data_present)
|
|
682 {
|
|
683 if (ics->ltp.lag_update)
|
|
684 hDecoder->ltp_lag[sce->channel] = ics->ltp.lag;
|
|
685 }
|
|
686 ics->ltp.lag = hDecoder->ltp_lag[sce->channel];
|
|
687 }
|
|
688 #endif
|
|
689
|
|
690 /* allocate the state only when needed */
|
|
691 if (hDecoder->lt_pred_stat[sce->channel] == NULL)
|
|
692 {
|
|
693 hDecoder->lt_pred_stat[sce->channel] = (int16_t*)malloc(hDecoder->frameLength*4 * sizeof(int16_t));
|
|
694 memset(hDecoder->lt_pred_stat[sce->channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
|
|
695 }
|
|
696
|
|
697 /* long term prediction */
|
|
698 lt_prediction(ics, &(ics->ltp), spec_coef, hDecoder->lt_pred_stat[sce->channel], hDecoder->fb,
|
|
699 ics->window_shape, hDecoder->window_shape_prev[sce->channel],
|
|
700 hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
|
|
701 }
|
|
702 #endif
|
|
703
|
|
704 /* tns decoding */
|
|
705 tns_decode_frame(ics, &(ics->tns), hDecoder->sf_index, hDecoder->object_type,
|
|
706 spec_coef, hDecoder->frameLength);
|
|
707
|
|
708 /* drc decoding */
|
|
709 if (hDecoder->drc->present)
|
|
710 {
|
|
711 if (!hDecoder->drc->exclude_mask[sce->channel] || !hDecoder->drc->excluded_chns_present)
|
|
712 drc_decode(hDecoder->drc, spec_coef);
|
|
713 }
|
|
714
|
|
715 if (hDecoder->time_out[sce->channel] == NULL)
|
|
716 {
|
|
717 hDecoder->time_out[sce->channel] = (real_t*)malloc(hDecoder->frameLength*2*sizeof(real_t));
|
|
718 memset(hDecoder->time_out[sce->channel], 0, hDecoder->frameLength*2*sizeof(real_t));
|
|
719 }
|
|
720
|
|
721 /* filter bank */
|
|
722 #ifdef SSR_DEC
|
|
723 if (hDecoder->object_type != SSR)
|
|
724 {
|
|
725 #endif
|
|
726 ifilter_bank(hDecoder->fb, ics->window_sequence, ics->window_shape,
|
|
727 hDecoder->window_shape_prev[sce->channel], spec_coef,
|
|
728 hDecoder->time_out[sce->channel], hDecoder->object_type, hDecoder->frameLength);
|
|
729 #ifdef SSR_DEC
|
|
730 } else {
|
|
731 if (hDecoder->ssr_overlap[sce->channel] == NULL)
|
|
732 {
|
|
733 hDecoder->ssr_overlap[sce->channel] = (real_t*)malloc(2*hDecoder->frameLength*sizeof(real_t));
|
|
734 memset(hDecoder->ssr_overlap[sce->channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
|
|
735 }
|
|
736 if (hDecoder->prev_fmd[sce->channel] == NULL)
|
|
737 {
|
|
738 uint16_t k;
|
|
739 hDecoder->prev_fmd[sce->channel] = (real_t*)malloc(2*hDecoder->frameLength*sizeof(real_t));
|
|
740 for (k = 0; k < 2*hDecoder->frameLength; k++)
|
|
741 hDecoder->prev_fmd[sce->channel][k] = REAL_CONST(-1);
|
|
742 }
|
|
743
|
|
744 ssr_decode(&(ics->ssr), hDecoder->fb, ics->window_sequence, ics->window_shape,
|
|
745 hDecoder->window_shape_prev[sce->channel], spec_coef, hDecoder->time_out[sce->channel],
|
|
746 hDecoder->ssr_overlap[sce->channel], hDecoder->ipqf_buffer[sce->channel], hDecoder->prev_fmd[sce->channel],
|
|
747 hDecoder->frameLength);
|
|
748 }
|
|
749 #endif
|
|
750
|
|
751 /* save window shape for next frame */
|
|
752 hDecoder->window_shape_prev[sce->channel] = ics->window_shape;
|
|
753
|
|
754 #ifdef LTP_DEC
|
|
755 if (is_ltp_ot(hDecoder->object_type))
|
|
756 {
|
|
757 lt_update_state(hDecoder->lt_pred_stat[sce->channel], hDecoder->time_out[sce->channel],
|
|
758 hDecoder->time_out[sce->channel]+hDecoder->frameLength, hDecoder->frameLength, hDecoder->object_type);
|
|
759 }
|
|
760 #endif
|
|
761 }
|
|
762
|
|
763 void reconstruct_channel_pair(faacDecHandle hDecoder, ic_stream *ics1, ic_stream *ics2,
|
|
764 element *cpe, int16_t *spec_data1, int16_t *spec_data2)
|
|
765 {
|
|
766 real_t spec_coef1[1024];
|
|
767 real_t spec_coef2[1024];
|
|
768
|
|
769 /* inverse quantization */
|
|
770 inverse_quantization(spec_coef1, spec_data1, hDecoder->frameLength);
|
|
771 inverse_quantization(spec_coef2, spec_data2, hDecoder->frameLength);
|
|
772
|
|
773 /* apply scalefactors */
|
|
774 apply_scalefactors(hDecoder, ics1, spec_coef1, hDecoder->frameLength);
|
|
775 apply_scalefactors(hDecoder, ics2, spec_coef2, hDecoder->frameLength);
|
|
776
|
|
777 /* deinterleave short block grouping */
|
|
778 if (ics1->window_sequence == EIGHT_SHORT_SEQUENCE)
|
|
779 quant_to_spec(ics1, spec_coef1, hDecoder->frameLength);
|
|
780 if (ics2->window_sequence == EIGHT_SHORT_SEQUENCE)
|
|
781 quant_to_spec(ics2, spec_coef2, hDecoder->frameLength);
|
|
782
|
|
783
|
|
784 /* pns decoding */
|
|
785 if (ics1->ms_mask_present)
|
|
786 {
|
|
787 pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 1, hDecoder->object_type);
|
|
788 } else {
|
|
789 pns_decode(ics1, NULL, spec_coef1, NULL, hDecoder->frameLength, 0, hDecoder->object_type);
|
|
790 pns_decode(ics2, NULL, spec_coef2, NULL, hDecoder->frameLength, 0, hDecoder->object_type);
|
|
791 }
|
|
792
|
|
793 /* mid/side decoding */
|
|
794 ms_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength);
|
|
795
|
|
796 /* intensity stereo decoding */
|
|
797 is_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength);
|
|
798
|
|
799 #ifdef MAIN_DEC
|
|
800 /* MAIN object type prediction */
|
|
801 if (hDecoder->object_type == MAIN)
|
|
802 {
|
|
803 /* allocate the state only when needed */
|
|
804 if (hDecoder->pred_stat[cpe->channel] == NULL)
|
|
805 {
|
|
806 hDecoder->pred_stat[cpe->channel] = (pred_state*)malloc(hDecoder->frameLength * sizeof(pred_state));
|
|
807 reset_all_predictors(hDecoder->pred_stat[cpe->channel], hDecoder->frameLength);
|
|
808 }
|
|
809 if (hDecoder->pred_stat[cpe->paired_channel] == NULL)
|
|
810 {
|
|
811 hDecoder->pred_stat[cpe->paired_channel] = (pred_state*)malloc(hDecoder->frameLength * sizeof(pred_state));
|
|
812 reset_all_predictors(hDecoder->pred_stat[cpe->paired_channel], hDecoder->frameLength);
|
|
813 }
|
|
814
|
|
815 /* intra channel prediction */
|
|
816 ic_prediction(ics1, spec_coef1, hDecoder->pred_stat[cpe->channel], hDecoder->frameLength,
|
|
817 hDecoder->sf_index);
|
|
818 ic_prediction(ics2, spec_coef2, hDecoder->pred_stat[cpe->paired_channel], hDecoder->frameLength,
|
|
819 hDecoder->sf_index);
|
|
820
|
|
821 /* In addition, for scalefactor bands coded by perceptual
|
|
822 noise substitution the predictors belonging to the
|
|
823 corresponding spectral coefficients are reset.
|
|
824 */
|
|
825 pns_reset_pred_state(ics1, hDecoder->pred_stat[cpe->channel]);
|
|
826 pns_reset_pred_state(ics2, hDecoder->pred_stat[cpe->paired_channel]);
|
|
827 }
|
|
828 #endif
|
|
829
|
|
830 #ifdef LTP_DEC
|
|
831 if (is_ltp_ot(hDecoder->object_type))
|
|
832 {
|
|
833 ltp_info *ltp1 = &(ics1->ltp);
|
|
834 ltp_info *ltp2 = (cpe->common_window) ? &(ics2->ltp2) : &(ics2->ltp) ;
|
|
835 #ifdef LD_DEC
|
|
836 if (hDecoder->object_type == LD)
|
|
837 {
|
|
838 if (ltp1->data_present)
|
|
839 {
|
|
840 if (ltp1->lag_update)
|
|
841 hDecoder->ltp_lag[cpe->channel] = ltp1->lag;
|
|
842 }
|
|
843 ltp1->lag = hDecoder->ltp_lag[cpe->channel];
|
|
844 if (ltp2->data_present)
|
|
845 {
|
|
846 if (ltp2->lag_update)
|
|
847 hDecoder->ltp_lag[cpe->paired_channel] = ltp2->lag;
|
|
848 }
|
|
849 ltp2->lag = hDecoder->ltp_lag[cpe->paired_channel];
|
|
850 }
|
|
851 #endif
|
|
852
|
|
853 /* allocate the state only when needed */
|
|
854 if (hDecoder->lt_pred_stat[cpe->channel] == NULL)
|
|
855 {
|
|
856 hDecoder->lt_pred_stat[cpe->channel] = (int16_t*)malloc(hDecoder->frameLength*4 * sizeof(int16_t));
|
|
857 memset(hDecoder->lt_pred_stat[cpe->channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
|
|
858 }
|
|
859 if (hDecoder->lt_pred_stat[cpe->paired_channel] == NULL)
|
|
860 {
|
|
861 hDecoder->lt_pred_stat[cpe->paired_channel] = (int16_t*)malloc(hDecoder->frameLength*4 * sizeof(int16_t));
|
|
862 memset(hDecoder->lt_pred_stat[cpe->paired_channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
|
|
863 }
|
|
864
|
|
865 /* long term prediction */
|
|
866 lt_prediction(ics1, ltp1, spec_coef1, hDecoder->lt_pred_stat[cpe->channel], hDecoder->fb,
|
|
867 ics1->window_shape, hDecoder->window_shape_prev[cpe->channel],
|
|
868 hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
|
|
869 lt_prediction(ics2, ltp2, spec_coef2, hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->fb,
|
|
870 ics2->window_shape, hDecoder->window_shape_prev[cpe->paired_channel],
|
|
871 hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
|
|
872 }
|
|
873 #endif
|
|
874
|
|
875 /* tns decoding */
|
|
876 tns_decode_frame(ics1, &(ics1->tns), hDecoder->sf_index, hDecoder->object_type,
|
|
877 spec_coef1, hDecoder->frameLength);
|
|
878 tns_decode_frame(ics2, &(ics2->tns), hDecoder->sf_index, hDecoder->object_type,
|
|
879 spec_coef2, hDecoder->frameLength);
|
|
880
|
|
881 /* drc decoding */
|
|
882 if (hDecoder->drc->present)
|
|
883 {
|
|
884 if (!hDecoder->drc->exclude_mask[cpe->channel] || !hDecoder->drc->excluded_chns_present)
|
|
885 drc_decode(hDecoder->drc, spec_coef1);
|
|
886 if (!hDecoder->drc->exclude_mask[cpe->paired_channel] || !hDecoder->drc->excluded_chns_present)
|
|
887 drc_decode(hDecoder->drc, spec_coef2);
|
|
888 }
|
|
889
|
|
890 if (hDecoder->time_out[cpe->channel] == NULL)
|
|
891 {
|
|
892 hDecoder->time_out[cpe->channel] = (real_t*)malloc(hDecoder->frameLength*2*sizeof(real_t));
|
|
893 memset(hDecoder->time_out[cpe->channel], 0, hDecoder->frameLength*2*sizeof(real_t));
|
|
894 }
|
|
895 if (hDecoder->time_out[cpe->paired_channel] == NULL)
|
|
896 {
|
|
897 hDecoder->time_out[cpe->paired_channel] = (real_t*)malloc(hDecoder->frameLength*2*sizeof(real_t));
|
|
898 memset(hDecoder->time_out[cpe->paired_channel], 0, hDecoder->frameLength*2*sizeof(real_t));
|
|
899 }
|
|
900
|
|
901 /* filter bank */
|
|
902 #ifdef SSR_DEC
|
|
903 if (hDecoder->object_type != SSR)
|
|
904 {
|
|
905 #endif
|
|
906 ifilter_bank(hDecoder->fb, ics1->window_sequence, ics1->window_shape,
|
|
907 hDecoder->window_shape_prev[cpe->channel], spec_coef1,
|
|
908 hDecoder->time_out[cpe->channel], hDecoder->object_type, hDecoder->frameLength);
|
|
909 ifilter_bank(hDecoder->fb, ics2->window_sequence, ics2->window_shape,
|
|
910 hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2,
|
|
911 hDecoder->time_out[cpe->paired_channel], hDecoder->object_type, hDecoder->frameLength);
|
|
912 #ifdef SSR_DEC
|
|
913 } else {
|
|
914 if (hDecoder->ssr_overlap[cpe->channel] == NULL)
|
|
915 {
|
|
916 hDecoder->ssr_overlap[cpe->channel] = (real_t*)malloc(2*hDecoder->frameLength*sizeof(real_t));
|
|
917 memset(hDecoder->ssr_overlap[cpe->channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
|
|
918 }
|
|
919 if (hDecoder->ssr_overlap[cpe->paired_channel] == NULL)
|
|
920 {
|
|
921 hDecoder->ssr_overlap[cpe->paired_channel] = (real_t*)malloc(2*hDecoder->frameLength*sizeof(real_t));
|
|
922 memset(hDecoder->ssr_overlap[cpe->paired_channel], 0, 2*hDecoder->frameLength*sizeof(real_t));
|
|
923 }
|
|
924 if (hDecoder->prev_fmd[cpe->channel] == NULL)
|
|
925 {
|
|
926 uint16_t k;
|
|
927 hDecoder->prev_fmd[cpe->channel] = (real_t*)malloc(2*hDecoder->frameLength*sizeof(real_t));
|
|
928 for (k = 0; k < 2*hDecoder->frameLength; k++)
|
|
929 hDecoder->prev_fmd[cpe->channel][k] = REAL_CONST(-1);
|
|
930 }
|
|
931 if (hDecoder->prev_fmd[cpe->paired_channel] == NULL)
|
|
932 {
|
|
933 uint16_t k;
|
|
934 hDecoder->prev_fmd[cpe->paired_channel] = (real_t*)malloc(2*hDecoder->frameLength*sizeof(real_t));
|
|
935 for (k = 0; k < 2*hDecoder->frameLength; k++)
|
|
936 hDecoder->prev_fmd[cpe->paired_channel][k] = REAL_CONST(-1);
|
|
937 }
|
|
938
|
|
939 ssr_decode(&(ics1->ssr), hDecoder->fb, ics1->window_sequence, ics1->window_shape,
|
|
940 hDecoder->window_shape_prev[cpe->channel], spec_coef1, hDecoder->time_out[cpe->channel],
|
|
941 hDecoder->ssr_overlap[cpe->channel], hDecoder->ipqf_buffer[cpe->channel],
|
|
942 hDecoder->prev_fmd[cpe->channel], hDecoder->frameLength);
|
|
943 ssr_decode(&(ics2->ssr), hDecoder->fb, ics2->window_sequence, ics2->window_shape,
|
|
944 hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2, hDecoder->time_out[cpe->paired_channel],
|
|
945 hDecoder->ssr_overlap[cpe->paired_channel], hDecoder->ipqf_buffer[cpe->paired_channel],
|
|
946 hDecoder->prev_fmd[cpe->paired_channel], hDecoder->frameLength);
|
|
947 }
|
|
948 #endif
|
|
949
|
|
950 /* save window shape for next frame */
|
|
951 hDecoder->window_shape_prev[cpe->channel] = ics1->window_shape;
|
|
952 hDecoder->window_shape_prev[cpe->paired_channel] = ics2->window_shape;
|
|
953
|
|
954 #ifdef LTP_DEC
|
|
955 if (is_ltp_ot(hDecoder->object_type))
|
|
956 {
|
|
957 lt_update_state(hDecoder->lt_pred_stat[cpe->channel], hDecoder->time_out[cpe->channel],
|
|
958 hDecoder->time_out[cpe->channel]+hDecoder->frameLength, hDecoder->frameLength, hDecoder->object_type);
|
|
959 lt_update_state(hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->time_out[cpe->paired_channel],
|
|
960 hDecoder->time_out[cpe->paired_channel]+hDecoder->frameLength, hDecoder->frameLength,
|
|
961 hDecoder->object_type);
|
|
962 }
|
|
963 #endif
|
|
964 }
|