GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/atrac9dec.c Lines: 0 536 0.0 %
Date: 2021-03-07 19:55:24 Branches: 0 313 0.0 %

Line Branch Exec Source
1
/*
2
 * ATRAC9 decoder
3
 * Copyright (c) 2018 Rostislav Pehlivanov <atomnuker@gmail.com>
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21
22
#include "libavutil/thread.h"
23
24
#include "internal.h"
25
#include "get_bits.h"
26
#include "fft.h"
27
#include "atrac9tab.h"
28
#include "libavutil/lfg.h"
29
#include "libavutil/float_dsp.h"
30
#include "libavutil/mem_internal.h"
31
32
#define ATRAC9_SF_VLC_BITS 8
33
#define ATRAC9_COEFF_VLC_BITS 9
34
35
typedef struct ATRAC9ChannelData {
36
    int band_ext;
37
    int q_unit_cnt;
38
    int band_ext_data[4];
39
    int32_t scalefactors[31];
40
    int32_t scalefactors_prev[31];
41
42
    int precision_coarse[30];
43
    int precision_fine[30];
44
    int precision_mask[30];
45
46
    int codebookset[30];
47
48
    int32_t q_coeffs_coarse[256];
49
    int32_t q_coeffs_fine[256];
50
51
    DECLARE_ALIGNED(32, float, coeffs  )[256];
52
    DECLARE_ALIGNED(32, float, prev_win)[128];
53
} ATRAC9ChannelData;
54
55
typedef struct ATRAC9BlockData {
56
    ATRAC9ChannelData channel[2];
57
58
    /* Base */
59
    int band_count;
60
    int q_unit_cnt;
61
    int q_unit_cnt_prev;
62
63
    /* Stereo block only */
64
    int stereo_q_unit;
65
66
    /* Band extension only */
67
    int has_band_ext;
68
    int has_band_ext_data;
69
    int band_ext_q_unit;
70
71
    /* Gradient */
72
    int grad_mode;
73
    int grad_boundary;
74
    int gradient[31];
75
76
    /* Stereo */
77
    int cpe_base_channel;
78
    int is_signs[30];
79
80
    int reuseable;
81
82
} ATRAC9BlockData;
83
84
typedef struct ATRAC9Context {
85
    AVCodecContext *avctx;
86
    AVFloatDSPContext *fdsp;
87
    FFTContext imdct;
88
    ATRAC9BlockData block[5];
89
    AVLFG lfg;
90
91
    /* Set on init */
92
    int frame_log2;
93
    int avg_frame_size;
94
    int frame_count;
95
    int samplerate_idx;
96
    const ATRAC9BlockConfig *block_config;
97
98
    /* Generated on init */
99
    uint8_t alloc_curve[48][48];
100
    DECLARE_ALIGNED(32, float, imdct_win)[256];
101
102
    DECLARE_ALIGNED(32, float, temp)[256];
103
} ATRAC9Context;
104
105
static VLC sf_vlc[2][8];            /* Signed/unsigned, length */
106
static VLC coeff_vlc[2][8][4];      /* Cookbook, precision, cookbook index */
107
108
static inline int parse_gradient(ATRAC9Context *s, ATRAC9BlockData *b,
109
                                 GetBitContext *gb)
110
{
111
    int grad_range[2];
112
    int grad_value[2];
113
    int values, sign, base;
114
    uint8_t *curve;
115
    float scale;
116
117
    b->grad_mode = get_bits(gb, 2);
118
    if (b->grad_mode) {
119
        grad_range[0] = get_bits(gb, 5);
120
        grad_range[1] = 31;
121
        grad_value[0] = get_bits(gb, 5);
122
        grad_value[1] = 31;
123
    } else {
124
        grad_range[0] = get_bits(gb, 6);
125
        grad_range[1] = get_bits(gb, 6) + 1;
126
        grad_value[0] = get_bits(gb, 5);
127
        grad_value[1] = get_bits(gb, 5);
128
    }
129
    b->grad_boundary = get_bits(gb, 4);
130
131
    if (grad_range[0] >= grad_range[1] || grad_range[1] > 31)
132
        return AVERROR_INVALIDDATA;
133
134
    if (b->grad_boundary > b->q_unit_cnt)
135
        return AVERROR_INVALIDDATA;
136
137
    values    = grad_value[1] - grad_value[0];
138
    sign      = 1 - 2*(values < 0);
139
    base      = grad_value[0] + sign;
140
    scale     = (FFABS(values) - 1) / 31.0f;
141
    curve     = s->alloc_curve[grad_range[1] - grad_range[0] - 1];
142
143
    for (int i = 0; i <= b->q_unit_cnt; i++)
144
        b->gradient[i] = grad_value[i >= grad_range[0]];
145
146
    for (int i = grad_range[0]; i < grad_range[1]; i++)
147
        b->gradient[i] = base + sign*((int)(scale*curve[i - grad_range[0]]));
148
149
    return 0;
150
}
151
152
static inline void calc_precision(ATRAC9Context *s, ATRAC9BlockData *b,
153
                                  ATRAC9ChannelData *c)
