FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/qdmc.c
Date: 2021-09-26 18:22:30
Exec Total Coverage
Lines: 0 346 0.0%
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 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 },
153 };
154
155 static const uint8_t huff_sizes[] = {
156 27, 12, 28, 47, 9, 9
157 };
158
159 static const uint8_t huff_bits[] = {
160 12, 10, 12, 12, 8, 6
161 };
162
163 static av_cold void qdmc_init_static_data(void)
164 {
165 const uint8_t (*hufftab)[2] = qdmc_hufftab;
166 int i;
167
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;
177 }
178
179 for (i = 0; i < 512; i++)
180 sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);
181 }
182
183 static void make_noises(QDMCContext *s)
184 {
185 int i, j, n0, n1, n2, diff;
186 float *nptr;
187
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;
193
194 for (i = 0; i + n0 < n1; i++, nptr++)
195 nptr[0] = i / (float)(n1 - n0);
196
197 diff = n2 - n1;
198 nptr = s->noise_buffer + (j << 8) + n1 - n0;
199
200 for (i = n1; i < n2; i++, nptr++, diff--)
201 nptr[0] = diff / (float)(n2 - n1);
202 }
203 }
204
205 static av_cold int qdmc_decode_init(AVCodecContext *avctx)
206 {
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;
210 GetByteContext b;
211
212 ff_thread_once(&init_static_once, qdmc_init_static_data);
213
214 if (!avctx->extradata || (avctx->extradata_size < 48)) {
215 av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");
216 return AVERROR_INVALIDDATA;
217 }
218
219 bytestream2_init(&b, avctx->extradata, avctx->extradata_size);
220
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')))
224 break;
225 bytestream2_skipu(&b, 1);
226 }
227 bytestream2_skipu(&b, 8);
228
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;
233 }
234
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;
240 }
241
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;
245 }
246 bytestream2_skipu(&b, 4);
247
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;
252 }
253 avctx->channel_layout = avctx->channels == 2 ? AV_CH_LAYOUT_STEREO :
254 AV_CH_LAYOUT_MONO;
255
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;
265 }
266
267 if (avctx->sample_rate >= 32000) {
268 x = 28000;
269 s->frame_bits = 13;
270 } else if (avctx->sample_rate >= 16000) {
271 x = 20000;
272 s->frame_bits = 12;
273 } else {
274 x = 16000;
275 s->frame_bits = 11;
276 }
277 s->frame_size = 1 << s->frame_bits;
278 s->subframe_size = s->frame_size >> 5;
279
280 if (avctx->channels == 2)
281 x = 3 * x / 2;
282 s->band_index = noise_bands_selector[FFMIN(6, llrint(floor(avctx->bit_rate * 3.0 / (double)x + 0.5)))];
283
284 if ((fft_order < 7) || (fft_order > 9)) {
285 avpriv_request_sample(avctx, "Unknown FFT order %d", fft_order);
286 return AVERROR_PATCHWELCOME;
287 }
288
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;
292 }
293
294 ret = ff_fft_init(&s->fft_ctx, fft_order, 1);
295 if (ret < 0)
296 return ret;
297
298 avctx->sample_fmt = AV_SAMPLE_FMT_S16;
299
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)];
303 }
304
305 make_noises(s);
306
307 return 0;
308 }
309
310 static av_cold int qdmc_decode_close(AVCodecContext *avctx)
311 {
312 QDMCContext *s = avctx->priv_data;
313
314 ff_fft_end(&s->fft_ctx);
315
316 return 0;
317 }
318
319 static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)
320 {
321 int v;
322
323 if (get_bits_left(gb) < 1)
324 return AVERROR_INVALIDDATA;
325 v = get_vlc2(gb, table->table, table->bits, 2);
326 if (v < 0)
327 v = get_bits(gb, get_bits(gb, 3) + 1);
328
329 if (flag) {
330 if (v >= FF_ARRAY_ELEMS(code_prefix))
331 return AVERROR_INVALIDDATA;
332
333 v = code_prefix[v] + get_bitsz(gb, v >> 2);
334 }
335
336 return v;
337 }
338
339 static int skip_label(QDMCContext *s, GetBitContext *gb)
340 {
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;
344 int i;
345
346 if (label != MKTAG('Q', 'M', 'C', 1))
347 return AVERROR_INVALIDDATA;
348
349 for (i = 0; i < s->checksum_size - 6; i++)
350 sum += ptr[i];
351
352 return sum != checksum;
353 }
354
355 static int read_noise_data(QDMCContext *s, GetBitContext *gb)
356 {
357 int ch, j, k, v, idx, band, lastval, newval, len;
358
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);
362 if (v < 0)
363 return AVERROR_INVALIDDATA;
364
365 if (v & 1)
366 v = v + 1;
367 else
368 v = -v;
369
370 lastval = v / 2;
371 s->noise[ch][band][0] = lastval - 1;
372 for (j = 0; j < 15;) {
373 len = qdmc_get_vlc(gb, &vtable[1], 1);
374 if (len < 0)
375 return AVERROR_INVALIDDATA;
376 len += 1;
377
378 v = qdmc_get_vlc(gb, &vtable[0], 0);
379 if (v < 0)
380 return AVERROR_INVALIDDATA;
381
382 if (v & 1)
383 newval = lastval + (v + 1) / 2;
384 else
385 newval = lastval - v / 2;
386
387 idx = j + 1;
388 if (len + idx > 16)
389 return AVERROR_INVALIDDATA;
390
391 for (k = 1; idx <= j + len; k++, idx++)
392 s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;
393
394 lastval = newval;
395 j += len;
396 }
397 }
398 }
399
400 return 0;
401 }
402
403 static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)
404 {
405 const int index = s->nb_tones[group];
406
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");
409 return;
410 }
411
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]++;
418 }
419
420 static int read_wave_data(QDMCContext *s, GetBitContext *gb)
421 {
422 int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;
423 int amp2, phase2, pos2, off;
424
425 for (group = 0; group < 5; group++) {
426 group_size = 1 << (s->frame_bits - group - 1);
427 group_bits = 4 - group;
428 pos2 = 0;
429 off = 0;
430
431 for (i = 1; ; i = freq + 1) {
432 int v;
433
434 v = qdmc_get_vlc(gb, &vtable[3], 1);
435 if (v < 0)
436 return AVERROR_INVALIDDATA;
437
438 freq = i + v;
439 while (freq >= group_size - 1) {
440 freq += 2 - group_size;
441 pos2 += group_size;
442 off += 1 << group_bits;
443 }
444
445 if (pos2 >= s->frame_size)
446 break;
447
448 if (s->nb_channels > 1)
449 stereo_mode = get_bits(gb, 2);
450
451 amp = qdmc_get_vlc(gb, &vtable[2], 0);
452 if (amp < 0)
453 return AVERROR_INVALIDDATA;
454 phase = get_bits(gb, 3);
455
456 if (stereo_mode > 1) {
457 amp2 = qdmc_get_vlc(gb, &vtable[4], 0);
458 if (amp2 < 0)
459 return AVERROR_INVALIDDATA;
460 amp2 = amp - amp2;
461
462 phase2 = qdmc_get_vlc(gb, &vtable[5], 0);
463 if (phase2 < 0)
464 return AVERROR_INVALIDDATA;
465 phase2 = phase - phase2;
466
467 if (phase2 < 0)
468 phase2 += 8;
469 }
470
471 if ((freq >> group_bits) + 1 < s->subframe_size) {
472 add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);
473 if (stereo_mode > 1)
474 add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);
475 }
476 }
477 }
478
479 return 0;
480 }
481
482 static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)
483 {
484 int subframe_size, i, j, k, length;
485 float scale, *noise_ptr;
486
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;
492 j = node1;
493 noise_ptr = &s->noise_buffer[256 * index];
494
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];
500 }
501
502 k = length + node1;
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];
506 }
507
508 static void add_noise(QDMCContext *s, int ch, int current_subframe)
509 {
510 int i, j, aindex;
511 float amplitude;
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];
514
515 memset(s->noise2_buffer, 0, 4 * s->subframe_size);
516
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)
519 break;
520
521 aindex = s->noise[ch][i][current_subframe / 2];
522 amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;
523
524 lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],
525 qdmc_nodes[21 * s->band_index + i + 2], i);
526 }
527
528 for (j = 2; j < s->subframe_size - 1; j++) {
529 float rnd_re, rnd_im;
530
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];
535 im[j ] += rnd_im;
536 re[j ] += rnd_re;
537 im[j+1] -= rnd_im;
538 re[j+1] -= rnd_re;
539 }
540 }
541
542 static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)
543 {
544 int j, group_bits, pos, pindex;
545 float im, re, amplitude, level, *imptr, *reptr;
546
547 if (s->nb_channels == 1)
548 stereo_mode = 0;
549
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];
561 imptr[0] += im;
562 imptr[1] -= im;
563 reptr[0] += re;
564 reptr[1] -= re;
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];
570 }
571 }
572 }
573
574 static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)
575 {
576 float level, im, re;
577 int pos;
578
579 if (s->nb_channels == 1)
580 stereo_mode = 0;
581
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;
590 }
591
592 static void add_waves(QDMCContext *s, int current_subframe)
593 {
594 int w, g;
595
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];
599
600 if (current_subframe < t->offset)
601 break;
602 add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);
603 }
604 s->cur_tone[g] = w;
605 }
606 for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {
607 QDMCTone *t = &s->tones[4][w];
608
609 if (current_subframe < t->offset)
610 break;
611 add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);
612 }
613 s->cur_tone[4] = w;
614 }
615
616 static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)
617 {
618 int ret, ch, i, n;
619
620 if (skip_label(s, gb))
621 return AVERROR_INVALIDDATA;
622
623 s->fft_offset = s->frame_size - s->fft_offset;
624 s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];
625
626 ret = read_noise_data(s, gb);
627 if (ret < 0)
628 return ret;
629
630 ret = read_wave_data(s, gb);
631 if (ret < 0)
632 return ret;
633
634 for (n = 0; n < 32; n++) {
635 float *r;
636
637 for (ch = 0; ch < s->nb_channels; ch++)
638 add_noise(s, ch, n);
639
640 add_waves(s, n);
641
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;
648 }
649 }
650
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]);
654 }
655
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;
660 }
661 }
662
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);
666 }
667 out += s->subframe_size * s->nb_channels;
668
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);
672 }
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);
674 }
675
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;
680 }
681
682 return 0;
683 }
684
685 static av_cold void qdmc_flush(AVCodecContext *avctx)
686 {
687 QDMCContext *s = avctx->priv_data;
688
689 memset(s->buffer, 0, sizeof(s->buffer));
690 memset(s->fft_buffer, 0, sizeof(s->fft_buffer));
691 s->fft_offset = 0;
692 s->buffer_offset = 0;
693 }
694
695 static int qdmc_decode_frame(AVCodecContext *avctx, void *data,
696 int *got_frame_ptr, AVPacket *avpkt)
697 {
698 QDMCContext *s = avctx->priv_data;
699 AVFrame *frame = data;
700 GetBitContext gb;
701 int ret;
702
703 if (!avpkt->data)
704 return 0;
705 if (avpkt->size < s->checksum_size)
706 return AVERROR_INVALIDDATA;
707
708 s->avctx = avctx;
709 frame->nb_samples = s->frame_size;
710 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
711 return ret;
712
713 if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)
714 return ret;
715
716 memset(s->nb_tones, 0, sizeof(s->nb_tones));
717 memset(s->cur_tone, 0, sizeof(s->cur_tone));
718
719 ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);
720 if (ret >= 0) {
721 *got_frame_ptr = 1;
722 return s->checksum_size;
723 }
724 qdmc_flush(avctx);
725 return ret;
726 }
727
728 const AVCodec ff_qdmc_decoder = {
729 .name = "qdmc",
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,
737 .flush = qdmc_flush,
738 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,
739 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
740 };
741