FFmpeg coverage

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
25			#define BITSTREAM_READER_LE
26
27			#include "libavutil/channel_layout.h"
28			#include "libavutil/mem_internal.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 "decode.h"
36			#include "get_bits.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_vlc_init_from_lengths(&vtable[i], huff_bits[i], huff_sizes[i],
176		✗	&hufftab[0][1], 2, &hufftab[0][0], 2, 1, -1,
177			VLC_INIT_LE | VLC_INIT_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			CODEC_LONG_NAME("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			};
743