154
{
155
    memset(c->precision_mask, 0, sizeof(c->precision_mask));
156
    for (int i = 1; i < b->q_unit_cnt; i++) {
157
        const int delta = FFABS(c->scalefactors[i] - c->scalefactors[i - 1]) - 1;
158
        if (delta > 0) {
159
            const int neg = c->scalefactors[i - 1] > c->scalefactors[i];
160
            c->precision_mask[i - neg] += FFMIN(delta, 5);
161
        }
162
    }
163
164
    if (b->grad_mode) {
165
        for (int i = 0; i < b->q_unit_cnt; i++) {
166
            c->precision_coarse[i] = c->scalefactors[i];
167
            c->precision_coarse[i] += c->precision_mask[i] - b->gradient[i];
168
            if (c->precision_coarse[i] < 0)
169
                continue;
170
            switch (b->grad_mode) {
171
            case 1:
172
                c->precision_coarse[i] >>= 1;
173
                break;
174
            case 2:
175
                c->precision_coarse[i] = (3 * c->precision_coarse[i]) >> 3;
176
                break;
177
            case 3:
178
                c->precision_coarse[i] >>= 2;
179
                break;
180
            }
181
        }
182
    } else {
183
        for (int i = 0; i < b->q_unit_cnt; i++)
184
            c->precision_coarse[i] = c->scalefactors[i] - b->gradient[i];
185
    }
186
187
188
    for (int i = 0; i < b->q_unit_cnt; i++)
189
        c->precision_coarse[i] = FFMAX(c->precision_coarse[i], 1);
190
191
    for (int i = 0; i < b->grad_boundary; i++)
192
        c->precision_coarse[i]++;
193
194
    for (int i = 0; i < b->q_unit_cnt; i++) {
195
        c->precision_fine[i] = 0;
196
        if (c->precision_coarse[i] > 15) {
197
            c->precision_fine[i] = FFMIN(c->precision_coarse[i], 30) - 15;
198
            c->precision_coarse[i] = 15;
199
        }
200
    }
201
}
202
203
static inline int parse_band_ext(ATRAC9Context *s, ATRAC9BlockData *b,
204
                                 GetBitContext *gb, int stereo)
205
{
206
    int ext_band = 0;
207
208
    if (b->has_band_ext) {
209
        if (b->q_unit_cnt < 13 || b->q_unit_cnt > 20)
210
            return AVERROR_INVALIDDATA;
211
        ext_band = at9_tab_band_ext_group[b->q_unit_cnt - 13][2];
212
        if (stereo) {
213
            b->channel[1].band_ext = get_bits(gb, 2);
214
            b->channel[1].band_ext = ext_band > 2 ? b->channel[1].band_ext : 4;
215
        } else {
216
            skip_bits1(gb);
217
        }
218
    }
219
220
    b->has_band_ext_data = get_bits1(gb);
221
    if (!b->has_band_ext_data)
222
        return 0;
223
224
    if (!b->has_band_ext) {
225
        skip_bits(gb, 2);
226
        skip_bits_long(gb, get_bits(gb, 5));
227
        return 0;
228
    }
229
230
    b->channel[0].band_ext = get_bits(gb, 2);
231
    b->channel[0].band_ext = ext_band > 2 ? b->channel[0].band_ext : 4;
232
233
    if (!get_bits(gb, 5)) {
234
        for (int i = 0; i <= stereo; i++) {
235
            ATRAC9ChannelData *c = &b->channel[i];
236
            const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
237
            for (int j = 0; j < count; j++) {
238
                int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
239
                c->band_ext_data[j] = av_clip_uintp2_c(c->band_ext_data[j], len);
240
            }
241
        }
242
243
        return 0;
244
    }
245
246
    for (int i = 0; i <= stereo; i++) {
247
        ATRAC9ChannelData *c = &b->channel[i];
248
        const int count = at9_tab_band_ext_cnt[c->band_ext][ext_band];
249
        for (int j = 0; j < count; j++) {
250
            int len = at9_tab_band_ext_lengths[c->band_ext][ext_band][j];
251
            c->band_ext_data[j] = get_bits(gb, len);
252
        }
253
    }
254
255
    return 0;
256
}
257
258
static inline int read_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,
259
                                    ATRAC9ChannelData *c, GetBitContext *gb,
260
                                    int channel_idx, int first_in_pkt)
