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 qdmc_hufftab[][2] = {
123 /* Noise value - 27 entries */
124 { 1, 2 }, { 10, 7 }, { 26, 9 }, { 22, 9 }, { 24, 9 }, { 14, 9 },
125 { 8, 6 }, { 6, 5 }, { 7, 5 }, { 9, 7 }, { 30, 9 }, { 32, 10 },
126 { 13, 10 }, { 20, 9 }, { 28, 9 }, { 12, 7 }, { 15, 11 }, { 36, 12 },
127 { 0, 12 }, { 34, 10 }, { 18, 9 }, { 11, 9 }, { 16, 9 }, { 5, 3 },
128 { 2, 3 }, { 4, 3 }, { 3, 2 },
129 /* Noise segment length - 12 entries */
130 { 1, 1 }, { 2, 2 }, { 3, 4 }, { 8, 9 }, { 9, 10 }, { 0, 10 },
131 { 13, 8 }, { 7, 7 }, { 6, 6 }, { 17, 5 }, { 4, 4 }, { 5, 4 },
132 /* Amplitude - 28 entries */
133 { 18, 3 }, { 16, 3 }, { 22, 7 }, { 8, 10 }, { 4, 10 }, { 3, 9 },
134 { 2, 8 }, { 23, 8 }, { 10, 8 }, { 11, 7 }, { 21, 5 }, { 20, 4 },
135 { 1, 7 }, { 7, 10 }, { 5, 10 }, { 9, 9 }, { 6, 10 }, { 25, 11 },
136 { 26, 12 }, { 27, 13 }, { 0, 13 }, { 24, 9 }, { 12, 6 }, { 13, 5 },
137 { 14, 4 }, { 19, 3 }, { 15, 3 }, { 17, 2 },
138 /* Frequency differences - 47 entries */
139 { 2, 4 }, { 14, 6 }, { 26, 7 }, { 31, 8 }, { 32, 9 }, { 35, 9 },
140 { 7, 5 }, { 10, 5 }, { 22, 7 }, { 27, 7 }, { 19, 7 }, { 20, 7 },
141 { 4, 5 }, { 13, 5 }, { 17, 6 }, { 15, 6 }, { 8, 5 }, { 5, 4 },
142 { 28, 7 }, { 33, 9 }, { 36, 11 }, { 38, 12 }, { 42, 14 }, { 45, 16 },
143 { 44, 18 }, { 0, 18 }, { 46, 17 }, { 43, 15 }, { 40, 13 }, { 37, 11 },
144 { 39, 12 }, { 41, 12 }, { 34, 8 }, { 16, 6 }, { 11, 5 }, { 9, 4 },
145 { 1, 2 }, { 3, 4 }, { 30, 7 }, { 29, 7 }, { 23, 6 }, { 24, 6 },
146 { 18, 6 }, { 6, 4 }, { 12, 5 }, { 21, 6 }, { 25, 6 },
147 /* Amplitude differences - 9 entries */
148 { 1, 2 }, { 3, 3 }, { 4, 4 }, { 5, 5 }, { 6, 6 }, { 7, 7 },
149 { 8, 8 }, { 0, 8 }, { 2, 1 },
150 /* Phase differences - 9 entries */
151 { 2, 2 }, { 1, 2 }, { 3, 4 }, { 7, 4 }, { 6, 5 }, { 5, 6 },
152 { 0, 6 }, { 4, 4 }, { 8, 2 },
155 static const uint8_t huff_sizes[] = {
159 static const uint8_t huff_bits[] = {
163 static av_cold void qdmc_init_static_data(void)
165 const uint8_t (*hufftab)[2] = qdmc_hufftab;
168 for (unsigned i = 0, offset = 0; i < FF_ARRAY_ELEMS(vtable); i++) {
169 static VLC_TYPE vlc_buffer[13698][2];
170 vtable[i].table = &vlc_buffer[offset];
171 vtable[i].table_allocated = FF_ARRAY_ELEMS(vlc_buffer) - offset;
172 ff_init_vlc_from_lengths(&vtable[i], huff_bits[i], huff_sizes[i],
173 &hufftab[0][1], 2, &hufftab[0][0], 2, 1, -1,
174 INIT_VLC_LE | INIT_VLC_STATIC_OVERLONG, NULL);
175 hufftab += huff_sizes[i];
176 offset += vtable[i].table_size;
179 for (i = 0; i < 512; i++)
180 sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);
183 static void make_noises(QDMCContext *s)
185 int i, j, n0, n1, n2, diff;
188 for (j = 0; j < noise_bands_size[s->band_index]; j++) {
189 n0 = qdmc_nodes[j + 21 * s->band_index ];
190 n1 = qdmc_nodes[j + 21 * s->band_index + 1];
191 n2 = qdmc_nodes[j + 21 * s->band_index + 2];
192 nptr = s->noise_buffer + 256 * j;
194 for (i = 0; i + n0 < n1; i++, nptr++)
195 nptr[0] = i / (float)(n1 - n0);
198 nptr = s->noise_buffer + (j << 8) + n1 - n0;
200 for (i = n1; i < n2; i++, nptr++, diff--)
201 nptr[0] = diff / (float)(n2 - n1);
205 static av_cold int qdmc_decode_init(AVCodecContext *avctx)
207 static AVOnce init_static_once = AV_ONCE_INIT;
208 QDMCContext *s = avctx->priv_data;
209 int ret, fft_size, fft_order, size, g, j, x;
212 ff_thread_once(&init_static_once, qdmc_init_static_data);
214 if (!avctx->extradata || (avctx->extradata_size < 48)) {
215 av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
216 return AVERROR_INVALIDDATA;
219 bytestream2_init(&b, avctx->extradata, avctx->extradata_size);
221 while (bytestream2_get_bytes_left(&b) > 8) {
222 if (bytestream2_peek_be64(&b) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |
223 (uint64_t)MKBETAG('Q','D','M','C')))
225 bytestream2_skipu(&b, 1);
227 bytestream2_skipu(&b, 8);
229 if (bytestream2_get_bytes_left(&b) < 36) {
230 av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",
231 bytestream2_get_bytes_left(&b));
232 return AVERROR_INVALIDDATA;
235 size = bytestream2_get_be32u(&b);
236 if (size > bytestream2_get_bytes_left(&b)) {
237 av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",
238 bytestream2_get_bytes_left(&b), size);
239 return AVERROR_INVALIDDATA;
242 if (bytestream2_get_be32u(&b) != MKBETAG('Q','D','C','A')) {
243 av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");
244 return AVERROR_INVALIDDATA;
246 bytestream2_skipu(&b, 4);
248 avctx->channels = s->nb_channels = bytestream2_get_be32u(&b);
249 if (s->nb_channels <= 0 || s->nb_channels > 2) {
250 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");
251 return AVERROR_INVALIDDATA;
253 avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
256 avctx->sample_rate = bytestream2_get_be32u(&b);
257 avctx->bit_rate = bytestream2_get_be32u(&b);
258 bytestream2_skipu(&b, 4);
259 fft_size = bytestream2_get_be32u(&b);
260 fft_order = av_log2(fft_size) + 1;
261 s->checksum_size = bytestream2_get_be32u(&b);
262 if (s->checksum_size >= 1U << 28) {
263 av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);
264 return AVERROR_INVALIDDATA;
267 if (avctx->sample_rate >= 32000) {
270 } else if (avctx->sample_rate >= 16000) {
277 s->frame_size = 1 << s->frame_bits;
278 s->subframe_size = s->frame_size >> 5;
280 if (avctx->channels == 2)
282 s->band_index = noise_bands_selector[FFMIN(6, llrint(floor(avctx->bit_rate * 3.0 / (double)x + 0.5)))];
284 if ((fft_order < 7) || (fft_order > 9)) {
285 avpriv_request_sample(avctx, "Unknown FFT order %d", fft_order);
286 return AVERROR_PATCHWELCOME;
289 if (fft_size != (1 << (fft_order - 1))) {
290 av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", fft_size);
291 return AVERROR_INVALIDDATA;
294 ret = ff_fft_init(&s->fft_ctx, fft_order, 1);
298 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
300 for (g = 5; g > 0; g--) {
301 for (j = 0; j < (1 << g) - 1; j++)
302 s->alt_sin[5-g][j] = sin_table[(((j+1) << (8 - g)) & 0x1FF)];
310 static av_cold int qdmc_decode_close(AVCodecContext *avctx)
312 QDMCContext *s = avctx->priv_data;
314 ff_fft_end(&s->fft_ctx);
319 static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
323 if (get_bits_left(gb) < 1)
324 return AVERROR_INVALIDDATA;
325 v = get_vlc2(gb, table->table, table->bits, 2);
327 v = get_bits(gb, get_bits(gb, 3) + 1);
330 if (v >= FF_ARRAY_ELEMS(code_prefix))
331 return AVERROR_INVALIDDATA;
333 v = code_prefix[v] + get_bitsz(gb, v >> 2);
339 static int skip_label(QDMCContext *s, GetBitContext *gb)
341 uint32_t label = get_bits_long(gb, 32);
342 uint16_t sum = 226, checksum = get_bits(gb, 16);
343 const uint8_t *ptr = gb->buffer + 6;
346 if (label != MKTAG('Q', 'M', 'C', 1))
347 return AVERROR_INVALIDDATA;
349 for (i = 0; i < s->checksum_size - 6; i++)
352 return sum != checksum;
355 static int read_noise_data(QDMCContext *s, GetBitContext *gb)
357 int ch, j, k, v, idx, band, lastval, newval, len;
359 for (ch = 0; ch < s->nb_channels; ch++) {
360 for (band = 0; band < noise_bands_size[s->band_index]; band++) {
361 v = qdmc_get_vlc(gb, &vtable[0], 0);
363 return AVERROR_INVALIDDATA;
371 s->noise[ch][band][0] = lastval - 1;
372 for (j = 0; j < 15;) {
373 len = qdmc_get_vlc(gb, &vtable[1], 1);
375 return AVERROR_INVALIDDATA;
378 v = qdmc_get_vlc(gb, &vtable[0], 0);
380 return AVERROR_INVALIDDATA;
383 newval = lastval + (v + 1) / 2;
385 newval = lastval - v / 2;
389 return AVERROR_INVALIDDATA;
391 for (k = 1; idx <= j + len; k++, idx++)
392 s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
403 static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
405 const int index = s->nb_tones[group];
407 if (index >= FF_ARRAY_ELEMS(s->tones[group])) {
408 av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");
412 s->tones[group][index].offset = offset;
413 s->tones[group][index].freq = freq;
414 s->tones[group][index].mode = stereo_mode;
415 s->tones[group][index].amplitude = amplitude;
416 s->tones[group][index].phase = phase;
417 s->nb_tones[group]++;
420 static int read_wave_data(QDMCContext *s, GetBitContext *gb)
422 int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
423 int amp2, phase2, pos2, off;
425 for (group = 0; group < 5; group++) {
426 group_size = 1 << (s->frame_bits - group - 1);
427 group_bits = 4 - group;
431 for (i = 1; ; i = freq + 1) {
434 v = qdmc_get_vlc(gb, &vtable[3], 1);
436 return AVERROR_INVALIDDATA;
439 while (freq >= group_size - 1) {
440 freq += 2 - group_size;
442 off += 1 << group_bits;
445 if (pos2 >= s->frame_size)
448 if (s->nb_channels > 1)
449 stereo_mode = get_bits(gb, 2);
451 amp = qdmc_get_vlc(gb, &vtable[2], 0);
453 return AVERROR_INVALIDDATA;
454 phase = get_bits(gb, 3);
456 if (stereo_mode > 1) {
457 amp2 = qdmc_get_vlc(gb, &vtable[4], 0);
459 return AVERROR_INVALIDDATA;
462 phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
464 return AVERROR_INVALIDDATA;
465 phase2 = phase - phase2;
471 if ((freq >> group_bits) + 1 < s->subframe_size) {
472 add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
474 add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
482 static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
484 int subframe_size, i, j, k, length;
485 float scale, *noise_ptr;
487 scale = 0.5 * amplitude;
488 subframe_size = s->subframe_size;
489 if (subframe_size >= node2)
490 subframe_size = node2;
491 length = (subframe_size - node1) & 0xFFFC;
493 noise_ptr = &s->noise_buffer[256 * index];
495 for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {
496 s->noise2_buffer[j ] += scale * noise_ptr[0];
497 s->noise2_buffer[j + 1] += scale * noise_ptr[1];
498 s->noise2_buffer[j + 2] += scale * noise_ptr[2];
499 s->noise2_buffer[j + 3] += scale * noise_ptr[3];
503 noise_ptr = s->noise_buffer + length + (index << 8);
504 for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)
505 s->noise2_buffer[k] += scale * noise_ptr[0];
508 static void add_noise(QDMCContext *s, int ch, int current_subframe)
512 float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];
513 float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];
515 memset(s->noise2_buffer, 0, 4 * s->subframe_size);
517 for (i = 0; i < noise_bands_size[s->band_index]; i++) {
518 if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)
521 aindex = s->noise[ch][i][current_subframe / 2];
522 amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
524 lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
525 qdmc_nodes[21 * s->band_index + i + 2], i);
528 for (j = 2; j < s->subframe_size - 1; j++) {
529 float rnd_re, rnd_im;
531 s->rndval = 214013U * s->rndval + 2531011;
532 rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
533 s->rndval = 214013U * s->rndval + 2531011;
534 rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];
542 static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
544 int j, group_bits, pos, pindex;
545 float im, re, amplitude, level, *imptr, *reptr;
547 if (s->nb_channels == 1)
550 group_bits = 4 - group;
551 pos = freqs >> (4 - group);
552 amplitude = amplitude_tab[amp & 0x3F];
553 imptr = &s->fft_buffer[ stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
554 reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];
555 pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);
556 for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {
557 pindex += (2 * freqs + 1) << (7 - group_bits);
558 level = amplitude * s->alt_sin[group][j];
559 im = level * sin_table[ pindex & 0x1FF];
560 re = level * sin_table[(pindex + 128) & 0x1FF];
565 imptr += s->subframe_size;
566 reptr += s->subframe_size;
567 if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {
568 imptr = &s->fft_buffer[0 + stereo_mode][pos];
569 reptr = &s->fft_buffer[2 + stereo_mode][pos];
574 static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
579 if (s->nb_channels == 1)
582 level = amplitude_tab[amp & 0x3F];
583 im = level * sin_table[ (phase << 6) & 0x1FF];
584 re = level * sin_table[((phase << 6) + 128) & 0x1FF];
585 pos = s->fft_offset + freqs + s->subframe_size * offset;
586 s->fft_buffer[ stereo_mode][pos ] += im;
587 s->fft_buffer[2 + stereo_mode][pos ] += re;
588 s->fft_buffer[ stereo_mode][pos + 1] -= im;
589 s->fft_buffer[2 + stereo_mode][pos + 1] -= re;
592 static void add_waves(QDMCContext *s, int current_subframe)
596 for (g = 0; g < 4; g++) {
597 for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {
598 QDMCTone *t = &s->tones[g][w];
600 if (current_subframe < t->offset)
602 add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
606 for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
607 QDMCTone *t = &s->tones[4][w];
609 if (current_subframe < t->offset)
611 add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
616 static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
620 if (skip_label(s, gb))
621 return AVERROR_INVALIDDATA;
623 s->fft_offset = s->frame_size - s->fft_offset;
624 s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
626 ret = read_noise_data(s, gb);
630 ret = read_wave_data(s, gb);
634 for (n = 0; n < 32; n++) {
637 for (ch = 0; ch < s->nb_channels; ch++)
642 for (ch = 0; ch < s->nb_channels; ch++) {
643 for (i = 0; i < s->subframe_size; i++) {
644 s->cmplx[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];
645 s->cmplx[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];
646 s->cmplx[ch][s->subframe_size + i].re = 0;
647 s->cmplx[ch][s->subframe_size + i].im = 0;
651 for (ch = 0; ch < s->nb_channels; ch++) {
652 s->fft_ctx.fft_permute(&s->fft_ctx, s->cmplx[ch]);
653 s->fft_ctx.fft_calc(&s->fft_ctx, s->cmplx[ch]);
656 r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];
657 for (i = 0; i < 2 * s->subframe_size; i++) {
658 for (ch = 0; ch < s->nb_channels; ch++) {
659 *r++ += s->cmplx[ch][i].re;
663 r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];
664 for (i = 0; i < s->nb_channels * s->subframe_size; i++) {
665 out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);
667 out += s->subframe_size * s->nb_channels;
669 for (ch = 0; ch < s->nb_channels; ch++) {
670 memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
671 memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);
673 memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);
676 s->buffer_offset += s->frame_size;
677 if (s->buffer_offset >= 32768 - s->frame_size) {
678 memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);
679 s->buffer_offset = 0;
685 static av_cold void qdmc_flush(AVCodecContext *avctx)
687 QDMCContext *s = avctx->priv_data;
689 memset(s->buffer, 0, sizeof(s->buffer));
690 memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
692 s->buffer_offset = 0;
695 static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
696 int *got_frame_ptr, AVPacket *avpkt)
698 QDMCContext *s = avctx->priv_data;
699 AVFrame *frame = data;
705 if (avpkt->size < s->checksum_size)
706 return AVERROR_INVALIDDATA;
709 frame->nb_samples = s->frame_size;
710 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
713 if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
716 memset(s->nb_tones, 0, sizeof(s->nb_tones));
717 memset(s->cur_tone, 0, sizeof(s->cur_tone));
719 ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
722 return s->checksum_size;
728 const AVCodec ff_qdmc_decoder = {
730 .long_name = NULL_IF_CONFIG_SMALL("QDesign Music Codec 1"),
731 .type = AVMEDIA_TYPE_AUDIO,
732 .id = AV_CODEC_ID_QDMC,
733 .priv_data_size = sizeof(QDMCContext),
734 .init = qdmc_decode_init,
735 .close = qdmc_decode_close,
736 .decode = qdmc_decode_frame,
738 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
739 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,