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