261
{
262
    static const uint8_t mode_map[2][4] = { { 0, 1, 2, 3 }, { 0, 2, 3, 4 } };
263
    const int mode = mode_map[channel_idx][get_bits(gb, 2)];
264
265
    memset(c->scalefactors, 0, sizeof(c->scalefactors));
266
267
    if (first_in_pkt && (mode == 4 || ((mode == 3) && !channel_idx))) {
268
        av_log(s->avctx, AV_LOG_ERROR, "Invalid scalefactor coding mode!\n");
269
        return AVERROR_INVALIDDATA;
270
    }
271
272
    switch (mode) {
273
    case 0: { /* VLC delta offset */
274
        const uint8_t *sf_weights = at9_tab_sf_weights[get_bits(gb, 3)];
275
        const int base = get_bits(gb, 5);
276
        const int len = get_bits(gb, 2) + 3;
277
        const VLC *tab = &sf_vlc[0][len];
278
279
        c->scalefactors[0] = get_bits(gb, len);
280
281
        for (int i = 1; i < b->band_ext_q_unit; i++) {
282
            int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table,
283
                                                        ATRAC9_SF_VLC_BITS, 1);
284
            c->scalefactors[i] = val & ((1 << len) - 1);
285
        }
286
287
        for (int i = 0; i < b->band_ext_q_unit; i++)
288
            c->scalefactors[i] += base - sf_weights[i];
289
290
        break;
291
    }
292
    case 1: { /* CLC offset */
293
        const int len = get_bits(gb, 2) + 2;
294
        const int base = len < 5 ? get_bits(gb, 5) : 0;
295
        for (int i = 0; i < b->band_ext_q_unit; i++)
296
            c->scalefactors[i] = base + get_bits(gb, len);
297
        break;
298
    }
299
    case 2:
300
    case 4: { /* VLC dist to baseline */
301
        const int *baseline = mode == 4 ? c->scalefactors_prev :
302
                              channel_idx ? b->channel[0].scalefactors :
303
                              c->scalefactors_prev;
304
        const int baseline_len = mode == 4 ? b->q_unit_cnt_prev :
305
                                 channel_idx ? b->band_ext_q_unit :
306
                                 b->q_unit_cnt_prev;
307
308
        const int len = get_bits(gb, 2) + 2;
309
        const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
310
        const VLC *tab = &sf_vlc[1][len];
311
312
        for (int i = 0; i < unit_cnt; i++) {
313
            int dist = get_vlc2(gb, tab->table, ATRAC9_SF_VLC_BITS, 1);
314
            c->scalefactors[i] = baseline[i] + dist;
315
        }
316
317
        for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
318
            c->scalefactors[i] = get_bits(gb, 5);
319
320
        break;
321
    }
322
    case 3: { /* VLC offset with baseline */
323
        const int *baseline = channel_idx ? b->channel[0].scalefactors :
324
                              c->scalefactors_prev;
325
        const int baseline_len = channel_idx ? b->band_ext_q_unit :
326
                                 b->q_unit_cnt_prev;
327
328
        const int base = get_bits(gb, 5) - (1 << (5 - 1));
329
        const int len = get_bits(gb, 2) + 1;
330
        const int unit_cnt = FFMIN(b->band_ext_q_unit, baseline_len);
331
        const VLC *tab = &sf_vlc[0][len];
332
333
        c->scalefactors[0] = get_bits(gb, len);
334
335
        for (int i = 1; i < unit_cnt; i++) {
336
            int val = c->scalefactors[i - 1] + get_vlc2(gb, tab->table,
337
                                                        ATRAC9_SF_VLC_BITS, 1);
338
            c->scalefactors[i] = val & ((1 << len) - 1);
339
        }
340
341
        for (int i = 0; i < unit_cnt; i++)
342
            c->scalefactors[i] += base + baseline[i];
343
344
        for (int i = unit_cnt; i < b->band_ext_q_unit; i++)
345
            c->scalefactors[i] = get_bits(gb, 5);
346
        break;
347
    }
348
    }
349
350
    for (int i = 0; i < b->band_ext_q_unit; i++)
351
        if (c->scalefactors[i] < 0 || c->scalefactors[i] > 31)
352
            return AVERROR_INVALIDDATA;
353
354
    memcpy(c->scalefactors_prev, c->scalefactors, sizeof(c->scalefactors));
355
356
    return 0;
357
}
358
359
static inline void calc_codebook_idx(ATRAC9Context *s, ATRAC9BlockData *b,
360
                                     ATRAC9ChannelData *c)
361
{
362
    int avg = 0;
363
    const int last_sf = c->scalefactors[c->q_unit_cnt];
364
365
    memset(c->codebookset, 0, sizeof(c->codebookset));
366
367
    if (c->q_unit_cnt <= 1)
368
        return;
369
    if (s->samplerate_idx > 7)
370
        return;
371
372
    c->scalefactors[c->q_unit_cnt] = c->scalefactors[c->q_unit_cnt - 1];
373
374
    if (c->q_unit_cnt > 12) {
375
        for (int i = 0; i < 12; i++)
376
            avg += c->scalefactors[i];
377
        avg = (avg + 6) / 12;
378
    }
379
380
    for (int i = 8; i < c->q_unit_cnt; i++) {
381
        const int prev = c->scalefactors[i - 1];
382
        const int cur  = c->scalefactors[i    ];
383
        const int next = c->scalefactors[i + 1];
384
        const int min  = FFMIN(prev, next);
385
        if ((cur - min >= 3 || 2*cur - prev - next >= 3))
386
            c->codebookset[i] = 1;
387
    }
388
389
390
    for (int i = 12; i < c->q_unit_cnt; i++) {
391
        const int cur = c->scalefactors[i];
392
        const int cnd = at9_q_unit_to_coeff_cnt[i] == 16;
393
        const int min = FFMIN(c->scalefactors[i + 1], c->scalefactors[i - 1]);
394
        if (c->codebookset[i])
395
            continue;
396
397
        c->codebookset[i] = (((cur - min) >= 2) && (cur >= (avg - cnd)));
398
    }
399
400
    c->scalefactors[c->q_unit_cnt] = last_sf;
401
}
402
403
static inline void read_coeffs_coarse(ATRAC9Context *s, ATRAC9BlockData *b,
404
                                      ATRAC9ChannelData *c, GetBitContext *gb)
