GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/qdmc.c Lines: 0 347 0.0 %
Date: 2020-08-14 10:39:37 Branches: 0 176 0.0 %

Line Branch Exec Source
1
/*
2
 * QDMC compatible decoder
3
 * Copyright (c) 2017 Paul B Mahol
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 <math.h>
23
#include <stddef.h>
24
#include <stdio.h>
25
26
#define BITSTREAM_READER_LE
27
28
#include "libavutil/channel_layout.h"
29
#include "libavutil/thread.h"
30
31
#include "avcodec.h"
32
#include "bytestream.h"
33
#include "get_bits.h"
34
#include "internal.h"
35
#include "fft.h"
36
37
typedef struct QDMCTone {
38
    uint8_t mode;
39
    uint8_t phase;
40
    uint8_t offset;
41
    int16_t freq;
42
    int16_t amplitude;
43
} QDMCTone;
44
45
typedef struct QDMCContext {
46
    AVCodecContext *avctx;
47
48
    uint8_t frame_bits;
49
    int band_index;
50
    int frame_size;
51
    int subframe_size;
52
    int fft_offset;
53
    int buffer_offset;
54
    int nb_channels;
55
    int checksum_size;
56
57
    uint8_t noise[2][19][17];
58
    QDMCTone tones[5][8192];
59
    int nb_tones[5];
60
    int cur_tone[5];
61
    float alt_sin[5][31];
62
    float fft_buffer[4][8192 * 2];
63
    float noise2_buffer[4096 * 2];
64
    float noise_buffer[4096 * 2];
65
    float buffer[2 * 32768];
66
    float *buffer_ptr;
67
    int rndval;
68
69
    DECLARE_ALIGNED(32, FFTComplex, cmplx)[2][512];
70
    FFTContext fft_ctx;
71
} QDMCContext;
72
73
static float sin_table[512];
74
static VLC vtable[6];
75
76
static const unsigned code_prefix[] = {
77
    0x0, 0x1, 0x2, 0x3, 0x4, 0x6, 0x8, 0xA,
78
    0xC, 0x10, 0x14, 0x18, 0x1C, 0x24, 0x2C, 0x34,
79
    0x3C, 0x4C, 0x5C, 0x6C, 0x7C, 0x9C, 0xBC, 0xDC,
80
    0xFC, 0x13C, 0x17C, 0x1BC, 0x1FC, 0x27C, 0x2FC, 0x37C,
81
    0x3FC, 0x4FC, 0x5FC, 0x6FC, 0x7FC, 0x9FC, 0xBFC, 0xDFC,
82
    0xFFC, 0x13FC, 0x17FC, 0x1BFC, 0x1FFC, 0x27FC, 0x2FFC, 0x37FC,
83
    0x3FFC, 0x4FFC, 0x5FFC, 0x6FFC, 0x7FFC, 0x9FFC, 0xBFFC, 0xDFFC,
84
    0xFFFC, 0x13FFC, 0x17FFC, 0x1BFFC, 0x1FFFC, 0x27FFC, 0x2FFFC, 0x37FFC,
85
    0x3FFFC
86
};
87
88
static const float amplitude_tab[64] = {
89
    1.18750000f, 1.68359380f, 2.37500000f, 3.36718750f, 4.75000000f,
90
    6.73437500f, 9.50000000f, 13.4687500f, 19.0000000f, 26.9375000f,
91
    38.0000000f, 53.8750000f, 76.0000000f, 107.750000f, 152.000000f,
92
    215.500000f, 304.000000f, 431.000000f, 608.000000f, 862.000000f,
93
    1216.00000f, 1724.00000f, 2432.00000f, 3448.00000f, 4864.00000f,
94
    6896.00000f, 9728.00000f, 13792.0000f, 19456.0000f, 27584.0000f,
95
    38912.0000f, 55168.0000f, 77824.0000f, 110336.000f, 155648.000f,
96
    220672.000f, 311296.000f, 441344.000f, 622592.000f, 882688.000f,
97
    1245184.00f, 1765376.00f, 2490368.00f, 3530752.00f, 4980736.00f,
98
    7061504.00f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
99
};
100
101
static const uint16_t qdmc_nodes[112] = {
102
    0, 1, 2, 4, 6, 8, 12, 16, 24, 32, 48, 56, 64,
103
    80, 96, 120, 144, 176, 208, 240, 256,
104
    0, 2, 4, 8, 16, 24, 32, 48, 56, 64, 80, 104,
105
    128, 160, 208, 256, 0, 0, 0, 0, 0,
106
    0, 2, 4, 8, 16, 32, 48, 64, 80, 112, 160, 208,
107
    256, 0, 0, 0, 0, 0, 0, 0, 0,
108
    0, 4, 8, 16, 32, 48, 64, 96, 144, 208, 256,
109
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
110
    0, 4, 16, 32, 64, 256, 0, 0, 0, 0, 0, 0, 0, 0,
111
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
112
};
113
114
static const uint8_t noise_bands_size[] = {
115
    19, 14, 11, 9, 4, 2, 0
116
};
117
118
static const uint8_t noise_bands_selector[] = {
119
    4, 3, 2, 1, 0, 0, 0,
120
};
121
122
static const uint8_t noise_value_bits[] = {
123
    12, 7, 9, 7, 10, 9, 11, 9, 9, 2, 9, 9, 9, 9,
124
    9, 3, 9, 10, 10, 12, 2, 3, 3, 5, 5, 6, 7,
125
};
126
127
static const uint8_t noise_value_symbols[] = {
128
    0, 10, 11, 12, 13, 14, 15, 16, 18, 1, 20, 22, 24,
129
    26, 28, 2, 30, 32, 34, 36, 3, 4, 5, 6, 7, 8, 9,
130
};
131
132
static const uint16_t noise_value_codes[] = {
133
    0xC7A, 0x002, 0x0FA, 0x03A, 0x35A, 0x1C2, 0x07A, 0x1FA,
134
    0x17A, 0x000, 0x0DA, 0x142, 0x0C2, 0x042, 0x1DA, 0x001,
135
    0x05A, 0x15A, 0x27A, 0x47A, 0x003, 0x005, 0x006, 0x012,
136
    0x00A, 0x022, 0x01A,
137
};
138
139
static const uint8_t noise_segment_length_bits[] = {
140
    10, 8, 5, 1, 2, 4, 4, 4, 6, 7, 9, 10,
141
};
142
143
static const uint8_t noise_segment_length_symbols[] = {
144
    0, 13, 17, 1, 2, 3, 4, 5, 6, 7, 8, 9,
145
};
146
147
static const uint16_t noise_segment_length_codes[] = {
148
    0x30B, 0x8B, 0x1B, 0x0, 0x1, 0x3, 0x7, 0xF, 0x2b, 0x4B, 0xB, 0x10B,
149
};
150
151
static const uint8_t freq_diff_bits[] = {
152
    18, 2, 4, 4, 5, 4, 4, 5, 5, 4, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 6,
153
    7, 6, 6, 6, 7, 7, 7, 7, 7, 8, 9, 9, 8, 9, 11, 11, 12, 12, 13, 12,
154
    14, 15, 18, 16, 17,
155
};
156
157
static const uint32_t freq_diff_codes[] = {
158
    0x2AD46, 0x1, 0x0, 0x3, 0xC, 0xA, 0x7, 0x18, 0x12, 0xE, 0x4, 0x16,
159
    0xF, 0x1C, 0x8, 0x22, 0x26, 0x2, 0x3B, 0x34, 0x74, 0x1F, 0x14, 0x2B,
160
    0x1B, 0x3F, 0x28, 0x54, 0x6, 0x4B, 0xB, 0x68, 0xE8, 0x46, 0xC6, 0x1E8,
161
    0x146, 0x346, 0x546, 0x746, 0x1D46, 0xF46, 0xD46, 0x6D46, 0xAD46, 0x2D46,
162
    0x1AD46,
163
};
164
165
static const uint8_t amplitude_bits[] = {
166
    13, 7, 8, 9, 10, 10, 10, 10, 10, 9, 8, 7, 6,
167
    5, 4, 3, 3, 2, 3, 3, 4, 5, 7, 8, 9, 11, 12, 13,
168
};
169
170
static const uint16_t amplitude_codes[] = {
171
    0x1EC6, 0x6, 0xC2, 0x142, 0x242, 0x246, 0xC6, 0x46, 0x42, 0x146, 0xA2,
172
    0x62, 0x26, 0x16, 0xE, 0x5, 0x4, 0x3, 0x0, 0x1, 0xA, 0x12, 0x2, 0x22,
173
    0x1C6, 0x2C6, 0x6C6, 0xEC6,
174
};
175
176
static const uint8_t amplitude_diff_bits[] = {
177
    8, 2, 1, 3, 4, 5, 6, 7, 8,
178
};
179
180
static const uint8_t amplitude_diff_codes[] = {
181
    0xFE, 0x0, 0x1, 0x2, 0x6, 0xE, 0x1E, 0x3E, 0x7E,
182
};
183
184
static const uint8_t phase_diff_bits[] = {
185
    6, 2, 2, 4, 4, 6, 5, 4, 2,
186
};
187
188
static const uint8_t phase_diff_codes[] = {
189
    0x35, 0x2, 0x0, 0x1, 0xD, 0x15, 0x5, 0x9, 0x3,
190
};
191
192
#define INIT_VLC_STATIC_LE(vlc, nb_bits, nb_codes,                 \
193
                           bits, bits_wrap, bits_size,             \
194
                           codes, codes_wrap, codes_size,          \
195
                           symbols, symbols_wrap, symbols_size,    \
196
                           static_size)                            \
197
    do {                                                           \
198
        static VLC_TYPE table[static_size][2];                     \
199
        (vlc)->table           = table;                            \
200
        (vlc)->table_allocated = static_size;                      \
201
        ff_init_vlc_sparse(vlc, nb_bits, nb_codes,                 \
202
                           bits, bits_wrap, bits_size,             \
203
                           codes, codes_wrap, codes_size,          \
204
                           symbols, symbols_wrap, symbols_size,    \
205
                           INIT_VLC_LE | INIT_VLC_USE_NEW_STATIC); \
206
    } while (0)
207
208
static av_cold void qdmc_init_static_data(void)
209
{
210
    int i;
211
212
    INIT_VLC_STATIC_LE(&vtable[0], 12, FF_ARRAY_ELEMS(noise_value_bits),
213
                       noise_value_bits, 1, 1, noise_value_codes, 2, 2, noise_value_symbols, 1, 1, 4096);
214
    INIT_VLC_STATIC_LE(&vtable[1], 10, FF_ARRAY_ELEMS(noise_segment_length_bits),
215
                       noise_segment_length_bits, 1, 1, noise_segment_length_codes, 2, 2,
216
                       noise_segment_length_symbols, 1, 1, 1024);
217
    INIT_VLC_STATIC_LE(&vtable[2], 13, FF_ARRAY_ELEMS(amplitude_bits),
218
                       amplitude_bits, 1, 1, amplitude_codes, 2, 2, NULL, 0, 0, 8192);
219
    INIT_VLC_STATIC_LE(&vtable[3], 18, FF_ARRAY_ELEMS(freq_diff_bits),
220
                       freq_diff_bits, 1, 1, freq_diff_codes, 4, 4, NULL, 0, 0, 262144);
221
    INIT_VLC_STATIC_LE(&vtable[4], 8, FF_ARRAY_ELEMS(amplitude_diff_bits),
222
                       amplitude_diff_bits, 1, 1, amplitude_diff_codes, 1, 1, NULL, 0, 0, 256);
223
    INIT_VLC_STATIC_LE(&vtable[5], 6, FF_ARRAY_ELEMS(phase_diff_bits),
224
                       phase_diff_bits, 1, 1, phase_diff_codes, 1, 1, NULL, 0, 0, 64);
225
226
    for (i = 0; i < 512; i++)
227
        sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);
228
}
229
230
static void make_noises(QDMCContext *s)
231
{
232
    int i, j, n0, n1, n2, diff;
233
    float *nptr;
234
235
    for (j = 0; j < noise_bands_size[s->band_index]; j++) {
236
        n0 = qdmc_nodes[j + 21 * s->band_index    ];
237
        n1 = qdmc_nodes[j + 21 * s->band_index + 1];
238
        n2 = qdmc_nodes[j + 21 * s->band_index + 2];
239
        nptr = s->noise_buffer + 256 * j;
240
241
        for (i = 0; i + n0 < n1; i++, nptr++)
242
            nptr[0] = i / (float)(n1 - n0);
243
244
        diff = n2 - n1;
245
        nptr = s->noise_buffer + (j << 8) + n1 - n0;
246
247
        for (i = n1; i < n2; i++, nptr++, diff--)
248
            nptr[0] = diff / (float)(n2 - n1);
249
    }
250
}
251
252
static av_cold int qdmc_decode_init(AVCodecContext *avctx)
253
{
254
    static AVOnce init_static_once = AV_ONCE_INIT;
255
    QDMCContext *s = avctx->priv_data;
256
    int ret, fft_size, fft_order, size, g, j, x;
257
    GetByteContext b;
258
259
    ff_thread_once(&init_static_once, qdmc_init_static_data);
260
261
    if (!avctx->extradata || (avctx->extradata_size < 48)) {
262
        av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
263
        return AVERROR_INVALIDDATA;
264
    }
265
266
    bytestream2_init(&b, avctx->extradata, avctx->extradata_size);
267
268
    while (bytestream2_get_bytes_left(&b) > 8) {
269
        if (bytestream2_peek_be64(&b) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |
270
                                           (uint64_t)MKBETAG('Q','D','M','C')))
271
            break;
272
        bytestream2_skipu(&b, 1);
273
    }
274
    bytestream2_skipu(&b, 8);
275
276
    if (bytestream2_get_bytes_left(&b) < 36) {
277
        av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
278
               bytestream2_get_bytes_left(&b));
279
        return AVERROR_INVALIDDATA;
280
    }
281
282
    size = bytestream2_get_be32u(&b);
283
    if (size > bytestream2_get_bytes_left(&b)) {
284
        av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
285
               bytestream2_get_bytes_left(&b), size);
286
        return AVERROR_INVALIDDATA;
287
    }
288
289
    if (bytestream2_get_be32u(&b) != MKBETAG('Q','D','C','A')) {
290
        av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
291
        return AVERROR_INVALIDDATA;
292
    }
293
    bytestream2_skipu(&b, 4);
294
295
    avctx->channels = s->nb_channels = bytestream2_get_be32u(&b);
296
    if (s->nb_channels <= 0 || s->nb_channels > 2) {
297
        av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
298
        return AVERROR_INVALIDDATA;
299
    }
300
    avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
301
                                                   AV_CH_LAYOUT_MONO;
302
303
    avctx->sample_rate = bytestream2_get_be32u(&b);
304
    avctx->bit_rate = bytestream2_get_be32u(&b);
305
    bytestream2_skipu(&b, 4);
306
    fft_size = bytestream2_get_be32u(&b);
307
    fft_order = av_log2(fft_size) + 1;
308
    s->checksum_size = bytestream2_get_be32u(&b);
309
    if (s->checksum_size >= 1U << 28) {
310
        av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);
311
        return AVERROR_INVALIDDATA;
312
    }
313
314
    if (avctx->sample_rate >= 32000) {
315
        x = 28000;
316
        s->frame_bits = 13;
317
    } else if (avctx->sample_rate >= 16000) {
318
        x = 20000;
319
        s->frame_bits = 12;
320
    } else {
321
        x = 16000;
322
        s->frame_bits = 11;
323
    }
324
    s->frame_size = 1 << s->frame_bits;
325
    s->subframe_size = s->frame_size >> 5;
326
327
    if (avctx->channels == 2)
328
        x = 3 * x / 2;
329
    s->band_index = noise_bands_selector[FFMIN(6, llrint(floor(avctx->bit_rate * 3.0 / (double)x + 0.5)))];
330
331
    if ((fft_order < 7) || (fft_order > 9)) {
332
        avpriv_request_sample(avctx, "Unknown FFT order %d", fft_order);
333
        return AVERROR_PATCHWELCOME;
334
    }
335
336
    if (fft_size != (1 << (fft_order - 1))) {
337
        av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", fft_size);
338
        return AVERROR_INVALIDDATA;
339
    }
340
341
    ret = ff_fft_init(&s->fft_ctx, fft_order, 1);
342
    if (ret < 0)
343
        return ret;
344
345
    avctx->sample_fmt = AV_SAMPLE_FMT_S16;
346
347
    for (g = 5; g > 0; g--) {
348
        for (j = 0; j < (1 << g) - 1; j++)
349
            s->alt_sin[5-g][j] = sin_table[(((j+1) << (8 - g)) & 0x1FF)];
350
    }
351
352
    make_noises(s);
353
354
    return 0;
355
}
356
357
static av_cold int qdmc_decode_close(AVCodecContext *avctx)
358
{
359
    QDMCContext *s = avctx->priv_data;
360
361
    ff_fft_end(&s->fft_ctx);
362
363
    return 0;
364
}
365
366
static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
367
{
368
    int v;
369
370
    if (get_bits_left(gb) < 1)
371
        return AVERROR_INVALIDDATA;
372
    v = get_vlc2(gb, table->table, table->bits, 1);
373
    if (v < 0)
374
        return AVERROR_INVALIDDATA;
375
    if (v)
376
        v = v - 1;
377
    else
378
        v = get_bits(gb, get_bits(gb, 3) + 1);
379
380
    if (flag) {
381
        if (v >= FF_ARRAY_ELEMS(code_prefix))
382
            return AVERROR_INVALIDDATA;
383
384
        v = code_prefix[v] + get_bitsz(gb, v >> 2);
385
    }
386
387
    return v;
388
}
389
390
static int skip_label(QDMCContext *s, GetBitContext *gb)
391
{
392
    uint32_t label = get_bits_long(gb, 32);
393
    uint16_t sum = 226, checksum = get_bits(gb, 16);
394
    const uint8_t *ptr = gb->buffer + 6;
395
    int i;
396
397
    if (label != MKTAG('Q', 'M', 'C', 1))
398
        return AVERROR_INVALIDDATA;
399
400
    for (i = 0; i < s->checksum_size - 6; i++)
401
        sum += ptr[i];
402
403
    return sum != checksum;
404
}
405
406
static int read_noise_data(QDMCContext *s, GetBitContext *gb)
407
{
408
    int ch, j, k, v, idx, band, lastval, newval, len;
409
410
    for (ch = 0; ch < s->nb_channels; ch++) {
411
        for (band = 0; band < noise_bands_size[s->band_index]; band++) {
412
            v = qdmc_get_vlc(gb, &vtable[0], 0);
413
            if (v < 0)
414
                return AVERROR_INVALIDDATA;
415
416
            if (v & 1)
417
                v = v + 1;
418
            else
419
                v = -v;
420
421
            lastval = v / 2;
422
            s->noise[ch][band][0] = lastval - 1;
423
            for (j = 0; j < 15;) {
424
                len = qdmc_get_vlc(gb, &vtable[1], 1);
425
                if (len < 0)
426
                    return AVERROR_INVALIDDATA;
427
                len += 1;
428
429
                v = qdmc_get_vlc(gb, &vtable[0], 0);
430
                if (v < 0)
431
                    return AVERROR_INVALIDDATA;
432
433
                if (v & 1)
434
                    newval = lastval + (v + 1) / 2;
435
                else
436
                    newval = lastval - v / 2;
437
438
                idx = j + 1;
439
                if (len + idx > 16)
440
                    return AVERROR_INVALIDDATA;
441
442
                for (k = 1; idx <= j + len; k++, idx++)
443
                    s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
444
445
                lastval = newval;
446
                j += len;
447
            }
448
        }
449
    }
450
451
    return 0;
452
}
453
454
static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
455
{
456
    const int index = s->nb_tones[group];
457
458
    if (index >= FF_ARRAY_ELEMS(s->tones[group])) {
459
        av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");
460
        return;
461
    }
462
463
    s->tones[group][index].offset    = offset;
464
    s->tones[group][index].freq      = freq;
465
    s->tones[group][index].mode      = stereo_mode;
466
    s->tones[group][index].amplitude = amplitude;
467
    s->tones[group][index].phase     = phase;
468
    s->nb_tones[group]++;
469
}
470
471
static int read_wave_data(QDMCContext *s, GetBitContext *gb)
472
{
473
    int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
474
    int amp2, phase2, pos2, off;
475
476
    for (group = 0; group < 5; group++) {
477
        group_size = 1 << (s->frame_bits - group - 1);
478
        group_bits = 4 - group;
479
        pos2 = 0;
480
        off  = 0;
481
482
        for (i = 1; ; i = freq + 1) {
483
            int v;
484
485
            v = qdmc_get_vlc(gb, &vtable[3], 1);
486
            if (v < 0)
487
                return AVERROR_INVALIDDATA;
488
489
            freq = i + v;
490
            while (freq >= group_size - 1) {
491
                freq += 2 - group_size;
492
                pos2 += group_size;
493
                off  += 1 << group_bits;
494
            }
495
496
            if (pos2 >= s->frame_size)
497
                break;
498
499
            if (s->nb_channels > 1)
500
                stereo_mode = get_bits(gb, 2);
501
502
            amp   = qdmc_get_vlc(gb, &vtable[2], 0);
503
            if (amp < 0)
504
                return AVERROR_INVALIDDATA;
505
            phase = get_bits(gb, 3);
506
507
            if (stereo_mode > 1) {
508
                amp2   = qdmc_get_vlc(gb, &vtable[4], 0);
509
                if (amp2 < 0)
510
                    return AVERROR_INVALIDDATA;
511
                amp2   = amp - amp2;
512
513
                phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
514
                if (phase2 < 0)
515
                    return AVERROR_INVALIDDATA;
516
                phase2 = phase - phase2;
517
518
                if (phase2 < 0)
519
                    phase2 += 8;
520
            }
521
522
            if ((freq >> group_bits) + 1 < s->subframe_size) {
523
                add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
524
                if (stereo_mode > 1)
525
                    add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
526
            }
527
        }
528
    }
529
530
    return 0;
531
}
532
533
static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
534
{
535
    int subframe_size, i, j, k, length;
536
    float scale, *noise_ptr;
537
538
    scale = 0.5 * amplitude;
539
    subframe_size = s->subframe_size;
540
    if (subframe_size >= node2)
541
        subframe_size = node2;
542
    length = (subframe_size - node1) & 0xFFFC;
543
    j = node1;
544
    noise_ptr = &s->noise_buffer[256 * index];
545
546
    for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {
547
        s->noise2_buffer[j    ] += scale * noise_ptr[0];
548
        s->noise2_buffer[j + 1] += scale * noise_ptr[1];
549
        s->noise2_buffer[j + 2] += scale * noise_ptr[2];
550
        s->noise2_buffer[j + 3] += scale * noise_ptr[3];
551
    }
552
553
    k = length + node1;
554
    noise_ptr = s->noise_buffer + length + (index << 8);
555
    for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)
556
        s->noise2_buffer[k] += scale * noise_ptr[0];
557
}
558
559
static void add_noise(QDMCContext *s, int ch, int current_subframe)
560
{
561
    int i, j, aindex;
562
    float amplitude;
563
    float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];
564
    float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];
565
566
    memset(s->noise2_buffer, 0, 4 * s->subframe_size);
567
568
    for (i = 0; i < noise_bands_size[s->band_index]; i++) {
569
        if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)
570
            break;
571
572
        aindex = s->noise[ch][i][current_subframe / 2];
573
        amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
574
575
        lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
576
                 qdmc_nodes[21 * s->band_index + i + 2], i);
577
    }
578
579
    for (j = 2; j < s->subframe_size - 1; j++) {
580
        float rnd_re, rnd_im;
581
582
        s->rndval = 214013U * s->rndval + 2531011;
583
        rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
584
        s->rndval = 214013U * s->rndval + 2531011;
585
        rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
586
        im[j  ] += rnd_im;
587
        re[j  ] += rnd_re;
588
        im[j+1] -= rnd_im;
589
        re[j+1] -= rnd_re;
590
    }
591
}
592
593
static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
594
{
595
    int j, group_bits, pos, pindex;
596
    float im, re, amplitude, level, *imptr, *reptr;
597
598
    if (s->nb_channels == 1)
599
        stereo_mode = 0;
600
601
    group_bits = 4 - group;
602
    pos = freqs >> (4 - group);
603
    amplitude = amplitude_tab[amp & 0x3F];
604
    imptr = &s->fft_buffer[    stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
605
    reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
606
    pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);
607
    for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {
608
        pindex += (2 * freqs + 1) << (7 - group_bits);
609
        level = amplitude * s->alt_sin[group][j];
610
        im = level * sin_table[ pindex        & 0x1FF];
611
        re = level * sin_table[(pindex + 128) & 0x1FF];
612
        imptr[0] += im;
613
        imptr[1] -= im;
614
        reptr[0] += re;
615
        reptr[1] -= re;
616
        imptr += s->subframe_size;
617
        reptr += s->subframe_size;
618
        if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {
619
            imptr = &s->fft_buffer[0 + stereo_mode][pos];
620
            reptr = &s->fft_buffer[2 + stereo_mode][pos];
621
        }
622
    }
623
}
624
625
static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
626
{
627
    float level, im, re;
628
    int pos;
629
630
    if (s->nb_channels == 1)
631
        stereo_mode = 0;
632
633
    level = amplitude_tab[amp & 0x3F];
634
    im = level * sin_table[ (phase << 6)        & 0x1FF];
635
    re = level * sin_table[((phase << 6) + 128) & 0x1FF];
636
    pos = s->fft_offset + freqs + s->subframe_size * offset;
637
    s->fft_buffer[    stereo_mode][pos    ] += im;
638
    s->fft_buffer[2 + stereo_mode][pos    ] += re;
639
    s->fft_buffer[    stereo_mode][pos + 1] -= im;
640
    s->fft_buffer[2 + stereo_mode][pos + 1] -= re;
641
}
642
643
static void add_waves(QDMCContext *s, int current_subframe)
644
{
645
    int w, g;
646
647
    for (g = 0; g < 4; g++) {
648
        for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {
649
            QDMCTone *t = &s->tones[g][w];
650
651
            if (current_subframe < t->offset)
652
                break;
653
            add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
654
        }
655
        s->cur_tone[g] = w;
656
    }
657
    for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
658
        QDMCTone *t = &s->tones[4][w];
659
660
        if (current_subframe < t->offset)
661
            break;
662
        add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
663
    }
664
    s->cur_tone[4] = w;
665
}
666
667
static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
668
{
669
    int ret, ch, i, n;
670
671
    if (skip_label(s, gb))
672
        return AVERROR_INVALIDDATA;
673
674
    s->fft_offset = s->frame_size - s->fft_offset;
675
    s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
676
677
    ret = read_noise_data(s, gb);
678
    if (ret < 0)
679
        return ret;
680
681
    ret = read_wave_data(s, gb);
682
    if (ret < 0)
683
        return ret;
684
685
    for (n = 0; n < 32; n++) {
686
        float *r;
687
688
        for (ch = 0; ch < s->nb_channels; ch++)
689
            add_noise(s, ch, n);
690
691
        add_waves(s, n);
692
693
        for (ch = 0; ch < s->nb_channels; ch++) {
694
            for (i = 0; i < s->subframe_size; i++) {
695
                s->cmplx[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];
696
                s->cmplx[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];
697
                s->cmplx[ch][s->subframe_size + i].re = 0;
698
                s->cmplx[ch][s->subframe_size + i].im = 0;
699
            }
700
        }
701
702
        for (ch = 0; ch < s->nb_channels; ch++) {
703
            s->fft_ctx.fft_permute(&s->fft_ctx, s->cmplx[ch]);
704
            s->fft_ctx.fft_calc(&s->fft_ctx, s->cmplx[ch]);
705
        }
706
707
        r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];
708
        for (i = 0; i < 2 * s->subframe_size; i++) {
709
            for (ch = 0; ch < s->nb_channels; ch++) {
710
                *r++ += s->cmplx[ch][i].re;
711
            }
712
        }
713
714
        r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];
715
        for (i = 0; i < s->nb_channels * s->subframe_size; i++) {
716
            out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);
717
        }
718
        out += s->subframe_size * s->nb_channels;
719
720
        for (ch = 0; ch < s->nb_channels; ch++) {
721
            memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
722
            memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
723
        }
724
        memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);
725
    }
726
727
    s->buffer_offset += s->frame_size;
728
    if (s->buffer_offset >= 32768 - s->frame_size) {
729
        memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);
730
        s->buffer_offset = 0;
731
    }
732
733
    return 0;
734
}
735
736
static av_cold void qdmc_flush(AVCodecContext *avctx)
737
{
738
    QDMCContext *s = avctx->priv_data;
739
740
    memset(s->buffer, 0, sizeof(s->buffer));
741
    memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
742
    s->fft_offset = 0;
743
    s->buffer_offset = 0;
744
}
745
746
static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
747
                             int *got_frame_ptr, AVPacket *avpkt)
748
{
749
    QDMCContext *s = avctx->priv_data;
750
    AVFrame *frame = data;
751
    GetBitContext gb;
752
    int ret;
753
754
    if (!avpkt->data)
755
        return 0;
756
    if (avpkt->size < s->checksum_size)
757
        return AVERROR_INVALIDDATA;
758
759
    s->avctx = avctx;
760
    frame->nb_samples = s->frame_size;
761
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
762
        return ret;
763
764
    if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
765
        return ret;
766
767
    memset(s->nb_tones, 0, sizeof(s->nb_tones));
768
    memset(s->cur_tone, 0, sizeof(s->cur_tone));
769
770
    ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
771
    if (ret >= 0) {
772
        *got_frame_ptr = 1;
773
        return s->checksum_size;
774
    }
775
    qdmc_flush(avctx);
776
    return ret;
777
}
778
779
AVCodec ff_qdmc_decoder = {
780
    .name             = "qdmc",
781
    .long_name        = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),
782
    .type             = AVMEDIA_TYPE_AUDIO,
783
    .id               = AV_CODEC_ID_QDMC,
784
    .priv_data_size   = sizeof(QDMCContext),
785
    .init             = qdmc_decode_init,
786
    .close            = qdmc_decode_close,
787
    .decode           = qdmc_decode_frame,
788
    .flush            = qdmc_flush,
789
    .capabilities     = AV_CODEC_CAP_DR1,
790
};