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