405
{
406
    const int max_prec = s->samplerate_idx > 7 ? 1 : 7;
407
408
    memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
409
410
    for (int i = 0; i < c->q_unit_cnt; i++) {
411
        int *coeffs = &c->q_coeffs_coarse[at9_q_unit_to_coeff_idx[i]];
412
        const int bands = at9_q_unit_to_coeff_cnt[i];
413
        const int prec = c->precision_coarse[i] + 1;
414
415
        if (prec <= max_prec) {
416
            const int cb = c->codebookset[i];
417
            const int cbi = at9_q_unit_to_codebookidx[i];
418
            const VLC *tab = &coeff_vlc[cb][prec][cbi];
419
            const HuffmanCodebook *huff = &at9_huffman_coeffs[cb][prec][cbi];
420
            const int groups = bands >> huff->value_cnt_pow;
421
422
            for (int j = 0; j < groups; j++) {
423
                uint16_t val = get_vlc2(gb, tab->table, ATRAC9_COEFF_VLC_BITS, 2);
424
425
                for (int k = 0; k < huff->value_cnt; k++) {
426
                    coeffs[k] = sign_extend(val, huff->value_bits);
427
                    val >>= huff->value_bits;
428
                }
429
430
                coeffs += huff->value_cnt;
431
            }
432
        } else {
433
            for (int j = 0; j < bands; j++)
434
                coeffs[j] = sign_extend(get_bits(gb, prec), prec);
435
        }
436
    }
437
}
438
439
static inline void read_coeffs_fine(ATRAC9Context *s, ATRAC9BlockData *b,
440
                                    ATRAC9ChannelData *c, GetBitContext *gb)
441
{
442
    memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
443
444
    for (int i = 0; i < c->q_unit_cnt; i++) {
445
        const int start = at9_q_unit_to_coeff_idx[i + 0];
446
        const int end   = at9_q_unit_to_coeff_idx[i + 1];
447
        const int len   = c->precision_fine[i] + 1;
448
449
        if (c->precision_fine[i] <= 0)
450
            continue;
451
452
        for (int j = start; j < end; j++)
453
            c->q_coeffs_fine[j] = sign_extend(get_bits(gb, len), len);
454
    }
455
}
456
457
static inline void dequantize(ATRAC9Context *s, ATRAC9BlockData *b,
458
                              ATRAC9ChannelData *c)
459
{
460
    memset(c->coeffs, 0, sizeof(c->coeffs));
461
462
    for (int i = 0; i < c->q_unit_cnt; i++) {
463
        const int start = at9_q_unit_to_coeff_idx[i + 0];
464
        const int end   = at9_q_unit_to_coeff_idx[i + 1];
465
466
        const float coarse_c = at9_quant_step_coarse[c->precision_coarse[i]];
467
        const float fine_c   = at9_quant_step_fine[c->precision_fine[i]];
468
469
        for (int j = start; j < end; j++) {
470
            const float vc = c->q_coeffs_coarse[j] * coarse_c;
471
            const float vf = c->q_coeffs_fine[j]   * fine_c;
472
            c->coeffs[j] = vc + vf;
473
        }
474
    }
475
}
476
477
static inline void apply_intensity_stereo(ATRAC9Context *s, ATRAC9BlockData *b,
478
                                          const int stereo)
479
{
480
    float *src = b->channel[ b->cpe_base_channel].coeffs;
481
    float *dst = b->channel[!b->cpe_base_channel].coeffs;
482
483
    if (!stereo)
484
        return;
485
486
    if (b->q_unit_cnt <= b->stereo_q_unit)
487
        return;
488
489
    for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++) {
490
        const int sign  = b->is_signs[i];
491
        const int start = at9_q_unit_to_coeff_idx[i + 0];
492
        const int end   = at9_q_unit_to_coeff_idx[i + 1];
493
        for (int j = start; j < end; j++)
494
            dst[j] = sign*src[j];
495
    }
496
}
497
498
static inline void apply_scalefactors(ATRAC9Context *s, ATRAC9BlockData *b,
499
                                      const int stereo)
500
{
501
    for (int i = 0; i <= stereo; i++) {
502
        float *coeffs = b->channel[i].coeffs;
503
        for (int j = 0; j < b->q_unit_cnt; j++) {
504
            const int start = at9_q_unit_to_coeff_idx[j + 0];
505
            const int end   = at9_q_unit_to_coeff_idx[j + 1];
506
            const int scalefactor = b->channel[i].scalefactors[j];
507
            const float scale = at9_scalefactor_c[scalefactor];
508
            for (int k = start; k < end; k++)
509
                coeffs[k] *= scale;
510
        }
511
    }
512
}
513
514
static inline void fill_with_noise(ATRAC9Context *s, ATRAC9ChannelData *c,
515
                                   int start, int count)
516
{
517
    float maxval = 0.0f;
518
    for (int i = 0; i < count; i += 2) {
519
        double tmp[2];
520
        av_bmg_get(&s->lfg, tmp);
521
        c->coeffs[start + i + 0] = tmp[0];
522
        c->coeffs[start + i + 1] = tmp[1];
523
        maxval = FFMAX(FFMAX(FFABS(tmp[0]), FFABS(tmp[1])), maxval);
524
    }
525
    /* Normalize */
526
    for (int i = 0; i < count; i++)
527
        c->coeffs[start + i] /= maxval;
528
}
529
530
static inline void scale_band_ext_coeffs(ATRAC9ChannelData *c, float sf[6],
531
                                         const int s_unit, const int e_unit)
532
{
533
    for (int i = s_unit; i < e_unit; i++) {
534
        const int start = at9_q_unit_to_coeff_idx[i + 0];
535
        const int end   = at9_q_unit_to_coeff_idx[i + 1];
536
        for (int j = start; j < end; j++)
537
            c->coeffs[j] *= sf[i - s_unit];
538
    }
539
}
540
541
static inline void apply_band_extension(ATRAC9Context *s, ATRAC9BlockData *b,
542
                                       const int stereo)
