FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* WavArc audio decoder
3			* Copyright (c) 2023 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 "libavutil/intreadwrite.h"
23			#include "libavutil/mem.h"
24			#include "avcodec.h"
25			#include "codec_internal.h"
26			#include "decode.h"
27			#include "get_bits.h"
28			#include "mathops.h"
29			#include "unary.h"
30
31			typedef struct WavArcContext {
32			AVClass *av_class;
33
34			GetBitContext gb;
35
36			int shift;
37			int nb_samples;
38			int offset;
39			int align;
40
41			int eof;
42			int skip;
43			uint8_t *bitstream;
44			int64_t max_framesize;
45			int bitstream_size;
46			int bitstream_index;
47
48			int pred[2][70];
49			int filter[2][70];
50			int samples[2][640];
51			uint8_t model[256];
52			uint16_t freqs[257];
53			uint16_t ac_value;
54			uint16_t ac_low;
55			uint16_t ac_high;
56			uint16_t range_high;
57			uint16_t range_low;
58			uint16_t freq_range;
59			int ac_pred[70];
60			int ac_out[570];
61			} WavArcContext;
62
63		✗	static av_cold int wavarc_init(AVCodecContext *avctx)
64			{
65		✗	WavArcContext *s = avctx->priv_data;
66
67		✗	if (avctx->extradata_size < 52)
68		✗	return AVERROR_INVALIDDATA;
69		✗	if (AV_RL32(avctx->extradata + 16) != MKTAG('R','I','F','F'))
70		✗	return AVERROR_INVALIDDATA;
71		✗	if (AV_RL32(avctx->extradata + 24) != MKTAG('W','A','V','E'))
72		✗	return AVERROR_INVALIDDATA;
73		✗	if (AV_RL32(avctx->extradata + 28) != MKTAG('f','m','t',' '))
74		✗	return AVERROR_INVALIDDATA;
75		✗	if (AV_RL16(avctx->extradata + 38) != 1 &&
76		✗	AV_RL16(avctx->extradata + 38) != 2)
77		✗	return AVERROR_INVALIDDATA;
78
79		✗	av_channel_layout_uninit(&avctx->ch_layout);
80		✗	av_channel_layout_default(&avctx->ch_layout, AV_RL16(avctx->extradata + 38));
81		✗	avctx->sample_rate = AV_RL32(avctx->extradata + 40);
82
83		✗	s->align = avctx->ch_layout.nb_channels;
84
85		✗	switch (AV_RL16(avctx->extradata + 50)) {
86		✗	case 8: avctx->sample_fmt = AV_SAMPLE_FMT_U8P; break;
87		✗	case 16: s->align *= 2;
88		✗	avctx->sample_fmt = AV_SAMPLE_FMT_S16P; break;
89			}
90
91		✗	s->shift = 0;
92		✗	switch (avctx->codec_tag) {
93		✗	case MKTAG('0','C','P','Y'):
94		✗	s->nb_samples = 640;
95		✗	s->offset = 0;
96		✗	break;
97		✗	case MKTAG('1','D','I','F'):
98		✗	s->nb_samples = 256;
99		✗	s->offset = 4;
100		✗	break;
101		✗	case MKTAG('2','S','L','P'):
102			case MKTAG('3','N','L','P'):
103			case MKTAG('4','A','L','P'):
104			case MKTAG('5','E','L','P'):
105		✗	s->nb_samples = 570;
106		✗	s->offset = 70;
107		✗	break;
108		✗	default:
109		✗	return AVERROR_INVALIDDATA;
110			}
111
112		✗	s->max_framesize = s->nb_samples * 16;
113		✗	s->bitstream = av_calloc(s->max_framesize + AV_INPUT_BUFFER_PADDING_SIZE, sizeof(*s->bitstream));
114		✗	if (!s->bitstream)
115		✗	return AVERROR(ENOMEM);
116
117		✗	return 0;
118			}
119
120		✗	static unsigned get_urice(GetBitContext *gb, int k)
121			{
122		✗	unsigned x = get_unary(gb, 1, get_bits_left(gb));
123		✗	unsigned y = get_bits_long(gb, k);
124		✗	unsigned z = (x << k) | y;
125
126		✗	return z;
127			}
128
129		✗	static int get_srice(GetBitContext *gb, int k)
130			{
131		✗	unsigned z = get_urice(gb, k);
132
133		✗	return (z & 1) ? ~((int)(z >> 1)) : z >> 1;
134			}
135
136		✗	static void do_stereo(WavArcContext *s, int ch, int correlated, int len)
137			{
138		✗	const int nb_samples = s->nb_samples;
139		✗	const int shift = s->shift;
140
141		✗	if (ch == 0) {
142		✗	if (correlated) {
143		✗	for (int n = 0; n < len; n++) {
144		✗	s->samples[0][n] = s->samples[0][nb_samples + n] >> shift;
145		✗	s->samples[1][n] = s->pred[1][n] >> shift;
146			}
147			} else {
148		✗	for (int n = 0; n < len; n++) {
149		✗	s->samples[0][n] = s->samples[0][nb_samples + n] >> shift;
150		✗	s->samples[1][n] = s->pred[0][n] >> shift;
151			}
152			}
153			} else {
154		✗	if (correlated) {
155		✗	for (int n = 0; n < nb_samples; n++)
156		✗	s->samples[1][n + len] += (unsigned)s->samples[0][n + len];
157			}
158		✗	for (int n = 0; n < len; n++) {
159		✗	s->pred[0][n] = s->samples[1][nb_samples + n];
160		✗	s->pred[1][n] = s->pred[0][n] - (unsigned)s->samples[0][nb_samples + n];
161			}
162			}
163		✗	}
164
165		✗	static int decode_0cpy(AVCodecContext *avctx,
166			WavArcContext *s, GetBitContext *gb)
167			{
168		✗	const int bits = s->align * 8;
169
170		✗	s->nb_samples = FFMIN(640, get_bits_left(gb) / bits);
171
172		✗	switch (avctx->sample_fmt) {
173		✗	case AV_SAMPLE_FMT_U8P:
174		✗	for (int n = 0; n < s->nb_samples; n++) {
175		✗	for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
176		✗	s->samples[ch][n] = get_bits(gb, 8) - 0x80;
177			}
178		✗	break;
179		✗	case AV_SAMPLE_FMT_S16P:
180		✗	for (int n = 0; n < s->nb_samples; n++) {
181		✗	for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++)
182		✗	s->samples[ch][n] = sign_extend(av_bswap16(get_bits(gb, 16)), 16);
183			}
184		✗	break;
185			}
186		✗	return 0;
187			}
188
189		✗	static int decode_1dif(AVCodecContext *avctx,
190			WavArcContext *s, GetBitContext *gb)
191			{
192			int ch, finished, fill, correlated;
193
194		✗	ch = 0;
195		✗	finished = 0;
196		✗	while (!finished) {
197		✗	int *samples = s->samples[ch];
198			int k, block_type;
199
200		✗	if (get_bits_left(gb) <= 0)
201		✗	return AVERROR_INVALIDDATA;
202
203		✗	block_type = get_urice(gb, 1);
204		✗	if (block_type < 4 && block_type >= 0) {
205		✗	k = 1 + (avctx->sample_fmt == AV_SAMPLE_FMT_S16P);
206		✗	k = get_urice(gb, k) + 1;
207		✗	if (k >= 32)
208		✗	return AVERROR_INVALIDDATA;
209			}
210
211		✗	switch (block_type) {
212		✗	case 8:
213		✗	s->eof = 1;
214		✗	return AVERROR_EOF;
215		✗	case 7:
216		✗	s->nb_samples = get_bits(gb, 8);
217		✗	continue;
218		✗	case 6:
219		✗	s->shift = get_urice(gb, 2);
220		✗	if ((unsigned)s->shift > 31) {
221		✗	s->shift = 0;
222		✗	return AVERROR_INVALIDDATA;
223			}
224		✗	continue;
225		✗	case 5:
226		✗	if (avctx->sample_fmt == AV_SAMPLE_FMT_U8P) {
227		✗	fill = (int8_t)get_bits(gb, 8);
228		✗	fill -= 0x80;
229			} else {
230		✗	fill = (int16_t)get_bits(gb, 16);
231		✗	fill -= 0x8000;
232			}
233
234		✗	for (int n = 0; n < s->nb_samples; n++)
235		✗	samples[n + 4] = fill;
236		✗	finished = 1;
237		✗	break;
238		✗	case 4:
239		✗	for (int n = 0; n < s->nb_samples; n++)
240		✗	samples[n + 4] = 0;
241		✗	finished = 1;
242		✗	break;
243		✗	case 3:
244		✗	for (int n = 0; n < s->nb_samples; n++)
245		✗	samples[n + 4] = get_srice(gb, k) + (samples[n + 3] - (unsigned)samples[n + 2]) * 3 +
246		✗	samples[n + 1];
247		✗	finished = 1;
248		✗	break;
249		✗	case 2:
250		✗	for (int n = 0; n < s->nb_samples; n++)
251		✗	samples[n + 4] = get_srice(gb, k) + (samples[n + 3] * 2U - samples[n + 2]);
252		✗	finished = 1;
253		✗	break;
254		✗	case 1:
255		✗	for (int n = 0; n < s->nb_samples; n++)
256		✗	samples[n + 4] = get_srice(gb, k) + (unsigned)samples[n + 3];
257		✗	finished = 1;
258		✗	break;
259		✗	case 0:
260		✗	for (int n = 0; n < s->nb_samples; n++)
261		✗	samples[n + 4] = get_srice(gb, k);
262		✗	finished = 1;
263		✗	break;
264		✗	default:
265		✗	return AVERROR_INVALIDDATA;
266			}
267
268		✗	if (finished == 1 && avctx->ch_layout.nb_channels == 2) {
269		✗	if (ch == 0)
270		✗	correlated = get_bits1(gb);
271		✗	finished = ch != 0;
272		✗	do_stereo(s, ch, correlated, 4);
273		✗	ch = 1;
274			}
275			}
276
277		✗	if (avctx->ch_layout.nb_channels == 1) {
278		✗	for (int n = 0; n < 4; n++)
279		✗	s->samples[0][n] = s->samples[0][s->nb_samples + n];
280			}
281
282		✗	return 0;
283			}
284
285		✗	static int decode_2slp(AVCodecContext *avctx,
286			WavArcContext *s, GetBitContext *gb)
287			{
288			int ch, finished, fill, correlated, order;
289
290		✗	ch = 0;
291		✗	finished = 0;
292		✗	while (!finished) {
293		✗	int *samples = s->samples[ch];
294			int k, block_type;
295
296		✗	if (get_bits_left(gb) <= 0)
297		✗	return AVERROR_INVALIDDATA;
298
299		✗	block_type = get_urice(gb, 1);
300		✗	if (block_type < 5 && block_type >= 0) {
301		✗	k = 1 + (avctx->sample_fmt == AV_SAMPLE_FMT_S16P);
302		✗	k = get_urice(gb, k) + 1;
303		✗	if (k >= 32)
304		✗	return AVERROR_INVALIDDATA;
305			}
306
307		✗	switch (block_type) {
308		✗	case 9:
309		✗	s->eof = 1;
310		✗	return AVERROR_EOF;
311		✗	case 8:
312		✗	s->nb_samples = get_urice(gb, 8);
313		✗	if (s->nb_samples > 570U) {
314		✗	s->nb_samples = 570;
315		✗	return AVERROR_INVALIDDATA;
316			}
317		✗	continue;
318		✗	case 7:
319		✗	s->shift = get_urice(gb, 2);
320		✗	if ((unsigned)s->shift > 31) {
321		✗	s->shift = 0;
322		✗	return AVERROR_INVALIDDATA;
323			}
324		✗	continue;
325		✗	case 6:
326		✗	if (avctx->sample_fmt == AV_SAMPLE_FMT_U8P) {
327		✗	fill = (int8_t)get_bits(gb, 8);
328		✗	fill -= 0x80;
329			} else {
330		✗	fill = (int16_t)get_bits(gb, 16);
331		✗	fill -= 0x8000;
332			}
333
334		✗	for (int n = 0; n < s->nb_samples; n++)
335		✗	samples[n + 70] = fill;
336		✗	finished = 1;
337		✗	break;
338		✗	case 5:
339		✗	for (int n = 0; n < s->nb_samples; n++)
340		✗	samples[n + 70] = 0;
341		✗	finished = 1;
342		✗	break;
343		✗	case 4:
344		✗	for (int n = 0; n < s->nb_samples; n++)
345		✗	samples[n + 70] = get_srice(gb, k) + (samples[n + 69] - (unsigned)samples[n + 68]) * 3 +
346		✗	samples[n + 67];
347		✗	finished = 1;
348		✗	break;
349		✗	case 3:
350		✗	for (int n = 0; n < s->nb_samples; n++)
351		✗	samples[n + 70] = get_srice(gb, k) + (samples[n + 69] * 2U - samples[n + 68]);
352		✗	finished = 1;
353		✗	break;
354		✗	case 2:
355		✗	for (int n = 0; n < s->nb_samples; n++)
356		✗	samples[n + 70] = get_srice(gb, k);
357		✗	finished = 1;
358		✗	break;
359		✗	case 1:
360		✗	for (int n = 0; n < s->nb_samples; n++)
361		✗	samples[n + 70] = get_srice(gb, k) + (unsigned)samples[n + 69];
362		✗	finished = 1;
363		✗	break;
364		✗	case 0:
365		✗	order = get_urice(gb, 2);
366		✗	if ((unsigned)order > FF_ARRAY_ELEMS(s->filter[ch]))
367		✗	return AVERROR_INVALIDDATA;
368		✗	for (int o = 0; o < order; o++)
369		✗	s->filter[ch][o] = get_srice(gb, 2);
370		✗	for (int n = 0; n < s->nb_samples; n++) {
371		✗	int sum = 15;
372
373		✗	for (int o = 0; o < order; o++)
374		✗	sum += s->filter[ch][o] * (unsigned)samples[n + 70 - o - 1];
375
376		✗	samples[n + 70] = get_srice(gb, k) + (unsigned)(sum >> 4);
377			}
378		✗	finished = 1;
379		✗	break;
380		✗	default:
381		✗	return AVERROR_INVALIDDATA;
382			}
383
384		✗	if (finished == 1 && avctx->ch_layout.nb_channels == 2) {
385		✗	if (ch == 0)
386		✗	correlated = get_bits1(gb);
387		✗	finished = ch != 0;
388		✗	do_stereo(s, ch, correlated, 70);
389		✗	ch = 1;
390			}
391			}
392
393		✗	if (avctx->ch_layout.nb_channels == 1) {
394		✗	for (int n = 0; n < 70; n++)
395		✗	s->samples[0][n] = s->samples[0][s->nb_samples + n];
396			}
397
398		✗	return 0;
399			}
400
401		✗	static int ac_init(AVCodecContext *avctx,
402			WavArcContext *s, GetBitContext *gb)
403			{
404		✗	s->ac_low = 0;
405		✗	s->ac_high = 0xffffu;
406		✗	s->ac_value = get_bits(gb, 16);
407
408		✗	s->freq_range = s->freqs[256];
409		✗	if (!s->freq_range)
410		✗	return AVERROR_INVALIDDATA;
411		✗	return 0;
412			}
413
414		✗	static uint16_t ac_get_prob(WavArcContext *s)
415			{
416		✗	return ((s->freq_range - 1) + (s->ac_value - s->ac_low) * (unsigned)s->freq_range) /
417		✗	((s->ac_high - s->ac_low) + 1U);
418			}
419
420		✗	static uint8_t ac_map_symbol(WavArcContext *s, uint16_t prob)
421			{
422		✗	int idx = 255;
423
424		✗	while (prob < s->freqs[idx])
425		✗	idx--;
426
427		✗	s->range_high = s->freqs[idx + 1];
428		✗	s->range_low = s->freqs[idx];
429
430		✗	return idx;
431			}
432
433		✗	static int ac_normalize(AVCodecContext *avctx, WavArcContext *s, GetBitContext *gb)
434			{
435			int range;
436
437		✗	if (s->ac_high < s->ac_low)
438		✗	goto fail;
439
440		✗	range = (s->ac_high - s->ac_low) + 1;
441		✗	s->ac_high = (range * (unsigned)s->range_high) / s->freq_range + s->ac_low - 1;
442		✗	s->ac_low += (range * (unsigned)s->range_low) / s->freq_range;
443
444		✗	if (s->ac_high < s->ac_low)
445		✗	goto fail;
446
447			for (;;) {
448		✗	if ((s->ac_high & 0x8000) != (s->ac_low & 0x8000)) {
449		✗	if (((s->ac_low & 0x4000) == 0) || ((s->ac_high & 0x4000) != 0))
450		✗	return 0;
451		✗	s->ac_value ^= 0x4000;
452		✗	s->ac_low &= 0x3fff;
453		✗	s->ac_high |= 0x4000;
454			}
455
456		✗	s->ac_low = s->ac_low * 2;
457		✗	s->ac_high = s->ac_high * 2 | 1;
458		✗	if (s->ac_high < s->ac_low)
459		✗	goto fail;
460
461		✗	if (get_bits_left(gb) <= 0) {
462		✗	av_log(avctx, AV_LOG_ERROR, "overread in arithmetic coder\n");
463		✗	goto fail;
464			}
465
466		✗	s->ac_value = s->ac_value * 2 + get_bits1(gb);
467		✗	if (s->ac_low > s->ac_value || s->ac_high < s->ac_value)
468		✗	goto fail;
469			}
470
471		✗	fail:
472		✗	av_log(avctx, AV_LOG_ERROR, "invalid state\n");
473		✗	return AVERROR_INVALIDDATA;
474			}
475
476		✗	static void ac_init_model(WavArcContext *s)
477			{
478		✗	memset(s->freqs, 0, sizeof(s->freqs));
479
480		✗	for (int n = 0; n < 256; n++)
481		✗	s->freqs[n+1] = s->model[n] + s->freqs[n];
482		✗	}
483
484		✗	static int ac_read_model(AVCodecContext *avctx,
485			WavArcContext *s,
486			GetBitContext *gb)
487			{
488			unsigned start, end;
489
490		✗	memset(s->model, 0, sizeof(s->model));
491
492		✗	start = get_bits(gb, 8);
493		✗	end = get_bits(gb, 8);
494
495			for (;;) {
496		✗	while (start <= end) {
497		✗	if (get_bits_left(gb) < 8)
498		✗	return AVERROR_INVALIDDATA;
499		✗	s->model[start++] = get_bits(gb, 8);
500			}
501
502		✗	if (get_bits_left(gb) < 8)
503		✗	return AVERROR_INVALIDDATA;
504
505		✗	start = get_bits(gb, 8);
506		✗	if (!start)
507		✗	break;
508
509		✗	end = get_bits(gb, 8);
510			}
511
512		✗	ac_init_model(s);
513
514		✗	return 0;
515			}
516
517		✗	static int decode_5elp(AVCodecContext *avctx,
518			WavArcContext *s, GetBitContext *gb)
519			{
520		✗	int ch, finished, fill, correlated, order = 0;
521
522		✗	ch = 0;
523		✗	finished = 0;
524		✗	while (!finished) {
525		✗	int *samples = s->samples[ch];
526		✗	int *ac_pred = s->ac_pred;
527		✗	int *ac_out = s->ac_out;
528			int k, block_type;
529
530		✗	if (get_bits_left(gb) <= 0)
531		✗	return AVERROR_INVALIDDATA;
532
533		✗	memset(s->ac_out, 0, sizeof(s->ac_out));
534
535		✗	block_type = get_urice(gb, 1);
536		✗	av_log(avctx, AV_LOG_DEBUG, "block_type : %d\n", block_type);
537
538		✗	if (block_type >= 0 && block_type <= 7) {
539		✗	k = 1 + (avctx->sample_fmt == AV_SAMPLE_FMT_S16P);
540		✗	k = get_urice(gb, k) + 1;
541		✗	if (k >= 32)
542		✗	return AVERROR_INVALIDDATA;
543			}
544
545		✗	if (block_type <= 2 || block_type == 6 || block_type == 13 ||
546		✗	block_type == 14 || block_type == 15 || block_type == 19) {
547		✗	order = get_urice(gb, 2);
548		✗	if ((unsigned)order > FF_ARRAY_ELEMS(s->filter[ch]))
549		✗	return AVERROR_INVALIDDATA;
550		✗	for (int o = 0; o < order; o++)
551		✗	s->filter[ch][o] = get_srice(gb, 2);
552			}
553
554		✗	if (block_type >= 0 && block_type <= 7) {
555		✗	for (int n = 0; n < s->nb_samples; n++)
556		✗	samples[n + 70] = get_srice(gb, k);
557			} else {
558		✗	for (int n = 0; n < s->nb_samples; n++)
559		✗	samples[n + 70] = 0;
560			}
561
562		✗	if (block_type >= 13 && block_type <= 20) {
563		✗	const int ac_size = get_bits(gb, 12);
564		✗	const int ac_pos = get_bits_count(gb);
565		✗	GetBitContext ac_gb = *gb;
566			int ret;
567
568		✗	skip_bits_long(gb, ac_size);
569		✗	ret = ac_read_model(avctx, s, &ac_gb);
570		✗	if (ret < 0) {
571		✗	av_log(avctx, AV_LOG_ERROR, "bad arithmetic model\n");
572		✗	return ret;
573			}
574
575		✗	ret = ac_init(avctx, s, &ac_gb);
576		✗	if (ret < 0) {
577		✗	av_log(avctx, AV_LOG_ERROR, "cannot init arithmetic decoder\n");
578		✗	return ret;
579			}
580
581		✗	for (int n = 0; n < s->nb_samples; n++) {
582		✗	uint16_t prob = ac_get_prob(s);
583		✗	int ac = ac_map_symbol(s, prob);
584		✗	ac_out[n] = ac - 0x80;
585		✗	if ((ret = ac_normalize(avctx, s, &ac_gb)) < 0)
586		✗	return ret;
587			}
588
589		✗	if (get_bits_count(&ac_gb) != ac_pos + ac_size) {
590		✗	av_log(avctx, AV_LOG_DEBUG, "over/under-read in arithmetic coder: %d\n",
591		✗	ac_pos + ac_size - get_bits_count(&ac_gb));
592			}
593			}
594
595		✗	switch (block_type) {
596		✗	case 12:
597		✗	s->eof = 1;
598		✗	return AVERROR_EOF;
599		✗	case 11:
600		✗	s->nb_samples = get_urice(gb, 8);
601		✗	if (s->nb_samples > 570U) {
602		✗	s->nb_samples = 570;
603		✗	return AVERROR_INVALIDDATA;
604			}
605		✗	continue;
606		✗	case 10:
607		✗	s->shift = get_urice(gb, 2);
608		✗	if ((unsigned)s->shift > 31) {
609		✗	s->shift = 0;
610		✗	return AVERROR_INVALIDDATA;
611			}
612		✗	continue;
613		✗	case 9:
614		✗	if (avctx->sample_fmt == AV_SAMPLE_FMT_U8P) {
615		✗	fill = (int8_t)get_bits(gb, 8);
616		✗	fill -= 0x80;
617			} else {
618		✗	fill = (int16_t)get_bits(gb, 16);
619		✗	fill -= 0x8000;
620			}
621
622		✗	for (int n = 0; n < s->nb_samples; n++)
623		✗	samples[n + 70] = fill;
624		✗	finished = 1;
625		✗	break;
626		✗	case 8:
627		✗	for (int n = 0; n < s->nb_samples; n++)
628		✗	samples[n + 70] = 0;
629		✗	finished = 1;
630		✗	break;
631		✗	case 20:
632			case 7:
633		✗	for (int n = 0; n < s->nb_samples; n++)
634		✗	samples[n + 70] += ac_out[n] + samples[n + 69] * 3U - samples[n + 68] * 3U + samples[n + 67];
635		✗	finished = 1;
636		✗	break;
637		✗	case 19:
638			case 6:
639		✗	for (int n = 0; n < 70; n++) {
640		✗	ac_pred[n] = samples[n];
641		✗	samples[n] = 0;
642			}
643
644		✗	for (int n = 0; n < s->nb_samples; n++) {
645		✗	int sum = 15;
646
647		✗	for (int o = 0; o < order; o++)
648		✗	sum += s->filter[ch][o] * (unsigned)samples[n + 70 - o - 1];
649
650		✗	samples[n + 70] += ac_out[n] + (unsigned)(sum >> 4);
651			}
652
653		✗	for (int n = 0; n < 70; n++)
654		✗	samples[n] = ac_pred[n];
655
656		✗	for (int n = 0; n < s->nb_samples; n++)
657		✗	samples[n + 70] += ac_out[n] + samples[n + 69] * 3U - samples[n + 68] * 3U + samples[n + 67];
658
659		✗	finished = 1;
660		✗	break;
661		✗	case 18:
662			case 5:
663		✗	for (int n = 0; n < s->nb_samples; n++)
664		✗	samples[n + 70] += ac_out[n] + samples[n + 69] * 2U - samples[n + 68];
665		✗	finished = 1;
666		✗	break;
667		✗	case 17:
668			case 4:
669		✗	for (int n = 0; n < s->nb_samples; n++)
670		✗	samples[n + 70] += ac_out[n];
671		✗	finished = 1;
672		✗	break;
673		✗	case 16:
674			case 3:
675		✗	for (int n = 0; n < s->nb_samples; n++)
676		✗	samples[n + 70] += ac_out[n] + (unsigned)samples[n + 69];
677		✗	finished = 1;
678		✗	break;
679		✗	case 15:
680			case 2:
681		✗	for (int n = 0; n < 70; n++) {
682		✗	ac_pred[n] = samples[n];
683		✗	samples[n] = 0;
684			}
685
686		✗	for (int n = 0; n < s->nb_samples; n++) {
687		✗	int sum = 15;
688
689		✗	for (int o = 0; o < order; o++)
690		✗	sum += s->filter[ch][o] * (unsigned)samples[n + 70 - o - 1];
691
692		✗	samples[n + 70] += ac_out[n] + (unsigned)(sum >> 4);
693			}
694
695		✗	for (int n = 0; n < 70; n++)
696		✗	samples[n] = ac_pred[n];
697
698		✗	for (int n = 0; n < s->nb_samples; n++)
699		✗	samples[n + 70] += samples[n + 69] * 2U - samples[n + 68];
700
701		✗	finished = 1;
702		✗	break;
703		✗	case 14:
704			case 1:
705		✗	for (int n = 0; n < 70; n++) {
706		✗	ac_pred[n] = samples[n];
707		✗	samples[n] = 0;
708			}
709
710		✗	for (int n = 0; n < s->nb_samples; n++) {
711		✗	int sum = 15;
712
713		✗	for (int o = 0; o < order; o++)
714		✗	sum += s->filter[ch][o] * (unsigned)samples[n + 70 - o - 1];
715
716		✗	samples[n + 70] += (unsigned)ac_out[n] + (sum >> 4);
717			}
718
719		✗	for (int n = 0; n < 70; n++)
720		✗	samples[n] = ac_pred[n];
721
722		✗	for (int n = 0; n < s->nb_samples; n++)
723		✗	samples[n + 70] += (unsigned)samples[n + 69];
724
725		✗	finished = 1;
726		✗	break;
727		✗	case 13:
728			case 0:
729		✗	for (int n = 0; n < s->nb_samples; n++) {
730		✗	int sum = 15;
731
732		✗	for (int o = 0; o < order; o++)
733		✗	sum += s->filter[ch][o] * (unsigned)samples[n + 70 - o - 1];
734
735		✗	samples[n + 70] += (unsigned)ac_out[n] + (sum >> 4);
736			}
737		✗	finished = 1;
738		✗	break;
739		✗	default:
740		✗	return AVERROR_INVALIDDATA;
741			}
742
743		✗	if (finished == 1 && avctx->ch_layout.nb_channels == 2) {
744		✗	if (ch == 0)
745		✗	correlated = get_bits1(gb);
746		✗	finished = ch != 0;
747		✗	do_stereo(s, ch, correlated, 70);
748		✗	ch = 1;
749			}
750			}
751
752		✗	if (avctx->ch_layout.nb_channels == 1) {
753		✗	for (int n = 0; n < 70; n++)
754		✗	s->samples[0][n] = s->samples[0][s->nb_samples + n];
755			}
756
757		✗	return 0;
758			}
759
760		✗	static int wavarc_decode(AVCodecContext *avctx, AVFrame *frame,
761			int *got_frame_ptr, AVPacket *pkt)
762			{
763		✗	WavArcContext *s = avctx->priv_data;
764		✗	GetBitContext *gb = &s->gb;
765			int buf_size, input_buf_size;
766			const uint8_t *buf;
767			int ret, n;
768
769		✗	if ((!pkt->size && !s->bitstream_size) || s->nb_samples == 0 || s->eof) {
770		✗	*got_frame_ptr = 0;
771		✗	return pkt->size;
772			}
773
774		✗	buf_size = FFMIN(pkt->size, s->max_framesize - s->bitstream_size);
775		✗	input_buf_size = buf_size;
776		✗	if (s->bitstream_index + s->bitstream_size + buf_size + AV_INPUT_BUFFER_PADDING_SIZE > s->max_framesize) {
777		✗	memmove(s->bitstream, &s->bitstream[s->bitstream_index], s->bitstream_size);
778		✗	s->bitstream_index = 0;
779			}
780		✗	if (pkt->data)
781		✗	memcpy(&s->bitstream[s->bitstream_index + s->bitstream_size], pkt->data, buf_size);
782		✗	buf = &s->bitstream[s->bitstream_index];
783		✗	buf_size += s->bitstream_size;
784		✗	s->bitstream_size = buf_size;
785		✗	if (buf_size < s->max_framesize && pkt->data) {
786		✗	*got_frame_ptr = 0;
787		✗	return input_buf_size;
788			}
789
790		✗	if ((ret = init_get_bits8(gb, buf, buf_size)) < 0)
791		✗	goto fail;
792		✗	skip_bits(gb, s->skip);
793
794		✗	switch (avctx->codec_tag) {
795		✗	case MKTAG('0','C','P','Y'):
796		✗	ret = decode_0cpy(avctx, s, gb);
797		✗	break;
798		✗	case MKTAG('1','D','I','F'):
799		✗	ret = decode_1dif(avctx, s, gb);
800		✗	break;
801		✗	case MKTAG('2','S','L','P'):
802			case MKTAG('3','N','L','P'):
803			case MKTAG('4','A','L','P'):
804		✗	ret = decode_2slp(avctx, s, gb);
805		✗	break;
806		✗	case MKTAG('5','E','L','P'):
807		✗	ret = decode_5elp(avctx, s, gb);
808		✗	break;
809		✗	default:
810		✗	ret = AVERROR_INVALIDDATA;
811			}
812
813		✗	if (ret < 0)
814		✗	goto fail;
815
816		✗	s->skip = get_bits_count(gb) - 8 * (get_bits_count(gb) / 8);
817		✗	n = get_bits_count(gb) / 8;
818
819		✗	if (n > buf_size) {
820		✗	fail:
821		✗	s->bitstream_size = 0;
822		✗	s->bitstream_index = 0;
823		✗	if (ret == AVERROR_EOF)
824		✗	return 0;
825		✗	return AVERROR_INVALIDDATA;
826			}
827
828		✗	frame->nb_samples = s->nb_samples;
829		✗	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
830		✗	goto fail;
831
832		✗	switch (avctx->sample_fmt) {
833		✗	case AV_SAMPLE_FMT_U8P:
834		✗	for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
835		✗	uint8_t *dst = (uint8_t *)frame->extended_data[ch];
836		✗	const int *src = s->samples[ch] + s->offset;
837
838		✗	for (int n = 0; n < frame->nb_samples; n++)
839		✗	dst[n] = src[n] * (1U << s->shift) + 0x80U;
840			}
841		✗	break;
842		✗	case AV_SAMPLE_FMT_S16P:
843		✗	for (int ch = 0; ch < avctx->ch_layout.nb_channels; ch++) {
844		✗	int16_t *dst = (int16_t *)frame->extended_data[ch];
845		✗	const int *src = s->samples[ch] + s->offset;
846
847		✗	for (int n = 0; n < frame->nb_samples; n++)
848		✗	dst[n] = src[n] * (1U << s->shift);
849			}
850		✗	break;
851			}
852
853		✗	*got_frame_ptr = 1;
854
855		✗	if (s->bitstream_size) {
856		✗	s->bitstream_index += n;
857		✗	s->bitstream_size -= n;
858		✗	return input_buf_size;
859			}
860
861		✗	return n;
862			}
863
864		✗	static av_cold int wavarc_close(AVCodecContext *avctx)
865			{
866		✗	WavArcContext *s = avctx->priv_data;
867
868		✗	av_freep(&s->bitstream);
869		✗	s->bitstream_size = 0;
870
871		✗	return 0;
872			}
873
874			const FFCodec ff_wavarc_decoder = {
875			.p.name = "wavarc",
876			CODEC_LONG_NAME("Waveform Archiver"),
877			.p.type = AVMEDIA_TYPE_AUDIO,
878			.p.id = AV_CODEC_ID_WAVARC,
879			.priv_data_size = sizeof(WavArcContext),
880			.init = wavarc_init,
881			FF_CODEC_DECODE_CB(wavarc_decode),
882			.close = wavarc_close,
883			.p.capabilities = AV_CODEC_CAP_DR1 |
884			AV_CODEC_CAP_DELAY,
885			CODEC_SAMPLEFMTS(AV_SAMPLE_FMT_U8P, AV_SAMPLE_FMT_S16P),
886			};
887