GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/dca_lbr.c Lines: 20 1012 2.0 %
Date: 2021-04-19 06:27:07 Branches: 9 692 1.3 %

Line Branch Exec Source
1
/*
2
 * Copyright (C) 2016 foo86
3
 *
4
 * This file is part of FFmpeg.
5
 *
6
 * FFmpeg is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2.1 of the License, or (at your option) any later version.
10
 *
11
 * FFmpeg is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with FFmpeg; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19
 */
20
21
#define BITSTREAM_READER_LE
22
23
#include "libavutil/channel_layout.h"
24
#include "libavutil/mem_internal.h"
25
26
#include "dcadec.h"
27
#include "dcadata.h"
28
#include "dcahuff.h"
29
#include "dca_syncwords.h"
30
#include "bytestream.h"
31
32
#define AMP_MAX     56
33
34
enum LBRFlags {
35
    LBR_FLAG_24_BIT             = 0x01,
36
    LBR_FLAG_LFE_PRESENT        = 0x02,
37
    LBR_FLAG_BAND_LIMIT_2_3     = 0x04,
38
    LBR_FLAG_BAND_LIMIT_1_2     = 0x08,
39
    LBR_FLAG_BAND_LIMIT_1_3     = 0x0c,
40
    LBR_FLAG_BAND_LIMIT_1_4     = 0x10,
41
    LBR_FLAG_BAND_LIMIT_1_8     = 0x18,
42
    LBR_FLAG_BAND_LIMIT_NONE    = 0x14,
43
    LBR_FLAG_BAND_LIMIT_MASK    = 0x1c,
44
    LBR_FLAG_DMIX_STEREO        = 0x20,
45
    LBR_FLAG_DMIX_MULTI_CH      = 0x40
46
};
47
48
enum LBRChunkTypes {
49
    LBR_CHUNK_NULL              = 0x00,
50
    LBR_CHUNK_PAD               = 0x01,
51
    LBR_CHUNK_FRAME             = 0x04,
52
    LBR_CHUNK_FRAME_NO_CSUM     = 0x06,
53
    LBR_CHUNK_LFE               = 0x0a,
54
    LBR_CHUNK_ECS               = 0x0b,
55
    LBR_CHUNK_RESERVED_1        = 0x0c,
56
    LBR_CHUNK_RESERVED_2        = 0x0d,
57
    LBR_CHUNK_SCF               = 0x0e,
58
    LBR_CHUNK_TONAL             = 0x10,
59
    LBR_CHUNK_TONAL_GRP_1       = 0x11,
60
    LBR_CHUNK_TONAL_GRP_2       = 0x12,
61
    LBR_CHUNK_TONAL_GRP_3       = 0x13,
62
    LBR_CHUNK_TONAL_GRP_4       = 0x14,
63
    LBR_CHUNK_TONAL_GRP_5       = 0x15,
64
    LBR_CHUNK_TONAL_SCF         = 0x16,
65
    LBR_CHUNK_TONAL_SCF_GRP_1   = 0x17,
66
    LBR_CHUNK_TONAL_SCF_GRP_2   = 0x18,
67
    LBR_CHUNK_TONAL_SCF_GRP_3   = 0x19,
68
    LBR_CHUNK_TONAL_SCF_GRP_4   = 0x1a,
69
    LBR_CHUNK_TONAL_SCF_GRP_5   = 0x1b,
70
    LBR_CHUNK_RES_GRID_LR       = 0x30,
71
    LBR_CHUNK_RES_GRID_LR_LAST  = 0x3f,
72
    LBR_CHUNK_RES_GRID_HR       = 0x40,
73
    LBR_CHUNK_RES_GRID_HR_LAST  = 0x4f,
74
    LBR_CHUNK_RES_TS_1          = 0x50,
75
    LBR_CHUNK_RES_TS_1_LAST     = 0x5f,
76
    LBR_CHUNK_RES_TS_2          = 0x60,
77
    LBR_CHUNK_RES_TS_2_LAST     = 0x6f,
78
    LBR_CHUNK_EXTENSION         = 0x7f
79
};
80
81
typedef struct LBRChunk {
82
    int id, len;
83
    const uint8_t *data;
84
} LBRChunk;
85
86
static const int8_t channel_reorder_nolfe[7][5] = {
87
    { 0, -1, -1, -1, -1 },  // C
88
    { 0,  1, -1, -1, -1 },  // LR
89
    { 0,  1,  2, -1, -1 },  // LR C
90
    { 0,  1, -1, -1, -1 },  // LsRs
91
    { 1,  2,  0, -1, -1 },  // LsRs C
92
    { 0,  1,  2,  3, -1 },  // LR LsRs
93
    { 0,  1,  3,  4,  2 },  // LR LsRs C
94
};
95
96
static const int8_t channel_reorder_lfe[7][5] = {
97
    { 0, -1, -1, -1, -1 },  // C
98
    { 0,  1, -1, -1, -1 },  // LR
99
    { 0,  1,  2, -1, -1 },  // LR C
100
    { 1,  2, -1, -1, -1 },  // LsRs
101
    { 2,  3,  0, -1, -1 },  // LsRs C
102
    { 0,  1,  3,  4, -1 },  // LR LsRs
103
    { 0,  1,  4,  5,  2 },  // LR LsRs C
104
};
105
106
static const uint8_t lfe_index[7] = {
107
    1, 2, 3, 0, 1, 2, 3
108
};
109
110
static const uint8_t channel_counts[7] = {
111
    1, 2, 3, 2, 3, 4, 5
112
};
113
114
static const uint16_t channel_layouts[7] = {
115
    AV_CH_LAYOUT_MONO,
116
    AV_CH_LAYOUT_STEREO,
117
    AV_CH_LAYOUT_SURROUND,
118
    AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,
119
    AV_CH_FRONT_CENTER | AV_CH_SIDE_LEFT | AV_CH_SIDE_RIGHT,
120
    AV_CH_LAYOUT_2_2,
121
    AV_CH_LAYOUT_5POINT0
122
};
123
124
static float    cos_tab[256];
125
static float    lpc_tab[16];
126
127
92
static av_cold void init_tables(void)
128
{
129
    static int initialized;
130
    int i;
131
132
92
    if (initialized)
133
45
        return;
134
135
12079
    for (i = 0; i < 256; i++)
136
12032
        cos_tab[i] = cos(M_PI * i / 128);
137
138
799
    for (i = 0; i < 16; i++)
139
752
        lpc_tab[i] = sin((i - 8) * (M_PI / ((i < 8) ? 17 : 15)));
140
141
47
    initialized = 1;
142
}
143
144
static int parse_lfe_24(DCALbrDecoder *s)
145
{
146
    int step_max = FF_ARRAY_ELEMS(ff_dca_lfe_step_size_24) - 1;
147
    int i, ps, si, code, step_i;
148
    float step, value, delta;
149
150
    ps = get_bits(&s->gb, 24);
151
    si = ps >> 23;
152
153
    value = (((ps & 0x7fffff) ^ -si) + si) * (1.0f / 0x7fffff);
154
155
    step_i = get_bits(&s->gb, 8);
156
    if (step_i > step_max) {
157
        av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE step size index\n");
158
        return AVERROR_INVALIDDATA;
159
    }
160
161
    step = ff_dca_lfe_step_size_24[step_i];
162
163
    for (i = 0; i < 64; i++) {
164
        code = get_bits(&s->gb, 6);
165
166
        delta = step * 0.03125f;
167
        if (code & 16)
168
            delta += step;
169
        if (code & 8)
170
            delta += step * 0.5f;
171
        if (code & 4)
172
            delta += step * 0.25f;
173
        if (code & 2)
174
            delta += step * 0.125f;
175
        if (code & 1)
176
            delta += step * 0.0625f;
177
178
        if (code & 32) {
179
            value -= delta;
180
            if (value < -3.0f)
181
                value = -3.0f;
182
        } else {
183
            value += delta;
184
            if (value > 3.0f)
185
                value = 3.0f;
186
        }
187
188
        step_i += ff_dca_lfe_delta_index_24[code & 31];
189
        step_i = av_clip(step_i, 0, step_max);
190
191
        step = ff_dca_lfe_step_size_24[step_i];
192
        s->lfe_data[i] = value * s->lfe_scale;
193
    }
194
195
    return 0;
196
}
197
198
static int parse_lfe_16(DCALbrDecoder *s)
199
{
200
    int step_max = FF_ARRAY_ELEMS(ff_dca_lfe_step_size_16) - 1;
201
    int i, ps, si, code, step_i;
202
    float step, value, delta;
203
204
    ps = get_bits(&s->gb, 16);
205
    si = ps >> 15;
206
207
    value = (((ps & 0x7fff) ^ -si) + si) * (1.0f / 0x7fff);
208
209
    step_i = get_bits(&s->gb, 8);
210
    if (step_i > step_max) {
211
        av_log(s->avctx, AV_LOG_ERROR, "Invalid LFE step size index\n");
212
        return AVERROR_INVALIDDATA;
213
    }
214
215
    step = ff_dca_lfe_step_size_16[step_i];
216
217
    for (i = 0; i < 64; i++) {
218
        code = get_bits(&s->gb, 4);
219
220
        delta = step * 0.125f;
221
        if (code & 4)
222
            delta += step;
223
        if (code & 2)
224
            delta += step * 0.5f;
225
        if (code & 1)
226
            delta += step * 0.25f;
227
228
        if (code & 8) {
229
            value -= delta;
230
            if (value < -3.0f)
231
                value = -3.0f;
232
        } else {
233
            value += delta;
234
            if (value > 3.0f)
235
                value = 3.0f;
236
        }
237
238
        step_i += ff_dca_lfe_delta_index_16[code & 7];
239
        step_i = av_clip(step_i, 0, step_max);
240
241
        step = ff_dca_lfe_step_size_16[step_i];
242
        s->lfe_data[i] = value * s->lfe_scale;
243
    }
244
245
    return 0;
246
}
247
248
static int parse_lfe_chunk(DCALbrDecoder *s, LBRChunk *chunk)
249
{
250
    int ret;
251
252
    if (!(s->flags & LBR_FLAG_LFE_PRESENT))
253
        return 0;
254
255
    if (!chunk->len)
256
        return 0;
257
258
    ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
259
    if (ret < 0)
260
        return ret;
261
262
    // Determine bit depth from chunk size
263
    if (chunk->len >= 52)
264
        return parse_lfe_24(s);
265
    if (chunk->len >= 35)
266
        return parse_lfe_16(s);
267
268
    av_log(s->avctx, AV_LOG_ERROR, "LFE chunk too short\n");
269
    return AVERROR_INVALIDDATA;
270
}
271
272
static inline int parse_vlc(GetBitContext *s, VLC *vlc, int max_depth)
273
{
274
    int v = get_vlc2(s, vlc->table, vlc->bits, max_depth);
275
    if (v > 0)
276
        return v - 1;
277
    // Rare value
278
    return get_bits(s, get_bits(s, 3) + 1);
279
}
280
281
static int parse_tonal(DCALbrDecoder *s, int group)
282
{
283
    unsigned int amp[DCA_LBR_CHANNELS_TOTAL];
284
    unsigned int phs[DCA_LBR_CHANNELS_TOTAL];
285
    unsigned int diff, main_amp, shift;
286
    int sf, sf_idx, ch, main_ch, freq;
287
    int ch_nbits = av_ceil_log2(s->nchannels_total);
288
289
    // Parse subframes for this group
290
    for (sf = 0; sf < 1 << group; sf += diff ? 8 : 1) {
291
        sf_idx = ((s->framenum << group) + sf) & 31;
292
        s->tonal_bounds[group][sf_idx][0] = s->ntones;
293
294
        // Parse tones for this subframe
295
        for (freq = 1;; freq++) {
296
            if (get_bits_left(&s->gb) < 1) {
297
                av_log(s->avctx, AV_LOG_ERROR, "Tonal group chunk too short\n");
298
                return AVERROR_INVALIDDATA;
299
            }
300
301
            diff = parse_vlc(&s->gb, &ff_dca_vlc_tnl_grp[group], 2);
302
            if (diff >= FF_ARRAY_ELEMS(ff_dca_fst_amp)) {
303
                av_log(s->avctx, AV_LOG_ERROR, "Invalid tonal frequency diff\n");
304
                return AVERROR_INVALIDDATA;
305
            }
306
307
            diff = get_bitsz(&s->gb, diff >> 2) + ff_dca_fst_amp[diff];
308
            if (diff <= 1)
309
                break;  // End of subframe
310
311
            freq += diff - 2;
312
            if (freq >> (5 - group) > s->nsubbands * 4 - 6) {
313
                av_log(s->avctx, AV_LOG_ERROR, "Invalid spectral line offset\n");
314
                return AVERROR_INVALIDDATA;
315
            }
316
317
            // Main channel
318
            main_ch = get_bitsz(&s->gb, ch_nbits);
319
            main_amp = parse_vlc(&s->gb, &ff_dca_vlc_tnl_scf, 2)
320
                + s->tonal_scf[ff_dca_freq_to_sb[freq >> (7 - group)]]
321
                + s->limited_range - 2;
322
            amp[main_ch] = main_amp < AMP_MAX ? main_amp : 0;
323
            phs[main_ch] = get_bits(&s->gb, 3);
324
325
            // Secondary channels
326
            for (ch = 0; ch < s->nchannels_total; ch++) {
327
                if (ch == main_ch)
328
                    continue;
329
                if (get_bits1(&s->gb)) {
330
                    amp[ch] = amp[main_ch] - parse_vlc(&s->gb, &ff_dca_vlc_damp, 1);
331
                    phs[ch] = phs[main_ch] - parse_vlc(&s->gb, &ff_dca_vlc_dph,  1);
332
                } else {
333
                    amp[ch] = 0;
334
                    phs[ch] = 0;
335
                }
336
            }
337
338
            if (amp[main_ch]) {
339
                // Allocate new tone
340
                DCALbrTone *t = &s->tones[s->ntones];
341
                s->ntones = (s->ntones + 1) & (DCA_LBR_TONES - 1);
342
343
                t->x_freq = freq >> (5 - group);
344
                t->f_delt = (freq & ((1 << (5 - group)) - 1)) << group;
345
                t->ph_rot = 256 - (t->x_freq & 1) * 128 - t->f_delt * 4;
346
347
                shift = ff_dca_ph0_shift[(t->x_freq & 3) * 2 + (freq & 1)]
348
                    - ((t->ph_rot << (5 - group)) - t->ph_rot);
349
350
                for (ch = 0; ch < s->nchannels; ch++) {
351
                    t->amp[ch] = amp[ch] < AMP_MAX ? amp[ch] : 0;
352
                    t->phs[ch] = 128 - phs[ch] * 32 + shift;
353
                }
354
            }
355
        }
356
357
        s->tonal_bounds[group][sf_idx][1] = s->ntones;
358
    }
359
360
    return 0;
361
}
362
363
static int parse_tonal_chunk(DCALbrDecoder *s, LBRChunk *chunk)
364
{
365
    int sb, group, ret;
366
367
    if (!chunk->len)
368
        return 0;
369
370
    ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
371
372
    if (ret < 0)
373
        return ret;
374
375
    // Scale factors
376
    if (chunk->id == LBR_CHUNK_SCF || chunk->id == LBR_CHUNK_TONAL_SCF) {
377
        if (get_bits_left(&s->gb) < 36) {
378
            av_log(s->avctx, AV_LOG_ERROR, "Tonal scale factor chunk too short\n");
379
            return AVERROR_INVALIDDATA;
380
        }
381
        for (sb = 0; sb < 6; sb++)
382
            s->tonal_scf[sb] = get_bits(&s->gb, 6);
383
    }
384
385
    // Tonal groups
386
    if (chunk->id == LBR_CHUNK_TONAL || chunk->id == LBR_CHUNK_TONAL_SCF)
387
        for (group = 0; group < 5; group++) {
388
            ret = parse_tonal(s, group);
389
            if (ret < 0)
390
                return ret;
391
        }
392
393
    return 0;
394
}
395
396
static int parse_tonal_group(DCALbrDecoder *s, LBRChunk *chunk)
397
{
398
    int ret;
399
400
    if (!chunk->len)
401
        return 0;
402
403
    ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
404
    if (ret < 0)
405
        return ret;
406
407
    return parse_tonal(s, chunk->id);
408
}
409
410
/**
411
 * Check point to ensure that enough bits are left. Aborts decoding
412
 * by skipping to the end of chunk otherwise.
413
 */