543
{
544
    const int g_units[4] = { /* A, B, C, total units */
545
        b->q_unit_cnt,
546
        at9_tab_band_ext_group[b->q_unit_cnt - 13][0],
547
        at9_tab_band_ext_group[b->q_unit_cnt - 13][1],
548
        FFMAX(g_units[2], 22),
549
    };
550
551
    const int g_bins[4] = { /* A, B, C, total bins */
552
        at9_q_unit_to_coeff_idx[g_units[0]],
553
        at9_q_unit_to_coeff_idx[g_units[1]],
554
        at9_q_unit_to_coeff_idx[g_units[2]],
555
        at9_q_unit_to_coeff_idx[g_units[3]],
556
    };
557
558
    for (int ch = 0; ch <= stereo; ch++) {
559
        ATRAC9ChannelData *c = &b->channel[ch];
560
561
        /* Mirror the spectrum */
562
        for (int i = 0; i < 3; i++)
563
            for (int j = 0; j < (g_bins[i + 1] - g_bins[i + 0]); j++)
564
                c->coeffs[g_bins[i] + j] = c->coeffs[g_bins[i] - j - 1];
565
566
        switch (c->band_ext) {
567
        case 0: {
568
            float sf[6] = { 0.0f };
569
            const int l = g_units[3] - g_units[0] - 1;
570
            const int n_start = at9_q_unit_to_coeff_idx[g_units[3] - 1];
571
            const int n_cnt   = at9_q_unit_to_coeff_cnt[g_units[3] - 1];
572
            switch (at9_tab_band_ext_group[b->q_unit_cnt - 13][2]) {
573
            case 3:
574
                sf[0] = at9_band_ext_scales_m0[0][0][c->band_ext_data[0]];
575
                sf[1] = at9_band_ext_scales_m0[0][1][c->band_ext_data[0]];
576
                sf[2] = at9_band_ext_scales_m0[0][2][c->band_ext_data[1]];
577
                sf[3] = at9_band_ext_scales_m0[0][3][c->band_ext_data[2]];
578
                sf[4] = at9_band_ext_scales_m0[0][4][c->band_ext_data[3]];
579
                break;
580
            case 4:
581
                sf[0] = at9_band_ext_scales_m0[1][0][c->band_ext_data[0]];
582
                sf[1] = at9_band_ext_scales_m0[1][1][c->band_ext_data[0]];
583
                sf[2] = at9_band_ext_scales_m0[1][2][c->band_ext_data[1]];
584
                sf[3] = at9_band_ext_scales_m0[1][3][c->band_ext_data[2]];
585
                sf[4] = at9_band_ext_scales_m0[1][4][c->band_ext_data[3]];
586
                break;
587
            case 5:
588
                sf[0] = at9_band_ext_scales_m0[2][0][c->band_ext_data[0]];
589
                sf[1] = at9_band_ext_scales_m0[2][1][c->band_ext_data[1]];
590
                sf[2] = at9_band_ext_scales_m0[2][2][c->band_ext_data[1]];
591
                break;
592
            }
593
594
            sf[l] = at9_scalefactor_c[c->scalefactors[g_units[0]]];
595
596
            fill_with_noise(s, c, n_start, n_cnt);
597
            scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
598
            break;
599
        }
600
        case 1: {
601
            float sf[6];
602
            for (int i = g_units[0]; i < g_units[3]; i++)
603
                sf[i - g_units[0]] = at9_scalefactor_c[c->scalefactors[i]];
604
605
            fill_with_noise(s, c, g_bins[0], g_bins[3] - g_bins[0]);
606
            scale_band_ext_coeffs(c, sf, g_units[0], g_units[3]);
607
            break;
608
        }
609
        case 2: {
610
            const float g_sf[2] = {
611
                at9_band_ext_scales_m2[c->band_ext_data[0]],
612
                at9_band_ext_scales_m2[c->band_ext_data[1]],
613
            };
614
615
            for (int i = 0; i < 2; i++)
616
                for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
617
                    c->coeffs[j] *= g_sf[i];
618
            break;
619
        }
620
        case 3: {
621
            float scale = at9_band_ext_scales_m3[c->band_ext_data[0]][0];
622
            float rate  = at9_band_ext_scales_m3[c->band_ext_data[1]][1];
623
            rate = pow(2, rate);
624
            for (int i = g_bins[0]; i < g_bins[3]; i++) {
625
                scale *= rate;
626
                c->coeffs[i] *= scale;
627
            }
628
            break;
629
        }
630
        case 4: {
631
            const float m = at9_band_ext_scales_m4[c->band_ext_data[0]];
632
            const float g_sf[3] = { 0.7079468f*m, 0.5011902f*m, 0.3548279f*m };
633
634
            for (int i = 0; i < 3; i++)
635
                for (int j = g_bins[i + 0]; j < g_bins[i + 1]; j++)
636
                    c->coeffs[j] *= g_sf[i];
637
            break;
638
        }
639
        }
640
    }
641
}
642
643
static int atrac9_decode_block(ATRAC9Context *s, GetBitContext *gb,
644
                               ATRAC9BlockData *b, AVFrame *frame,
645
                               int frame_idx, int block_idx)
