Coverage Report

Created: 2025-07-18 06:36

/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
482k
#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
697k
{
304
697k
    uint8_t i, g;
305
306
697k
    uint8_t sf_index = hDecoder->sf_index;
307
308
697k
    if (sf_index >= 12)
309
10
        return 32;
310
311
697k
    switch (ics->window_sequence) {
312
583k
    case ONLY_LONG_SEQUENCE:
313
615k
    case LONG_START_SEQUENCE:
314
628k
    case LONG_STOP_SEQUENCE:
315
628k
        ics->num_windows = 1;
316
628k
        ics->num_window_groups = 1;
317
628k
        ics->window_group_length[ics->num_window_groups-1] = 1;
318
#ifdef LD_DEC
319
473k
        if (hDecoder->object_type == LD)
320
4.47k
        {
321
4.47k
            if (hDecoder->frameLength == 512)
322
2.23k
                ics->num_swb = num_swb_512_window[sf_index];
323
2.23k
            else /* if (hDecoder->frameLength == 480) */
324
2.23k
                ics->num_swb = num_swb_480_window[sf_index];
325
468k
        } else {
326
468k
#endif
327
623k
            if (hDecoder->frameLength == 1024)
328
528k
                ics->num_swb = num_swb_1024_window[sf_index];
329
95.4k
            else /* if (hDecoder->frameLength == 960) */
330
95.4k
                ics->num_swb = num_swb_960_window[sf_index];
331
#ifdef LD_DEC
332
        }
333
#endif
334
335
628k
        if (ics->max_sfb > ics->num_swb)
336
283
        {
337
283
            return 32;
338
283
        }
339
340
        /* preparation of sect_sfb_offset for long blocks */
341
        /* also copy the last value! */
342
#ifdef LD_DEC
343
472k
        if (hDecoder->object_type == LD)
344
4.46k
        {
345
4.46k
            if (hDecoder->frameLength == 512)
346
2.23k
            {
347
60.1k
                for (i = 0; i < ics->num_swb; i++)
348
57.8k
                {
349
57.8k
                    ics->sect_sfb_offset[0][i] = swb_offset_512_window[sf_index][i];
350
57.8k
                    ics->swb_offset[i] = swb_offset_512_window[sf_index][i];
351
57.8k
                }
352
2.23k
            } else /* if (hDecoder->frameLength == 480) */ {
353
68.0k
                for (i = 0; i < ics->num_swb; i++)
354
65.7k
                {
355
65.7k
                    ics->sect_sfb_offset[0][i] = swb_offset_480_window[sf_index][i];
356
65.7k
                    ics->swb_offset[i] = swb_offset_480_window[sf_index][i];
357
65.7k
                }
358
2.23k
            }
359
4.46k
            ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
360
4.46k
            ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
361
4.46k
            ics->swb_offset_max = hDecoder->frameLength;
362
468k
        } else {
363
468k
#endif
364
27.0M
            for (i = 0; i < ics->num_swb; i++)
365
26.4M
            {
366
26.4M
                ics->sect_sfb_offset[0][i] = swb_offset_1024_window[sf_index][i];
367
26.4M
                ics->swb_offset[i] = swb_offset_1024_window[sf_index][i];
368
26.4M
            }
369
154k
            ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
370
154k
            ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
371
154k
            ics->swb_offset_max = hDecoder->frameLength;
372
#ifdef LD_DEC
373
        }
374
#endif
375
154k
        return 0;
376
69.0k
    case EIGHT_SHORT_SEQUENCE:
377
69.0k
        ics->num_windows = 8;
378
69.0k
        ics->num_window_groups = 1;
379
69.0k
        ics->window_group_length[ics->num_window_groups-1] = 1;
380
69.0k
        ics->num_swb = num_swb_128_window[sf_index];
381
382
69.0k
        if (ics->max_sfb > ics->num_swb)
383
18
        {
384
18
            return 32;
385
18
        }
386
387
1.02M
        for (i = 0; i < ics->num_swb; i++)
388
953k
            ics->swb_offset[i] = swb_offset_128_window[sf_index][i];
389
68.9k
        ics->swb_offset[ics->num_swb] = hDecoder->frameLength/8;
390
68.9k
        ics->swb_offset_max = hDecoder->frameLength/8;
391
392
551k
        for (i = 0; i < ics->num_windows-1; i++) {
393
482k
            if (bit_set(ics->scale_factor_grouping, 6-i) == 0)
394
397k
            {
395
397k
                ics->num_window_groups += 1;
396
397k
                ics->window_group_length[ics->num_window_groups-1] = 1;
397
397k
            } else {
398
85.6k
                ics->window_group_length[ics->num_window_groups-1] += 1;
399
85.6k
            }
400
482k
        }
401
402
        /* preparation of sect_sfb_offset for short blocks */
403
535k
        for (g = 0; g < ics->num_window_groups; g++)
404
466k
        {
405
466k
            uint16_t width;
406
466k
            uint8_t sect_sfb = 0;
407
466k
            uint16_t offset = 0;
408
409
6.90M
            for (i = 0; i < ics->num_swb; i++)
410
6.43M
            {
411
6.43M
                if (i+1 == ics->num_swb)
412
466k
                {
413
466k
                    width = (hDecoder->frameLength/8) - swb_offset_128_window[sf_index][i];
414
5.97M
                } else {
415
5.97M
                    width = swb_offset_128_window[sf_index][i+1] -
416
5.97M
                        swb_offset_128_window[sf_index][i];
417
5.97M
                }
418
6.43M
                width *= ics->window_group_length[g];
419
6.43M
                ics->sect_sfb_offset[g][sect_sfb++] = offset;
420
6.43M
                offset += width;
421
6.43M
            }
422
466k
            ics->sect_sfb_offset[g][sect_sfb] = offset;
423
466k
        }
424
68.9k
        return 0;
425
0
    default:
426
0
        return 32;
427
697k
    }
428
697k
}
window_grouping_info
Line
Count
Source
303
182k
{
304
182k
    uint8_t i, g;
305
306
182k
    uint8_t sf_index = hDecoder->sf_index;
307
308
182k
    if (sf_index >= 12)
309
3
        return 32;
310
311
182k
    switch (ics->window_sequence) {
312
140k
    case ONLY_LONG_SEQUENCE:
313
149k
    case LONG_START_SEQUENCE:
314
154k
    case LONG_STOP_SEQUENCE:
315
154k
        ics->num_windows = 1;
316
154k
        ics->num_window_groups = 1;
317
154k
        ics->window_group_length[ics->num_window_groups-1] = 1;
318
#ifdef LD_DEC
319
        if (hDecoder->object_type == LD)
320
        {
321
            if (hDecoder->frameLength == 512)
322
                ics->num_swb = num_swb_512_window[sf_index];
323
            else /* if (hDecoder->frameLength == 480) */
324
                ics->num_swb = num_swb_480_window[sf_index];
325
        } else {
326
#endif
327
154k
            if (hDecoder->frameLength == 1024)
328
122k
                ics->num_swb = num_swb_1024_window[sf_index];
329
32.1k
            else /* if (hDecoder->frameLength == 960) */
330
32.1k
                ics->num_swb = num_swb_960_window[sf_index];
331
#ifdef LD_DEC
332
        }
333
#endif
334
335
154k
        if (ics->max_sfb > ics->num_swb)
336
83
        {
337
83
            return 32;
338
83
        }
339
340
        /* preparation of sect_sfb_offset for long blocks */
341
        /* also copy the last value! */
342
#ifdef LD_DEC
343
        if (hDecoder->object_type == LD)
344
        {
345
            if (hDecoder->frameLength == 512)
346
            {
347
                for (i = 0; i < ics->num_swb; i++)
348
                {
349
                    ics->sect_sfb_offset[0][i] = swb_offset_512_window[sf_index][i];
350
                    ics->swb_offset[i] = swb_offset_512_window[sf_index][i];
351
                }
352
            } else /* if (hDecoder->frameLength == 480) */ {
353
                for (i = 0; i < ics->num_swb; i++)
354
                {
355
                    ics->sect_sfb_offset[0][i] = swb_offset_480_window[sf_index][i];
356
                    ics->swb_offset[i] = swb_offset_480_window[sf_index][i];
357
                }
358
            }
359
            ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
360
            ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
361
            ics->swb_offset_max = hDecoder->frameLength;
362
        } else {
363
#endif
364
6.80M
            for (i = 0; i < ics->num_swb; i++)
365
6.64M
            {
366
6.64M
                ics->sect_sfb_offset[0][i] = swb_offset_1024_window[sf_index][i];
367
6.64M
                ics->swb_offset[i] = swb_offset_1024_window[sf_index][i];
368
6.64M
            }
369
154k
            ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
370
154k
            ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
371
154k
            ics->swb_offset_max = hDecoder->frameLength;
372
#ifdef LD_DEC
373
        }
374
#endif
375
154k
        return 0;
376
27.7k
    case EIGHT_SHORT_SEQUENCE:
377
27.7k
        ics->num_windows = 8;
378
27.7k
        ics->num_window_groups = 1;
379
27.7k
        ics->window_group_length[ics->num_window_groups-1] = 1;
380
27.7k
        ics->num_swb = num_swb_128_window[sf_index];
381
382
27.7k
        if (ics->max_sfb > ics->num_swb)
383
8
        {
384
8
            return 32;
385
8
        }
386
387
416k
        for (i = 0; i < ics->num_swb; i++)
388
388k
            ics->swb_offset[i] = swb_offset_128_window[sf_index][i];
389
27.7k
        ics->swb_offset[ics->num_swb] = hDecoder->frameLength/8;
390
27.7k
        ics->swb_offset_max = hDecoder->frameLength/8;
391
392
221k
        for (i = 0; i < ics->num_windows-1; i++) {
393
193k
            if (bit_set(ics->scale_factor_grouping, 6-i) == 0)
394
158k
            {
395
158k
                ics->num_window_groups += 1;
396
158k
                ics->window_group_length[ics->num_window_groups-1] = 1;
397
158k
            } else {
398
35.8k
                ics->window_group_length[ics->num_window_groups-1] += 1;
399
35.8k
            }
400
193k
        }
401
402
        /* preparation of sect_sfb_offset for short blocks */
403
213k
        for (g = 0; g < ics->num_window_groups; g++)
404
185k
        {
405
185k
            uint16_t width;
406
185k
            uint8_t sect_sfb = 0;
407
185k
            uint16_t offset = 0;
408
409
2.78M
            for (i = 0; i < ics->num_swb; i++)
410
2.60M
            {
411
2.60M
                if (i+1 == ics->num_swb)
412
185k
                {
413
185k
                    width = (hDecoder->frameLength/8) - swb_offset_128_window[sf_index][i];
414
2.41M
                } else {
415
2.41M
                    width = swb_offset_128_window[sf_index][i+1] -
416
2.41M
                        swb_offset_128_window[sf_index][i];
417
2.41M
                }
418
2.60M
                width *= ics->window_group_length[g];
419
2.60M
                ics->sect_sfb_offset[g][sect_sfb++] = offset;
420
2.60M
                offset += width;
421
2.60M
            }
422
185k
            ics->sect_sfb_offset[g][sect_sfb] = offset;
423
185k
        }
424
27.7k
        return 0;
425
0
    default:
426
0
        return 32;
427
182k
    }
428
182k
}
window_grouping_info
Line
Count
Source
303
514k
{
304
514k
    uint8_t i, g;
305
306
514k
    uint8_t sf_index = hDecoder->sf_index;
307
308
514k
    if (sf_index >= 12)
309
7
        return 32;
310
311
514k
    switch (ics->window_sequence) {
312
442k
    case ONLY_LONG_SEQUENCE:
313
465k
    case LONG_START_SEQUENCE:
314
473k
    case LONG_STOP_SEQUENCE:
315
473k
        ics->num_windows = 1;
316
473k
        ics->num_window_groups = 1;
317
473k
        ics->window_group_length[ics->num_window_groups-1] = 1;
318
473k
#ifdef LD_DEC
319
473k
        if (hDecoder->object_type == LD)
320
4.47k
        {
321
4.47k
            if (hDecoder->frameLength == 512)
322
2.23k
                ics->num_swb = num_swb_512_window[sf_index];
323
2.23k
            else /* if (hDecoder->frameLength == 480) */
324
2.23k
                ics->num_swb = num_swb_480_window[sf_index];
325
468k
        } else {
326
468k
#endif
327
468k
            if (hDecoder->frameLength == 1024)
328
405k
                ics->num_swb = num_swb_1024_window[sf_index];
329
63.2k
            else /* if (hDecoder->frameLength == 960) */
330
63.2k
                ics->num_swb = num_swb_960_window[sf_index];
331
468k
#ifdef LD_DEC
332
468k
        }
333
473k
#endif
334
335
473k
        if (ics->max_sfb > ics->num_swb)
336
200
        {
337
200
            return 32;
338
200
        }
339
340
        /* preparation of sect_sfb_offset for long blocks */
341
        /* also copy the last value! */
342
472k
#ifdef LD_DEC
343
472k
        if (hDecoder->object_type == LD)
344
4.46k
        {
345
4.46k
            if (hDecoder->frameLength == 512)
346
2.23k
            {
347
60.1k
                for (i = 0; i < ics->num_swb; i++)
348
57.8k
                {
349
57.8k
                    ics->sect_sfb_offset[0][i] = swb_offset_512_window[sf_index][i];
350
57.8k
                    ics->swb_offset[i] = swb_offset_512_window[sf_index][i];
351
57.8k
                }
352
2.23k
            } else /* if (hDecoder->frameLength == 480) */ {
353
68.0k
                for (i = 0; i < ics->num_swb; i++)
354
65.7k
                {
355
65.7k
                    ics->sect_sfb_offset[0][i] = swb_offset_480_window[sf_index][i];
356
65.7k
                    ics->swb_offset[i] = swb_offset_480_window[sf_index][i];
357
65.7k
                }
358
2.23k
            }
359
4.46k
            ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
360
4.46k
            ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
361
4.46k
            ics->swb_offset_max = hDecoder->frameLength;
362
468k
        } else {
363
468k
#endif
364
20.2M
            for (i = 0; i < ics->num_swb; i++)
365
19.7M
            {
366
19.7M
                ics->sect_sfb_offset[0][i] = swb_offset_1024_window[sf_index][i];
367
19.7M
                ics->swb_offset[i] = swb_offset_1024_window[sf_index][i];
368
19.7M
            }
369
468k
            ics->sect_sfb_offset[0][ics->num_swb] = hDecoder->frameLength;
370
468k
            ics->swb_offset[ics->num_swb] = hDecoder->frameLength;
371
468k
            ics->swb_offset_max = hDecoder->frameLength;
372
468k
#ifdef LD_DEC
373
468k
        }
374
472k
#endif
375
472k
        return 0;
376
41.2k
    case EIGHT_SHORT_SEQUENCE:
377
41.2k
        ics->num_windows = 8;
378
41.2k
        ics->num_window_groups = 1;
379
41.2k
        ics->window_group_length[ics->num_window_groups-1] = 1;
380
41.2k
        ics->num_swb = num_swb_128_window[sf_index];
381
382
41.2k
        if (ics->max_sfb > ics->num_swb)
383
10
        {
384
10
            return 32;
385
10
        }
386
387
606k
        for (i = 0; i < ics->num_swb; i++)
388
565k
            ics->swb_offset[i] = swb_offset_128_window[sf_index][i];
389
41.2k
        ics->swb_offset[ics->num_swb] = hDecoder->frameLength/8;
390
41.2k
        ics->swb_offset_max = hDecoder->frameLength/8;
391
392
330k
        for (i = 0; i < ics->num_windows-1; i++) {
393
289k
            if (bit_set(ics->scale_factor_grouping, 6-i) == 0)
394
239k
            {
395
239k
                ics->num_window_groups += 1;
396
239k
                ics->window_group_length[ics->num_window_groups-1] = 1;
397
239k
            } else {
398
49.7k
                ics->window_group_length[ics->num_window_groups-1] += 1;
399
49.7k
            }
400
289k
        }
401
402
        /* preparation of sect_sfb_offset for short blocks */
403
321k
        for (g = 0; g < ics->num_window_groups; g++)
404
280k
        {
405
280k
            uint16_t width;
406
280k
            uint8_t sect_sfb = 0;
407
280k
            uint16_t offset = 0;
408
409
4.11M
            for (i = 0; i < ics->num_swb; i++)
410
3.83M
            {
411
3.83M
                if (i+1 == ics->num_swb)
412
280k
                {
413
280k
                    width = (hDecoder->frameLength/8) - swb_offset_128_window[sf_index][i];
414
3.55M
                } else {
415
3.55M
                    width = swb_offset_128_window[sf_index][i+1] -
416
3.55M
                        swb_offset_128_window[sf_index][i];
417
3.55M
                }
418
3.83M
                width *= ics->window_group_length[g];
419
3.83M
                ics->sect_sfb_offset[g][sect_sfb++] = offset;
420
3.83M
                offset += width;
421
3.83M
            }
422
280k
            ics->sect_sfb_offset[g][sect_sfb] = offset;
423
280k
        }
424
41.2k
        return 0;
425
0
    default:
426
0
        return 32;
427
514k
    }
428
514k
}
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
738M
{
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
314M
        REAL_CONST(0), REAL_CONST(1.0/8.0), REAL_CONST(2.0/8.0), REAL_CONST(3.0/8.0),
441
314M
        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
314M
        REAL_CONST(0)
443
    };
