FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Bonk audio decoder
3			*
4			* This file is part of FFmpeg.
5			*
6			* FFmpeg is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10			*
11			* FFmpeg is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public
17			* License along with FFmpeg; if not, write to the Free Software
18			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19			*/
20
21			#include "libavutil/internal.h"
22			#include "libavutil/intreadwrite.h"
23			#include "avcodec.h"
24			#include "codec_internal.h"
25			#include "decode.h"
26			#define BITSTREAM_READER_LE
27			#include "get_bits.h"
28			#include "bytestream.h"
29
30			typedef struct BitCount {
31			uint8_t bit;
32			unsigned count;
33			} BitCount;
34
35			typedef struct BonkContext {
36			GetBitContext gb;
37			int skip;
38
39			uint8_t *bitstream;
40			int64_t max_framesize;
41			int bitstream_size;
42			int bitstream_index;
43
44			uint64_t nb_samples;
45			int lossless;
46			int mid_side;
47			int n_taps;
48			int down_sampling;
49			int samples_per_packet;
50
51			int state[2][2048], k[2048];
52			int *samples[2];
53			int *input_samples;
54			uint8_t quant[2048];
55			BitCount *bits;
56			} BonkContext;
57
58		✗	static av_cold int bonk_close(AVCodecContext *avctx)
59			{
60		✗	BonkContext *s = avctx->priv_data;
61
62		✗	av_freep(&s->bitstream);
63		✗	av_freep(&s->input_samples);
64		✗	av_freep(&s->samples[0]);
65		✗	av_freep(&s->samples[1]);
66		✗	av_freep(&s->bits);
67		✗	s->bitstream_size = 0;
68
69		✗	return 0;
70			}
71
72		✗	static av_cold int bonk_init(AVCodecContext *avctx)
73			{
74		✗	BonkContext *s = avctx->priv_data;
75
76		✗	avctx->sample_fmt = AV_SAMPLE_FMT_S16P;
77		✗	if (avctx->extradata_size < 17)
78		✗	return AVERROR(EINVAL);
79
80		✗	if (avctx->extradata[0]) {
81		✗	av_log(avctx, AV_LOG_ERROR, "Unsupported version.\n");
82		✗	return AVERROR_INVALIDDATA;
83			}
84
85		✗	if (avctx->ch_layout.nb_channels < 1 || avctx->ch_layout.nb_channels > 2)
86		✗	return AVERROR_INVALIDDATA;
87
88		✗	s->nb_samples = AV_RL32(avctx->extradata + 1) / avctx->ch_layout.nb_channels;
89		✗	if (!s->nb_samples)
90		✗	s->nb_samples = UINT64_MAX;
91		✗	s->lossless = avctx->extradata[10] != 0;
92		✗	s->mid_side = avctx->extradata[11] != 0;
93		✗	s->n_taps = AV_RL16(avctx->extradata + 12);
94		✗	if (!s->n_taps || s->n_taps > 2048)
95		✗	return AVERROR(EINVAL);
96
97		✗	s->down_sampling = avctx->extradata[14];
98		✗	if (!s->down_sampling)
99		✗	return AVERROR(EINVAL);
100
101		✗	s->samples_per_packet = AV_RL16(avctx->extradata + 15);
102		✗	if (!s->samples_per_packet)
103		✗	return AVERROR(EINVAL);
104
105		✗	if (s->down_sampling * s->samples_per_packet < s->n_taps)
106		✗	return AVERROR_INVALIDDATA;
107
108		✗	s->max_framesize = s->samples_per_packet * avctx->ch_layout.nb_channels * s->down_sampling * 16LL;
109		✗	if (s->max_framesize > (INT32_MAX - AV_INPUT_BUFFER_PADDING_SIZE) / 8)
110		✗	return AVERROR_INVALIDDATA;
111
112		✗	s->bitstream = av_calloc(s->max_framesize + AV_INPUT_BUFFER_PADDING_SIZE, sizeof(*s->bitstream));
113		✗	if (!s->bitstream)
114		✗	return AVERROR(ENOMEM);
115
116		✗	s->input_samples = av_calloc(s->samples_per_packet, sizeof(*s->input_samples));
117		✗	if (!s->input_samples)
118		✗	return AVERROR(ENOMEM);
119
120		✗	s->samples[0] = av_calloc(s->samples_per_packet * s->down_sampling, sizeof(*s->samples[0]));
121		✗	s->samples[1] = av_calloc(s->samples_per_packet * s->down_sampling, sizeof(*s->samples[0]));
122		✗	if (!s->samples[0] || !s->samples[1])
123		✗	return AVERROR(ENOMEM);
124
125		✗	s->bits = av_calloc(s->max_framesize * 8, sizeof(*s->bits));
126		✗	if (!s->bits)
127		✗	return AVERROR(ENOMEM);
128
129		✗	for (int i = 0; i < 512; i++) {
130		✗	s->quant[i] = sqrt(i + 1);
131			}
132
133		✗	return 0;
134			}
135
136		✗	static unsigned read_uint_max(BonkContext *s, uint32_t max)
137			{
138		✗	unsigned value = 0;
139
140		✗	if (max == 0)
141		✗	return 0;
142
143		✗	av_assert0(max >> 31 == 0);
144
145		✗	for (unsigned i = 1; i <= max - value; i+=i)
146		✗	if (get_bits1(&s->gb))
147		✗	value += i;
148
149		✗	return value;
150			}
151
152		✗	static int intlist_read(BonkContext *s, int *buf, int entries, int base_2_part)
153			{
154		✗	int i, low_bits = 0, x = 0, max_x;
155		✗	int n_zeros = 0, step = 256, dominant = 0;
156		✗	int pos = 0, level = 0;
157		✗	BitCount *bits = s->bits;
158		✗	int passes = 1;
159
160		✗	memset(buf, 0, entries * sizeof(*buf));
161		✗	if (base_2_part) {
162		✗	low_bits = get_bits(&s->gb, 4);
163
164		✗	if (low_bits)
165		✗	for (i = 0; i < entries; i++)
166		✗	buf[i] = get_bits(&s->gb, low_bits);
167			}
168
169		✗	while (n_zeros < entries) {
170		✗	int steplet = step >> 8;
171
172		✗	if (get_bits_left(&s->gb) <= 0)
173		✗	return AVERROR_INVALIDDATA;
174
175		✗	if (!get_bits1(&s->gb)) {
176		✗	av_assert0(steplet >= 0);
177
178		✗	if (steplet > 0) {
179		✗	bits[x ].bit = dominant;
180		✗	bits[x++].count = steplet;
181			}
182
183		✗	if (!dominant)
184		✗	n_zeros += steplet;
185
186		✗	if (step > INT32_MAX*8LL/9 + 1)
187		✗	return AVERROR_INVALIDDATA;
188		✗	step += step / 8;
189		✗	} else if (steplet > 0) {
190		✗	int actual_run = read_uint_max(s, steplet - 1);
191
192		✗	av_assert0(actual_run >= 0);
193
194		✗	if (actual_run > 0) {
195		✗	bits[x ].bit = dominant;
196		✗	bits[x++].count = actual_run;
197			}
198
199		✗	bits[x ].bit = !dominant;
200		✗	bits[x++].count = 1;
201
202		✗	if (!dominant)
203		✗	n_zeros += actual_run;
204			else
205		✗	n_zeros++;
206
207		✗	step -= step / 8;
208			}
209
210		✗	if (step < 256) {
211		✗	step = 65536 / step;
212		✗	dominant = !dominant;
213			}
214			}
215
216		✗	max_x = x;
217		✗	x = 0;
218		✗	n_zeros = 0;
219		✗	for (i = 0; n_zeros < entries; i++) {
220		✗	if (x >= max_x)
221		✗	return AVERROR_INVALIDDATA;
222
223		✗	if (pos >= entries) {
224		✗	pos = 0;
225		✗	level += passes << low_bits;
226		✗	passes = 1;
227		✗	if (bits[x].bit && bits[x].count > entries - n_zeros)
228		✗	passes = bits[x].count / (entries - n_zeros);
229			}
230
231		✗	if (level > 1 << 16)
232		✗	return AVERROR_INVALIDDATA;
233
234		✗	if (buf[pos] >= level) {
235		✗	if (bits[x].bit)
236		✗	buf[pos] += passes << low_bits;
237			else
238		✗	n_zeros++;
239
240			av_assert1(bits[x].count >= passes);
241		✗	bits[x].count -= passes;
242		✗	x += bits[x].count == 0;
243			}
244
245		✗	pos++;
246			}
247
248		✗	for (i = 0; i < entries; i++) {
249		✗	if (buf[i] && get_bits1(&s->gb)) {
250		✗	buf[i] = -buf[i];
251			}
252			}
253
254		✗	return 0;
255			}
256
257		✗	static inline int shift_down(int a, int b)
258			{
259		✗	return (a >> b) + (a < 0);
260			}
261
262		✗	static inline int shift(int a, int b)
263			{
264		✗	return a + (1 << b - 1) >> b;
265			}
266
267			#define LATTICE_SHIFT 10
268			#define SAMPLE_SHIFT 4
269			#define SAMPLE_FACTOR (1 << SAMPLE_SHIFT)
270
271		✗	static int predictor_calc_error(int *k, int *state, int order, int error)
272			{
273		✗	int i, x = error - (unsigned)shift_down(k[order-1] * (unsigned)state[order-1], LATTICE_SHIFT);
274		✗	int *k_ptr = &(k[order-2]),
275		✗	*state_ptr = &(state[order-2]);
276
277		✗	for (i = order-2; i >= 0; i--, k_ptr--, state_ptr--) {
278		✗	unsigned k_value = *k_ptr, state_value = *state_ptr;
279
280		✗	x -= (unsigned) shift_down(k_value * (unsigned)state_value, LATTICE_SHIFT);
281		✗	state_ptr[1] = state_value + shift_down(k_value * x, LATTICE_SHIFT);
282			}
283
284			// don't drift too far, to avoid overflows
285		✗	x = av_clip(x, -(SAMPLE_FACTOR << 16), SAMPLE_FACTOR << 16);
286
287		✗	state[0] = x;
288
289		✗	return x;
290			}
291
292		✗	static void predictor_init_state(int *k, unsigned *state, int order)
293			{
294		✗	for (int i = order - 2; i >= 0; i--) {
295		✗	unsigned x = state[i];
296
297		✗	for (int j = 0, p = i + 1; p < order; j++, p++) {
298		✗	int tmp = x + shift_down(k[j] * state[p], LATTICE_SHIFT);
299
300		✗	state[p] += shift_down(k[j] * x, LATTICE_SHIFT);
301		✗	x = tmp;
302			}
303			}
304		✗	}
305
306		✗	static int bonk_decode(AVCodecContext *avctx, AVFrame *frame,
307			int *got_frame_ptr, AVPacket *pkt)
308			{
309		✗	BonkContext *s = avctx->priv_data;
310		✗	GetBitContext *gb = &s->gb;
311			const uint8_t *buf;
312			int quant, n, buf_size, input_buf_size;
313		✗	int ret = AVERROR_INVALIDDATA;
314
315		✗	if ((!pkt->size && !s->bitstream_size) || s->nb_samples == 0) {
316		✗	*got_frame_ptr = 0;
317		✗	return pkt->size;
318			}
319
320		✗	buf_size = FFMIN(pkt->size, s->max_framesize - s->bitstream_size);
321		✗	input_buf_size = buf_size;
322		✗	if (s->bitstream_index + s->bitstream_size + buf_size + AV_INPUT_BUFFER_PADDING_SIZE > s->max_framesize) {
323		✗	memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
324		✗	s->bitstream_index = 0;
325			}
326		✗	if (pkt->data)
327		✗	memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], pkt->data, buf_size);
328		✗	buf = &s->bitstream[s->bitstream_index];
329		✗	buf_size += s->bitstream_size;
330		✗	s->bitstream_size = buf_size;
331		✗	if (buf_size < s->max_framesize && pkt->data) {
332		✗	*got_frame_ptr = 0;
333		✗	return input_buf_size;
334			}
335
336		✗	frame->nb_samples = FFMIN(s->samples_per_packet * s->down_sampling, s->nb_samples);
337		✗	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
338		✗	goto fail;
339
340		✗	if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
341		✗	goto fail;
342
343		✗	skip_bits(gb, s->skip);
344		✗	if ((ret = intlist_read(s, s->k, s->n_taps, 0)) < 0)
345		✗	goto fail;
346
347		✗	for (int i = 0; i < s->n_taps; i++)
348		✗	s->k[i] *= s->quant[i];
349		✗	quant = s->lossless ? 1 : get_bits(&s->gb, 16) * SAMPLE_FACTOR;
350
351		✗	for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
352		✗	const int samples_per_packet = s->samples_per_packet;
353		✗	const int down_sampling = s->down_sampling;
354		✗	const int offset = samples_per_packet * down_sampling - 1;
355		✗	int *state = s->state[ch];
356		✗	int *sample = s->samples[ch];
357
358		✗	predictor_init_state(s->k, state, s->n_taps);
359		✗	if ((ret = intlist_read(s, s->input_samples, samples_per_packet, 1)) < 0)
360		✗	goto fail;
361
362		✗	for (int i = 0; i < samples_per_packet; i++) {
363		✗	for (int j = 0; j < s->down_sampling - 1; j++) {
364		✗	sample[0] = predictor_calc_error(s->k, state, s->n_taps, 0);
365		✗	sample++;
366			}
367
368		✗	sample[0] = predictor_calc_error(s->k, state, s->n_taps, s->input_samples[i] * (unsigned)quant);
369		✗	sample++;
370			}
371
372		✗	sample = s->samples[ch];
373		✗	for (int i = 0; i < s->n_taps; i++)
374		✗	state[i] = sample[offset - i];
375			}
376
377		✗	if (s->mid_side && avctx->ch_layout.nb_channels == 2) {
378		✗	for (int i = 0; i < frame->nb_samples; i++) {
379		✗	s->samples[1][i] += shift(s->samples[0][i], 1);
380		✗	s->samples[0][i] -= s->samples[1][i];
381			}
382			}
383
384		✗	if (!s->lossless) {
385		✗	for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
386		✗	int *samples = s->samples[ch];
387		✗	for (int i = 0; i < frame->nb_samples; i++)
388		✗	samples[i] = shift(samples[i], 4);
389			}
390			}
391
392		✗	for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
393		✗	int16_t *osamples = (int16_t *)frame->extended_data[ch];
394		✗	int *samples = s->samples[ch];
395		✗	for (int i = 0; i < frame->nb_samples; i++)
396		✗	osamples[i] = av_clip_int16(samples[i]);
397			}
398
399		✗	s->nb_samples -= frame->nb_samples;
400
401		✗	s->skip = get_bits_count(gb) - 8 * (get_bits_count(gb) / 8);
402		✗	n = get_bits_count(gb) / 8;
403
404		✗	if (n > buf_size) {
405		✗	fail:
406		✗	s->bitstream_size = 0;
407		✗	s->bitstream_index = 0;
408		✗	return AVERROR_INVALIDDATA;
409			}
410
411		✗	*got_frame_ptr = 1;
412
413		✗	if (s->bitstream_size) {
414		✗	s->bitstream_index += n;
415		✗	s->bitstream_size -= n;
416		✗	return input_buf_size;
417			}
418		✗	return n;
419			}
420
421			const FFCodec ff_bonk_decoder = {
422			.p.name = "bonk",
423			CODEC_LONG_NAME("Bonk audio"),
424			.p.type = AVMEDIA_TYPE_AUDIO,
425			.p.id = AV_CODEC_ID_BONK,
426			.priv_data_size = sizeof(BonkContext),
427			.init = bonk_init,
428			FF_CODEC_DECODE_CB(bonk_decode),
429			.close = bonk_close,
430			.p.capabilities = AV_CODEC_CAP_DELAY |
431			#if FF_API_SUBFRAMES
432			AV_CODEC_CAP_SUBFRAMES |
433			#endif
434			AV_CODEC_CAP_DR1,
435			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
436			.p.sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S16P,
437			AV_SAMPLE_FMT_NONE },
438			};
439