2 * QDMC compatible decoder
3 * Copyright (c) 2017 Paul B Mahol
5 * This file is part of FFmpeg.
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.
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.
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
26 #define BITSTREAM_READER_LE
28 #include "libavutil/channel_layout.h"
29 #include "libavutil/thread.h"
32 #include "bytestream.h"
37 typedef struct QDMCTone {
45 typedef struct QDMCContext {
46 AVCodecContext *avctx;
57 uint8_t noise[2][19][17];
58 QDMCTone tones[5][8192];
62 float fft_buffer[4][8192 * 2];
63 float noise2_buffer[4096 * 2];
64 float noise_buffer[4096 * 2];
65 float buffer[2 * 32768];
69 DECLARE_ALIGNED(32, FFTComplex, cmplx)[2][512];
73 static float sin_table[512];
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,
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,
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
114 static const uint8_t noise_bands_size[] = {
115 19, 14, 11, 9, 4, 2, 0
118 static const uint8_t noise_bands_selector[] = {
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,
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,
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,
139 static const uint8_t noise_segment_length_bits[] = {
140 10, 8, 5, 1, 2, 4, 4, 4, 6, 7, 9, 10,
143 static const uint8_t noise_segment_length_symbols[] = {
144 0, 13, 17, 1, 2, 3, 4, 5, 6, 7, 8, 9,
147 static const uint16_t noise_segment_length_codes[] = {
148 0x30B, 0x8B, 0x1B, 0x0, 0x1, 0x3, 0x7, 0xF, 0x2b, 0x4B, 0xB, 0x10B,
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,
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,
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,
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,
176 static const uint8_t amplitude_diff_bits[] = {
177 8, 2, 1, 3, 4, 5, 6, 7, 8,
180 static const uint8_t amplitude_diff_codes[] = {
181 0xFE, 0x0, 0x1, 0x2, 0x6, 0xE, 0x1E, 0x3E, 0x7E,
184 static const uint8_t phase_diff_bits[] = {
185 6, 2, 2, 4, 4, 6, 5, 4, 2,
188 static const uint8_t phase_diff_codes[] = {
189 0x35, 0x2, 0x0, 0x1, 0xD, 0x15, 0x5, 0x9, 0x3,
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, \
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); \
208 static av_cold void qdmc_init_static_data(void)
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);
226 for (i = 0; i < 512; i++)
227 sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);
230 static void make_noises(QDMCContext *s)
232 int i, j, n0, n1, n2, diff;
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;
241 for (i = 0; i + n0 < n1; i++, nptr++)
242 nptr[0] = i / (float)(n1 - n0);
245 nptr = s->noise_buffer + (j << 8) + n1 - n0;
247 for (i = n1; i < n2; i++, nptr++, diff--)
248 nptr[0] = diff / (float)(n2 - n1);
252 static av_cold int qdmc_decode_init(AVCodecContext *avctx)
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;
259 ff_thread_once(&init_static_once, qdmc_init_static_data);
261 if (!avctx->extradata || (avctx->extradata_size < 48)) {
262 av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
263 return AVERROR_INVALIDDATA;
266 bytestream2_init(&b, avctx->extradata, avctx->extradata_size);
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')))
272 bytestream2_skipu(&b, 1);
274 bytestream2_skipu(&b, 8);
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;
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;
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;
293 bytestream2_skipu(&b, 4);
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;
300 avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
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;
314 if (avctx->sample_rate >= 32000) {
317 } else if (avctx->sample_rate >= 16000) {
324 s->frame_size = 1 << s->frame_bits;
325 s->subframe_size = s->frame_size >> 5;
327 if (avctx->channels == 2)
329 s->band_index = noise_bands_selector[FFMIN(6, llrint(floor(avctx->bit_rate * 3.0 / (double)x + 0.5)))];
331 if ((fft_order < 7) || (fft_order > 9)) {
332 avpriv_request_sample(avctx, "Unknown FFT order %d", fft_order);
333 return AVERROR_PATCHWELCOME;
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;
341 ret = ff_fft_init(&s->fft_ctx, fft_order, 1);
345 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
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)];
357 static av_cold int qdmc_decode_close(AVCodecContext *avctx)
359 QDMCContext *s = avctx->priv_data;
361 ff_fft_end(&s->fft_ctx);
366 static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
370 if (get_bits_left(gb) < 1)
371 return AVERROR_INVALIDDATA;
372 v = get_vlc2(gb, table->table, table->bits, 1);
374 return AVERROR_INVALIDDATA;
378 v = get_bits(gb, get_bits(gb, 3) + 1);
381 if (v >= FF_ARRAY_ELEMS(code_prefix))
382 return AVERROR_INVALIDDATA;
384 v = code_prefix[v] + get_bitsz(gb, v >> 2);
390 static int skip_label(QDMCContext *s, GetBitContext *gb)
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;
397 if (label != MKTAG('Q', 'M', 'C', 1))
398 return AVERROR_INVALIDDATA;
400 for (i = 0; i < s->checksum_size - 6; i++)
403 return sum != checksum;
406 static int read_noise_data(QDMCContext *s, GetBitContext *gb)
408 int ch, j, k, v, idx, band, lastval, newval, len;
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);
414 return AVERROR_INVALIDDATA;
422 s->noise[ch][band][0] = lastval - 1;
423 for (j = 0; j < 15;) {
424 len = qdmc_get_vlc(gb, &vtable[1], 1);
426 return AVERROR_INVALIDDATA;
429 v = qdmc_get_vlc(gb, &vtable[0], 0);
431 return AVERROR_INVALIDDATA;
434 newval = lastval + (v + 1) / 2;
436 newval = lastval - v / 2;
440 return AVERROR_INVALIDDATA;
442 for (k = 1; idx <= j + len; k++, idx++)
443 s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
454 static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
456 const int index = s->nb_tones[group];
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");
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]++;
471 static int read_wave_data(QDMCContext *s, GetBitContext *gb)
473 int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
474 int amp2, phase2, pos2, off;
476 for (group = 0; group < 5; group++) {
477 group_size = 1 << (s->frame_bits - group - 1);
478 group_bits = 4 - group;
482 for (i = 1; ; i = freq + 1) {
485 v = qdmc_get_vlc(gb, &vtable[3], 1);
487 return AVERROR_INVALIDDATA;
490 while (freq >= group_size - 1) {
491 freq += 2 - group_size;
493 off += 1 << group_bits;
496 if (pos2 >= s->frame_size)
499 if (s->nb_channels > 1)
500 stereo_mode = get_bits(gb, 2);
502 amp = qdmc_get_vlc(gb, &vtable[2], 0);
504 return AVERROR_INVALIDDATA;
505 phase = get_bits(gb, 3);
507 if (stereo_mode > 1) {
508 amp2 = qdmc_get_vlc(gb, &vtable[4], 0);
510 return AVERROR_INVALIDDATA;
513 phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
515 return AVERROR_INVALIDDATA;
516 phase2 = phase - phase2;
522 if ((freq >> group_bits) + 1 < s->subframe_size) {
523 add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
525 add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
533 static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
535 int subframe_size, i, j, k, length;
536 float scale, *noise_ptr;
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;
544 noise_ptr = &s->noise_buffer[256 * index];
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];
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];
559 static void add_noise(QDMCContext *s, int ch, int current_subframe)
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];
566 memset(s->noise2_buffer, 0, 4 * s->subframe_size);
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)
572 aindex = s->noise[ch][i][current_subframe / 2];
573 amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
575 lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
576 qdmc_nodes[21 * s->band_index + i + 2], i);
579 for (j = 2; j < s->subframe_size - 1; j++) {
580 float rnd_re, rnd_im;
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];
593 static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
595 int j, group_bits, pos, pindex;
596 float im, re, amplitude, level, *imptr, *reptr;
598 if (s->nb_channels == 1)
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];
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];
625 static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
630 if (s->nb_channels == 1)
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;
643 static void add_waves(QDMCContext *s, int current_subframe)
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];
651 if (current_subframe < t->offset)
653 add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
657 for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
658 QDMCTone *t = &s->tones[4][w];
660 if (current_subframe < t->offset)
662 add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
667 static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
671 if (skip_label(s, gb))
672 return AVERROR_INVALIDDATA;
674 s->fft_offset = s->frame_size - s->fft_offset;
675 s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
677 ret = read_noise_data(s, gb);
681 ret = read_wave_data(s, gb);
685 for (n = 0; n < 32; n++) {
688 for (ch = 0; ch < s->nb_channels; ch++)
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;
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]);
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;
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);
718 out += s->subframe_size * s->nb_channels;
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);
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);
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;
736 static av_cold void qdmc_flush(AVCodecContext *avctx)
738 QDMCContext *s = avctx->priv_data;
740 memset(s->buffer, 0, sizeof(s->buffer));
741 memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
743 s->buffer_offset = 0;
746 static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
747 int *got_frame_ptr, AVPacket *avpkt)
749 QDMCContext *s = avctx->priv_data;
750 AVFrame *frame = data;
756 if (avpkt->size < s->checksum_size)
757 return AVERROR_INVALIDDATA;
760 frame->nb_samples = s->frame_size;
761 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
764 if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
767 memset(s->nb_tones, 0, sizeof(s->nb_tones));
768 memset(s->cur_tone, 0, sizeof(s->cur_tone));
770 ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
773 return s->checksum_size;
779 AVCodec ff_qdmc_decoder = {
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,
789 .capabilities = AV_CODEC_CAP_DR1,