646
{
647
    const int first_in_pkt = !get_bits1(gb);
648
    const int reuse_params =  get_bits1(gb);
649
    const int stereo = s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_CPE;
650
651
    if (s->block_config->type[block_idx] == ATRAC9_BLOCK_TYPE_LFE) {
652
        ATRAC9ChannelData *c = &b->channel[0];
653
        const int precision = reuse_params ? 8 : 4;
654
        c->q_unit_cnt = b->q_unit_cnt = 2;
655
656
        memset(c->scalefactors, 0, sizeof(c->scalefactors));
657
        memset(c->q_coeffs_fine, 0, sizeof(c->q_coeffs_fine));
658
        memset(c->q_coeffs_coarse, 0, sizeof(c->q_coeffs_coarse));
659
660
        for (int i = 0; i < b->q_unit_cnt; i++) {
661
            c->scalefactors[i] = get_bits(gb, 5);
662
            c->precision_coarse[i] = precision;
663
            c->precision_fine[i] = 0;
664
        }
665
666
        for (int i = 0; i < c->q_unit_cnt; i++) {
667
            const int start = at9_q_unit_to_coeff_idx[i + 0];
668
            const int end   = at9_q_unit_to_coeff_idx[i + 1];
669
            for (int j = start; j < end; j++)
670
                c->q_coeffs_coarse[j] = get_bits(gb, c->precision_coarse[i] + 1);
671
        }
672
673
        dequantize        (s, b, c);
674
        apply_scalefactors(s, b, 0);
675
676
        goto imdct;
677
    }
678
679
    if (first_in_pkt && reuse_params) {
680
        av_log(s->avctx, AV_LOG_ERROR, "Invalid block flags!\n");
681
        return AVERROR_INVALIDDATA;
682
    }
683
684
    /* Band parameters */
685
    if (!reuse_params) {
686
        int stereo_band, ext_band;
687
        const int min_band_count = s->samplerate_idx > 7 ? 1 : 3;
688
        b->reuseable = 0;
689
        b->band_count = get_bits(gb, 4) + min_band_count;
690
        b->q_unit_cnt = at9_tab_band_q_unit_map[b->band_count];
691
692
        b->band_ext_q_unit = b->stereo_q_unit = b->q_unit_cnt;
693
694
        if (b->band_count > at9_tab_sri_max_bands[s->samplerate_idx]) {
695
            av_log(s->avctx, AV_LOG_ERROR, "Invalid band count %i!\n",
696
                   b->band_count);
697
            return AVERROR_INVALIDDATA;
698
        }
699
700
        if (stereo) {
701
            stereo_band = get_bits(gb, 4) + min_band_count;
702
            if (stereo_band > b->band_count) {
703
                av_log(s->avctx, AV_LOG_ERROR, "Invalid stereo band %i!\n",
704
                       stereo_band);
705
                return AVERROR_INVALIDDATA;
706
            }
707
            b->stereo_q_unit = at9_tab_band_q_unit_map[stereo_band];
708
        }
709
710
        b->has_band_ext = get_bits1(gb);
711
        if (b->has_band_ext) {
712
            ext_band = get_bits(gb, 4) + min_band_count;
713
            if (ext_band < b->band_count) {
714
                av_log(s->avctx, AV_LOG_ERROR, "Invalid extension band %i!\n",
715
                       ext_band);
716
                return AVERROR_INVALIDDATA;
717
            }
718
            b->band_ext_q_unit = at9_tab_band_q_unit_map[ext_band];
719
        }
720
        b->reuseable = 1;
721
    }
722
    if (!b->reuseable) {
723
        av_log(s->avctx, AV_LOG_ERROR, "invalid block reused!\n");
724
        return AVERROR_INVALIDDATA;
725
    }
726
727
    /* Calculate bit alloc gradient */
728
    if (parse_gradient(s, b, gb))
729
        return AVERROR_INVALIDDATA;
730
731
    /* IS data */
732
    b->cpe_base_channel = 0;
733
    if (stereo) {
734
        b->cpe_base_channel = get_bits1(gb);
735
        if (get_bits1(gb)) {
736
            for (int i = b->stereo_q_unit; i < b->q_unit_cnt; i++)
737
                b->is_signs[i] = 1 - 2*get_bits1(gb);
738
        } else {
739
            for (int i = 0; i < FF_ARRAY_ELEMS(b->is_signs); i++)
740
                b->is_signs[i] = 1;
741
        }
742
    }
743
744
    /* Band extension */
745
    if (parse_band_ext(s, b, gb, stereo))
746
        return AVERROR_INVALIDDATA;
747
748
    /* Scalefactors */
749
    for (int i = 0; i <= stereo; i++) {
750
        ATRAC9ChannelData *c = &b->channel[i];
751
        c->q_unit_cnt = i == b->cpe_base_channel ? b->q_unit_cnt :
752
                                                   b->stereo_q_unit;
753
        if (read_scalefactors(s, b, c, gb, i, first_in_pkt))
754
            return AVERROR_INVALIDDATA;
755
756
        calc_precision    (s, b, c);
757
        calc_codebook_idx (s, b, c);
758
        read_coeffs_coarse(s, b, c, gb);
759
        read_coeffs_fine  (s, b, c, gb);
760
        dequantize        (s, b, c);
761
    }
762
763
    b->q_unit_cnt_prev = b->has_band_ext ? b->band_ext_q_unit : b->q_unit_cnt;
764
765
    apply_intensity_stereo(s, b, stereo);
766
    apply_scalefactors    (s, b, stereo);
767
768
    if (b->has_band_ext && b->has_band_ext_data)
769
        apply_band_extension  (s, b, stereo);
770
771
imdct:
772
    for (int i = 0; i <= stereo; i++) {
773
        ATRAC9ChannelData *c = &b->channel[i];
774
        const int dst_idx = s->block_config->plane_map[block_idx][i];
775
        const int wsize = 1 << s->frame_log2;
776
        const ptrdiff_t offset = wsize*frame_idx*sizeof(float);
777
        float *dst = (float *)(frame->extended_data[dst_idx] + offset);
778
779
        s->imdct.imdct_half(&s->imdct, s->temp, c->coeffs);
780
        s->fdsp->vector_fmul_window(dst, c->prev_win, s->temp,
781
                                    s->imdct_win, wsize >> 1);
782
        memcpy(c->prev_win, s->temp + (wsize >> 1), sizeof(float)*wsize >> 1);
783
    }
784
785
    return 0;
786
}
787
788
static int atrac9_decode_frame(AVCodecContext *avctx, void *data,
789
                               int *got_frame_ptr, AVPacket *avpkt)