444
    real_t x1, x2;
445
#endif
446
    int16_t sgn = 1;
447
448
314M
    if (q < 0)
449
129k
    {
450
129k
        q = -q;
451
129k
        sgn = -1;
452
129k
    }
453
454
314M
    if (q < IQ_TABLE_SIZE)
455
314M
    {
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
314M
        return sgn * tab[q];
462
314M
    }
463
464
2.68k
#ifndef BIG_IQ_TABLE
465
2.68k
    if (q >= 8192)
466
793
    {
467
793
        *error = 17;
468
793
        return 0;
469
793
    }
470
471
    /* linear interpolation */
472
1.89k
    x1 = tab[q>>3];
473
1.89k
    x2 = tab[(q>>3) + 1];
474
1.89k
    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
423M
    if (q < 0)
482
116k
    {
483
        /* tab contains a value for all possible q [0,8192] */
484
116k
        if (-q < IQ_TABLE_SIZE)
485
115k
            return -tab[-q];
486
487
1.18k
        *error = 17;
488
1.18k
        return 0;
489
423M
    } else {
490
        /* tab contains a value for all possible q [0,8192] */
491
423M
        if (q < IQ_TABLE_SIZE)
492
423M
            return tab[q];
493
494
1.07k
        *error = 17;
495
1.07k
        return 0;
496
423M
    }
497
#endif
498
2.68k
}
specrec.c:iquant
Line
Count
Source
432
314M
{
433
314M
#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
314M
#ifndef BIG_IQ_TABLE
439
314M
    static const real_t errcorr[] = {
440
314M
        REAL_CONST(0), REAL_CONST(1.0/8.0), REAL_CONST(2.0/8.0), REAL_CONST(3.0/8.0),
441
314M
        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
314M
        REAL_CONST(0)
443
314M
    };
444
314M
    real_t x1, x2;
445
314M
#endif
446
314M
    int16_t sgn = 1;
447
448
314M
    if (q < 0)
449
129k
    {
450
129k
        q = -q;
451
129k
        sgn = -1;
452
129k
    }
453
454
314M
    if (q < IQ_TABLE_SIZE)
455
314M
    {
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
314M
        return sgn * tab[q];
462
314M
    }
463
464
2.68k
#ifndef BIG_IQ_TABLE
465
2.68k
    if (q >= 8192)
466
793
    {
467
793
        *error = 17;
468
793
        return 0;
469
793
    }
470
471
    /* linear interpolation */
472
1.89k
    x1 = tab[q>>3];
473
1.89k
    x2 = tab[(q>>3) + 1];
474
1.89k
    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
    if (q < 0)
482
    {
483
        /* tab contains a value for all possible q [0,8192] */
484
        if (-q < IQ_TABLE_SIZE)
485
            return -tab[-q];
486
487
        *error = 17;
488
        return 0;
489
    } else {
490
        /* tab contains a value for all possible q [0,8192] */
491
        if (q < IQ_TABLE_SIZE)
492
            return tab[q];
493
494
        *error = 17;
495
        return 0;
496
    }
497
#endif
498
2.68k
}
specrec.c:iquant
Line
Count
Source
432
423M
{
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
423M
    if (q < 0)
482
116k
    {
483
        /* tab contains a value for all possible q [0,8192] */
484
116k
        if (-q < IQ_TABLE_SIZE)
485
115k
            return -tab[-q];
486
487
1.18k
        *error = 17;
488
1.18k
        return 0;
489
423M
    } else {
490
        /* tab contains a value for all possible q [0,8192] */
491
423M
        if (q < IQ_TABLE_SIZE)
492
423M
            return tab[q];
493
494
1.07k
        *error = 17;
495
1.07k
        return 0;
496
423M
    }
497
423M
#endif
498
423M
}
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
730k
{
553
730k
    ALIGN static const real_t pow2_table[] =
554
730k
    {
555
730k
        COEF_CONST(1.0),
556
730k
        COEF_CONST(1.1892071150027210667174999705605), /* 2^0.25 */
557
730k
        COEF_CONST(1.4142135623730950488016887242097), /* 2^0.5 */
558
730k
        COEF_CONST(1.6817928305074290860622509524664) /* 2^0.75 */
559
730k
    };
560
730k
    const real_t *tab = iq_table;
561
562
730k
    uint8_t g, sfb, win;
563
730k
    uint16_t width, bin, k, gindex;
564
730k
    uint8_t error = 0; /* Init error flag */
565
#ifndef FIXED_POINT
566
    real_t scf;
567
#else
568
    int32_t sat_shift_mask = 0;
569
#endif
570
571
730k
    k = 0;
572
730k
    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
730k
    if (ics->num_swb == 0)
578
1.02k
        memset(spec_data, 0, frame_len * sizeof(real_t));
579
580
1.87M
    for (g = 0; g < ics->num_window_groups; g++)
581
1.14M
    {
582
1.14M
        uint16_t j = 0;
583
1.14M
        uint16_t gincrease = 0;
584
1.14M
        uint16_t win_inc = ics->swb_offset[ics->num_swb];
585
586
35.6M
        for (sfb = 0; sfb < ics->num_swb; sfb++)
587
34.5M
        {
588
34.5M
            int32_t exp, frac;
589
34.5M
            uint16_t wa = gindex + j;
590
34.5M
            int16_t scale_factor = ics->scale_factors[g][sfb];
591
592
34.5M
            width = ics->swb_offset[sfb+1] - ics->swb_offset[sfb];
593
594
#ifdef FIXED_POINT
595
            scale_factor -= 100;
596
            /* IMDCT pre-scaling */
597
14.6M
            if (hDecoder->object_type == LD)
598
52.5k
            {
599
52.5k
                scale_factor -= 24 /*9*/;
600
14.5M
            } else {
601
14.5M
                if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
602
2.80M
                    scale_factor -= 16 /*7*/;
603
11.7M
                else
604
11.7M
                    scale_factor -= 28 /*10*/;
605
14.5M
            }
606
14.6M
            if (scale_factor > 120)
607
649
                scale_factor = 120;  /* => exp <= 30 */
608
#else
609
            (void)hDecoder;
610
#endif
611
612
            /* scale_factor for IS or PNS, has different meaning; fill with almost zeroes */
613
34.5M
            if (is_intensity(ics, g, sfb) || is_noise(ics, g, sfb))
614
67.8k
            {
615
67.8k
                scale_factor = 0;
616
67.8k
            }
617
618
            /* scale_factor must be between 0 and 255 */
619
34.5M
            exp = (scale_factor /* - 100 */) >> 2;
620
            /* frac must always be > 0 */
621
34.5M
            frac = (scale_factor /* - 100 */) & 3;
622
623
#ifndef FIXED_POINT
624
            scf = pow2sf_tab[exp/*+25*/] * pow2_table[frac];
625
#else
626
14.6M
            if (exp > 0)
627
24.9k
                sat_shift_mask = SAT_SHIFT_MASK(exp);
628
#endif
629
630
70.3M
            for (win = 0; win < ics->window_group_length[g]; win++)
631
35.8M
            {
632
220M
                for (bin = 0; bin < width; bin += 4)
633
184M
                {
634
184M
                    uint16_t wb = wa + bin;
635
#ifndef FIXED_POINT
636
                    spec_data[wb+0] = iquant(quant_data[k+0], tab, &error) * scf;
637
                    spec_data[wb+1] = iquant(quant_data[k+1], tab, &error) * scf;
638
                    spec_data[wb+2] = iquant(quant_data[k+2], tab, &error) * scf;
639
                    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
78.7M
                    if (exp == -32)
647
70.6M
                    {
648
70.6M
                        spec_data[wb+0] = 0;
649
70.6M
                        spec_data[wb+1] = 0;
650
70.6M
                        spec_data[wb+2] = 0;
651
70.6M
                        spec_data[wb+3] = 0;
652
70.6M
                    } else if (exp <= 0) {
653
7.96M
                        spec_data[wb+0] = iq0 >> -exp;
654
7.96M
                        spec_data[wb+1] = iq1 >> -exp;
655
7.96M
                        spec_data[wb+2] = iq2 >> -exp;
656
7.96M
                        spec_data[wb+3] = iq3 >> -exp;
657
7.96M
                    } else { /* exp > 0 */
658
117k
                        spec_data[wb+0] = SAT_SHIFT(iq0, exp, sat_shift_mask);
659
117k
                        spec_data[wb+1] = SAT_SHIFT(iq1, exp, sat_shift_mask);
660
117k
                        spec_data[wb+2] = SAT_SHIFT(iq2, exp, sat_shift_mask);
661
117k
                        spec_data[wb+3] = SAT_SHIFT(iq3, exp, sat_shift_mask);
662
117k
                    }
663
78.7M
                    if (frac != 0)
664
207k
                    {
665
207k
                        spec_data[wb+0] = MUL_C(spec_data[wb+0],pow2_table[frac]);
666
207k
                        spec_data[wb+1] = MUL_C(spec_data[wb+1],pow2_table[frac]);
667
207k
                        spec_data[wb+2] = MUL_C(spec_data[wb+2],pow2_table[frac]);
668
207k
                        spec_data[wb+3] = MUL_C(spec_data[wb+3],pow2_table[frac]);
669
207k
                    }
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
184M
                    gincrease += 4;
685
184M
                    k += 4;
686
184M
                }
687
35.8M
                wa += win_inc;
688
35.8M
            }
689
34.5M
            j += width;
690
34.5M
        }
691
1.14M
        gindex += gincrease;
692
1.14M
    }
693
694
730k
    return error;
695
730k
}
specrec.c:quant_to_spec
Line
Count
Source
552
311k
{
553
311k
    ALIGN static const real_t pow2_table[] =
554
311k
    {
555
311k
        COEF_CONST(1.0),
556
311k
        COEF_CONST(1.1892071150027210667174999705605), /* 2^0.25 */
557
311k
        COEF_CONST(1.4142135623730950488016887242097), /* 2^0.5 */
558
311k
        COEF_CONST(1.6817928305074290860622509524664) /* 2^0.75 */
559
311k
    };
560
311k
    const real_t *tab = iq_table;
561
562
311k
    uint8_t g, sfb, win;
563
311k
    uint16_t width, bin, k, gindex;
564
311k
    uint8_t error = 0; /* Init error flag */
565
#ifndef FIXED_POINT
566
    real_t scf;
567
#else
568
311k
    int32_t sat_shift_mask = 0;
569
311k
#endif
570
571
311k
    k = 0;
572
311k
    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
311k
    if (ics->num_swb == 0)
578
483
        memset(spec_data, 0, frame_len * sizeof(real_t));
579
580
796k
    for (g = 0; g < ics->num_window_groups; g++)
581
485k
    {
582
485k
        uint16_t j = 0;
583
485k
        uint16_t gincrease = 0;
584
485k
        uint16_t win_inc = ics->swb_offset[ics->num_swb];
585
586
15.1M
        for (sfb = 0; sfb < ics->num_swb; sfb++)
587
14.6M
        {
588
14.6M
            int32_t exp, frac;
589
14.6M
            uint16_t wa = gindex + j;
590
14.6M
            int16_t scale_factor = ics->scale_factors[g][sfb];
591
592
14.6M
            width = ics->swb_offset[sfb+1] - ics->swb_offset[sfb];
593
594
14.6M
#ifdef FIXED_POINT
595
14.6M
            scale_factor -= 100;
596
            /* IMDCT pre-scaling */
597
14.6M
            if (hDecoder->object_type == LD)
598
52.5k
            {
599
52.5k
                scale_factor -= 24 /*9*/;
600
14.5M
            } else {
601
14.5M
                if (ics->window_sequence == EIGHT_SHORT_SEQUENCE)
602
2.80M
                    scale_factor -= 16 /*7*/;
603
11.7M
                else
604
11.7M
                    scale_factor -= 28 /*10*/;
605
14.5M
            }
606
14.6M
            if (scale_factor > 120)
607
649
                scale_factor = 120;  /* => exp <= 30 */
608
#else
609
            (void)hDecoder;
610
#endif
611
612
            /* scale_factor for IS or PNS, has different meaning; fill with almost zeroes */
613
14.6M
            if (is_intensity(ics, g, sfb) || is_noise(ics, g, sfb))
614
40.5k
            {
615
40.5k
                scale_factor = 0;
616
40.5k
            }
617
618
            /* scale_factor must be between 0 and 255 */
619
14.6M
            exp = (scale_factor /* - 100 */) >> 2;
620
            /* frac must always be > 0 */
621
14.6M
            frac = (scale_factor /* - 100 */) & 3;
622
623
#ifndef FIXED_POINT
624
            scf = pow2sf_tab[exp/*+25*/] * pow2_table[frac];
625
#else
626
14.6M
            if (exp > 0)
627
24.9k
                sat_shift_mask = SAT_SHIFT_MASK(exp);
628
14.6M
#endif
629
630
29.7M
            for (win = 0; win < ics->window_group_length[g]; win++)
631
15.1M
            {
632
93.8M
                for (bin = 0; bin < width; bin += 4)
633
78.7M
                {
634
78.7M
                    uint16_t wb = wa + bin;
635
#ifndef FIXED_POINT
636
                    spec_data[wb+0] = iquant(quant_data[k+0], tab, &error) * scf;
637
                    spec_data[wb+1] = iquant(quant_data[k+1], tab, &error) * scf;
638
                    spec_data[wb+2] = iquant(quant_data[k+2], tab, &error) * scf;
639
                    spec_data[wb+3] = iquant(quant_data[k+3], tab, &error) * scf;
640
#else
641
78.7M
                    real_t iq0 = iquant(quant_data[k+0], tab, &error);
642
78.7M
                    real_t iq1 = iquant(quant_data[k+1], tab, &error);
643
78.7M
                    real_t iq2 = iquant(quant_data[k+2], tab, &error);
644
78.7M
                    real_t iq3 = iquant(quant_data[k+3], tab, &error);
645
646
78.7M
                    if (exp == -32)
647
70.6M
                    {
648
70.6M
                        spec_data[wb+0] = 0;
649
70.6M
                        spec_data[wb+1] = 0;
650
70.6M
                        spec_data[wb+2] = 0;
651
70.6M
                        spec_data[wb+3] = 0;
652
70.6M
                    } else if (exp <= 0) {
653
7.96M
                        spec_data[wb+0] = iq0 >> -exp;
654
7.96M
                        spec_data[wb+1] = iq1 >> -exp;
655
7.96M
                        spec_data[wb+2] = iq2 >> -exp;
656
7.96M
                        spec_data[wb+3] = iq3 >> -exp;
657
7.96M
                    } else { /* exp > 0 */
658
117k
                        spec_data[wb+0] = SAT_SHIFT(iq0, exp, sat_shift_mask);
659
117k
                        spec_data[wb+1] = SAT_SHIFT(iq1, exp, sat_shift_mask);
660
117k
                        spec_data[wb+2] = SAT_SHIFT(iq2, exp, sat_shift_mask);
661
117k
                        spec_data[wb+3] = SAT_SHIFT(iq3, exp, sat_shift_mask);
662
117k
                    }
663
78.7M
                    if (frac != 0)
664
207k
                    {
665
207k
                        spec_data[wb+0] = MUL_C(spec_data[wb+0],pow2_table[frac]);
666
207k
                        spec_data[wb+1] = MUL_C(spec_data[wb+1],pow2_table[frac]);
667
207k
                        spec_data[wb+2] = MUL_C(spec_data[wb+2],pow2_table[frac]);
668
207k
                        spec_data[wb+3] = MUL_C(spec_data[wb+3],pow2_table[frac]);
669
207k
                    }
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
78.7M
#endif
683
684
78.7M
                    gincrease += 4;
685
78.7M
                    k += 4;
686
78.7M
                }
687
15.1M
                wa += win_inc;
688
15.1M
            }
689
14.6M
            j += width;
690
14.6M
        }
691
485k
        gindex += gincrease;
692
485k
    }
693
694
311k
    return error;
695
311k
}
specrec.c:quant_to_spec
Line
Count
Source
552
418k
{
553
418k
    ALIGN static const real_t pow2_table[] =
554
418k
    {
555
418k
        COEF_CONST(1.0),
556
418k
        COEF_CONST(1.1892071150027210667174999705605), /* 2^0.25 */
557
418k
        COEF_CONST(1.4142135623730950488016887242097), /* 2^0.5 */
558
418k
        COEF_CONST(1.6817928305074290860622509524664) /* 2^0.75 */
559
418k
    };
560
418k
    const real_t *tab = iq_table;
561
562
418k
    uint8_t g, sfb, win;
563
418k
    uint16_t width, bin, k, gindex;
564
418k
    uint8_t error = 0; /* Init error flag */
565
418k
#ifndef FIXED_POINT
566
418k
    real_t scf;
567
#else
568
    int32_t sat_shift_mask = 0;
569
#endif
570
571
418k
    k = 0;
572
418k
    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
418k
    if (ics->num_swb == 0)
578
540
        memset(spec_data, 0, frame_len * sizeof(real_t));
579
580
1.07M
    for (g = 0; g < ics->num_window_groups; g++)
581
657k
    {
582
657k
        uint16_t j = 0;
583
657k
        uint16_t gincrease = 0;
584
657k
        uint16_t win_inc = ics->swb_offset[ics->num_swb];
585
586
20.5M
        for (sfb = 0; sfb < ics->num_swb; sfb++)
587
19.8M
        {
588
19.8M
            int32_t exp, frac;
589
19.8M
            uint16_t wa = gindex + j;
590
19.8M
            int16_t scale_factor = ics->scale_factors[g][sfb];
591
592
19.8M
            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
19.8M
            (void)hDecoder;
610
19.8M
#endif
611
612
            /* scale_factor for IS or PNS, has different meaning; fill with almost zeroes */
613
19.8M
            if (is_intensity(ics, g, sfb) || is_noise(ics, g, sfb))
614
27.3k
            {
615
27.3k
                scale_factor = 0;
616
27.3k
            }
617
618
            /* scale_factor must be between 0 and 255 */
619
19.8M
            exp = (scale_factor /* - 100 */) >> 2;
620
            /* frac must always be > 0 */
621
19.8M
            frac = (scale_factor /* - 100 */) & 3;
622
623
19.8M
#ifndef FIXED_POINT
624
19.8M
            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
40.5M
            for (win = 0; win < ics->window_group_length[g]; win++)
631
20.6M
            {
632
126M
                for (bin = 0; bin < width; bin += 4)
633
105M
                {
634
105M
                    uint16_t wb = wa + bin;
635
105M
#ifndef FIXED_POINT
636
105M
                    spec_data[wb+0] = iquant(quant_data[k+0], tab, &error) * scf;
637
105M
                    spec_data[wb+1] = iquant(quant_data[k+1], tab, &error) * scf;
638
105M
                    spec_data[wb+2] = iquant(quant_data[k+2], tab, &error) * scf;
639
105M
                    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
105M
                    gincrease += 4;
685
105M
                    k += 4;
686
105M
                }
687
20.6M
                wa += win_inc;
688
20.6M
            }
689
19.8M
            j += width;
690
19.8M
        }
691
657k
        gindex += gincrease;
692
657k
    }
693
694
418k
    return error;
695
418k
}
696
697
static uint8_t allocate_single_channel(NeAACDecStruct *hDecoder, uint8_t channel,
698
                                       uint8_t output_channels)