414
static int ensure_bits(GetBitContext *s, int n)
415
{
416
    int left = get_bits_left(s);
417
    if (left < 0)
418
        return AVERROR_INVALIDDATA;
419
    if (left < n) {
420
        skip_bits_long(s, left);
421
        return 1;
422
    }
423
    return 0;
424
}
425
426
static int parse_scale_factors(DCALbrDecoder *s, uint8_t *scf)
427
{
428
    int i, sf, prev, next, dist;
429
430
    // Truncated scale factors remain zero
431
    if (ensure_bits(&s->gb, 20))
432
        return 0;
433
434
    // Initial scale factor
435
    prev = parse_vlc(&s->gb, &ff_dca_vlc_fst_rsd_amp, 2);
436
437
    for (sf = 0; sf < 7; sf += dist) {
438
        scf[sf] = prev; // Store previous value
439
440
        if (ensure_bits(&s->gb, 20))
441
            return 0;
442
443
        // Interpolation distance
444
        dist = parse_vlc(&s->gb, &ff_dca_vlc_rsd_apprx, 1) + 1;
445
        if (dist > 7 - sf) {
446
            av_log(s->avctx, AV_LOG_ERROR, "Invalid scale factor distance\n");
447
            return AVERROR_INVALIDDATA;
448
        }
449
450
        if (ensure_bits(&s->gb, 20))
451
            return 0;
452
453
        // Final interpolation point
454
        next = parse_vlc(&s->gb, &ff_dca_vlc_rsd_amp, 2);
455
456
        if (next & 1)
457
            next = prev + ((next + 1) >> 1);
458
        else
459
            next = prev - ( next      >> 1);
460
461
        // Interpolate
462
        switch (dist) {
463
        case 2:
464
            if (next > prev)
465
                scf[sf + 1] = prev + ((next - prev) >> 1);
466
            else
467
                scf[sf + 1] = prev - ((prev - next) >> 1);
468
            break;
469
470
        case 4:
471
            if (next > prev) {
472
                scf[sf + 1] = prev + ( (next - prev)      >> 2);
473
                scf[sf + 2] = prev + ( (next - prev)      >> 1);
474
                scf[sf + 3] = prev + (((next - prev) * 3) >> 2);
475
            } else {
476
                scf[sf + 1] = prev - ( (prev - next)      >> 2);
477
                scf[sf + 2] = prev - ( (prev - next)      >> 1);
478
                scf[sf + 3] = prev - (((prev - next) * 3) >> 2);
479
            }
480
            break;
481
482
        default:
483
            for (i = 1; i < dist; i++)
484
                scf[sf + i] = prev + (next - prev) * i / dist;
485
            break;
486
        }
487
488
        prev = next;
489
    }
490
491
    scf[sf] = next; // Store final value
492
493
    return 0;
494
}
495
496
static int parse_st_code(GetBitContext *s, int min_v)
497
{
498
    unsigned int v = parse_vlc(s, &ff_dca_vlc_st_grid, 2) + min_v;
499
500
    if (v & 1)
501
        v = 16 + (v >> 1);
502
    else
503
        v = 16 - (v >> 1);
504
505
    if (v >= FF_ARRAY_ELEMS(ff_dca_st_coeff))
506
        v = 16;
507
    return v;
508
}
509
510
static int parse_grid_1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
511
{
512
    int ch, sb, sf, nsubbands, ret;
513
514
    if (!chunk->len)
515
        return 0;
516
517
    ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
518
    if (ret < 0)
519
        return ret;
520
521
    // Scale factors
522
    nsubbands = ff_dca_scf_to_grid_1[s->nsubbands - 1] + 1;
523
    for (sb = 2; sb < nsubbands; sb++) {
524
        ret = parse_scale_factors(s, s->grid_1_scf[ch1][sb]);
525
        if (ret < 0)
526
            return ret;
527
        if (ch1 != ch2 && ff_dca_grid_1_to_scf[sb] < s->min_mono_subband) {
528
            ret = parse_scale_factors(s, s->grid_1_scf[ch2][sb]);
529
            if (ret < 0)
530
                return ret;
531
        }
532
    }
533
534
    if (get_bits_left(&s->gb) < 1)
535
        return 0;   // Should not happen, but a sample exists that proves otherwise
536
537
    // Average values for third grid
538
    for (sb = 0; sb < s->nsubbands - 4; sb++) {
539
        s->grid_3_avg[ch1][sb] = parse_vlc(&s->gb, &ff_dca_vlc_avg_g3, 2) - 16;
540
        if (ch1 != ch2) {
541
            if (sb + 4 < s->min_mono_subband)
542
                s->grid_3_avg[ch2][sb] = parse_vlc(&s->gb, &ff_dca_vlc_avg_g3, 2) - 16;
543
            else
544
                s->grid_3_avg[ch2][sb] = s->grid_3_avg[ch1][sb];
545
        }
546
    }
547
548
    if (get_bits_left(&s->gb) < 0) {
549
        av_log(s->avctx, AV_LOG_ERROR, "First grid chunk too short\n");
550
        return AVERROR_INVALIDDATA;
551
    }
552
553
    // Stereo image for partial mono mode
554
    if (ch1 != ch2) {
555
        int min_v[2];
556
557
        if (ensure_bits(&s->gb, 8))
558
            return 0;
559
560
        min_v[0] = get_bits(&s->gb, 4);
561
        min_v[1] = get_bits(&s->gb, 4);
562
563
        nsubbands = (s->nsubbands - s->min_mono_subband + 3) / 4;
564
        for (sb = 0; sb < nsubbands; sb++)
565
            for (ch = ch1; ch <= ch2; ch++)
566
                for (sf = 1; sf <= 4; sf++)
567
                    s->part_stereo[ch][sb][sf] = parse_st_code(&s->gb, min_v[ch - ch1]);
568
569
        if (get_bits_left(&s->gb) >= 0)
570
            s->part_stereo_pres |= 1 << ch1;
571
    }
572
573
    // Low resolution spatial information is not decoded
574
575
    return 0;
576
}
577
578
static int parse_grid_1_sec_ch(DCALbrDecoder *s, int ch2)
579
{
580
    int sb, nsubbands, ret;
581
582
    // Scale factors
583
    nsubbands = ff_dca_scf_to_grid_1[s->nsubbands - 1] + 1;
584
    for (sb = 2; sb < nsubbands; sb++) {
585
        if (ff_dca_grid_1_to_scf[sb] >= s->min_mono_subband) {
586
            ret = parse_scale_factors(s, s->grid_1_scf[ch2][sb]);
587
            if (ret < 0)
588
                return ret;
589
        }
590
    }
591
592
    // Average values for third grid
593
    for (sb = 0; sb < s->nsubbands - 4; sb++) {
594
        if (sb + 4 >= s->min_mono_subband) {
595
            if (ensure_bits(&s->gb, 20))
596
                return 0;
597
            s->grid_3_avg[ch2][sb] = parse_vlc(&s->gb, &ff_dca_vlc_avg_g3, 2) - 16;
598
        }
599
    }
600
601
    return 0;
602
}
603
604
static void parse_grid_3(DCALbrDecoder *s, int ch1, int ch2, int sb, int flag)
605
{
606
    int i, ch;
607
608
    for (ch = ch1; ch <= ch2; ch++) {
609
        if ((ch != ch1 && sb + 4 >= s->min_mono_subband) != flag)
610
            continue;
611
612
        if (s->grid_3_pres[ch] & (1U << sb))
613
            continue;   // Already parsed
614
615
        for (i = 0; i < 8; i++) {
616
            if (ensure_bits(&s->gb, 20))
617
                return;
618
            s->grid_3_scf[ch][sb][i] = parse_vlc(&s->gb, &ff_dca_vlc_grid_3, 2) - 16;
619
        }
620
621
        // Flag scale factors for this subband parsed
622
        s->grid_3_pres[ch] |= 1U << sb;
623
    }
624
}
625
626
static float lbr_rand(DCALbrDecoder *s, int sb)
627
{
628
    s->lbr_rand = 1103515245U * s->lbr_rand + 12345U;
629
    return s->lbr_rand * s->sb_scf[sb];
630
}
631
632
/**
633
 * Parse time samples for one subband, filling truncated samples with randomness
634
 */