790
{
791
    int ret;
792
    GetBitContext gb;
793
    AVFrame *frame = data;
794
    ATRAC9Context *s = avctx->priv_data;
795
    const int frames = FFMIN(avpkt->size / s->avg_frame_size, s->frame_count);
796
797
    frame->nb_samples = (1 << s->frame_log2) * frames;
798
    ret = ff_get_buffer(avctx, frame, 0);
799
    if (ret < 0)
800
        return ret;
801
802
    init_get_bits8(&gb, avpkt->data, avpkt->size);
803
804
    for (int i = 0; i < frames; i++) {
805
        for (int j = 0; j < s->block_config->count; j++) {
806
            ret = atrac9_decode_block(s, &gb, &s->block[j], frame, i, j);
807
            if (ret)
808
                return ret;
809
            align_get_bits(&gb);
810
        }
811
    }
812
813
    *got_frame_ptr = 1;
814
815
    return avctx->block_align;
816
}
817
818
static void atrac9_decode_flush(AVCodecContext *avctx)
819
{
820
    ATRAC9Context *s = avctx->priv_data;
821
822
    for (int j = 0; j < s->block_config->count; j++) {
823
        ATRAC9BlockData *b = &s->block[j];
824
        const int stereo = s->block_config->type[j] == ATRAC9_BLOCK_TYPE_CPE;
825
        for (int i = 0; i <= stereo; i++) {
826
            ATRAC9ChannelData *c = &b->channel[i];
827
            memset(c->prev_win, 0, sizeof(c->prev_win));
828
        }
829
    }
830
}
831
832
static av_cold int atrac9_decode_close(AVCodecContext *avctx)
833
{
834
    ATRAC9Context *s = avctx->priv_data;
835
836
    ff_mdct_end(&s->imdct);
837
    av_freep(&s->fdsp);
838
839
    return 0;
840
}
841
842
static av_cold void atrac9_init_vlc(VLC *vlc, int nb_bits, int nb_codes,
843
                                    const uint8_t (**tab)[2],
844
                                    unsigned *buf_offset, int offset)
