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 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 ff_fft_init(&s->fft_ctx, fft_order, 1);
343 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
345 for (g = 5; g > 0; g--) {
346 for (j = 0; j < (1 << g) - 1; j++)
347 s->alt_sin[5-g][j] = sin_table[(((j+1) << (8 - g)) & 0x1FF)];
355 static av_cold int qdmc_decode_close(AVCodecContext *avctx)
357 QDMCContext *s = avctx->priv_data;
359 ff_fft_end(&s->fft_ctx);
364 static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
368 v = get_vlc2(gb, table->table, table->bits, 1);
370 return AVERROR_INVALIDDATA;
374 v = get_bits(gb, get_bits(gb, 3) + 1);
377 if (v >= FF_ARRAY_ELEMS(code_prefix))
378 return AVERROR_INVALIDDATA;
380 v = code_prefix[v] + get_bitsz(gb, v >> 2);
386 static int skip_label(QDMCContext *s, GetBitContext *gb)
388 uint32_t label = get_bits_long(gb, 32);
389 uint16_t sum = 226, checksum = get_bits(gb, 16);
390 const uint8_t *ptr = gb->buffer + 6;
393 if (label != MKTAG('Q', 'M', 'C', 1))
394 return AVERROR_INVALIDDATA;
396 for (i = 0; i < s->checksum_size - 6; i++)
399 return sum != checksum;
402 static int read_noise_data(QDMCContext *s, GetBitContext *gb)
404 int ch, j, k, v, idx, band, lastval, newval, len;
406 for (ch = 0; ch < s->nb_channels; ch++) {
407 for (band = 0; band < noise_bands_size[s->band_index]; band++) {
408 v = qdmc_get_vlc(gb, &vtable[0], 0);
410 return AVERROR_INVALIDDATA;
418 s->noise[ch][band][0] = lastval - 1;
419 for (j = 0; j < 15;) {
420 len = qdmc_get_vlc(gb, &vtable[1], 1);
422 return AVERROR_INVALIDDATA;
425 v = qdmc_get_vlc(gb, &vtable[0], 0);
427 return AVERROR_INVALIDDATA;
430 newval = lastval + (v + 1) / 2;
432 newval = lastval - v / 2;
436 return AVERROR_INVALIDDATA;
438 for (k = 1; idx <= j + len; k++, idx++)
439 s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
450 static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
452 const int index = s->nb_tones[group];
454 if (index >= FF_ARRAY_ELEMS(s->tones[group])) {
455 av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");
459 s->tones[group][index].offset = offset;
460 s->tones[group][index].freq = freq;
461 s->tones[group][index].mode = stereo_mode;
462 s->tones[group][index].amplitude = amplitude;
463 s->tones[group][index].phase = phase;
464 s->nb_tones[group]++;
467 static int read_wave_data(QDMCContext *s, GetBitContext *gb)
469 int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
470 int amp2, phase2, pos2, off;
472 for (group = 0; group < 5; group++) {
473 group_size = 1 << (s->frame_bits - group - 1);
474 group_bits = 4 - group;
478 for (i = 1; ; i = freq + 1) {
481 v = qdmc_get_vlc(gb, &vtable[3], 1);
483 return AVERROR_INVALIDDATA;
486 while (freq >= group_size - 1) {
487 freq += 2 - group_size;
489 off += 1 << group_bits;
492 if (pos2 >= s->frame_size)
495 if (s->nb_channels > 1)
496 stereo_mode = get_bits(gb, 2);
498 amp = qdmc_get_vlc(gb, &vtable[2], 0);
500 return AVERROR_INVALIDDATA;
501 phase = get_bits(gb, 3);
503 if (stereo_mode > 1) {
504 amp2 = qdmc_get_vlc(gb, &vtable[4], 0);
506 return AVERROR_INVALIDDATA;
509 phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
511 return AVERROR_INVALIDDATA;
512 phase2 = phase - phase2;
518 if ((freq >> group_bits) + 1 < s->subframe_size) {
519 add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
521 add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
529 static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
531 int subframe_size, i, j, k, length;
532 float scale, *noise_ptr;
534 scale = 0.5 * amplitude;
535 subframe_size = s->subframe_size;
536 if (subframe_size >= node2)
537 subframe_size = node2;
538 length = (subframe_size - node1) & 0xFFFC;
540 noise_ptr = &s->noise_buffer[256 * index];
542 for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {
543 s->noise2_buffer[j ] += scale * noise_ptr[0];
544 s->noise2_buffer[j + 1] += scale * noise_ptr[1];
545 s->noise2_buffer[j + 2] += scale * noise_ptr[2];
546 s->noise2_buffer[j + 3] += scale * noise_ptr[3];
550 noise_ptr = s->noise_buffer + length + (index << 8);
551 for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)
552 s->noise2_buffer[k] += scale * noise_ptr[0];
555 static void add_noise(QDMCContext *s, int ch, int current_subframe)
559 float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];
560 float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];
562 memset(s->noise2_buffer, 0, 4 * s->subframe_size);
564 for (i = 0; i < noise_bands_size[s->band_index]; i++) {
565 if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)
568 aindex = s->noise[ch][i][current_subframe / 2];
569 amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
571 lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
572 qdmc_nodes[21 * s->band_index + i + 2], i);
575 for (j = 2; j < s->subframe_size - 1; j++) {
576 float rnd_re, rnd_im;
578 s->rndval = 214013 * s->rndval + 2531011;
579 rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
580 s->rndval = 214013 * s->rndval + 2531011;
581 rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
589 static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
591 int j, group_bits, pos, pindex;
592 float im, re, amplitude, level, *imptr, *reptr;
594 if (s->nb_channels == 1)
597 group_bits = 4 - group;
598 pos = freqs >> (4 - group);
599 amplitude = amplitude_tab[amp & 0x3F];
600 imptr = &s->fft_buffer[ stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
601 reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
602 pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);
603 for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {
604 pindex += (2 * freqs + 1) << (7 - group_bits);
605 level = amplitude * s->alt_sin[group][j];
606 im = level * sin_table[ pindex & 0x1FF];
607 re = level * sin_table[(pindex + 128) & 0x1FF];
612 imptr += s->subframe_size;
613 reptr += s->subframe_size;
614 if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {
615 imptr = &s->fft_buffer[0 + stereo_mode][pos];
616 reptr = &s->fft_buffer[2 + stereo_mode][pos];
621 static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
626 if (s->nb_channels == 1)
629 level = amplitude_tab[amp & 0x3F];
630 im = level * sin_table[ (phase << 6) & 0x1FF];
631 re = level * sin_table[((phase << 6) + 128) & 0x1FF];
632 pos = s->fft_offset + freqs + s->subframe_size * offset;
633 s->fft_buffer[ stereo_mode][pos ] += im;
634 s->fft_buffer[2 + stereo_mode][pos ] += re;
635 s->fft_buffer[ stereo_mode][pos + 1] -= im;
636 s->fft_buffer[2 + stereo_mode][pos + 1] -= re;
639 static void add_waves(QDMCContext *s, int current_subframe)
643 for (g = 0; g < 4; g++) {
644 for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {
645 QDMCTone *t = &s->tones[g][w];
647 if (current_subframe < t->offset)
649 add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
653 for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
654 QDMCTone *t = &s->tones[4][w];
656 if (current_subframe < t->offset)
658 add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
663 static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
667 if (skip_label(s, gb))
668 return AVERROR_INVALIDDATA;
670 s->fft_offset = s->frame_size - s->fft_offset;
671 s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
673 ret = read_noise_data(s, gb);
677 ret = read_wave_data(s, gb);
681 for (n = 0; n < 32; n++) {
684 for (ch = 0; ch < s->nb_channels; ch++)
689 for (ch = 0; ch < s->nb_channels; ch++) {
690 for (i = 0; i < s->subframe_size; i++) {
691 s->cmplx[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];
692 s->cmplx[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];
693 s->cmplx[ch][s->subframe_size + i].re = 0;
694 s->cmplx[ch][s->subframe_size + i].im = 0;
698 for (ch = 0; ch < s->nb_channels; ch++) {
699 s->fft_ctx.fft_permute(&s->fft_ctx, s->cmplx[ch]);
700 s->fft_ctx.fft_calc(&s->fft_ctx, s->cmplx[ch]);
703 r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];
704 for (i = 0; i < 2 * s->subframe_size; i++) {
705 for (ch = 0; ch < s->nb_channels; ch++) {
706 *r++ += s->cmplx[ch][i].re;
710 r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];
711 for (i = 0; i < s->nb_channels * s->subframe_size; i++) {
712 out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);
714 out += s->subframe_size * s->nb_channels;
716 for (ch = 0; ch < s->nb_channels; ch++) {
717 memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
718 memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
720 memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);
723 s->buffer_offset += s->frame_size;
724 if (s->buffer_offset >= 32768 - s->frame_size) {
725 memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);
726 s->buffer_offset = 0;
732 static av_cold void qdmc_flush(AVCodecContext *avctx)
734 QDMCContext *s = avctx->priv_data;
736 memset(s->buffer, 0, sizeof(s->buffer));
737 memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
739 s->buffer_offset = 0;
742 static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
743 int *got_frame_ptr, AVPacket *avpkt)
745 QDMCContext *s = avctx->priv_data;
746 AVFrame *frame = data;
752 if (avpkt->size < s->checksum_size)
753 return AVERROR_INVALIDDATA;
756 frame->nb_samples = s->frame_size;
757 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
760 if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
763 memset(s->nb_tones, 0, sizeof(s->nb_tones));
764 memset(s->cur_tone, 0, sizeof(s->cur_tone));
766 ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
769 return s->checksum_size;
775 AVCodec ff_qdmc_decoder = {
777 .long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),
778 .type = AVMEDIA_TYPE_AUDIO,
779 .id = AV_CODEC_ID_QDMC,
780 .priv_data_size = sizeof(QDMCContext),
781 .init = qdmc_decode_init,
782 .close = qdmc_decode_close,
783 .decode = qdmc_decode_frame,
785 .capabilities = AV_CODEC_CAP_DR1,