635
static void parse_ch(DCALbrDecoder *s, int ch, int sb, int quant_level, int flag)
636
{
637
    float *samples = s->time_samples[ch][sb];
638
    int i, j, code, nblocks, coding_method;
639
640
    if (ensure_bits(&s->gb, 20))
641
        return; // Too few bits left
642
643
    coding_method = get_bits1(&s->gb);
644
645
    switch (quant_level) {
646
    case 1:
647
        nblocks = FFMIN(get_bits_left(&s->gb) / 8, DCA_LBR_TIME_SAMPLES / 8);
648
        for (i = 0; i < nblocks; i++, samples += 8) {
649
            code = get_bits(&s->gb, 8);
650
            for (j = 0; j < 8; j++)
651
                samples[j] = ff_dca_rsd_level_2a[(code >> j) & 1];
652
        }
653
        i = nblocks * 8;
654
        break;
655
656
    case 2:
657
        if (coding_method) {
658
            for (i = 0; i < DCA_LBR_TIME_SAMPLES && get_bits_left(&s->gb) >= 2; i++) {
659
                if (get_bits1(&s->gb))
660
                    samples[i] = ff_dca_rsd_level_2b[get_bits1(&s->gb)];
661
                else
662
                    samples[i] = 0;
663
            }
664
        } else {
665
            nblocks = FFMIN(get_bits_left(&s->gb) / 8, (DCA_LBR_TIME_SAMPLES + 4) / 5);
666
            for (i = 0; i < nblocks; i++, samples += 5) {
667
                code = ff_dca_rsd_pack_5_in_8[get_bits(&s->gb, 8)];
668
                for (j = 0; j < 5; j++)
669
                    samples[j] = ff_dca_rsd_level_3[(code >> j * 2) & 3];
670
            }
671
            i = nblocks * 5;
672
        }
673
        break;
674
675
    case 3:
676
        nblocks = FFMIN(get_bits_left(&s->gb) / 7, (DCA_LBR_TIME_SAMPLES + 2) / 3);
677
        for (i = 0; i < nblocks; i++, samples += 3) {
678
            code = get_bits(&s->gb, 7);
679
            for (j = 0; j < 3; j++)
680
                samples[j] = ff_dca_rsd_level_5[ff_dca_rsd_pack_3_in_7[code][j]];
681
        }
682
        i = nblocks * 3;
683
        break;
684
685
    case 4:
686
        for (i = 0; i < DCA_LBR_TIME_SAMPLES && get_bits_left(&s->gb) >= 6; i++)
687
            samples[i] = ff_dca_rsd_level_8[get_vlc2(&s->gb, ff_dca_vlc_rsd.table, 6, 1)];
688
        break;
689
690
    case 5:
691
        nblocks = FFMIN(get_bits_left(&s->gb) / 4, DCA_LBR_TIME_SAMPLES);
692
        for (i = 0; i < nblocks; i++)
693
            samples[i] = ff_dca_rsd_level_16[get_bits(&s->gb, 4)];
694
        break;
695
696
    default:
697
        av_assert0(0);
698
    }
699
700
    if (flag && get_bits_left(&s->gb) < 20)
701
        return; // Skip incomplete mono subband
702
703
    for (; i < DCA_LBR_TIME_SAMPLES; i++)
704
        s->time_samples[ch][sb][i] = lbr_rand(s, sb);
705
706
    s->ch_pres[ch] |= 1U << sb;
707
}
708
709
static int parse_ts(DCALbrDecoder *s, int ch1, int ch2,
710
                    int start_sb, int end_sb, int flag)
711
{
712
    int sb, sb_g3, sb_reorder, quant_level;
713
714
    for (sb = start_sb; sb < end_sb; sb++) {
715
        // Subband number before reordering
716
        if (sb < 6) {
717
            sb_reorder = sb;
718
        } else if (flag && sb < s->max_mono_subband) {
719
            sb_reorder = s->sb_indices[sb];
720
        } else {
721
            if (ensure_bits(&s->gb, 28))
722
                break;
723
            sb_reorder = get_bits(&s->gb, s->limited_range + 3);
724
            if (sb_reorder < 6)
725
                sb_reorder = 6;
726
            s->sb_indices[sb] = sb_reorder;
727
        }
728
        if (sb_reorder >= s->nsubbands)
729
            return AVERROR_INVALIDDATA;
730
731
        // Third grid scale factors
732
        if (sb == 12) {
733
            for (sb_g3 = 0; sb_g3 < s->g3_avg_only_start_sb - 4; sb_g3++)
734
                parse_grid_3(s, ch1, ch2, sb_g3, flag);
735
        } else if (sb < 12 && sb_reorder >= 4) {
736
            parse_grid_3(s, ch1, ch2, sb_reorder - 4, flag);
737
        }
738
739
        // Secondary channel flags
740
        if (ch1 != ch2) {
741
            if (ensure_bits(&s->gb, 20))
742
                break;
743
            if (!flag || sb_reorder >= s->max_mono_subband)
744
                s->sec_ch_sbms[ch1 / 2][sb_reorder] = get_bits(&s->gb, 8);
745
            if (flag && sb_reorder >= s->min_mono_subband)
746
                s->sec_ch_lrms[ch1 / 2][sb_reorder] = get_bits(&s->gb, 8);
747
        }
748
749
        quant_level = s->quant_levels[ch1 / 2][sb];
750
        if (!quant_level)
751
            return AVERROR_INVALIDDATA;
752
753
        // Time samples for one or both channels
754
        if (sb < s->max_mono_subband && sb_reorder >= s->min_mono_subband) {
755
            if (!flag)
756
                parse_ch(s, ch1, sb_reorder, quant_level, 0);
757
            else if (ch1 != ch2)
758
                parse_ch(s, ch2, sb_reorder, quant_level, 1);
759
        } else {
760
            parse_ch(s, ch1, sb_reorder, quant_level, 0);
761
            if (ch1 != ch2)
762
                parse_ch(s, ch2, sb_reorder, quant_level, 0);
763
        }
764
    }
765
766
    return 0;
767
}
768
769
/**
770
 * Convert from reflection coefficients to direct form coefficients
771
 */
