Coverage Report

Created: 2025-07-23 06:30

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