845
{
846
    static VLC_TYPE vlc_buf[24812][2];
847
848
    vlc->table           = &vlc_buf[*buf_offset];
849
    vlc->table_allocated = FF_ARRAY_ELEMS(vlc_buf) - *buf_offset;
850
    ff_init_vlc_from_lengths(vlc, nb_bits, nb_codes,
851
                             &(*tab)[0][1], 2, &(*tab)[0][0], 2, 1,
852
                             offset, INIT_VLC_STATIC_OVERLONG, NULL);
853
    *buf_offset += vlc->table_size;
854
    *tab        += nb_codes;
855
}
856
857
static av_cold void atrac9_init_static(void)
858
{
859
    const uint8_t (*tab)[2];
860
    unsigned offset = 0;
861
862
    /* Unsigned scalefactor VLCs */
863
    tab = at9_sfb_a_tab;
864
    for (int i = 1; i < 7; i++) {
865
        const HuffmanCodebook *hf = &at9_huffman_sf_unsigned[i];
866
867
        atrac9_init_vlc(&sf_vlc[0][i], ATRAC9_SF_VLC_BITS,
868
                        hf->size, &tab, &offset, 0);
869
    }
870
871
    /* Signed scalefactor VLCs */
872
    tab = at9_sfb_b_tab;
873
    for (int i = 2; i < 6; i++) {
874
        const HuffmanCodebook *hf = &at9_huffman_sf_signed[i];
875
876
        /* The symbols are signed integers in the range -16..15;
877
         * the values in the source table are offset by 16 to make
878
         * them fit into an uint8_t; the -16 reverses this shift. */
879
        atrac9_init_vlc(&sf_vlc[1][i], ATRAC9_SF_VLC_BITS,
880
                        hf->size, &tab, &offset, -16);
881
    }
882
883
    /* Coefficient VLCs */
884
    tab = at9_coeffs_tab;
885
    for (int i = 0; i < 2; i++) {
886
        for (int j = 2; j < 8; j++) {
887
            for (int k = i; k < 4; k++) {
888
                const HuffmanCodebook *hf = &at9_huffman_coeffs[i][j][k];
889
                atrac9_init_vlc(&coeff_vlc[i][j][k], ATRAC9_COEFF_VLC_BITS,
890
                                hf->size, &tab, &offset, 0);
891
            }
892
        }
893
    }
894
}
895
896
static av_cold int atrac9_decode_init(AVCodecContext *avctx)
897
{
898
    static AVOnce static_table_init = AV_ONCE_INIT;
899
    GetBitContext gb;
900
    ATRAC9Context *s = avctx->priv_data;
901
    int version, block_config_idx, superframe_idx, alloc_c_len;
902
903
    s->avctx = avctx;
904
905
    av_lfg_init(&s->lfg, 0xFBADF00D);
906
907
    if (avctx->block_align <= 0) {
908
        av_log(avctx, AV_LOG_ERROR, "Invalid block align\n");
909
        return AVERROR_INVALIDDATA;
910
    }
911
912
    if (avctx->extradata_size != 12) {
913
        av_log(avctx, AV_LOG_ERROR, "Invalid extradata length!\n");
914
        return AVERROR_INVALIDDATA;
915
    }
916
917
    version = AV_RL32(avctx->extradata);
918
    if (version > 2) {
919
        av_log(avctx, AV_LOG_ERROR, "Unsupported version (%i)!\n", version);
920
        return AVERROR_INVALIDDATA;
921
    }
922
923
    init_get_bits8(&gb, avctx->extradata + 4, avctx->extradata_size);
924
925
    if (get_bits(&gb, 8) != 0xFE) {
926
        av_log(avctx, AV_LOG_ERROR, "Incorrect magic byte!\n");
927
        return AVERROR_INVALIDDATA;
928
    }
929
930
    s->samplerate_idx = get_bits(&gb, 4);
931
    avctx->sample_rate = at9_tab_samplerates[s->samplerate_idx];
932
933
    block_config_idx = get_bits(&gb, 3);
934
    if (block_config_idx > 5) {
935
        av_log(avctx, AV_LOG_ERROR, "Incorrect block config!\n");
936
        return AVERROR_INVALIDDATA;
937
    }
938
    s->block_config = &at9_block_layout[block_config_idx];
939
940
    avctx->channel_layout = s->block_config->channel_layout;
941
    avctx->channels       = av_get_channel_layout_nb_channels(avctx->channel_layout);
942
    avctx->sample_fmt     = AV_SAMPLE_FMT_FLTP;
943
944
    if (get_bits1(&gb)) {
945
        av_log(avctx, AV_LOG_ERROR, "Incorrect verification bit!\n");
946
        return AVERROR_INVALIDDATA;
947
    }
948
949
    /* Average frame size in bytes */
950
    s->avg_frame_size = get_bits(&gb, 11) + 1;
951
952
    superframe_idx = get_bits(&gb, 2);
953
    if (superframe_idx & 1) {
954
        av_log(avctx, AV_LOG_ERROR, "Invalid superframe index!\n");
955
        return AVERROR_INVALIDDATA;
956
    }
957
958
    s->frame_count = 1 << superframe_idx;
959
    s->frame_log2  = at9_tab_sri_frame_log2[s->samplerate_idx];
960
961
    if (ff_mdct_init(&s->imdct, s->frame_log2 + 1, 1, 1.0f / 32768.0f))
962
        return AVERROR(ENOMEM);
963
964
    s->fdsp = avpriv_float_dsp_alloc(avctx->flags & AV_CODEC_FLAG_BITEXACT);
965
    if (!s->fdsp)
966
        return AVERROR(ENOMEM);
967
968
    /* iMDCT window */
969
    for (int i = 0; i < (1 << s->frame_log2); i++) {
970
        const int   len  = 1 << s->frame_log2;
971
        const float sidx = (      i + 0.5f) / len;
972
        const float eidx = (len - i - 0.5f) / len;
973
        const float s_c  = sinf(sidx*M_PI - M_PI_2)*0.5f + 0.5f;
974
        const float e_c  = sinf(eidx*M_PI - M_PI_2)*0.5f + 0.5f;
975
        s->imdct_win[i]  = s_c / ((s_c * s_c) + (e_c * e_c));
976
    }
977
978
    /* Allocation curve */
979
    alloc_c_len = FF_ARRAY_ELEMS(at9_tab_b_dist);
980
    for (int i = 1; i <= alloc_c_len; i++)
981
        for (int j = 0; j < i; j++)
982
            s->alloc_curve[i - 1][j] = at9_tab_b_dist[(j * alloc_c_len) / i];
983
984
    ff_thread_once(&static_table_init, atrac9_init_static);
985
986
    return 0;
987
}
988
989
AVCodec ff_atrac9_decoder = {
990
    .name           = "atrac9",
991
    .long_name      = NULL_IF_CONFIG_SMALL("ATRAC9 (Adaptive TRansform Acoustic Coding 9)"),
992
    .type           = AVMEDIA_TYPE_AUDIO,
993
    .id             = AV_CODEC_ID_ATRAC9,
994
    .priv_data_size = sizeof(ATRAC9Context),
995
    .init           = atrac9_decode_init,
996
    .close          = atrac9_decode_close,
997
    .decode         = atrac9_decode_frame,
998
    .flush          = atrac9_decode_flush,
999
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,
1000
    .capabilities   = AV_CODEC_CAP_SUBFRAMES | AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
1001
};