699
313k
{
700
313k
    int mul = 1;
701
702
#ifdef MAIN_DEC
703
    /* MAIN object type prediction */
704
195k
    if (hDecoder->object_type == MAIN)
705
76.6k
    {
706
        /* allocate the state only when needed */
707
76.6k
        if (hDecoder->pred_stat[channel] != NULL)
708
1.00k
        {
709
1.00k
            faad_free(hDecoder->pred_stat[channel]);
710
1.00k
            hDecoder->pred_stat[channel] = NULL;
711
1.00k
        }
712
713
76.6k
        hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
714
76.6k
        reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
715
76.6k
    }
716
#endif
717
718
#ifdef LTP_DEC
719
195k
    if (is_ltp_ot(hDecoder->object_type))
720
57.6k
    {
721
        /* allocate the state only when needed */
722
57.6k
        if (hDecoder->lt_pred_stat[channel] != NULL)
723
1.62k
        {
724
1.62k
            faad_free(hDecoder->lt_pred_stat[channel]);
725
1.62k
            hDecoder->lt_pred_stat[channel] = NULL;
726
1.62k
        }
727
728
57.6k
        hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
729
57.6k
        memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
730
57.6k
    }
731
#endif
732
733
313k
    if (hDecoder->time_out[channel] != NULL)
734
4.25k
    {
735
4.25k
        faad_free(hDecoder->time_out[channel]);
736
4.25k
        hDecoder->time_out[channel] = NULL;
737
4.25k
    }
738
739
313k
    {
740
313k
        mul = 1;
741
313k
#ifdef SBR_DEC
742
313k
        hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
743
313k
        if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
744
246k
        {
745
            /* SBR requires 2 times as much output data */
746
246k
            mul = 2;
747
246k
            hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
748
246k
        }
749
313k
#endif
750
313k
        hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
751
313k
        memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
752
313k
    }
753
754
313k
#if (defined(PS_DEC) || defined(DRM_PS))
755
313k
    if (output_channels == 2)
756
122k
    {
757
122k
        if (hDecoder->time_out[channel+1] != NULL)
758
1.07k
        {
759
1.07k
            faad_free(hDecoder->time_out[channel+1]);
760
1.07k
            hDecoder->time_out[channel+1] = NULL;
761
1.07k
        }
762
763
122k
        hDecoder->time_out[channel+1] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
764
122k
        memset(hDecoder->time_out[channel+1], 0, mul*hDecoder->frameLength*sizeof(real_t));
765
122k
    }
766
313k
#endif
767
768
313k
    if (hDecoder->fb_intermed[channel] != NULL)
769
3.74k
    {
770
3.74k
        faad_free(hDecoder->fb_intermed[channel]);
771
3.74k
        hDecoder->fb_intermed[channel] = NULL;
772
3.74k
    }
773
774
313k
    hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
775
313k
    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
313k
    return 0;
796
313k
}
specrec.c:allocate_single_channel
Line
Count
Source
699
118k
{
700
118k
    int mul = 1;
701
702
#ifdef MAIN_DEC
703
    /* MAIN object type prediction */
704
    if (hDecoder->object_type == MAIN)
705
    {
706
        /* allocate the state only when needed */
707
        if (hDecoder->pred_stat[channel] != NULL)
708
        {
709
            faad_free(hDecoder->pred_stat[channel]);
710
            hDecoder->pred_stat[channel] = NULL;
711
        }
712
713
        hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
714
        reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
715
    }
716
#endif
717
718
#ifdef LTP_DEC
719
    if (is_ltp_ot(hDecoder->object_type))
720
    {
721
        /* allocate the state only when needed */
722
        if (hDecoder->lt_pred_stat[channel] != NULL)
723
        {
724
            faad_free(hDecoder->lt_pred_stat[channel]);
725
            hDecoder->lt_pred_stat[channel] = NULL;
726
        }
727
728
        hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
729
        memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
730
    }
731
#endif
732
733
118k
    if (hDecoder->time_out[channel] != NULL)
734
0
    {
735
0
        faad_free(hDecoder->time_out[channel]);
736
0
        hDecoder->time_out[channel] = NULL;
737
0
    }
738
739
118k
    {
740
118k
        mul = 1;
741
118k
#ifdef SBR_DEC
742
118k
        hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
743
118k
        if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
744
101k
        {
745
            /* SBR requires 2 times as much output data */
746
101k
            mul = 2;
747
101k
            hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
748
101k
        }
749
118k
#endif
750
118k
        hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
751
118k
        memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
752
118k
    }
753
754
118k
#if (defined(PS_DEC) || defined(DRM_PS))
755
118k
    if (output_channels == 2)
756
118k
    {
757
118k
        if (hDecoder->time_out[channel+1] != NULL)
758
0
        {
759
0
            faad_free(hDecoder->time_out[channel+1]);
760
0
            hDecoder->time_out[channel+1] = NULL;
761
0
        }
762
763
118k
        hDecoder->time_out[channel+1] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
764
118k
        memset(hDecoder->time_out[channel+1], 0, mul*hDecoder->frameLength*sizeof(real_t));
765
118k
    }
766
118k
#endif
767
768
118k
    if (hDecoder->fb_intermed[channel] != NULL)
769
0
    {
770
0
        faad_free(hDecoder->fb_intermed[channel]);
771
0
        hDecoder->fb_intermed[channel] = NULL;
772
0
    }
773
774
118k
    hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
775
118k
    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
118k
    return 0;
796
118k
}
specrec.c:allocate_single_channel
Line
Count
Source
699
195k
{
700
195k
    int mul = 1;
701
702
195k
#ifdef MAIN_DEC
703
    /* MAIN object type prediction */
704
195k
    if (hDecoder->object_type == MAIN)
705
76.6k
    {
706
        /* allocate the state only when needed */
707
76.6k
        if (hDecoder->pred_stat[channel] != NULL)
708
1.00k
        {
709
1.00k
            faad_free(hDecoder->pred_stat[channel]);
710
1.00k
            hDecoder->pred_stat[channel] = NULL;
711
1.00k
        }
712
713
76.6k
        hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
714
76.6k
        reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
715
76.6k
    }
716
195k
#endif
717
718
195k
#ifdef LTP_DEC
719
195k
    if (is_ltp_ot(hDecoder->object_type))
720
57.6k
    {
721
        /* allocate the state only when needed */
722
57.6k
        if (hDecoder->lt_pred_stat[channel] != NULL)
723
1.62k
        {
724
1.62k
            faad_free(hDecoder->lt_pred_stat[channel]);
725
1.62k
            hDecoder->lt_pred_stat[channel] = NULL;
726
1.62k
        }
727
728
57.6k
        hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
729
57.6k
        memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
730
57.6k
    }
731
195k
#endif
732
733
195k
    if (hDecoder->time_out[channel] != NULL)
734
4.25k
    {
735
4.25k
        faad_free(hDecoder->time_out[channel]);
736
4.25k
        hDecoder->time_out[channel] = NULL;
737
4.25k
    }
738
739
195k
    {
740
195k
        mul = 1;
741
195k
#ifdef SBR_DEC
742
195k
        hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
743
195k
        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
195k
#endif
750
195k
        hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
751
195k
        memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
752
195k
    }
753
754
195k
#if (defined(PS_DEC) || defined(DRM_PS))
755
195k
    if (output_channels == 2)
756
4.00k
    {
757
4.00k
        if (hDecoder->time_out[channel+1] != NULL)
758
1.07k
        {
759
1.07k
            faad_free(hDecoder->time_out[channel+1]);
760
1.07k
            hDecoder->time_out[channel+1] = NULL;
761
1.07k
        }
762
763
4.00k
        hDecoder->time_out[channel+1] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
764
4.00k
        memset(hDecoder->time_out[channel+1], 0, mul*hDecoder->frameLength*sizeof(real_t));
765
4.00k
    }
766
195k
#endif
767
768
195k
    if (hDecoder->fb_intermed[channel] != NULL)
769
3.74k
    {
770
3.74k
        faad_free(hDecoder->fb_intermed[channel]);
771
3.74k
        hDecoder->fb_intermed[channel] = NULL;
772
3.74k
    }
773
774
195k
    hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
775
195k
    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
195k
    return 0;
796
195k
}
797
798
static uint8_t allocate_channel_pair(NeAACDecStruct *hDecoder,
799
                                     uint8_t channel, uint8_t paired_channel)