772
static void convert_lpc(float *coeff, const int *codes)
773
{
774
    int i, j;
775
776
    for (i = 0; i < 8; i++) {
777
        float rc = lpc_tab[codes[i]];
778
        for (j = 0; j < (i + 1) / 2; j++) {
779
            float tmp1 = coeff[    j    ];
780
            float tmp2 = coeff[i - j - 1];
781
            coeff[    j    ] = tmp1 + rc * tmp2;
782
            coeff[i - j - 1] = tmp2 + rc * tmp1;
783
        }
784
        coeff[i] = rc;
785
    }
786
}
787
788
static int parse_lpc(DCALbrDecoder *s, int ch1, int ch2, int start_sb, int end_sb)
789
{
790
    int f = s->framenum & 1;
791
    int i, sb, ch, codes[16];
792
793
    // First two subbands have two sets of coefficients, third subband has one
794
    for (sb = start_sb; sb < end_sb; sb++) {
795
        int ncodes = 8 * (1 + (sb < 2));
796
        for (ch = ch1; ch <= ch2; ch++) {
797
            if (ensure_bits(&s->gb, 4 * ncodes))
798
                return 0;
799
            for (i = 0; i < ncodes; i++)
800
                codes[i] = get_bits(&s->gb, 4);
801
            for (i = 0; i < ncodes / 8; i++)
802
                convert_lpc(s->lpc_coeff[f][ch][sb][i], &codes[i * 8]);
803
        }
804
    }
805
806
    return 0;
807
}
808
809
static int parse_high_res_grid(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
810
{
811
    int quant_levels[DCA_LBR_SUBBANDS];
812
    int sb, ch, ol, st, max_sb, profile, ret;
813
814
    if (!chunk->len)
815
        return 0;
816
817
    ret = init_get_bits8(&s->gb, chunk->data, chunk->len);
818
    if (ret < 0)
819
        return ret;
820
821
    // Quantizer profile
822
    profile = get_bits(&s->gb, 8);
823
    // Overall level
824
    ol = (profile >> 3) & 7;
825
    // Steepness
826
    st = profile >> 6;
827
    // Max energy subband
828
    max_sb = profile & 7;
829
830
    // Calculate quantization levels
831
    for (sb = 0; sb < s->nsubbands; sb++) {
832
        int f = sb * s->limited_rate / s->nsubbands;
833
        int a = 18000 / (12 * f / 1000 + 100 + 40 * st) + 20 * ol;
834
        if (a <= 95)
835
            quant_levels[sb] = 1;
836
        else if (a <= 140)
837
            quant_levels[sb] = 2;
838
        else if (a <= 180)
839
            quant_levels[sb] = 3;
840
        else if (a <= 230)
841
            quant_levels[sb] = 4;
842
        else
843
            quant_levels[sb] = 5;
844
    }
845
846
    // Reorder quantization levels for lower subbands
847
    for (sb = 0; sb < 8; sb++)
848
        s->quant_levels[ch1 / 2][sb] = quant_levels[ff_dca_sb_reorder[max_sb][sb]];
849
    for (; sb < s->nsubbands; sb++)
850
        s->quant_levels[ch1 / 2][sb] = quant_levels[sb];
851
852
    // LPC for the first two subbands
853
    ret = parse_lpc(s, ch1, ch2, 0, 2);
854
    if (ret < 0)
855
        return ret;
856
857
    // Time-samples for the first two subbands of main channel
858
    ret = parse_ts(s, ch1, ch2, 0, 2, 0);
859
    if (ret < 0)
860
        return ret;
861
862
    // First two bands of the first grid
863
    for (sb = 0; sb < 2; sb++)
864
        for (ch = ch1; ch <= ch2; ch++)
865
            if ((ret = parse_scale_factors(s, s->grid_1_scf[ch][sb])) < 0)
866
                return ret;
867
868
    return 0;
869
}
870
871
static int parse_grid_2(DCALbrDecoder *s, int ch1, int ch2,
872
                        int start_sb, int end_sb, int flag)
873
{
874
    int i, j, sb, ch, nsubbands;
875
876
    nsubbands = ff_dca_scf_to_grid_2[s->nsubbands - 1] + 1;
877
    if (end_sb > nsubbands)
878
        end_sb = nsubbands;
879
880
    for (sb = start_sb; sb < end_sb; sb++) {
881
        for (ch = ch1; ch <= ch2; ch++) {
882
            uint8_t *g2_scf = s->grid_2_scf[ch][sb];
883
884
            if ((ch != ch1 && ff_dca_grid_2_to_scf[sb] >= s->min_mono_subband) != flag) {
885
                if (!flag)
886
                    memcpy(g2_scf, s->grid_2_scf[ch1][sb], 64);
887
                continue;
888
            }
889
890
            // Scale factors in groups of 8
891
            for (i = 0; i < 8; i++, g2_scf += 8) {
892
                if (get_bits_left(&s->gb) < 1) {
893
                    memset(g2_scf, 0, 64 - i * 8);
894
                    break;
895
                }
896
                // Bit indicating if whole group has zero values
897
                if (get_bits1(&s->gb)) {
898
                    for (j = 0; j < 8; j++) {
899
                        if (ensure_bits(&s->gb, 20))
900
                            break;
901
                        g2_scf[j] = parse_vlc(&s->gb, &ff_dca_vlc_grid_2, 2);
902
                    }
903
                } else {
904
                    memset(g2_scf, 0, 8);
905
                }
906
            }
907
        }
908
    }
909
910
    return 0;
911
}
912
913
static int parse_ts1_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
914
{
915
    int ret;
916
    if (!chunk->len)
917
        return 0;
918
    if ((ret = init_get_bits8(&s->gb, chunk->data, chunk->len)) < 0)
919
        return ret;
920
    if ((ret = parse_lpc(s, ch1, ch2, 2, 3)) < 0)
921
        return ret;
922
    if ((ret = parse_ts(s, ch1, ch2, 2, 4, 0)) < 0)
923
        return ret;
924
    if ((ret = parse_grid_2(s, ch1, ch2, 0, 1, 0)) < 0)
925
        return ret;
926
    if ((ret = parse_ts(s, ch1, ch2, 4, 6, 0)) < 0)
927
        return ret;
928
    return 0;
929
}
930
931
static int parse_ts2_chunk(DCALbrDecoder *s, LBRChunk *chunk, int ch1, int ch2)
932
{
933
    int ret;
934
935
    if (!chunk->len)
936
        return 0;
937
    if ((ret = init_get_bits8(&s->gb, chunk->data, chunk->len)) < 0)
938
        return ret;
939
    if ((ret = parse_grid_2(s, ch1, ch2, 1, 3, 0)) < 0)
940
        return ret;
941
    if ((ret = parse_ts(s, ch1, ch2, 6, s->max_mono_subband, 0)) < 0)
942
        return ret;
943
    if (ch1 != ch2) {
944
        if ((ret = parse_grid_1_sec_ch(s, ch2)) < 0)
945
            return ret;
946
        if ((ret = parse_grid_2(s, ch1, ch2, 0, 3, 1)) < 0)
947
            return ret;
948
    }
949
    if ((ret = parse_ts(s, ch1, ch2, s->min_mono_subband, s->nsubbands, 1)) < 0)
950
        return ret;
951
    return 0;
952
}
953
954
static int init_sample_rate(DCALbrDecoder *s)
955
{
956
    double scale = (-1.0 / (1 << 17)) * sqrt(1 << (2 - s->limited_range));
957
    int i, br_per_ch = s->bit_rate_scaled / s->nchannels_total;
958
    int ret;
959
960
    ff_mdct_end(&s->imdct);
961
962
    ret = ff_mdct_init(&s->imdct, s->freq_range + 6, 1, scale);
963
    if (ret < 0)
964
        return ret;
965
966
    for (i = 0; i < 32 << s->freq_range; i++)
967
        s->window[i] = ff_dca_long_window[i << (2 - s->freq_range)];
968
969
    if (br_per_ch < 14000)
970
        scale = 0.85;
971
    else if (br_per_ch < 32000)
972
        scale = (br_per_ch - 14000) * (1.0 / 120000) + 0.85;
973
    else
974
        scale = 1.0;
975
976
    scale *= 1.0 / INT_MAX;
977
978
    for (i = 0; i < s->nsubbands; i++) {
979
        if (i < 2)
980
            s->sb_scf[i] = 0;   // The first two subbands are always zero
981
        else if (i < 5)
982
            s->sb_scf[i] = (i - 1) * 0.25 * 0.785 * scale;
983
        else
984
            s->sb_scf[i] = 0.785 * scale;
985
    }
986
987
    s->lfe_scale = (16 << s->freq_range) * 0.0000078265894;
988
989
    return 0;
990
}
991
992
static int alloc_sample_buffer(DCALbrDecoder *s)
993
{
994
    // Reserve space for history and padding
995
    int nchsamples = DCA_LBR_TIME_SAMPLES + DCA_LBR_TIME_HISTORY * 2;
996
    int nsamples = nchsamples * s->nchannels * s->nsubbands;
997
    int ch, sb;
998
    float *ptr;
999
1000
    // Reallocate time sample buffer
1001
    av_fast_mallocz(&s->ts_buffer, &s->ts_size, nsamples * sizeof(float));
1002
    if (!s->ts_buffer)
1003
        return AVERROR(ENOMEM);
1004
1005
    ptr = s->ts_buffer + DCA_LBR_TIME_HISTORY;
1006
    for (ch = 0; ch < s->nchannels; ch++) {
1007
        for (sb = 0; sb < s->nsubbands; sb++) {
1008
            s->time_samples[ch][sb] = ptr;
1009
            ptr += nchsamples;
1010
        }
1011
    }
1012
1013
    return 0;
1014
}
1015
1016
static int parse_decoder_init(DCALbrDecoder *s, GetByteContext *gb)
1017
{
1018
    int old_rate = s->sample_rate;
1019
    int old_band_limit = s->band_limit;
1020
    int old_nchannels = s->nchannels;
1021
    int version, bit_rate_hi;
1022
    unsigned int sr_code;
1023
1024
    // Sample rate of LBR audio
1025
    sr_code = bytestream2_get_byte(gb);
1026
    if (sr_code >= FF_ARRAY_ELEMS(ff_dca_sampling_freqs)) {
1027
        av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR sample rate\n");
1028
        return AVERROR_INVALIDDATA;
1029
    }
1030
    s->sample_rate = ff_dca_sampling_freqs[sr_code];
1031
    if (s->sample_rate > 48000) {
1032
        avpriv_report_missing_feature(s->avctx, "%d Hz LBR sample rate", s->sample_rate);
1033
        return AVERROR_PATCHWELCOME;
1034
    }
1035
1036
    // LBR speaker mask
1037
    s->ch_mask = bytestream2_get_le16(gb);
1038
    if (!(s->ch_mask & 0x7)) {
1039
        avpriv_report_missing_feature(s->avctx, "LBR channel mask %#x", s->ch_mask);
1040
        return AVERROR_PATCHWELCOME;
1041
    }
1042
    if ((s->ch_mask & 0xfff0) && !(s->warned & 1)) {
1043
        avpriv_report_missing_feature(s->avctx, "LBR channel mask %#x", s->ch_mask);
1044
        s->warned |= 1;
1045
    }
1046
1047
    // LBR bitstream version
1048
    version = bytestream2_get_le16(gb);
1049
    if ((version & 0xff00) != 0x0800) {
1050
        avpriv_report_missing_feature(s->avctx, "LBR stream version %#x", version);
1051
        return AVERROR_PATCHWELCOME;
1052
    }
1053
1054
    // Flags for LBR decoder initialization
1055
    s->flags = bytestream2_get_byte(gb);
1056
    if (s->flags & LBR_FLAG_DMIX_MULTI_CH) {
1057
        avpriv_report_missing_feature(s->avctx, "LBR multi-channel downmix");
1058
        return AVERROR_PATCHWELCOME;
1059
    }
1060
    if ((s->flags & LBR_FLAG_LFE_PRESENT) && s->sample_rate != 48000) {
1061
        if (!(s->warned & 2)) {
1062
            avpriv_report_missing_feature(s->avctx, "%d Hz LFE interpolation", s->sample_rate);
1063
            s->warned |= 2;
1064
        }
1065
        s->flags &= ~LBR_FLAG_LFE_PRESENT;
1066
    }
1067
1068
    // Most significant bit rate nibbles
1069
    bit_rate_hi = bytestream2_get_byte(gb);
1070
1071
    // Least significant original bit rate word
1072
    s->bit_rate_orig = bytestream2_get_le16(gb) | ((bit_rate_hi & 0x0F) << 16);
1073
1074
    // Least significant scaled bit rate word
1075
    s->bit_rate_scaled = bytestream2_get_le16(gb) | ((bit_rate_hi & 0xF0) << 12);
1076
1077
    // Setup number of fullband channels
1078
    s->nchannels_total = ff_dca_count_chs_for_mask(s->ch_mask & ~DCA_SPEAKER_PAIR_LFE1);
1079
    s->nchannels = FFMIN(s->nchannels_total, DCA_LBR_CHANNELS);
1080
1081
    // Setup band limit
1082
    switch (s->flags & LBR_FLAG_BAND_LIMIT_MASK) {
1083
    case LBR_FLAG_BAND_LIMIT_NONE:
1084
        s->band_limit = 0;
1085
        break;
1086
    case LBR_FLAG_BAND_LIMIT_1_2:
1087
        s->band_limit = 1;
1088
        break;
1089
    case LBR_FLAG_BAND_LIMIT_1_4:
1090
        s->band_limit = 2;
1091
        break;
1092
    default:
1093
        avpriv_report_missing_feature(s->avctx, "LBR band limit %#x", s->flags & LBR_FLAG_BAND_LIMIT_MASK);
1094
        return AVERROR_PATCHWELCOME;
1095
    }
1096
1097
    // Setup frequency range
1098
    s->freq_range = ff_dca_freq_ranges[sr_code];
1099
1100
    // Setup resolution profile
1101
    if (s->bit_rate_orig >= 44000 * (s->nchannels_total + 2))
1102
        s->res_profile = 2;
1103
    else if (s->bit_rate_orig >= 25000 * (s->nchannels_total + 2))
1104
        s->res_profile = 1;
1105
    else
1106
        s->res_profile = 0;
1107
1108
    // Setup limited sample rate, number of subbands, etc
1109
    s->limited_rate = s->sample_rate >> s->band_limit;
1110
    s->limited_range = s->freq_range - s->band_limit;
1111
    if (s->limited_range < 0) {
1112
        av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR band limit for frequency range\n");
1113
        return AVERROR_INVALIDDATA;
1114
    }
1115
1116
    s->nsubbands = 8 << s->limited_range;
1117
1118
    s->g3_avg_only_start_sb = s->nsubbands * ff_dca_avg_g3_freqs[s->res_profile] / (s->limited_rate / 2);
1119
    if (s->g3_avg_only_start_sb > s->nsubbands)
1120
        s->g3_avg_only_start_sb = s->nsubbands;
1121
1122
    s->min_mono_subband = s->nsubbands *  2000 / (s->limited_rate / 2);
1123
    if (s->min_mono_subband > s->nsubbands)
1124
        s->min_mono_subband = s->nsubbands;
1125
1126
    s->max_mono_subband = s->nsubbands * 14000 / (s->limited_rate / 2);
1127
    if (s->max_mono_subband > s->nsubbands)
1128
        s->max_mono_subband = s->nsubbands;
1129
1130
    // Handle change of sample rate
1131
    if ((old_rate != s->sample_rate || old_band_limit != s->band_limit) && init_sample_rate(s) < 0)
1132
        return AVERROR(ENOMEM);
1133
1134
    // Setup stereo downmix
1135
    if (s->flags & LBR_FLAG_DMIX_STEREO) {
1136
        DCAContext *dca = s->avctx->priv_data;
1137
1138
        if (s->nchannels_total < 3 || s->nchannels_total > DCA_LBR_CHANNELS_TOTAL - 2) {
1139
            av_log(s->avctx, AV_LOG_ERROR, "Invalid number of channels for LBR stereo downmix\n");
1140
            return AVERROR_INVALIDDATA;
1141
        }
1142
1143
        // This decoder doesn't support ECS chunk
1144
        if (dca->request_channel_layout != DCA_SPEAKER_LAYOUT_STEREO && !(s->warned & 4)) {
1145
            avpriv_report_missing_feature(s->avctx, "Embedded LBR stereo downmix");
1146
            s->warned |= 4;
1147
        }
1148
1149
        // Account for extra downmixed channel pair
1150
        s->nchannels_total += 2;
1151
        s->nchannels = 2;
1152
        s->ch_mask = DCA_SPEAKER_PAIR_LR;
1153
        s->flags &= ~LBR_FLAG_LFE_PRESENT;
1154
    }
1155
1156
    // Handle change of sample rate or number of channels
1157
    if (old_rate != s->sample_rate
1158
        || old_band_limit != s->band_limit
1159
        || old_nchannels != s->nchannels) {
1160
        if (alloc_sample_buffer(s) < 0)
1161
            return AVERROR(ENOMEM);
1162
        ff_dca_lbr_flush(s);
1163
    }
1164
1165
    return 0;
1166
}
1167
1168
int ff_dca_lbr_parse(DCALbrDecoder *s, uint8_t *data, DCAExssAsset *asset)
1169
{
1170
    struct {
1171
        LBRChunk    lfe;
1172
        LBRChunk    tonal;
1173
        LBRChunk    tonal_grp[5];
1174
        LBRChunk    grid1[DCA_LBR_CHANNELS / 2];
1175
        LBRChunk    hr_grid[DCA_LBR_CHANNELS / 2];
1176
        LBRChunk    ts1[DCA_LBR_CHANNELS / 2];
1177
        LBRChunk    ts2[DCA_LBR_CHANNELS / 2];
1178
    } chunk = { {0} };
1179
1180
    GetByteContext gb;
1181
1182
    int i, ch, sb, sf, ret, group, chunk_id, chunk_len;
1183
1184
    bytestream2_init(&gb, data + asset->lbr_offset, asset->lbr_size);
1185
1186
    // LBR sync word
1187
    if (bytestream2_get_be32(&gb) != DCA_SYNCWORD_LBR) {
1188
        av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR sync word\n");
1189
        return AVERROR_INVALIDDATA;
1190
    }
1191
1192
    // LBR header type
1193
    switch (bytestream2_get_byte(&gb)) {
1194
    case DCA_LBR_HEADER_SYNC_ONLY:
1195
        if (!s->sample_rate) {
1196
            av_log(s->avctx, AV_LOG_ERROR, "LBR decoder not initialized\n");
1197
            return AVERROR_INVALIDDATA;
1198
        }
1199
        break;
1200
    case DCA_LBR_HEADER_DECODER_INIT:
1201
        if ((ret = parse_decoder_init(s, &gb)) < 0) {
1202
            s->sample_rate = 0;
1203
            return ret;
1204
        }
1205
        break;
1206
    default:
1207
        av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR header type\n");
1208
        return AVERROR_INVALIDDATA;
1209
    }
1210
1211
    // LBR frame chunk header
1212
    chunk_id = bytestream2_get_byte(&gb);
1213
    chunk_len = (chunk_id & 0x80) ? bytestream2_get_be16(&gb) : bytestream2_get_byte(&gb);
1214
1215
    if (chunk_len > bytestream2_get_bytes_left(&gb)) {
1216
        chunk_len = bytestream2_get_bytes_left(&gb);
1217
        av_log(s->avctx, AV_LOG_WARNING, "LBR frame chunk was truncated\n");
1218
        if (s->avctx->err_recognition & AV_EF_EXPLODE)
1219
            return AVERROR_INVALIDDATA;
1220
    }
1221
1222
    bytestream2_init(&gb, gb.buffer, chunk_len);
1223
1224
    switch (chunk_id & 0x7f) {
1225
    case LBR_CHUNK_FRAME:
1226
        if (s->avctx->err_recognition & (AV_EF_CRCCHECK | AV_EF_CAREFUL)) {
1227
            int checksum = bytestream2_get_be16(&gb);
1228
            uint16_t res = chunk_id;
1229
            res += (chunk_len >> 8) & 0xff;
1230
            res += chunk_len & 0xff;
1231
            for (i = 0; i < chunk_len - 2; i++)
1232
                res += gb.buffer[i];
1233
            if (checksum != res) {
1234
                av_log(s->avctx, AV_LOG_WARNING, "Invalid LBR checksum\n");
1235
                if (s->avctx->err_recognition & AV_EF_EXPLODE)
1236
                    return AVERROR_INVALIDDATA;
1237
            }
1238
        } else {
1239
            bytestream2_skip(&gb, 2);
1240
        }
1241
        break;
1242
    case LBR_CHUNK_FRAME_NO_CSUM:
1243
        break;
1244
    default:
1245
        av_log(s->avctx, AV_LOG_ERROR, "Invalid LBR frame chunk ID\n");
1246
        return AVERROR_INVALIDDATA;
1247
    }
1248
1249
    // Clear current frame
1250
    memset(s->quant_levels, 0, sizeof(s->quant_levels));
1251
    memset(s->sb_indices, 0xff, sizeof(s->sb_indices));
1252
    memset(s->sec_ch_sbms, 0, sizeof(s->sec_ch_sbms));
1253
    memset(s->sec_ch_lrms, 0, sizeof(s->sec_ch_lrms));
1254
    memset(s->ch_pres, 0, sizeof(s->ch_pres));
1255
    memset(s->grid_1_scf, 0, sizeof(s->grid_1_scf));
1256
    memset(s->grid_2_scf, 0, sizeof(s->grid_2_scf));
1257
    memset(s->grid_3_avg, 0, sizeof(s->grid_3_avg));
1258
    memset(s->grid_3_scf, 0, sizeof(s->grid_3_scf));
1259
    memset(s->grid_3_pres, 0, sizeof(s->grid_3_pres));
1260
    memset(s->tonal_scf, 0, sizeof(s->tonal_scf));
1261
    memset(s->lfe_data, 0, sizeof(s->lfe_data));
1262
    s->part_stereo_pres = 0;
1263
    s->framenum = (s->framenum + 1) & 31;
1264
1265
    for (ch = 0; ch < s->nchannels; ch++) {
1266
        for (sb = 0; sb < s->nsubbands / 4; sb++) {
1267
            s->part_stereo[ch][sb][0] = s->part_stereo[ch][sb][4];
1268
            s->part_stereo[ch][sb][4] = 16;
1269
        }
1270
    }
1271
1272
    memset(s->lpc_coeff[s->framenum & 1], 0, sizeof(s->lpc_coeff[0]));
1273
1274
    for (group = 0; group < 5; group++) {
1275
        for (sf = 0; sf < 1 << group; sf++) {
1276
            int sf_idx = ((s->framenum << group) + sf) & 31;
1277
            s->tonal_bounds[group][sf_idx][0] =
1278
            s->tonal_bounds[group][sf_idx][1] = s->ntones;
1279
        }
1280
    }
1281
1282
    // Parse chunk headers
1283
    while (bytestream2_get_bytes_left(&gb) > 0) {
1284
        chunk_id = bytestream2_get_byte(&gb);
1285
        chunk_len = (chunk_id & 0x80) ? bytestream2_get_be16(&gb) : bytestream2_get_byte(&gb);
1286
        chunk_id &= 0x7f;
1287
1288
        if (chunk_len > bytestream2_get_bytes_left(&gb)) {
1289
            chunk_len = bytestream2_get_bytes_left(&gb);
1290
            av_log(s->avctx, AV_LOG_WARNING, "LBR chunk %#x was truncated\n", chunk_id);
1291
            if (s->avctx->err_recognition & AV_EF_EXPLODE)
1292
                return AVERROR_INVALIDDATA;
1293
        }
1294
1295
        switch (chunk_id) {
1296
        case LBR_CHUNK_LFE:
1297
            chunk.lfe.len  = chunk_len;
1298
            chunk.lfe.data = gb.buffer;
1299
            break;
1300
1301
        case LBR_CHUNK_SCF:
1302
        case LBR_CHUNK_TONAL:
1303
        case LBR_CHUNK_TONAL_SCF:
1304
            chunk.tonal.id   = chunk_id;
1305
            chunk.tonal.len  = chunk_len;
1306
            chunk.tonal.data = gb.buffer;
1307
            break;
1308
1309
        case LBR_CHUNK_TONAL_GRP_1:
1310
        case LBR_CHUNK_TONAL_GRP_2:
1311
        case LBR_CHUNK_TONAL_GRP_3:
1312
        case LBR_CHUNK_TONAL_GRP_4:
1313
        case LBR_CHUNK_TONAL_GRP_5:
1314
            i = LBR_CHUNK_TONAL_GRP_5 - chunk_id;
1315
            chunk.tonal_grp[i].id   = i;
1316
            chunk.tonal_grp[i].len  = chunk_len;
1317
            chunk.tonal_grp[i].data = gb.buffer;
1318
            break;
1319
1320
        case LBR_CHUNK_TONAL_SCF_GRP_1:
1321
        case LBR_CHUNK_TONAL_SCF_GRP_2:
1322
        case LBR_CHUNK_TONAL_SCF_GRP_3:
1323
        case LBR_CHUNK_TONAL_SCF_GRP_4:
1324
        case LBR_CHUNK_TONAL_SCF_GRP_5:
1325
            i = LBR_CHUNK_TONAL_SCF_GRP_5 - chunk_id;
1326
            chunk.tonal_grp[i].id   = i;
1327
            chunk.tonal_grp[i].len  = chunk_len;
1328
            chunk.tonal_grp[i].data = gb.buffer;
1329
            break;
1330
1331
        case LBR_CHUNK_RES_GRID_LR:
1332
        case LBR_CHUNK_RES_GRID_LR + 1:
1333
        case LBR_CHUNK_RES_GRID_LR + 2:
1334
            i = chunk_id - LBR_CHUNK_RES_GRID_LR;
1335
            chunk.grid1[i].len  = chunk_len;
1336
            chunk.grid1[i].data = gb.buffer;
1337
            break;
1338
1339
        case LBR_CHUNK_RES_GRID_HR:
1340
        case LBR_CHUNK_RES_GRID_HR + 1:
1341
        case LBR_CHUNK_RES_GRID_HR + 2:
1342
            i = chunk_id - LBR_CHUNK_RES_GRID_HR;
1343
            chunk.hr_grid[i].len  = chunk_len;
1344
            chunk.hr_grid[i].data = gb.buffer;
1345
            break;
1346
1347
        case LBR_CHUNK_RES_TS_1:
1348
        case LBR_CHUNK_RES_TS_1 + 1:
1349
        case LBR_CHUNK_RES_TS_1 + 2:
1350
            i = chunk_id - LBR_CHUNK_RES_TS_1;
1351
            chunk.ts1[i].len  = chunk_len;
1352
            chunk.ts1[i].data = gb.buffer;
1353
            break;
1354
1355
        case LBR_CHUNK_RES_TS_2:
1356
        case LBR_CHUNK_RES_TS_2 + 1:
1357
        case LBR_CHUNK_RES_TS_2 + 2:
1358
            i = chunk_id - LBR_CHUNK_RES_TS_2;
1359
            chunk.ts2[i].len  = chunk_len;
1360
            chunk.ts2[i].data = gb.buffer;
1361
            break;
1362
        }
1363
1364
        bytestream2_skip(&gb, chunk_len);
1365
    }
1366
1367
    // Parse the chunks
1368
    ret = parse_lfe_chunk(s, &chunk.lfe);
1369
1370
    ret |= parse_tonal_chunk(s, &chunk.tonal);
1371
1372
    for (i = 0; i < 5; i++)
1373
        ret |= parse_tonal_group(s, &chunk.tonal_grp[i]);
1374
1375
    for (i = 0; i < (s->nchannels + 1) / 2; i++) {
1376
        int ch1 = i * 2;
1377
        int ch2 = FFMIN(ch1 + 1, s->nchannels - 1);
1378
1379
        if (parse_grid_1_chunk (s, &chunk.grid1  [i], ch1, ch2) < 0 ||
1380
            parse_high_res_grid(s, &chunk.hr_grid[i], ch1, ch2) < 0) {
1381
            ret = -1;
1382
            continue;
1383
        }
1384
1385
        // TS chunks depend on both grids. TS_2 depends on TS_1.
1386
        if (!chunk.grid1[i].len || !chunk.hr_grid[i].len || !chunk.ts1[i].len)
1387
            continue;
1388
1389
        if (parse_ts1_chunk(s, &chunk.ts1[i], ch1, ch2) < 0 ||
1390
            parse_ts2_chunk(s, &chunk.ts2[i], ch1, ch2) < 0) {
1391
            ret = -1;
1392
            continue;
1393
        }
1394
    }
1395
1396
    if (ret < 0 && (s->avctx->err_recognition & AV_EF_EXPLODE))
1397
        return AVERROR_INVALIDDATA;
1398
1399
    return 0;
1400
}
1401
1402
/**
1403
 * Reconstruct high-frequency resolution grid from first and third grids
1404
 */
1405
static void decode_grid(DCALbrDecoder *s, int ch1, int ch2)
1406
{
1407
    int i, ch, sb;
1408
1409
    for (ch = ch1; ch <= ch2; ch++) {
1410
        for (sb = 0; sb < s->nsubbands; sb++) {
1411
            int g1_sb = ff_dca_scf_to_grid_1[sb];
1412
1413
            uint8_t *g1_scf_a = s->grid_1_scf[ch][g1_sb    ];
1414
            uint8_t *g1_scf_b = s->grid_1_scf[ch][g1_sb + 1];
1415
1416
            int w1 = ff_dca_grid_1_weights[g1_sb    ][sb];
1417
            int w2 = ff_dca_grid_1_weights[g1_sb + 1][sb];
1418
1419
            uint8_t *hr_scf = s->high_res_scf[ch][sb];
1420
1421
            if (sb < 4) {
1422
                for (i = 0; i < 8; i++) {
1423
                    int scf = w1 * g1_scf_a[i] + w2 * g1_scf_b[i];
1424
                    hr_scf[i] = scf >> 7;
1425
                }
1426
            } else {
1427
                int8_t *g3_scf = s->grid_3_scf[ch][sb - 4];
1428
                int g3_avg = s->grid_3_avg[ch][sb - 4];
1429
1430
                for (i = 0; i < 8; i++) {
1431
                    int scf = w1 * g1_scf_a[i] + w2 * g1_scf_b[i];
1432
                    hr_scf[i] = (scf >> 7) - g3_avg - g3_scf[i];
1433
                }
1434
            }
1435
        }
1436
    }
1437
}
1438
1439
/**
1440
 * Fill unallocated subbands with randomness
1441
 */
1442
static void random_ts(DCALbrDecoder *s, int ch1, int ch2)
1443
{
1444
    int i, j, k, ch, sb;
1445
1446
    for (ch = ch1; ch <= ch2; ch++) {
1447
        for (sb = 0; sb < s->nsubbands; sb++) {
1448
            float *samples = s->time_samples[ch][sb];
1449
1450
            if (s->ch_pres[ch] & (1U << sb))
1451
                continue;   // Skip allocated subband
1452
1453
            if (sb < 2) {
1454
                // The first two subbands are always zero
1455
                memset(samples, 0, DCA_LBR_TIME_SAMPLES * sizeof(float));
1456
            } else if (sb < 10) {
1457
                for (i = 0; i < DCA_LBR_TIME_SAMPLES; i++)
1458
                    samples[i] = lbr_rand(s, sb);
1459
            } else {
1460
                for (i = 0; i < DCA_LBR_TIME_SAMPLES / 8; i++, samples += 8) {
1461
                    float accum[8] = { 0 };
1462
1463
                    // Modulate by subbands 2-5 in blocks of 8
1464
                    for (k = 2; k < 6; k++) {
1465
                        float *other = &s->time_samples[ch][k][i * 8];
1466
                        for (j = 0; j < 8; j++)
1467
                            accum[j] += fabs(other[j]);
1468
                    }
1469
1470
                    for (j = 0; j < 8; j++)
1471
                        samples[j] = (accum[j] * 0.25f + 0.5f) * lbr_rand(s, sb);
1472
                }
1473
            }
1474
        }
1475
    }
1476
}
1477
1478
static void predict(float *samples, const float *coeff, int nsamples)
1479
{
1480
    int i, j;
1481
1482
    for (i = 0; i < nsamples; i++) {
1483
        float res = 0;
1484
        for (j = 0; j < 8; j++)
1485
            res += coeff[j] * samples[i - j - 1];
1486
        samples[i] -= res;
1487
    }
1488
}
1489
1490
static void synth_lpc(DCALbrDecoder *s, int ch1, int ch2, int sb)
1491
{
1492
    int f = s->framenum & 1;
1493
    int ch;
1494
1495
    for (ch = ch1; ch <= ch2; ch++) {
1496
        float *samples = s->time_samples[ch][sb];
1497
1498
        if (!(s->ch_pres[ch] & (1U << sb)))
1499
            continue;
1500
1501
        if (sb < 2) {
1502
            predict(samples,      s->lpc_coeff[f^1][ch][sb][1],  16);
1503
            predict(samples + 16, s->lpc_coeff[f  ][ch][sb][0],  64);
1504
            predict(samples + 80, s->lpc_coeff[f  ][ch][sb][1],  48);
1505
        } else {
1506
            predict(samples,      s->lpc_coeff[f^1][ch][sb][0],  16);
1507
            predict(samples + 16, s->lpc_coeff[f  ][ch][sb][0], 112);
1508
        }
1509
    }
1510
}
1511
1512
static void filter_ts(DCALbrDecoder *s, int ch1, int ch2)
1513
{
1514
    int i, j, sb, ch;
1515
1516
    for (sb = 0; sb < s->nsubbands; sb++) {
1517
        // Scale factors
1518
        for (ch = ch1; ch <= ch2; ch++) {
1519
            float *samples = s->time_samples[ch][sb];
1520
            uint8_t *hr_scf = s->high_res_scf[ch][sb];
1521
            if (sb < 4) {
1522
                for (i = 0; i < DCA_LBR_TIME_SAMPLES / 16; i++, samples += 16) {
1523
                    unsigned int scf = hr_scf[i];
1524
                    if (scf > AMP_MAX)
1525
                        scf = AMP_MAX;
1526
                    for (j = 0; j < 16; j++)
1527
                        samples[j] *= ff_dca_quant_amp[scf];
1528
                }
1529
            } else {
1530
                uint8_t *g2_scf = s->grid_2_scf[ch][ff_dca_scf_to_grid_2[sb]];
1531
                for (i = 0; i < DCA_LBR_TIME_SAMPLES / 2; i++, samples += 2) {
1532
                    unsigned int scf = hr_scf[i / 8] - g2_scf[i];
1533
                    if (scf > AMP_MAX)
1534
                        scf = AMP_MAX;
1535
                    samples[0] *= ff_dca_quant_amp[scf];
1536
                    samples[1] *= ff_dca_quant_amp[scf];
1537
                }
1538
            }
1539
        }
1540
1541
        // Mid-side stereo
1542
        if (ch1 != ch2) {
1543
            float *samples_l = s->time_samples[ch1][sb];
1544
            float *samples_r = s->time_samples[ch2][sb];
1545
            int ch2_pres = s->ch_pres[ch2] & (1U << sb);
1546
1547
            for (i = 0; i < DCA_LBR_TIME_SAMPLES / 16; i++) {
1548
                int sbms = (s->sec_ch_sbms[ch1 / 2][sb] >> i) & 1;
1549
                int lrms = (s->sec_ch_lrms[ch1 / 2][sb] >> i) & 1;
1550
1551
                if (sb >= s->min_mono_subband) {
1552
                    if (lrms && ch2_pres) {
1553
                        if (sbms) {
1554
                            for (j = 0; j < 16; j++) {
1555
                                float tmp = samples_l[j];
1556
                                samples_l[j] =  samples_r[j];
1557
                                samples_r[j] = -tmp;
1558
                            }
1559
                        } else {
1560
                            for (j = 0; j < 16; j++) {
1561
                                float tmp = samples_l[j];
1562
                                samples_l[j] =  samples_r[j];
1563
                                samples_r[j] =  tmp;
1564
                            }
1565
                        }
1566
                    } else if (!ch2_pres) {
1567
                        if (sbms && (s->part_stereo_pres & (1 << ch1))) {
1568
                            for (j = 0; j < 16; j++)
1569
                                samples_r[j] = -samples_l[j];
1570
                        } else {
1571
                            for (j = 0; j < 16; j++)
1572
                                samples_r[j] =  samples_l[j];
1573
                        }
1574
                    }
1575
                } else if (sbms && ch2_pres) {
1576
                    for (j = 0; j < 16; j++) {
1577
                        float tmp = samples_l[j];
1578
                        samples_l[j] = (tmp + samples_r[j]) * 0.5f;
1579
                        samples_r[j] = (tmp - samples_r[j]) * 0.5f;
1580
                    }
1581
                }
1582
1583
                samples_l += 16;
1584
                samples_r += 16;
1585
            }
1586
        }
1587
1588
        // Inverse prediction
1589
        if (sb < 3)
1590
            synth_lpc(s, ch1, ch2, sb);
1591
    }
1592
}
1593
1594
/**
1595
 * Modulate by interpolated partial stereo coefficients
1596
 */
1597
static void decode_part_stereo(DCALbrDecoder *s, int ch1, int ch2)
1598
{
1599
    int i, ch, sb, sf;
1600
1601
    for (ch = ch1; ch <= ch2; ch++) {
1602
        for (sb = s->min_mono_subband; sb < s->nsubbands; sb++) {
1603
            uint8_t *pt_st = s->part_stereo[ch][(sb - s->min_mono_subband) / 4];
1604
            float *samples = s->time_samples[ch][sb];
1605
1606
            if (s->ch_pres[ch2] & (1U << sb))
1607
                continue;
1608
1609
            for (sf = 1; sf <= 4; sf++, samples += 32) {
1610
                float prev = ff_dca_st_coeff[pt_st[sf - 1]];
1611
                float next = ff_dca_st_coeff[pt_st[sf    ]];
1612
1613
                for (i = 0; i < 32; i++)
1614
                    samples[i] *= (32 - i) * prev + i * next;
1615
            }
1616
        }
1617
    }
1618
}
1619
1620
/**
1621
 * Synthesise tones in the given group for the given tonal subframe
1622
 */
1623
static void synth_tones(DCALbrDecoder *s, int ch, float *values,
1624
                        int group, int group_sf, int synth_idx)
1625
{
1626
    int i, start, count;
1627
1628
    if (synth_idx < 0)
1629
        return;
1630
1631
    start =  s->tonal_bounds[group][group_sf][0];
1632
    count = (s->tonal_bounds[group][group_sf][1] - start) & (DCA_LBR_TONES - 1);
1633
1634
    for (i = 0; i < count; i++) {
1635
        DCALbrTone *t = &s->tones[(start + i) & (DCA_LBR_TONES - 1)];
1636
1637
        if (t->amp[ch]) {
1638
            float amp = ff_dca_synth_env[synth_idx] * ff_dca_quant_amp[t->amp[ch]];
1639
            float c = amp * cos_tab[(t->phs[ch]     ) & 255];
1640
            float s = amp * cos_tab[(t->phs[ch] + 64) & 255];
1641
            const float *cf = ff_dca_corr_cf[t->f_delt];
1642
            int x_freq = t->x_freq;
1643
1644
            switch (x_freq) {
1645
            case 0:
1646
                goto p0;
1647
            case 1:
1648
                values[3] += cf[0] * -s;
1649
                values[2] += cf[1] *  c;
1650
                values[1] += cf[2] *  s;
1651
                values[0] += cf[3] * -c;
1652
                goto p1;
1653
            case 2:
1654
                values[2] += cf[0] * -s;
1655
                values[1] += cf[1] *  c;
1656
                values[0] += cf[2] *  s;
1657
                goto p2;
1658
            case 3:
1659
                values[1] += cf[0] * -s;
1660
                values[0] += cf[1] *  c;
1661
                goto p3;
1662
            case 4:
1663
                values[0] += cf[0] * -s;
1664
                goto p4;
1665
            }
1666
1667
            values[x_freq - 5] += cf[ 0] * -s;
1668
        p4: values[x_freq - 4] += cf[ 1] *  c;
1669
        p3: values[x_freq - 3] += cf[ 2] *  s;
1670
        p2: values[x_freq - 2] += cf[ 3] * -c;
1671
        p1: values[x_freq - 1] += cf[ 4] * -s;
1672
        p0: values[x_freq    ] += cf[ 5] *  c;
1673
            values[x_freq + 1] += cf[ 6] *  s;
1674
            values[x_freq + 2] += cf[ 7] * -c;
1675
            values[x_freq + 3] += cf[ 8] * -s;
1676
            values[x_freq + 4] += cf[ 9] *  c;
1677
            values[x_freq + 5] += cf[10] *  s;
1678
        }
1679
1680
        t->phs[ch] += t->ph_rot;
1681
    }
1682
}
1683
1684
/**
1685
 * Synthesise all tones in all groups for the given residual subframe
1686
 */
1687
static void base_func_synth(DCALbrDecoder *s, int ch, float *values, int sf)
1688
{
1689
    int group;
1690
1691
    // Tonal vs residual shift is 22 subframes
1692
    for (group = 0; group < 5; group++) {
1693
        int group_sf = (s->framenum << group) + ((sf - 22) >> (5 - group));
1694
        int synth_idx = ((((sf - 22) & 31) << group) & 31) + (1 << group) - 1;
1695
1696
        synth_tones(s, ch, values, group, (group_sf - 1) & 31, 30 - synth_idx);
1697
        synth_tones(s, ch, values, group, (group_sf    ) & 31,      synth_idx);
1698
    }
1699
}
1700
1701
static void transform_channel(DCALbrDecoder *s, int ch, float *output)
1702
{
1703
    LOCAL_ALIGNED_32(float, values, [DCA_LBR_SUBBANDS    ], [4]);
1704
    LOCAL_ALIGNED_32(float, result, [DCA_LBR_SUBBANDS * 2], [4]);
1705
    int sf, sb, nsubbands = s->nsubbands, noutsubbands = 8 << s->freq_range;
1706
1707
    // Clear inactive subbands
1708
    if (nsubbands < noutsubbands)
1709
        memset(values[nsubbands], 0, (noutsubbands - nsubbands) * sizeof(values[0]));
1710
1711
    for (sf = 0; sf < DCA_LBR_TIME_SAMPLES / 4; sf++) {
1712
        // Hybrid filterbank
1713
        s->dcadsp->lbr_bank(values, s->time_samples[ch],
1714
                            ff_dca_bank_coeff, sf * 4, nsubbands);
1715
1716
        base_func_synth(s, ch, values[0], sf);
1717
1718
        s->imdct.imdct_calc(&s->imdct, result[0], values[0]);
1719
1720
        // Long window and overlap-add
1721
        s->fdsp->vector_fmul_add(output, result[0], s->window,
1722
                                 s->history[ch], noutsubbands * 4);
1723
        s->fdsp->vector_fmul_reverse(s->history[ch], result[noutsubbands],
1724
                                     s->window, noutsubbands * 4);
1725
        output += noutsubbands * 4;
1726
    }
1727
1728
    // Update history for LPC and forward MDCT
1729
    for (sb = 0; sb < nsubbands; sb++) {
1730
        float *samples = s->time_samples[ch][sb] - DCA_LBR_TIME_HISTORY;
1731
        memcpy(samples, samples + DCA_LBR_TIME_SAMPLES, DCA_LBR_TIME_HISTORY * sizeof(float));
1732
    }
1733
}
1734
1735
int ff_dca_lbr_filter_frame(DCALbrDecoder *s, AVFrame *frame)
1736
{
1737
    AVCodecContext *avctx = s->avctx;
1738
    int i, ret, nchannels, ch_conf = (s->ch_mask & 0x7) - 1;
1739
    const int8_t *reorder;
1740
1741
    avctx->channel_layout = channel_layouts[ch_conf];
1742
    avctx->channels = nchannels = channel_counts[ch_conf];
1743
    avctx->sample_rate = s->sample_rate;
1744
    avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
1745
    avctx->bits_per_raw_sample = 0;
1746
    avctx->profile = FF_PROFILE_DTS_EXPRESS;
1747
    avctx->bit_rate = s->bit_rate_scaled;
1748
1749
    if (s->flags & LBR_FLAG_LFE_PRESENT) {
1750
        avctx->channel_layout |= AV_CH_LOW_FREQUENCY;
1751
        avctx->channels++;
1752
        reorder = channel_reorder_lfe[ch_conf];
1753
    } else {
1754
        reorder = channel_reorder_nolfe[ch_conf];
1755
    }
1756
1757
    frame->nb_samples = 1024 << s->freq_range;
1758
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1759
        return ret;
1760
1761
    // Filter fullband channels
1762
    for (i = 0; i < (s->nchannels + 1) / 2; i++) {
1763
        int ch1 = i * 2;
1764
        int ch2 = FFMIN(ch1 + 1, s->nchannels - 1);
1765
1766
        decode_grid(s, ch1, ch2);
1767
1768
        random_ts(s, ch1, ch2);
1769
1770
        filter_ts(s, ch1, ch2);
1771
1772
        if (ch1 != ch2 && (s->part_stereo_pres & (1 << ch1)))
1773
            decode_part_stereo(s, ch1, ch2);
1774
1775
        if (ch1 < nchannels)
1776
            transform_channel(s, ch1, (float *)frame->extended_data[reorder[ch1]]);
1777
1778
        if (ch1 != ch2 && ch2 < nchannels)
1779
            transform_channel(s, ch2, (float *)frame->extended_data[reorder[ch2]]);
1780
    }
1781
1782
    // Interpolate LFE channel
1783
    if (s->flags & LBR_FLAG_LFE_PRESENT) {
1784
        s->dcadsp->lfe_iir((float *)frame->extended_data[lfe_index[ch_conf]],
1785
                           s->lfe_data, ff_dca_lfe_iir,
1786
                           s->lfe_history, 16 << s->freq_range);
1787
    }
1788
1789
    if ((ret = ff_side_data_update_matrix_encoding(frame, AV_MATRIX_ENCODING_NONE)) < 0)
1790
        return ret;
1791
1792
    return 0;
1793
}
1794
1795
av_cold void ff_dca_lbr_flush(DCALbrDecoder *s)
1796
{
1797
    int ch, sb;
1798
1799
    if (!s->sample_rate)
1800
        return;
1801
1802
    // Clear history
1803
    memset(s->part_stereo, 16, sizeof(s->part_stereo));
1804
    memset(s->lpc_coeff, 0, sizeof(s->lpc_coeff));
1805
    memset(s->history, 0, sizeof(s->history));
1806
    memset(s->tonal_bounds, 0, sizeof(s->tonal_bounds));
1807
    memset(s->lfe_history, 0, sizeof(s->lfe_history));
1808
    s->framenum = 0;
1809
    s->ntones = 0;
1810
1811
    for (ch = 0; ch < s->nchannels; ch++) {
1812
        for (sb = 0; sb < s->nsubbands; sb++) {
1813
            float *samples = s->time_samples[ch][sb] - DCA_LBR_TIME_HISTORY;
1814
            memset(samples, 0, DCA_LBR_TIME_HISTORY * sizeof(float));
1815
        }
1816
    }
1817
}
1818
1819
92
av_cold int ff_dca_lbr_init(DCALbrDecoder *s)
1820
{
1821
92
    init_tables();
1822
1823
92
    if (!(s->fdsp = avpriv_float_dsp_alloc(0)))
1824
        return AVERROR(ENOMEM);
1825
1826
92
    s->lbr_rand = 1;
1827
92
    return 0;
1828
}
1829
1830
92
av_cold void ff_dca_lbr_close(DCALbrDecoder *s)
1831
{
1832
92
    s->sample_rate = 0;
1833
1834
92
    av_freep(&s->ts_buffer);
1835
92
    s->ts_size = 0;
1836
1837
92
    av_freep(&s->fdsp);
1838
92
    ff_mdct_end(&s->imdct);
1839
92
}