FFmpeg coverage


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