800
45.3k
{
801
45.3k
    int mul = 1;
802
803
#ifdef MAIN_DEC
804
    /* MAIN object type prediction */
805
20.2k
    if (hDecoder->object_type == MAIN)
806
9.51k
    {
807
        /* allocate the state only when needed */
808
9.51k
        if (hDecoder->pred_stat[channel] == NULL)
809
9.49k
        {
810
9.49k
            hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
811
9.49k
            reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
812
9.49k
        }
813
9.51k
        if (hDecoder->pred_stat[paired_channel] == NULL)
814
9.49k
        {
815
9.49k
            hDecoder->pred_stat[paired_channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
816
9.49k
            reset_all_predictors(hDecoder->pred_stat[paired_channel], hDecoder->frameLength);
817
9.49k
        }
818
9.51k
    }
819
#endif
820
821
#ifdef LTP_DEC
822
20.2k
    if (is_ltp_ot(hDecoder->object_type))
823
7.86k
    {
824
        /* allocate the state only when needed */
825
7.86k
        if (hDecoder->lt_pred_stat[channel] == NULL)
826
7.81k
        {
827
7.81k
            hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
828
7.81k
            memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
829
7.81k
        }
830
7.86k
        if (hDecoder->lt_pred_stat[paired_channel] == NULL)
831
7.81k
        {
832
7.81k
            hDecoder->lt_pred_stat[paired_channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
833
7.81k
            memset(hDecoder->lt_pred_stat[paired_channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
834
7.81k
        }
835
7.86k
    }
836
#endif
837
838
45.3k
    {
839
45.3k
        mul = 1;
840
45.3k
#ifdef SBR_DEC
841
45.3k
        hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
842
45.3k
        if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
843
38.0k
        {
844
            /* SBR requires 2 times as much output data */
845
38.0k
            mul = 2;
846
38.0k
            hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
847
38.0k
        }
848
45.3k
#endif
849
45.3k
    }
850
45.3k
    if (hDecoder->time_out[channel] == NULL)
851
45.2k
    {
852
45.2k
        hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
853
45.2k
        memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
854
45.2k
    }
855
45.3k
    if (hDecoder->time_out[paired_channel] == NULL)
856
45.2k
    {
857
45.2k
        hDecoder->time_out[paired_channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
858
45.2k
        memset(hDecoder->time_out[paired_channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
859
45.2k
    }
860
861
45.3k
    if (hDecoder->fb_intermed[channel] == NULL)
862
45.2k
    {
863
45.2k
        hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
864
45.2k
        memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t));
865
45.2k
    }
866
45.3k
    if (hDecoder->fb_intermed[paired_channel] == NULL)
867
45.2k
    {
868
45.2k
        hDecoder->fb_intermed[paired_channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
869
45.2k
        memset(hDecoder->fb_intermed[paired_channel], 0, hDecoder->frameLength*sizeof(real_t));
870
45.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
45.3k
    return 0;
903
45.3k
}
specrec.c:allocate_channel_pair
Line
Count
Source
800
25.0k
{
801
25.0k
    int mul = 1;
802
803
#ifdef MAIN_DEC
804
    /* MAIN object type prediction */
805
    if (hDecoder->object_type == MAIN)
806
    {
807
        /* allocate the state only when needed */
808
        if (hDecoder->pred_stat[channel] == NULL)
809
        {
810
            hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
811
            reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
812
        }
813
        if (hDecoder->pred_stat[paired_channel] == NULL)
814
        {
815
            hDecoder->pred_stat[paired_channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
816
            reset_all_predictors(hDecoder->pred_stat[paired_channel], hDecoder->frameLength);
817
        }
818
    }
819
#endif
820
821
#ifdef LTP_DEC
822
    if (is_ltp_ot(hDecoder->object_type))
823
    {
824
        /* allocate the state only when needed */
825
        if (hDecoder->lt_pred_stat[channel] == NULL)
826
        {
827
            hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
828
            memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
829
        }
830
        if (hDecoder->lt_pred_stat[paired_channel] == NULL)
831
        {
832
            hDecoder->lt_pred_stat[paired_channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
833
            memset(hDecoder->lt_pred_stat[paired_channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
834
        }
835
    }
836
#endif
837
838
25.0k
    {
839
25.0k
        mul = 1;
840
25.0k
#ifdef SBR_DEC
841
25.0k
        hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
842
25.0k
        if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
843
22.3k
        {
844
            /* SBR requires 2 times as much output data */
845
22.3k
            mul = 2;
846
22.3k
            hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
847
22.3k
        }
848
25.0k
#endif
849
25.0k
    }
850
25.0k
    if (hDecoder->time_out[channel] == NULL)
851
25.0k
    {
852
25.0k
        hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
853
25.0k
        memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
854
25.0k
    }
855
25.0k
    if (hDecoder->time_out[paired_channel] == NULL)
856
25.0k
    {
857
25.0k
        hDecoder->time_out[paired_channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
858
25.0k
        memset(hDecoder->time_out[paired_channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
859
25.0k
    }
860
861
25.0k
    if (hDecoder->fb_intermed[channel] == NULL)
862
25.0k
    {
863
25.0k
        hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
864
25.0k
        memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t));
865
25.0k
    }
866
25.0k
    if (hDecoder->fb_intermed[paired_channel] == NULL)
867
25.0k
    {
868
25.0k
        hDecoder->fb_intermed[paired_channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
869
25.0k
        memset(hDecoder->fb_intermed[paired_channel], 0, hDecoder->frameLength*sizeof(real_t));
870
25.0k
    }
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
25.0k
    return 0;
903
25.0k
}
specrec.c:allocate_channel_pair
Line
Count
Source
800
20.2k
{
801
20.2k
    int mul = 1;
802
803
20.2k
#ifdef MAIN_DEC
804
    /* MAIN object type prediction */
805
20.2k
    if (hDecoder->object_type == MAIN)
806
9.51k
    {
807
        /* allocate the state only when needed */
808
9.51k
        if (hDecoder->pred_stat[channel] == NULL)
809
9.49k
        {
810
9.49k
            hDecoder->pred_stat[channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
811
9.49k
            reset_all_predictors(hDecoder->pred_stat[channel], hDecoder->frameLength);
812
9.49k
        }
813
9.51k
        if (hDecoder->pred_stat[paired_channel] == NULL)
814
9.49k
        {
815
9.49k
            hDecoder->pred_stat[paired_channel] = (pred_state*)faad_malloc(hDecoder->frameLength * sizeof(pred_state));
816
9.49k
            reset_all_predictors(hDecoder->pred_stat[paired_channel], hDecoder->frameLength);
817
9.49k
        }
818
9.51k
    }
819
20.2k
#endif
820
821
20.2k
#ifdef LTP_DEC
822
20.2k
    if (is_ltp_ot(hDecoder->object_type))
823
7.86k
    {
824
        /* allocate the state only when needed */
825
7.86k
        if (hDecoder->lt_pred_stat[channel] == NULL)
826
7.81k
        {
827
7.81k
            hDecoder->lt_pred_stat[channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
828
7.81k
            memset(hDecoder->lt_pred_stat[channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
829
7.81k
        }
830
7.86k
        if (hDecoder->lt_pred_stat[paired_channel] == NULL)
831
7.81k
        {
832
7.81k
            hDecoder->lt_pred_stat[paired_channel] = (int16_t*)faad_malloc(hDecoder->frameLength*4 * sizeof(int16_t));
833
7.81k
            memset(hDecoder->lt_pred_stat[paired_channel], 0, hDecoder->frameLength*4 * sizeof(int16_t));
834
7.81k
        }
835
7.86k
    }
836
20.2k
#endif
837
838
20.2k
    {
839
20.2k
        mul = 1;
840
20.2k
#ifdef SBR_DEC
841
20.2k
        hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 0;
842
20.2k
        if ((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
843
15.7k
        {
844
            /* SBR requires 2 times as much output data */
845
15.7k
            mul = 2;
846
15.7k
            hDecoder->sbr_alloced[hDecoder->fr_ch_ele] = 1;
847
15.7k
        }
848
20.2k
#endif
849
20.2k
    }
850
20.2k
    if (hDecoder->time_out[channel] == NULL)
851
20.1k
    {
852
20.1k
        hDecoder->time_out[channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
853
20.1k
        memset(hDecoder->time_out[channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
854
20.1k
    }
855
20.2k
    if (hDecoder->time_out[paired_channel] == NULL)
856
20.1k
    {
857
20.1k
        hDecoder->time_out[paired_channel] = (real_t*)faad_malloc(mul*hDecoder->frameLength*sizeof(real_t));
858
20.1k
        memset(hDecoder->time_out[paired_channel], 0, mul*hDecoder->frameLength*sizeof(real_t));
859
20.1k
    }
860
861
20.2k
    if (hDecoder->fb_intermed[channel] == NULL)
862
20.1k
    {
863
20.1k
        hDecoder->fb_intermed[channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
864
20.1k
        memset(hDecoder->fb_intermed[channel], 0, hDecoder->frameLength*sizeof(real_t));
865
20.1k
    }
866
20.2k
    if (hDecoder->fb_intermed[paired_channel] == NULL)
867
20.1k
    {
868
20.1k
        hDecoder->fb_intermed[paired_channel] = (real_t*)faad_malloc(hDecoder->frameLength*sizeof(real_t));
869
20.1k
        memset(hDecoder->fb_intermed[paired_channel], 0, hDecoder->frameLength*sizeof(real_t));
870
20.1k
    }
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.2k
    return 0;
903
20.2k
}
904
905
uint8_t reconstruct_single_channel(NeAACDecStruct *hDecoder, ic_stream *ics,
906
                                   element *sce, int16_t *spec_data)
907
583k
{
908
583k
    uint8_t retval;
909
583k
    uint8_t output_channels;
910
583k
    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
446k
    if (hDecoder->ps_used[hDecoder->fr_ch_ele])
922
11.3k
        output_channels = 2;
923
435k
    else
924
435k
        output_channels = 1;
925
#else
926
    output_channels = 1;
927
#endif
928
929
583k
    if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
930
511k
    {
931
        /* element_output_channels not set yet */
932
511k
        hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
933
511k
    } 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
1.36k
        memset(&hDecoder->element_alloced[hDecoder->fr_ch_ele], 0,
944
1.36k
            sizeof(uint8_t) * (MAX_SYNTAX_ELEMENTS - hDecoder->fr_ch_ele));
945
946
1.36k
        hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
947
948
        //return 21;
949
1.36k
    }
950
951
583k
    if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0)
952
520k
    {
953
520k
        retval = allocate_single_channel(hDecoder, sce->channel, output_channels);
954
520k
        if (retval > 0)
955
0
            return retval;
956
957
520k
        hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1;
958
520k
    }
959
960
    /* sanity check, CVE-2018-20199, CVE-2018-20360 */
961
583k
    if(!hDecoder->time_out[sce->channel])
962
0
        return 15;
963
583k
    if(output_channels > 1 && !hDecoder->time_out[sce->channel+1])
964
0
        return 15;
965
583k
    if(!hDecoder->fb_intermed[sce->channel])
966
0
        return 15;
967
968
    /* dequantisation and scaling */
969
583k
    retval = quant_to_spec(hDecoder, ics, spec_data, spec_coef, hDecoder->frameLength);
970
583k
    if (retval > 0)
971
214
        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
583k
    pns_decode(ics, NULL, spec_coef, NULL, hDecoder->frameLength, 0, hDecoder->object_type,
981
583k
        &(hDecoder->__r1), &(hDecoder->__r2));
982
983
#ifdef MAIN_DEC
984
    /* MAIN object type prediction */
985
220k
    if (hDecoder->object_type == MAIN)
986
86.0k
    {
987
86.0k
    if (!hDecoder->pred_stat[sce->channel])
988
0
      return 33;
989
990
        /* intra channel prediction */
991
86.0k
        ic_prediction(ics, spec_coef, hDecoder->pred_stat[sce->channel], hDecoder->frameLength,
992
86.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
86.0k
        pns_reset_pred_state(ics, hDecoder->pred_stat[sce->channel]);
999
86.0k
    }
1000
220k
#endif
1001
1002
#ifdef LTP_DEC
1003
446k
    if (is_ltp_ot(hDecoder->object_type))
1004
197k
    {
1005
197k
#ifdef LD_DEC
1006
197k
        if (hDecoder->object_type == LD)
1007
1.06k
        {
1008
1.06k
            if (ics->ltp.data_present)
1009
93
            {
1010
93
                if (ics->ltp.lag_update)
1011
23
                    hDecoder->ltp_lag[sce->channel] = ics->ltp.lag;
1012
93
            }
1013
1.06k
            ics->ltp.lag = hDecoder->ltp_lag[sce->channel];
1014
1.06k
        }
1015
197k
#endif
1016
1017
        /* long term prediction */
1018
197k
        lt_prediction(ics, &(ics->ltp), spec_coef, hDecoder->lt_pred_stat[sce->channel], hDecoder->fb,
1019
197k
            ics->window_shape, hDecoder->window_shape_prev[sce->channel],
1020
197k
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1021
197k
    }
1022
220k
#endif
1023
1024
    /* tns decoding */
1025
220k
    tns_decode_frame(ics, &(ics->tns), hDecoder->sf_index, hDecoder->object_type,
1026
220k
        spec_coef, hDecoder->frameLength);
1027
1028
    /* drc decoding */
1029
220k
#ifdef APPLY_DRC
1030
583k
    if (hDecoder->drc->present)
1031
28.7k
    {
1032
28.7k
        if (!hDecoder->drc->exclude_mask[sce->channel] || !hDecoder->drc->excluded_chns_present)
1033
25.9k
            drc_decode(hDecoder->drc, spec_coef);
1034
28.7k
    }
1035
220k
#endif
1036
    /* filter bank */
1037
#ifdef SSR_DEC
1038
    if (hDecoder->object_type != SSR)
1039
    {
1040
#endif
1041
220k
        ifilter_bank(hDecoder->fb, ics->window_sequence, ics->window_shape,
1042
220k
            hDecoder->window_shape_prev[sce->channel], spec_coef,
1043
220k
            hDecoder->time_out[sce->channel], hDecoder->fb_intermed[sce->channel],
1044
220k
            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
220k
    hDecoder->window_shape_prev[sce->channel] = ics->window_shape;
1056
1057
#ifdef LTP_DEC
1058
446k
    if (is_ltp_ot(hDecoder->object_type))
1059
197k
    {
1060
197k
        lt_update_state(hDecoder->lt_pred_stat[sce->channel], hDecoder->time_out[sce->channel],
1061
197k
            hDecoder->fb_intermed[sce->channel], hDecoder->frameLength, hDecoder->object_type);
1062
197k
    }
1063
#endif
1064
1065
220k
#ifdef SBR_DEC
1066
583k
    if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1067
583k
        && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1068
454k
    {
1069
454k
        int ele = hDecoder->fr_ch_ele;
1070
454k
        int ch = sce->channel;
1071
1072
        /* following case can happen when forceUpSampling == 1 */
1073
454k
        if (hDecoder->sbr[ele] == NULL)
1074
350k
        {
1075
350k
            hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
1076
350k
                hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
1077
350k
                hDecoder->downSampledSBR
1078
#ifdef DRM
1079
                , 0
1080
#endif
1081
350k
                );
1082
350k
        }
1083
454k
        if (!hDecoder->sbr[ele])
1084
115
            return 19;
1085
1086
454k
        if (sce->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
1087
50.1k
            hDecoder->sbr[ele]->maxAACLine = 8*min(sce->ics1.swb_offset[max(sce->ics1.max_sfb-1, 0)], sce->ics1.swb_offset_max);
1088
404k
        else
1089
404k
            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
454k
#if (defined(PS_DEC) || defined(DRM_PS))
1093
454k
        if (hDecoder->ps_used[ele] == 0)
1094
434k
        {
1095
434k
#endif
1096
434k
            retval = sbrDecodeSingleFrame(hDecoder->sbr[ele], hDecoder->time_out[ch],
1097
434k
                hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
1098
434k
#if (defined(PS_DEC) || defined(DRM_PS))
1099
434k
        } else {
1100
20.3k
            retval = sbrDecodeSingleFramePS(hDecoder->sbr[ele], hDecoder->time_out[ch],
1101
20.3k
                hDecoder->time_out[ch+1], hDecoder->postSeekResetFlag,
1102
20.3k
                hDecoder->downSampledSBR);
1103
20.3k
        }
1104
454k
#endif
1105
454k
        if (retval > 0)
1106
79
            return retval;
1107
454k
    } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1108
128k
        && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1109
18
    {
1110
18
        return 23;
1111
18
    }
1112
583k
#endif
1113
1114
    /* copy L to R when no PS is used */
1115
583k
#if (defined(PS_DEC) || defined(DRM_PS))
1116
583k
    if ((hDecoder->ps_used[hDecoder->fr_ch_ele] == 0) &&
1117
583k
        (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2))
1118
128k
    {
1119
128k
        int ele = hDecoder->fr_ch_ele;
1120
128k
        int ch = sce->channel;
1121
128k
        int frame_size = (hDecoder->sbr_alloced[ele]) ? 2 : 1;
1122
128k
        frame_size *= hDecoder->frameLength*sizeof(real_t);
1123
1124
128k
        memcpy(hDecoder->time_out[ch+1], hDecoder->time_out[ch], frame_size);
1125
128k
    }
1126
583k
#endif
1127
1128
583k
    return 0;
1129
220k
}
reconstruct_single_channel
Line
Count
Source
907
137k
{
908
137k
    uint8_t retval;
909
137k
    uint8_t output_channels;
910
137k
    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
137k
#if ( (defined(DRM) && defined(DRM_PS)) )
919
137k
    output_channels = 2;
920
#elif defined(PS_DEC)
921
    if (hDecoder->ps_used[hDecoder->fr_ch_ele])
922
        output_channels = 2;
923
    else
924
        output_channels = 1;
925
#else
926
    output_channels = 1;
927
#endif
928
929
137k
    if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
930
118k
    {
931
        /* element_output_channels not set yet */
932
118k
        hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
933
118k
    } 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
0
        memset(&hDecoder->element_alloced[hDecoder->fr_ch_ele], 0,
944
0
            sizeof(uint8_t) * (MAX_SYNTAX_ELEMENTS - hDecoder->fr_ch_ele));
945
946
0
        hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
947
948
        //return 21;
949
0
    }
950
951
137k
    if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0)
952
118k
    {
953
118k
        retval = allocate_single_channel(hDecoder, sce->channel, output_channels);
954
118k
        if (retval > 0)
955
0
            return retval;
956
957
118k
        hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1;
958
118k
    }
959
960
    /* sanity check, CVE-2018-20199, CVE-2018-20360 */
961
137k
    if(!hDecoder->time_out[sce->channel])
962
0
        return 15;
963
137k
    if(output_channels > 1 && !hDecoder->time_out[sce->channel+1])
964
0
        return 15;
965
137k
    if(!hDecoder->fb_intermed[sce->channel])
966
0
        return 15;
967
968
    /* dequantisation and scaling */
969
137k
    retval = quant_to_spec(hDecoder, ics, spec_data, spec_coef, hDecoder->frameLength);
970
137k
    if (retval > 0)
971
98
        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
137k
    pns_decode(ics, NULL, spec_coef, NULL, hDecoder->frameLength, 0, hDecoder->object_type,
981
137k
        &(hDecoder->__r1), &(hDecoder->__r2));
982
983
#ifdef MAIN_DEC
984
    /* MAIN object type prediction */
985
    if (hDecoder->object_type == MAIN)
986
    {
987
    if (!hDecoder->pred_stat[sce->channel])
988
      return 33;
989
990
        /* intra channel prediction */
991
        ic_prediction(ics, spec_coef, hDecoder->pred_stat[sce->channel], hDecoder->frameLength,
992
            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
        pns_reset_pred_state(ics, hDecoder->pred_stat[sce->channel]);
999
    }
1000
#endif
1001
1002
#ifdef LTP_DEC
1003
    if (is_ltp_ot(hDecoder->object_type))
1004
    {
1005
#ifdef LD_DEC
1006
        if (hDecoder->object_type == LD)
1007
        {
1008
            if (ics->ltp.data_present)
1009
            {
1010
                if (ics->ltp.lag_update)
1011
                    hDecoder->ltp_lag[sce->channel] = ics->ltp.lag;
1012
            }
1013
            ics->ltp.lag = hDecoder->ltp_lag[sce->channel];
1014
        }
1015
#endif
1016
1017
        /* long term prediction */
1018
        lt_prediction(ics, &(ics->ltp), spec_coef, hDecoder->lt_pred_stat[sce->channel], hDecoder->fb,
1019
            ics->window_shape, hDecoder->window_shape_prev[sce->channel],
1020
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1021
    }
1022
#endif
1023
1024
    /* tns decoding */
1025
137k
    tns_decode_frame(ics, &(ics->tns), hDecoder->sf_index, hDecoder->object_type,
1026
137k
        spec_coef, hDecoder->frameLength);
1027
1028
    /* drc decoding */
1029
137k
#ifdef APPLY_DRC
1030
137k
    if (hDecoder->drc->present)
1031
0
    {
1032
0
        if (!hDecoder->drc->exclude_mask[sce->channel] || !hDecoder->drc->excluded_chns_present)
1033
0
            drc_decode(hDecoder->drc, spec_coef);
1034
0
    }
1035
137k
#endif
1036
    /* filter bank */
1037
#ifdef SSR_DEC
1038
    if (hDecoder->object_type != SSR)
1039
    {
1040
#endif
1041
137k
        ifilter_bank(hDecoder->fb, ics->window_sequence, ics->window_shape,
1042
137k
            hDecoder->window_shape_prev[sce->channel], spec_coef,
1043
137k
            hDecoder->time_out[sce->channel], hDecoder->fb_intermed[sce->channel],
1044
137k
            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
137k
    hDecoder->window_shape_prev[sce->channel] = ics->window_shape;
1056
1057
#ifdef LTP_DEC
1058
    if (is_ltp_ot(hDecoder->object_type))
1059
    {
1060
        lt_update_state(hDecoder->lt_pred_stat[sce->channel], hDecoder->time_out[sce->channel],
1061
            hDecoder->fb_intermed[sce->channel], hDecoder->frameLength, hDecoder->object_type);
1062
    }
1063
#endif
1064
1065
137k
#ifdef SBR_DEC
1066
137k
    if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1067
137k
        && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1068
118k
    {
1069
118k
        int ele = hDecoder->fr_ch_ele;
1070
118k
        int ch = sce->channel;
1071
1072
        /* following case can happen when forceUpSampling == 1 */
1073
118k
        if (hDecoder->sbr[ele] == NULL)
1074
82.2k
        {
1075
82.2k
            hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
1076
82.2k
                hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
1077
82.2k
                hDecoder->downSampledSBR
1078
82.2k
#ifdef DRM
1079
82.2k
                , 0
1080
82.2k
#endif
1081
82.2k
                );
1082
82.2k
        }
1083
118k
        if (!hDecoder->sbr[ele])
1084
0
            return 19;
1085
1086
118k
        if (sce->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
1087
19.0k
            hDecoder->sbr[ele]->maxAACLine = 8*min(sce->ics1.swb_offset[max(sce->ics1.max_sfb-1, 0)], sce->ics1.swb_offset_max);
1088
99.2k
        else
1089
99.2k
            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
118k
#if (defined(PS_DEC) || defined(DRM_PS))
1093
118k
        if (hDecoder->ps_used[ele] == 0)
1094
109k
        {
1095
109k
#endif
1096
109k
            retval = sbrDecodeSingleFrame(hDecoder->sbr[ele], hDecoder->time_out[ch],
1097
109k
                hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
1098
109k
#if (defined(PS_DEC) || defined(DRM_PS))
1099
109k
        } else {
1100
8.97k
            retval = sbrDecodeSingleFramePS(hDecoder->sbr[ele], hDecoder->time_out[ch],
1101
8.97k
                hDecoder->time_out[ch+1], hDecoder->postSeekResetFlag,
1102
8.97k
                hDecoder->downSampledSBR);
1103
8.97k
        }
1104
118k
#endif
1105
118k
        if (retval > 0)
1106
12
            return retval;
1107
118k
    } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1108
18.7k
        && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1109
2
    {
1110
2
        return 23;
1111
2
    }
1112
137k
#endif
1113
1114
    /* copy L to R when no PS is used */
1115
137k
#if (defined(PS_DEC) || defined(DRM_PS))
1116
137k
    if ((hDecoder->ps_used[hDecoder->fr_ch_ele] == 0) &&
1117
137k
        (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 2))
1118
128k
    {
1119
128k
        int ele = hDecoder->fr_ch_ele;
1120
128k
        int ch = sce->channel;
1121
128k
        int frame_size = (hDecoder->sbr_alloced[ele]) ? 2 : 1;
1122
128k
        frame_size *= hDecoder->frameLength*sizeof(real_t);
1123
1124
128k
        memcpy(hDecoder->time_out[ch+1], hDecoder->time_out[ch], frame_size);
1125
128k
    }
1126
137k
#endif
1127
1128
137k
    return 0;
1129
137k
}
reconstruct_single_channel
Line
Count
Source
907
220k
{
908
220k
    uint8_t retval;
909
220k
    uint8_t output_channels;
910
220k
    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
220k
    if (hDecoder->ps_used[hDecoder->fr_ch_ele])
922
5.72k
        output_channels = 2;
923
214k
    else
924
214k
        output_channels = 1;
925
#else
926
    output_channels = 1;
927
#endif
928
929
220k
    if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
930
190k
    {
931
        /* element_output_channels not set yet */
932
190k
        hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
933
190k
    } 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
565
        memset(&hDecoder->element_alloced[hDecoder->fr_ch_ele], 0,
944
565
            sizeof(uint8_t) * (MAX_SYNTAX_ELEMENTS - hDecoder->fr_ch_ele));
945
946
565
        hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
947
948
        //return 21;
949
565
    }
950
951
220k
    if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0)
952
195k
    {
953
195k
        retval = allocate_single_channel(hDecoder, sce->channel, output_channels);
954
195k
        if (retval > 0)
955
0
            return retval;
956
957
195k
        hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1;
958
195k
    }
959
960
    /* sanity check, CVE-2018-20199, CVE-2018-20360 */
961
220k
    if(!hDecoder->time_out[sce->channel])
962
0
        return 15;
963
220k
    if(output_channels > 1 && !hDecoder->time_out[sce->channel+1])
964
0
        return 15;
965
220k
    if(!hDecoder->fb_intermed[sce->channel])
966
0
        return 15;
967
968
    /* dequantisation and scaling */
969
220k
    retval = quant_to_spec(hDecoder, ics, spec_data, spec_coef, hDecoder->frameLength);
970
220k
    if (retval > 0)
971
65
        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
220k
    pns_decode(ics, NULL, spec_coef, NULL, hDecoder->frameLength, 0, hDecoder->object_type,
981
220k
        &(hDecoder->__r1), &(hDecoder->__r2));
982
983
220k
#ifdef MAIN_DEC
984
    /* MAIN object type prediction */
985
220k
    if (hDecoder->object_type == MAIN)
986
86.0k
    {
987
86.0k
    if (!hDecoder->pred_stat[sce->channel])
988
0
      return 33;
989
990
        /* intra channel prediction */
991
86.0k
        ic_prediction(ics, spec_coef, hDecoder->pred_stat[sce->channel], hDecoder->frameLength,
992
86.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
86.0k
        pns_reset_pred_state(ics, hDecoder->pred_stat[sce->channel]);
999
86.0k
    }
1000
220k
#endif
1001
1002
220k
#ifdef LTP_DEC
1003
220k
    if (is_ltp_ot(hDecoder->object_type))
1004
61.2k
    {
1005
61.2k
#ifdef LD_DEC
1006
61.2k
        if (hDecoder->object_type == LD)
1007
608
        {
1008
608
            if (ics->ltp.data_present)
1009
66
            {
1010
66
                if (ics->ltp.lag_update)
1011
17
                    hDecoder->ltp_lag[sce->channel] = ics->ltp.lag;
1012
66
            }
1013
608
            ics->ltp.lag = hDecoder->ltp_lag[sce->channel];
1014
608
        }
1015
61.2k
#endif
1016
1017
        /* long term prediction */
1018
61.2k
        lt_prediction(ics, &(ics->ltp), spec_coef, hDecoder->lt_pred_stat[sce->channel], hDecoder->fb,
1019
61.2k
            ics->window_shape, hDecoder->window_shape_prev[sce->channel],
1020
61.2k
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1021
61.2k
    }
1022
220k
#endif
1023
1024
    /* tns decoding */
1025
220k
    tns_decode_frame(ics, &(ics->tns), hDecoder->sf_index, hDecoder->object_type,
1026
220k
        spec_coef, hDecoder->frameLength);
1027
1028
    /* drc decoding */
1029
220k
#ifdef APPLY_DRC
1030
220k
    if (hDecoder->drc->present)
1031
14.6k
    {
1032
14.6k
        if (!hDecoder->drc->exclude_mask[sce->channel] || !hDecoder->drc->excluded_chns_present)
1033
13.3k
            drc_decode(hDecoder->drc, spec_coef);
1034
14.6k
    }
1035
220k
#endif
1036
    /* filter bank */
1037
#ifdef SSR_DEC
1038
    if (hDecoder->object_type != SSR)
1039
    {
1040
#endif
1041
220k
        ifilter_bank(hDecoder->fb, ics->window_sequence, ics->window_shape,
1042
220k
            hDecoder->window_shape_prev[sce->channel], spec_coef,
1043
220k
            hDecoder->time_out[sce->channel], hDecoder->fb_intermed[sce->channel],
1044
220k
            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
220k
    hDecoder->window_shape_prev[sce->channel] = ics->window_shape;
1056
1057
220k
#ifdef LTP_DEC
1058
220k
    if (is_ltp_ot(hDecoder->object_type))
1059
61.2k
    {
1060
61.2k
        lt_update_state(hDecoder->lt_pred_stat[sce->channel], hDecoder->time_out[sce->channel],
1061
61.2k
            hDecoder->fb_intermed[sce->channel], hDecoder->frameLength, hDecoder->object_type);
1062
61.2k
    }
1063
220k
#endif
1064
1065
220k
#ifdef SBR_DEC
1066
220k
    if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1067
220k
        && 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
127k
        {
1075
127k
            hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
1076
127k
                hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
1077
127k
                hDecoder->downSampledSBR
1078
#ifdef DRM
1079
                , 0
1080
#endif
1081
127k
                );
1082
127k
        }
1083
164k
        if (!hDecoder->sbr[ele])
1084
33
            return 19;
1085
1086
164k
        if (sce->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
1087
18.6k
            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.72k
            retval = sbrDecodeSingleFramePS(hDecoder->sbr[ele], hDecoder->time_out[ch],
1101
5.72k
                hDecoder->time_out[ch+1], hDecoder->postSeekResetFlag,
1102
5.72k
                hDecoder->downSampledSBR);
1103
5.72k
        }
1104
164k
#endif
1105
164k
        if (retval > 0)
1106
36
            return retval;
1107
164k
    } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1108
56.2k
        && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1109
4
    {
1110
4
        return 23;
1111
4
    }
1112
220k
#endif
1113
1114
    /* copy L to R when no PS is used */
1115
220k
#if (defined(PS_DEC) || defined(DRM_PS))
1116
220k
    if ((hDecoder->ps_used[hDecoder->fr_ch_ele] == 0) &&
1117
220k
        (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
220k
#endif
1127
1128
220k
    return 0;
1129
220k
}
reconstruct_single_channel
Line
Count
Source
907
225k
{
908
225k
    uint8_t retval;
909
225k
    uint8_t output_channels;
910
225k
    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
225k
    if (hDecoder->ps_used[hDecoder->fr_ch_ele])
922
5.62k
        output_channels = 2;
923
220k
    else
924
220k
        output_channels = 1;
925
#else
926
    output_channels = 1;
927
#endif
928
929
225k
    if (hDecoder->element_output_channels[hDecoder->fr_ch_ele] == 0)
930
203k
    {
931
        /* element_output_channels not set yet */
932
203k
        hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
933
203k
    } 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
804
        memset(&hDecoder->element_alloced[hDecoder->fr_ch_ele], 0,
944
804
            sizeof(uint8_t) * (MAX_SYNTAX_ELEMENTS - hDecoder->fr_ch_ele));
945
946
804
        hDecoder->element_output_channels[hDecoder->fr_ch_ele] = output_channels;
947
948
        //return 21;
949
804
    }
950
951
225k
    if (hDecoder->element_alloced[hDecoder->fr_ch_ele] == 0)
952
206k
    {
953
206k
        retval = allocate_single_channel(hDecoder, sce->channel, output_channels);
954
206k
        if (retval > 0)
955
0
            return retval;
956
957
206k
        hDecoder->element_alloced[hDecoder->fr_ch_ele] = 1;
958
206k
    }
959
960
    /* sanity check, CVE-2018-20199, CVE-2018-20360 */
961
225k
    if(!hDecoder->time_out[sce->channel])
962
0
        return 15;
963
225k
    if(output_channels > 1 && !hDecoder->time_out[sce->channel+1])
964
0
        return 15;
965
225k
    if(!hDecoder->fb_intermed[sce->channel])
966
0
        return 15;
967
968
    /* dequantisation and scaling */
969
225k
    retval = quant_to_spec(hDecoder, ics, spec_data, spec_coef, hDecoder->frameLength);
970
225k
    if (retval > 0)
971
51
        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
225k
    pns_decode(ics, NULL, spec_coef, NULL, hDecoder->frameLength, 0, hDecoder->object_type,
981
225k
        &(hDecoder->__r1), &(hDecoder->__r2));
982
983
#ifdef MAIN_DEC
984
    /* MAIN object type prediction */
985
    if (hDecoder->object_type == MAIN)
986
    {
987
    if (!hDecoder->pred_stat[sce->channel])
988
      return 33;
989
990
        /* intra channel prediction */
991
        ic_prediction(ics, spec_coef, hDecoder->pred_stat[sce->channel], hDecoder->frameLength,
992
            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
        pns_reset_pred_state(ics, hDecoder->pred_stat[sce->channel]);
999
    }
1000
#endif
1001
1002
225k
#ifdef LTP_DEC
1003
225k
    if (is_ltp_ot(hDecoder->object_type))
1004
136k
    {
1005
136k
#ifdef LD_DEC
1006
136k
        if (hDecoder->object_type == LD)
1007
453
        {
1008
453
            if (ics->ltp.data_present)
1009
27
            {
1010
27
                if (ics->ltp.lag_update)
1011
6
                    hDecoder->ltp_lag[sce->channel] = ics->ltp.lag;
1012
27
            }
1013
453
            ics->ltp.lag = hDecoder->ltp_lag[sce->channel];
1014
453
        }
1015
136k
#endif
1016
1017
        /* long term prediction */
1018
136k
        lt_prediction(ics, &(ics->ltp), spec_coef, hDecoder->lt_pred_stat[sce->channel], hDecoder->fb,
1019
136k
            ics->window_shape, hDecoder->window_shape_prev[sce->channel],
1020
136k
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1021
136k
    }
1022
225k
#endif
1023
1024
    /* tns decoding */
1025
225k
    tns_decode_frame(ics, &(ics->tns), hDecoder->sf_index, hDecoder->object_type,
1026
225k
        spec_coef, hDecoder->frameLength);
1027
1028
    /* drc decoding */
1029
225k
#ifdef APPLY_DRC
1030
225k
    if (hDecoder->drc->present)
1031
14.0k
    {
1032
14.0k
        if (!hDecoder->drc->exclude_mask[sce->channel] || !hDecoder->drc->excluded_chns_present)
1033
12.6k
            drc_decode(hDecoder->drc, spec_coef);
1034
14.0k
    }
1035
225k
#endif
1036
    /* filter bank */
1037
#ifdef SSR_DEC
1038
    if (hDecoder->object_type != SSR)
1039
    {
1040
#endif
1041
225k
        ifilter_bank(hDecoder->fb, ics->window_sequence, ics->window_shape,
1042
225k
            hDecoder->window_shape_prev[sce->channel], spec_coef,
1043
225k
            hDecoder->time_out[sce->channel], hDecoder->fb_intermed[sce->channel],
1044
225k
            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
225k
    hDecoder->window_shape_prev[sce->channel] = ics->window_shape;
1056
1057
225k
#ifdef LTP_DEC
1058
225k
    if (is_ltp_ot(hDecoder->object_type))
1059
136k
    {
1060
136k
        lt_update_state(hDecoder->lt_pred_stat[sce->channel], hDecoder->time_out[sce->channel],
1061
136k
            hDecoder->fb_intermed[sce->channel], hDecoder->frameLength, hDecoder->object_type);
1062
136k
    }
1063
225k
#endif
1064
1065
225k
#ifdef SBR_DEC
1066
225k
    if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1067
225k
        && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1068
172k
    {
1069
172k
        int ele = hDecoder->fr_ch_ele;
1070
172k
        int ch = sce->channel;
1071
1072
        /* following case can happen when forceUpSampling == 1 */
1073
172k
        if (hDecoder->sbr[ele] == NULL)
1074
141k
        {
1075
141k
            hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
1076
141k
                hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
1077
141k
                hDecoder->downSampledSBR
1078
#ifdef DRM
1079
                , 0
1080
#endif
1081
141k
                );
1082
141k
        }
1083
172k
        if (!hDecoder->sbr[ele])
1084
82
            return 19;
1085
1086
172k
        if (sce->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
1087
12.4k
            hDecoder->sbr[ele]->maxAACLine = 8*min(sce->ics1.swb_offset[max(sce->ics1.max_sfb-1, 0)], sce->ics1.swb_offset_max);
1088
159k
        else
1089
159k
            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
172k
#if (defined(PS_DEC) || defined(DRM_PS))
1093
172k
        if (hDecoder->ps_used[ele] == 0)
1094
166k
        {
1095
166k
#endif
1096
166k
            retval = sbrDecodeSingleFrame(hDecoder->sbr[ele], hDecoder->time_out[ch],
1097
166k
                hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
1098
166k
#if (defined(PS_DEC) || defined(DRM_PS))
1099
166k
        } else {
1100
5.62k
            retval = sbrDecodeSingleFramePS(hDecoder->sbr[ele], hDecoder->time_out[ch],
1101
5.62k
                hDecoder->time_out[ch+1], hDecoder->postSeekResetFlag,
1102
5.62k
                hDecoder->downSampledSBR);
1103
5.62k
        }
1104
172k
#endif
1105
172k
        if (retval > 0)
1106
31
            return retval;
1107
172k
    } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1108
53.3k
        && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1109
12
    {
1110
12
        return 23;
1111
12
    }
1112
225k
#endif
1113
1114
    /* copy L to R when no PS is used */
1115
225k
#if (defined(PS_DEC) || defined(DRM_PS))
1116
225k
    if ((hDecoder->ps_used[hDecoder->fr_ch_ele] == 0) &&
1117
225k
        (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
225k
#endif
1127
1128
225k
    return 0;
1129
225k
}
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
73.6k
{
1134
73.6k
    uint8_t retval;
1135
73.6k
    ALIGN real_t spec_coef1[1024];
1136
73.6k
    ALIGN real_t spec_coef2[1024];
1137
1138
#ifdef PROFILE
1139
    int64_t count = faad_get_ts();
1140
#endif
1141
73.6k
    if (hDecoder->element_alloced[hDecoder->fr_ch_ele] != 2)
1142
62.7k
    {
1143
62.7k
        retval = allocate_channel_pair(hDecoder, cpe->channel, (uint8_t)cpe->paired_channel);
1144
62.7k
        if (retval > 0)
1145
0
            return retval;
1146
1147
62.7k
        hDecoder->element_alloced[hDecoder->fr_ch_ele] = 2;
1148
62.7k
    }
1149
1150
    /* sanity check, CVE-2018-20199, CVE-2018-20360 */
1151
73.6k
    if(!hDecoder->time_out[cpe->channel] || !hDecoder->time_out[cpe->paired_channel])
1152
0
        return 15;
1153
73.6k
    if(!hDecoder->fb_intermed[cpe->channel] || !hDecoder->fb_intermed[cpe->paired_channel])
1154
0
        return 15;
1155
1156
    /* dequantisation and scaling */
1157
73.6k
    retval = quant_to_spec(hDecoder, ics1, spec_data1, spec_coef1, hDecoder->frameLength);
1158
73.6k
    if (retval > 0)
1159
131
        return retval;
1160
73.5k
    retval = quant_to_spec(hDecoder, ics2, spec_data2, spec_coef2, hDecoder->frameLength);
1161
73.5k
    if (retval > 0)
1162
11
        return retval;
1163
1164
#ifdef PROFILE
1165
    count = faad_get_ts() - count;
1166
    hDecoder->requant_cycles += count;
1167
#endif
1168
1169
    /* pns decoding */
1170
73.5k
    if (ics1->ms_mask_present)
1171
18.6k
    {
1172
18.6k
        pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 1, hDecoder->object_type,
1173
18.6k
            &(hDecoder->__r1), &(hDecoder->__r2));
1174
54.8k
    } else {
1175
54.8k
        pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 0, hDecoder->object_type,
1176
54.8k
            &(hDecoder->__r1), &(hDecoder->__r2));
1177
54.8k
    }
1178
1179
    /* mid/side decoding */
1180
73.5k
    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
73.5k
    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
#ifdef MAIN_DEC
1218
    /* MAIN object type prediction */
1219
23.5k
    if (hDecoder->object_type == MAIN)
1220
10.7k
    {
1221
        /* intra channel prediction */
1222
10.7k
        ic_prediction(ics1, spec_coef1, hDecoder->pred_stat[cpe->channel], hDecoder->frameLength,
1223
10.7k
            hDecoder->sf_index);
1224
10.7k
        ic_prediction(ics2, spec_coef2, hDecoder->pred_stat[cpe->paired_channel], hDecoder->frameLength,
1225
10.7k
            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
10.7k
        pns_reset_pred_state(ics1, hDecoder->pred_stat[cpe->channel]);
1232
10.7k
        pns_reset_pred_state(ics2, hDecoder->pred_stat[cpe->paired_channel]);
1233
10.7k
    }
1234
#endif
1235
1236
#ifdef LTP_DEC
1237
44.0k
    if (is_ltp_ot(hDecoder->object_type))
1238
17.4k
    {
1239
17.4k
        ltp_info *ltp1 = &(ics1->ltp);
1240
17.4k
        ltp_info *ltp2 = (cpe->common_window) ? &(ics2->ltp2) : &(ics2->ltp);
1241
17.4k
#ifdef LD_DEC
1242
17.4k
        if (hDecoder->object_type == LD)
1243
1.66k
        {
1244
1.66k
            if (ltp1->data_present)
1245
226
            {
1246
226
                if (ltp1->lag_update)
1247
91
                    hDecoder->ltp_lag[cpe->channel] = ltp1->lag;
1248
226
            }
1249
1.66k
            ltp1->lag = hDecoder->ltp_lag[cpe->channel];
1250
1.66k
            if (ltp2->data_present)
1251
76
            {
1252
76
                if (ltp2->lag_update)
1253
31
                    hDecoder->ltp_lag[cpe->paired_channel] = ltp2->lag;
1254
76
            }
1255
1.66k
            ltp2->lag = hDecoder->ltp_lag[cpe->paired_channel];
1256
1.66k
        }
1257
17.4k
#endif
1258
1259
        /* long term prediction */
1260
17.4k
        lt_prediction(ics1, ltp1, spec_coef1, hDecoder->lt_pred_stat[cpe->channel], hDecoder->fb,
1261
17.4k
            ics1->window_shape, hDecoder->window_shape_prev[cpe->channel],
1262
17.4k
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1263
17.4k
        lt_prediction(ics2, ltp2, spec_coef2, hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->fb,
1264
17.4k
            ics2->window_shape, hDecoder->window_shape_prev[cpe->paired_channel],
1265
17.4k
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1266
17.4k
    }
1267
#endif
1268
1269
    /* tns decoding */
1270
73.5k
    tns_decode_frame(ics1, &(ics1->tns), hDecoder->sf_index, hDecoder->object_type,
1271
73.5k
        spec_coef1, hDecoder->frameLength);
1272
73.5k
    tns_decode_frame(ics2, &(ics2->tns), hDecoder->sf_index, hDecoder->object_type,
1273
73.5k
        spec_coef2, hDecoder->frameLength);
1274
1275
    /* drc decoding */
1276
73.5k
#if APPLY_DRC
1277
73.5k
    if (hDecoder->drc->present)
1278
1.26k
    {
1279
1.26k
        if (!hDecoder->drc->exclude_mask[cpe->channel] || !hDecoder->drc->excluded_chns_present)
1280
1.14k
            drc_decode(hDecoder->drc, spec_coef1);
1281
1.26k
        if (!hDecoder->drc->exclude_mask[cpe->paired_channel] || !hDecoder->drc->excluded_chns_present)
1282
1.13k
            drc_decode(hDecoder->drc, spec_coef2);
1283
1.26k
    }
1284
73.5k
#endif
1285
    /* filter bank */
1286
#ifdef SSR_DEC
1287
    if (hDecoder->object_type != SSR)
1288
    {
1289
#endif
1290
73.5k
        ifilter_bank(hDecoder->fb, ics1->window_sequence, ics1->window_shape,
1291
73.5k
            hDecoder->window_shape_prev[cpe->channel], spec_coef1,
1292
73.5k
            hDecoder->time_out[cpe->channel], hDecoder->fb_intermed[cpe->channel],
1293
73.5k
            hDecoder->object_type, hDecoder->frameLength);
1294
73.5k
        ifilter_bank(hDecoder->fb, ics2->window_sequence, ics2->window_shape,
1295
73.5k
            hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2,
1296
73.5k
            hDecoder->time_out[cpe->paired_channel], hDecoder->fb_intermed[cpe->paired_channel],
1297
73.5k
            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
73.5k
    hDecoder->window_shape_prev[cpe->channel] = ics1->window_shape;
1313
73.5k
    hDecoder->window_shape_prev[cpe->paired_channel] = ics2->window_shape;
1314
1315
#ifdef LTP_DEC
1316
44.0k
    if (is_ltp_ot(hDecoder->object_type))
1317
17.4k
    {
1318
17.4k
        lt_update_state(hDecoder->lt_pred_stat[cpe->channel], hDecoder->time_out[cpe->channel],
1319
17.4k
            hDecoder->fb_intermed[cpe->channel], hDecoder->frameLength, hDecoder->object_type);
1320
17.4k
        lt_update_state(hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->time_out[cpe->paired_channel],
1321
17.4k
            hDecoder->fb_intermed[cpe->paired_channel], hDecoder->frameLength, hDecoder->object_type);
1322
17.4k
    }
1323
#endif
1324
1325
73.5k
#ifdef SBR_DEC
1326
73.5k
    if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1327
73.5k
        && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1328
62.2k
    {
1329
62.2k
        int ele = hDecoder->fr_ch_ele;
1330
62.2k
        int ch0 = cpe->channel;
1331
62.2k
        int ch1 = cpe->paired_channel;
1332
1333
        /* following case can happen when forceUpSampling == 1 */
1334
62.2k
        if (hDecoder->sbr[ele] == NULL)
1335
20.4k
        {
1336
20.4k
            hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
1337
20.4k
                hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
1338
20.4k
                hDecoder->downSampledSBR
1339
#ifdef DRM
1340
                , 0
1341
#endif
1342
20.4k
                );
1343
20.4k
        }
1344
62.2k
        if (!hDecoder->sbr[ele])
1345
98
            return 19;
1346
1347
62.1k
        if (cpe->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
1348
2.96k
            hDecoder->sbr[ele]->maxAACLine = 8*min(cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)], cpe->ics1.swb_offset_max);
1349
59.1k
        else
1350
59.1k
            hDecoder->sbr[ele]->maxAACLine = min(cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)], cpe->ics1.swb_offset_max);
1351
1352
62.1k
        retval = sbrDecodeCoupleFrame(hDecoder->sbr[ele],
1353
62.1k
            hDecoder->time_out[ch0], hDecoder->time_out[ch1],
1354
62.1k
            hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
1355
62.1k
        if (retval > 0)
1356
7
            return retval;
1357
62.1k
    } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1358
11.2k
        && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1359
5
    {
1360
5
        return 23;
1361
5
    }
1362
73.3k
#endif
1363
1364
73.3k
    return 0;
1365
73.5k
}
reconstruct_channel_pair
Line
Count
Source
1133
29.5k
{
1134
29.5k
    uint8_t retval;
1135
29.5k
    ALIGN real_t spec_coef1[1024];
1136
29.5k
    ALIGN real_t spec_coef2[1024];
1137
1138
#ifdef PROFILE
1139
    int64_t count = faad_get_ts();
1140
#endif
1141
29.5k
    if (hDecoder->element_alloced[hDecoder->fr_ch_ele] != 2)
1142
25.0k
    {
1143
25.0k
        retval = allocate_channel_pair(hDecoder, cpe->channel, (uint8_t)cpe->paired_channel);
1144
25.0k
        if (retval > 0)
1145
0
            return retval;
1146
1147
25.0k
        hDecoder->element_alloced[hDecoder->fr_ch_ele] = 2;
1148
25.0k
    }
1149
1150
    /* sanity check, CVE-2018-20199, CVE-2018-20360 */
1151
29.5k
    if(!hDecoder->time_out[cpe->channel] || !hDecoder->time_out[cpe->paired_channel])
1152
0
        return 15;
1153
29.5k
    if(!hDecoder->fb_intermed[cpe->channel] || !hDecoder->fb_intermed[cpe->paired_channel])
1154
0
        return 15;
1155
1156
    /* dequantisation and scaling */
1157
29.5k
    retval = quant_to_spec(hDecoder, ics1, spec_data1, spec_coef1, hDecoder->frameLength);
1158
29.5k
    if (retval > 0)
1159
48
        return retval;
1160
29.4k
    retval = quant_to_spec(hDecoder, ics2, spec_data2, spec_coef2, hDecoder->frameLength);
1161
29.4k
    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
29.4k
    if (ics1->ms_mask_present)
1171
7.87k
    {
1172
7.87k
        pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 1, hDecoder->object_type,
1173
7.87k
            &(hDecoder->__r1), &(hDecoder->__r2));
1174
21.6k
    } else {
1175
21.6k
        pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 0, hDecoder->object_type,
1176
21.6k
            &(hDecoder->__r1), &(hDecoder->__r2));
1177
21.6k
    }
1178
1179
    /* mid/side decoding */
1180
29.4k
    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
29.4k
    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
#ifdef MAIN_DEC
1218
    /* MAIN object type prediction */
1219
    if (hDecoder->object_type == MAIN)
1220
    {
1221
        /* intra channel prediction */
1222
        ic_prediction(ics1, spec_coef1, hDecoder->pred_stat[cpe->channel], hDecoder->frameLength,
1223
            hDecoder->sf_index);
1224
        ic_prediction(ics2, spec_coef2, hDecoder->pred_stat[cpe->paired_channel], hDecoder->frameLength,
1225
            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
        pns_reset_pred_state(ics1, hDecoder->pred_stat[cpe->channel]);
1232
        pns_reset_pred_state(ics2, hDecoder->pred_stat[cpe->paired_channel]);
1233
    }
1234
#endif
1235
1236
#ifdef LTP_DEC
1237
    if (is_ltp_ot(hDecoder->object_type))
1238
    {
1239
        ltp_info *ltp1 = &(ics1->ltp);
1240
        ltp_info *ltp2 = (cpe->common_window) ? &(ics2->ltp2) : &(ics2->ltp);
1241
#ifdef LD_DEC
1242
        if (hDecoder->object_type == LD)
1243
        {
1244
            if (ltp1->data_present)
1245
            {
1246
                if (ltp1->lag_update)
1247
                    hDecoder->ltp_lag[cpe->channel] = ltp1->lag;
1248
            }
1249
            ltp1->lag = hDecoder->ltp_lag[cpe->channel];
1250
            if (ltp2->data_present)
1251
            {
1252
                if (ltp2->lag_update)
1253
                    hDecoder->ltp_lag[cpe->paired_channel] = ltp2->lag;
1254
            }
1255
            ltp2->lag = hDecoder->ltp_lag[cpe->paired_channel];
1256
        }
1257
#endif
1258
1259
        /* long term prediction */
1260
        lt_prediction(ics1, ltp1, spec_coef1, hDecoder->lt_pred_stat[cpe->channel], hDecoder->fb,
1261
            ics1->window_shape, hDecoder->window_shape_prev[cpe->channel],
1262
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1263
        lt_prediction(ics2, ltp2, spec_coef2, hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->fb,
1264
            ics2->window_shape, hDecoder->window_shape_prev[cpe->paired_channel],
1265
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1266
    }
1267
#endif
1268
1269
    /* tns decoding */
1270
29.4k
    tns_decode_frame(ics1, &(ics1->tns), hDecoder->sf_index, hDecoder->object_type,
1271
29.4k
        spec_coef1, hDecoder->frameLength);
1272
29.4k
    tns_decode_frame(ics2, &(ics2->tns), hDecoder->sf_index, hDecoder->object_type,
1273
29.4k
        spec_coef2, hDecoder->frameLength);
1274
1275
    /* drc decoding */
1276
29.4k
#if APPLY_DRC
1277
29.4k
    if (hDecoder->drc->present)
1278
0
    {
1279
0
        if (!hDecoder->drc->exclude_mask[cpe->channel] || !hDecoder->drc->excluded_chns_present)
1280
0
            drc_decode(hDecoder->drc, spec_coef1);
1281
0
        if (!hDecoder->drc->exclude_mask[cpe->paired_channel] || !hDecoder->drc->excluded_chns_present)
1282
0
            drc_decode(hDecoder->drc, spec_coef2);
1283
0
    }
1284
29.4k
#endif
1285
    /* filter bank */
1286
#ifdef SSR_DEC
1287
    if (hDecoder->object_type != SSR)
1288
    {
1289
#endif
1290
29.4k
        ifilter_bank(hDecoder->fb, ics1->window_sequence, ics1->window_shape,
1291
29.4k
            hDecoder->window_shape_prev[cpe->channel], spec_coef1,
1292
29.4k
            hDecoder->time_out[cpe->channel], hDecoder->fb_intermed[cpe->channel],
1293
29.4k
            hDecoder->object_type, hDecoder->frameLength);
1294
29.4k
        ifilter_bank(hDecoder->fb, ics2->window_sequence, ics2->window_shape,
1295
29.4k
            hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2,
1296
29.4k
            hDecoder->time_out[cpe->paired_channel], hDecoder->fb_intermed[cpe->paired_channel],
1297
29.4k
            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
29.4k
    hDecoder->window_shape_prev[cpe->channel] = ics1->window_shape;
1313
29.4k
    hDecoder->window_shape_prev[cpe->paired_channel] = ics2->window_shape;
1314
1315
#ifdef LTP_DEC
1316
    if (is_ltp_ot(hDecoder->object_type))
1317
    {
1318
        lt_update_state(hDecoder->lt_pred_stat[cpe->channel], hDecoder->time_out[cpe->channel],
1319
            hDecoder->fb_intermed[cpe->channel], hDecoder->frameLength, hDecoder->object_type);
1320
        lt_update_state(hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->time_out[cpe->paired_channel],
1321
            hDecoder->fb_intermed[cpe->paired_channel], hDecoder->frameLength, hDecoder->object_type);
1322
    }
1323
#endif
1324
1325
29.4k
#ifdef SBR_DEC
1326
29.4k
    if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1327
29.4k
        && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1328
26.4k
    {
1329
26.4k
        int ele = hDecoder->fr_ch_ele;
1330
26.4k
        int ch0 = cpe->channel;
1331
26.4k
        int ch1 = cpe->paired_channel;
1332
1333
        /* following case can happen when forceUpSampling == 1 */
1334
26.4k
        if (hDecoder->sbr[ele] == NULL)
1335
7.18k
        {
1336
7.18k
            hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
1337
7.18k
                hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
1338
7.18k
                hDecoder->downSampledSBR
1339
7.18k
#ifdef DRM
1340
7.18k
                , 0
1341
7.18k
#endif
1342
7.18k
                );
1343
7.18k
        }
1344
26.4k
        if (!hDecoder->sbr[ele])
1345
0
            return 19;
1346
1347
26.4k
        if (cpe->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
1348
1.32k
            hDecoder->sbr[ele]->maxAACLine = 8*min(cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)], cpe->ics1.swb_offset_max);
1349
25.1k
        else
1350
25.1k
            hDecoder->sbr[ele]->maxAACLine = min(cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)], cpe->ics1.swb_offset_max);
1351
1352
26.4k
        retval = sbrDecodeCoupleFrame(hDecoder->sbr[ele],
1353
26.4k
            hDecoder->time_out[ch0], hDecoder->time_out[ch1],
1354
26.4k
            hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
1355
26.4k
        if (retval > 0)
1356
7
            return retval;
1357
26.4k
    } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1358
2.99k
        && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1359
1
    {
1360
1
        return 23;
1361
1
    }
1362
29.4k
#endif
1363
1364
29.4k
    return 0;
1365
29.4k
}
reconstruct_channel_pair
Line
Count
Source
1133
23.6k
{
1134
23.6k
    uint8_t retval;
1135
23.6k
    ALIGN real_t spec_coef1[1024];
1136
23.6k
    ALIGN real_t spec_coef2[1024];
1137
1138
#ifdef PROFILE
1139
    int64_t count = faad_get_ts();
1140
#endif
1141
23.6k
    if (hDecoder->element_alloced[hDecoder->fr_ch_ele] != 2)
1142
20.2k
    {
1143
20.2k
        retval = allocate_channel_pair(hDecoder, cpe->channel, (uint8_t)cpe->paired_channel);
1144
20.2k
        if (retval > 0)
1145
0
            return retval;
1146
1147
20.2k
        hDecoder->element_alloced[hDecoder->fr_ch_ele] = 2;
1148
20.2k
    }
1149
1150
    /* sanity check, CVE-2018-20199, CVE-2018-20360 */
1151
23.6k
    if(!hDecoder->time_out[cpe->channel] || !hDecoder->time_out[cpe->paired_channel])
1152
0
        return 15;
1153
23.6k
    if(!hDecoder->fb_intermed[cpe->channel] || !hDecoder->fb_intermed[cpe->paired_channel])
1154
0
        return 15;
1155
1156
    /* dequantisation and scaling */
1157
23.6k
    retval = quant_to_spec(hDecoder, ics1, spec_data1, spec_coef1, hDecoder->frameLength);
1158
23.6k
    if (retval > 0)
1159
68
        return retval;
1160
23.5k
    retval = quant_to_spec(hDecoder, ics2, spec_data2, spec_coef2, hDecoder->frameLength);
1161
23.5k
    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.5k
    if (ics1->ms_mask_present)
1171
6.28k
    {
1172
6.28k
        pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 1, hDecoder->object_type,
1173
6.28k
            &(hDecoder->__r1), &(hDecoder->__r2));
1174
17.2k
    } else {
1175
17.2k
        pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 0, hDecoder->object_type,
1176
17.2k
            &(hDecoder->__r1), &(hDecoder->__r2));
1177
17.2k
    }
1178
1179
    /* mid/side decoding */
1180
23.5k
    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.5k
    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.5k
#ifdef MAIN_DEC
1218
    /* MAIN object type prediction */
1219
23.5k
    if (hDecoder->object_type == MAIN)
1220
10.7k
    {
1221
        /* intra channel prediction */
1222
10.7k
        ic_prediction(ics1, spec_coef1, hDecoder->pred_stat[cpe->channel], hDecoder->frameLength,
1223
10.7k
            hDecoder->sf_index);
1224
10.7k
        ic_prediction(ics2, spec_coef2, hDecoder->pred_stat[cpe->paired_channel], hDecoder->frameLength,
1225
10.7k
            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
10.7k
        pns_reset_pred_state(ics1, hDecoder->pred_stat[cpe->channel]);
1232
10.7k
        pns_reset_pred_state(ics2, hDecoder->pred_stat[cpe->paired_channel]);
1233
10.7k
    }
1234
23.5k
#endif
1235
1236
23.5k
#ifdef LTP_DEC
1237
23.5k
    if (is_ltp_ot(hDecoder->object_type))
1238
9.29k
    {
1239
9.29k
        ltp_info *ltp1 = &(ics1->ltp);
1240
9.29k
        ltp_info *ltp2 = (cpe->common_window) ? &(ics2->ltp2) : &(ics2->ltp);
1241
9.29k
#ifdef LD_DEC
1242
9.29k
        if (hDecoder->object_type == LD)
1243
918
        {
1244
918
            if (ltp1->data_present)
1245
125
            {
1246
125
                if (ltp1->lag_update)
1247
51
                    hDecoder->ltp_lag[cpe->channel] = ltp1->lag;
1248
125
            }
1249
918
            ltp1->lag = hDecoder->ltp_lag[cpe->channel];
1250
918
            if (ltp2->data_present)
1251
59
            {
1252
59
                if (ltp2->lag_update)
1253
23
                    hDecoder->ltp_lag[cpe->paired_channel] = ltp2->lag;
1254
59
            }
1255
918
            ltp2->lag = hDecoder->ltp_lag[cpe->paired_channel];
1256
918
        }
1257
9.29k
#endif
1258
1259
        /* long term prediction */
1260
9.29k
        lt_prediction(ics1, ltp1, spec_coef1, hDecoder->lt_pred_stat[cpe->channel], hDecoder->fb,
1261
9.29k
            ics1->window_shape, hDecoder->window_shape_prev[cpe->channel],
1262
9.29k
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1263
9.29k
        lt_prediction(ics2, ltp2, spec_coef2, hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->fb,
1264
9.29k
            ics2->window_shape, hDecoder->window_shape_prev[cpe->paired_channel],
1265
9.29k
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1266
9.29k
    }
1267
23.5k
#endif
1268
1269
    /* tns decoding */
1270
23.5k
    tns_decode_frame(ics1, &(ics1->tns), hDecoder->sf_index, hDecoder->object_type,
1271
23.5k
        spec_coef1, hDecoder->frameLength);
1272
23.5k
    tns_decode_frame(ics2, &(ics2->tns), hDecoder->sf_index, hDecoder->object_type,
1273
23.5k
        spec_coef2, hDecoder->frameLength);
1274
1275
    /* drc decoding */
1276
23.5k
#if APPLY_DRC
1277
23.5k
    if (hDecoder->drc->present)
1278
532
    {
1279
532
        if (!hDecoder->drc->exclude_mask[cpe->channel] || !hDecoder->drc->excluded_chns_present)
1280
452
            drc_decode(hDecoder->drc, spec_coef1);
1281
532
        if (!hDecoder->drc->exclude_mask[cpe->paired_channel] || !hDecoder->drc->excluded_chns_present)
1282
452
            drc_decode(hDecoder->drc, spec_coef2);
1283
532
    }
1284
23.5k
#endif
1285
    /* filter bank */
1286
#ifdef SSR_DEC
1287
    if (hDecoder->object_type != SSR)
1288
    {
1289
#endif
1290
23.5k
        ifilter_bank(hDecoder->fb, ics1->window_sequence, ics1->window_shape,
1291
23.5k
            hDecoder->window_shape_prev[cpe->channel], spec_coef1,
1292
23.5k
            hDecoder->time_out[cpe->channel], hDecoder->fb_intermed[cpe->channel],
1293
23.5k
            hDecoder->object_type, hDecoder->frameLength);
1294
23.5k
        ifilter_bank(hDecoder->fb, ics2->window_sequence, ics2->window_shape,
1295
23.5k
            hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2,
1296
23.5k
            hDecoder->time_out[cpe->paired_channel], hDecoder->fb_intermed[cpe->paired_channel],
1297
23.5k
            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.5k
    hDecoder->window_shape_prev[cpe->channel] = ics1->window_shape;
1313
23.5k
    hDecoder->window_shape_prev[cpe->paired_channel] = ics2->window_shape;
1314
1315
23.5k
#ifdef LTP_DEC
1316
23.5k
    if (is_ltp_ot(hDecoder->object_type))
1317
9.29k
    {
1318
9.29k
        lt_update_state(hDecoder->lt_pred_stat[cpe->channel], hDecoder->time_out[cpe->channel],
1319
9.29k
            hDecoder->fb_intermed[cpe->channel], hDecoder->frameLength, hDecoder->object_type);
1320
9.29k
        lt_update_state(hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->time_out[cpe->paired_channel],
1321
9.29k
            hDecoder->fb_intermed[cpe->paired_channel], hDecoder->frameLength, hDecoder->object_type);
1322
9.29k
    }
1323
23.5k
#endif
1324
1325
23.5k
#ifdef SBR_DEC
1326
23.5k
    if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1327
23.5k
        && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1328
18.5k
    {
1329
18.5k
        int ele = hDecoder->fr_ch_ele;
1330
18.5k
        int ch0 = cpe->channel;
1331
18.5k
        int ch1 = cpe->paired_channel;
1332
1333
        /* following case can happen when forceUpSampling == 1 */
1334
18.5k
        if (hDecoder->sbr[ele] == NULL)
1335
7.18k
        {
1336
7.18k
            hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
1337
7.18k
                hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
1338
7.18k
                hDecoder->downSampledSBR
1339
#ifdef DRM
1340
                , 0
1341
#endif
1342
7.18k
                );
1343
7.18k
        }
1344
18.5k
        if (!hDecoder->sbr[ele])
1345
41
            return 19;
1346
1347
18.4k
        if (cpe->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
1348
860
            hDecoder->sbr[ele]->maxAACLine = 8*min(cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)], cpe->ics1.swb_offset_max);
1349
17.6k
        else
1350
17.6k
            hDecoder->sbr[ele]->maxAACLine = min(cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)], cpe->ics1.swb_offset_max);
1351
1352
18.4k
        retval = sbrDecodeCoupleFrame(hDecoder->sbr[ele],
1353
18.4k
            hDecoder->time_out[ch0], hDecoder->time_out[ch1],
1354
18.4k
            hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
1355
18.4k
        if (retval > 0)
1356
0
            return retval;
1357
18.4k
    } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1358
5.04k
        && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1359
1
    {
1360
1
        return 23;
1361
1
    }
1362
23.5k
#endif
1363
1364
23.5k
    return 0;
1365
23.5k
}
reconstruct_channel_pair
Line
Count
Source
1133
20.4k
{
1134
20.4k
    uint8_t retval;
1135
20.4k
    ALIGN real_t spec_coef1[1024];
1136
20.4k
    ALIGN real_t spec_coef2[1024];
1137
1138
#ifdef PROFILE
1139
    int64_t count = faad_get_ts();
1140
#endif
1141
20.4k
    if (hDecoder->element_alloced[hDecoder->fr_ch_ele] != 2)
1142
17.4k
    {
1143
17.4k
        retval = allocate_channel_pair(hDecoder, cpe->channel, (uint8_t)cpe->paired_channel);
1144
17.4k
        if (retval > 0)
1145
0
            return retval;
1146
1147
17.4k
        hDecoder->element_alloced[hDecoder->fr_ch_ele] = 2;
1148
17.4k
    }
1149
1150
    /* sanity check, CVE-2018-20199, CVE-2018-20360 */
1151
20.4k
    if(!hDecoder->time_out[cpe->channel] || !hDecoder->time_out[cpe->paired_channel])
1152
0
        return 15;
1153
20.4k
    if(!hDecoder->fb_intermed[cpe->channel] || !hDecoder->fb_intermed[cpe->paired_channel])
1154
0
        return 15;
1155
1156
    /* dequantisation and scaling */
1157
20.4k
    retval = quant_to_spec(hDecoder, ics1, spec_data1, spec_coef1, hDecoder->frameLength);
1158
20.4k
    if (retval > 0)
1159
15
        return retval;
1160
20.4k
    retval = quant_to_spec(hDecoder, ics2, spec_data2, spec_coef2, hDecoder->frameLength);
1161
20.4k
    if (retval > 0)
1162
5
        return retval;
1163
1164
#ifdef PROFILE
1165
    count = faad_get_ts() - count;
1166
    hDecoder->requant_cycles += count;
1167
#endif
1168
1169
    /* pns decoding */
1170
20.4k
    if (ics1->ms_mask_present)
1171
4.52k
    {
1172
4.52k
        pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 1, hDecoder->object_type,
1173
4.52k
            &(hDecoder->__r1), &(hDecoder->__r2));
1174
15.9k
    } else {
1175
15.9k
        pns_decode(ics1, ics2, spec_coef1, spec_coef2, hDecoder->frameLength, 0, hDecoder->object_type,
1176
15.9k
            &(hDecoder->__r1), &(hDecoder->__r2));
1177
15.9k
    }
1178
1179
    /* mid/side decoding */
1180
20.4k
    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
20.4k
    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
#ifdef MAIN_DEC
1218
    /* MAIN object type prediction */
1219
    if (hDecoder->object_type == MAIN)
1220
    {
1221
        /* intra channel prediction */
1222
        ic_prediction(ics1, spec_coef1, hDecoder->pred_stat[cpe->channel], hDecoder->frameLength,
1223
            hDecoder->sf_index);
1224
        ic_prediction(ics2, spec_coef2, hDecoder->pred_stat[cpe->paired_channel], hDecoder->frameLength,
1225
            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
        pns_reset_pred_state(ics1, hDecoder->pred_stat[cpe->channel]);
1232
        pns_reset_pred_state(ics2, hDecoder->pred_stat[cpe->paired_channel]);
1233
    }
1234
#endif
1235
1236
20.4k
#ifdef LTP_DEC
1237
20.4k
    if (is_ltp_ot(hDecoder->object_type))
1238
8.11k
    {
1239
8.11k
        ltp_info *ltp1 = &(ics1->ltp);
1240
8.11k
        ltp_info *ltp2 = (cpe->common_window) ? &(ics2->ltp2) : &(ics2->ltp);
1241
8.11k
#ifdef LD_DEC
1242
8.11k
        if (hDecoder->object_type == LD)
1243
746
        {
1244
746
            if (ltp1->data_present)
1245
101
            {
1246
101
                if (ltp1->lag_update)
1247
40
                    hDecoder->ltp_lag[cpe->channel] = ltp1->lag;
1248
101
            }
1249
746
            ltp1->lag = hDecoder->ltp_lag[cpe->channel];
1250
746
            if (ltp2->data_present)
1251
17
            {
1252
17
                if (ltp2->lag_update)
1253
8
                    hDecoder->ltp_lag[cpe->paired_channel] = ltp2->lag;
1254
17
            }
1255
746
            ltp2->lag = hDecoder->ltp_lag[cpe->paired_channel];
1256
746
        }
1257
8.11k
#endif
1258
1259
        /* long term prediction */
1260
8.11k
        lt_prediction(ics1, ltp1, spec_coef1, hDecoder->lt_pred_stat[cpe->channel], hDecoder->fb,
1261
8.11k
            ics1->window_shape, hDecoder->window_shape_prev[cpe->channel],
1262
8.11k
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1263
8.11k
        lt_prediction(ics2, ltp2, spec_coef2, hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->fb,
1264
8.11k
            ics2->window_shape, hDecoder->window_shape_prev[cpe->paired_channel],
1265
8.11k
            hDecoder->sf_index, hDecoder->object_type, hDecoder->frameLength);
1266
8.11k
    }
1267
20.4k
#endif
1268
1269
    /* tns decoding */
1270
20.4k
    tns_decode_frame(ics1, &(ics1->tns), hDecoder->sf_index, hDecoder->object_type,
1271
20.4k
        spec_coef1, hDecoder->frameLength);
1272
20.4k
    tns_decode_frame(ics2, &(ics2->tns), hDecoder->sf_index, hDecoder->object_type,
1273
20.4k
        spec_coef2, hDecoder->frameLength);
1274
1275
    /* drc decoding */
1276
20.4k
#if APPLY_DRC
1277
20.4k
    if (hDecoder->drc->present)
1278
730
    {
1279
730
        if (!hDecoder->drc->exclude_mask[cpe->channel] || !hDecoder->drc->excluded_chns_present)
1280
688
            drc_decode(hDecoder->drc, spec_coef1);
1281
730
        if (!hDecoder->drc->exclude_mask[cpe->paired_channel] || !hDecoder->drc->excluded_chns_present)
1282
682
            drc_decode(hDecoder->drc, spec_coef2);
1283
730
    }
1284
20.4k
#endif
1285
    /* filter bank */
1286
#ifdef SSR_DEC
1287
    if (hDecoder->object_type != SSR)
1288
    {
1289
#endif
1290
20.4k
        ifilter_bank(hDecoder->fb, ics1->window_sequence, ics1->window_shape,
1291
20.4k
            hDecoder->window_shape_prev[cpe->channel], spec_coef1,
1292
20.4k
            hDecoder->time_out[cpe->channel], hDecoder->fb_intermed[cpe->channel],
1293
20.4k
            hDecoder->object_type, hDecoder->frameLength);
1294
20.4k
        ifilter_bank(hDecoder->fb, ics2->window_sequence, ics2->window_shape,
1295
20.4k
            hDecoder->window_shape_prev[cpe->paired_channel], spec_coef2,
1296
20.4k
            hDecoder->time_out[cpe->paired_channel], hDecoder->fb_intermed[cpe->paired_channel],
1297
20.4k
            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
20.4k
    hDecoder->window_shape_prev[cpe->channel] = ics1->window_shape;
1313
20.4k
    hDecoder->window_shape_prev[cpe->paired_channel] = ics2->window_shape;
1314
1315
20.4k
#ifdef LTP_DEC
1316
20.4k
    if (is_ltp_ot(hDecoder->object_type))
1317
8.11k
    {
1318
8.11k
        lt_update_state(hDecoder->lt_pred_stat[cpe->channel], hDecoder->time_out[cpe->channel],
1319
8.11k
            hDecoder->fb_intermed[cpe->channel], hDecoder->frameLength, hDecoder->object_type);
1320
8.11k
        lt_update_state(hDecoder->lt_pred_stat[cpe->paired_channel], hDecoder->time_out[cpe->paired_channel],
1321
8.11k
            hDecoder->fb_intermed[cpe->paired_channel], hDecoder->frameLength, hDecoder->object_type);
1322
8.11k
    }
1323
20.4k
#endif
1324
1325
20.4k
#ifdef SBR_DEC
1326
20.4k
    if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1327
20.4k
        && hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1328
17.2k
    {
1329
17.2k
        int ele = hDecoder->fr_ch_ele;
1330
17.2k
        int ch0 = cpe->channel;
1331
17.2k
        int ch1 = cpe->paired_channel;
1332
1333
        /* following case can happen when forceUpSampling == 1 */
1334
17.2k
        if (hDecoder->sbr[ele] == NULL)
1335
6.06k
        {
1336
6.06k
            hDecoder->sbr[ele] = sbrDecodeInit(hDecoder->frameLength,
1337
6.06k
                hDecoder->element_id[ele], 2*get_sample_rate(hDecoder->sf_index),
1338
6.06k
                hDecoder->downSampledSBR
1339
#ifdef DRM
1340
                , 0
1341
#endif
1342
6.06k
                );
1343
6.06k
        }
1344
17.2k
        if (!hDecoder->sbr[ele])
1345
57
            return 19;
1346
1347
17.1k
        if (cpe->ics1.window_sequence == EIGHT_SHORT_SEQUENCE)
1348
781
            hDecoder->sbr[ele]->maxAACLine = 8*min(cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)], cpe->ics1.swb_offset_max);
1349
16.4k
        else
1350
16.4k
            hDecoder->sbr[ele]->maxAACLine = min(cpe->ics1.swb_offset[max(cpe->ics1.max_sfb-1, 0)], cpe->ics1.swb_offset_max);
1351
1352
17.1k
        retval = sbrDecodeCoupleFrame(hDecoder->sbr[ele],
1353
17.1k
            hDecoder->time_out[ch0], hDecoder->time_out[ch1],
1354
17.1k
            hDecoder->postSeekResetFlag, hDecoder->downSampledSBR);
1355
17.1k
        if (retval > 0)
1356
0
            return retval;
1357
17.1k
    } else if (((hDecoder->sbr_present_flag == 1) || (hDecoder->forceUpSampling == 1))
1358
3.21k
        && !hDecoder->sbr_alloced[hDecoder->fr_ch_ele])
1359
3
    {
1360
3
        return 23;
1361
3
    }
1362
20.3k
#endif
1363
1364
20.3k
    return 0;
1365
20.4k
}