FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* MidiVid Archive codec
3			*
4			* Copyright (c) 2019 Paul B Mahol
5			*
6			* This file is part of FFmpeg.
7			*
8			* FFmpeg is free software; you can redistribute it and/or
9			* modify it under the terms of the GNU Lesser General Public
10			* License as published by the Free Software Foundation; either
11			* version 2.1 of the License, or (at your option) any later version.
12			*
13			* FFmpeg is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16			* Lesser General Public License for more details.
17			*
18			* You should have received a copy of the GNU Lesser General Public
19			* License along with FFmpeg; if not, write to the Free Software
20			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21			*/
22
23			#define CACHED_BITSTREAM_READER !ARCH_X86_32
24			#include "libavutil/intreadwrite.h"
25
26			#include "avcodec.h"
27			#include "codec_internal.h"
28			#include "decode.h"
29			#include "get_bits.h"
30			#include "lossless_videodsp.h"
31			#include "zlib_wrapper.h"
32
33			#include <zlib.h>
34
35			typedef struct MVHAContext {
36			GetBitContext gb;
37			int nb_symbols;
38
39			uint8_t symb[256];
40			uint32_t prob[256];
41			VLC vlc;
42
43			FFZStream zstream;
44			LLVidDSPContext llviddsp;
45			} MVHAContext;
46
47			typedef struct Node {
48			int16_t sym;
49			int16_t n0;
50			int16_t l, r;
51			uint32_t count;
52			} Node;
53
54		✗	static void get_tree_codes(uint32_t *bits, int16_t *lens, uint8_t *xlat,
55			Node *nodes, int node,
56			uint32_t pfx, int pl, int *pos)
57			{
58			int s;
59
60		✗	s = nodes[node].sym;
61		✗	if (s != -1) {
62		✗	bits[*pos] = (~pfx) & ((1ULL << FFMAX(pl, 1)) - 1);
63		✗	lens[*pos] = FFMAX(pl, 1);
64		✗	xlat[*pos] = s + (pl == 0);
65		✗	(*pos)++;
66			} else {
67		✗	pfx <<= 1;
68		✗	pl++;
69		✗	get_tree_codes(bits, lens, xlat, nodes, nodes[node].l, pfx, pl,
70			pos);
71		✗	pfx |= 1;
72		✗	get_tree_codes(bits, lens, xlat, nodes, nodes[node].r, pfx, pl,
73			pos);
74			}
75		✗	}
76
77		✗	static int build_vlc(AVCodecContext *avctx, VLC *vlc)
78			{
79		✗	MVHAContext *s = avctx->priv_data;
80			Node nodes[512];
81			uint32_t bits[256];
82			int16_t lens[256];
83			uint8_t xlat[256];
84		✗	int cur_node, i, j, pos = 0;
85
86		✗	ff_vlc_free(vlc);
87
88		✗	for (i = 0; i < s->nb_symbols; i++) {
89		✗	nodes[i].count = s->prob[i];
90		✗	nodes[i].sym = s->symb[i];
91		✗	nodes[i].n0 = -2;
92		✗	nodes[i].l = i;
93		✗	nodes[i].r = i;
94			}
95
96		✗	cur_node = s->nb_symbols;
97		✗	j = 0;
98			do {
99		✗	for (i = 0; ; i++) {
100		✗	int new_node = j;
101		✗	int first_node = cur_node;
102		✗	int second_node = cur_node;
103			unsigned nd, st;
104
105		✗	nodes[cur_node].count = -1;
106
107			do {
108		✗	int val = nodes[new_node].count;
109		✗	if (val && (val < nodes[first_node].count)) {
110		✗	if (val >= nodes[second_node].count) {
111		✗	first_node = new_node;
112			} else {
113		✗	first_node = second_node;
114		✗	second_node = new_node;
115			}
116			}
117		✗	new_node += 1;
118		✗	} while (new_node != cur_node);
119
120		✗	if (first_node == cur_node)
121		✗	break;
122
123		✗	nd = nodes[second_node].count;
124		✗	st = nodes[first_node].count;
125		✗	nodes[second_node].count = 0;
126		✗	nodes[first_node].count = 0;
127		✗	if (nd >= UINT32_MAX - st) {
128		✗	av_log(avctx, AV_LOG_ERROR, "count overflow\n");
129		✗	return AVERROR_INVALIDDATA;
130			}
131		✗	nodes[cur_node].count = nd + st;
132		✗	nodes[cur_node].sym = -1;
133		✗	nodes[cur_node].n0 = cur_node;
134		✗	nodes[cur_node].l = first_node;
135		✗	nodes[cur_node].r = second_node;
136		✗	cur_node++;
137			}
138		✗	j++;
139		✗	} while (cur_node - s->nb_symbols == j);
140
141		✗	get_tree_codes(bits, lens, xlat, nodes, cur_node - 1, 0, 0, &pos);
142
143		✗	return ff_vlc_init_sparse(vlc, 12, pos, lens, 2, 2, bits, 4, 4, xlat, 1, 1, 0);
144			}
145
146		✗	static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
147			int *got_frame, AVPacket *avpkt)
148			{
149		✗	MVHAContext *s = avctx->priv_data;
150			uint32_t type, size;
151			int ret;
152
153		✗	if (avpkt->size <= 8)
154		✗	return AVERROR_INVALIDDATA;
155
156		✗	type = AV_RB32(avpkt->data);
157		✗	size = AV_RL32(avpkt->data + 4);
158
159		✗	if (size < 1 || size >= avpkt->size)
160		✗	return AVERROR_INVALIDDATA;
161
162		✗	if (type == MKTAG('L','Z','Y','V')) {
163		✗	z_stream *const zstream = &s->zstream.zstream;
164		✗	ret = inflateReset(zstream);
165		✗	if (ret != Z_OK) {
166		✗	av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
167		✗	return AVERROR_EXTERNAL;
168			}
169
170		✗	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
171		✗	return ret;
172
173		✗	zstream->next_in = avpkt->data + 8;
174		✗	zstream->avail_in = avpkt->size - 8;
175
176		✗	for (int p = 0; p < 3; p++) {
177		✗	for (int y = 0; y < avctx->height; y++) {
178		✗	zstream->next_out = frame->data[p] + (avctx->height - y - 1) * frame->linesize[p];
179		✗	zstream->avail_out = avctx->width >> (p > 0);
180
181		✗	ret = inflate(zstream, Z_SYNC_FLUSH);
182		✗	if (ret != Z_OK && ret != Z_STREAM_END) {
183		✗	av_log(avctx, AV_LOG_ERROR, "Inflate error: %d\n", ret);
184		✗	return AVERROR_EXTERNAL;
185			}
186			}
187			}
188		✗	} else if (type == MKTAG('H','U','F','Y')) {
189		✗	GetBitContext *gb = &s->gb;
190			int first_symbol, symbol;
191
192		✗	ret = init_get_bits8(gb, avpkt->data + 8, avpkt->size - 8);
193		✗	if (ret < 0)
194		✗	return ret;
195
196		✗	skip_bits(gb, 24);
197
198		✗	first_symbol = get_bits(gb, 8);
199		✗	s->nb_symbols = get_bits(gb, 8) + 1;
200
201		✗	symbol = first_symbol;
202		✗	for (int i = 0; i < s->nb_symbols; symbol++) {
203			int prob;
204
205		✗	if (get_bits_left(gb) < 4)
206		✗	return AVERROR_INVALIDDATA;
207
208		✗	if (get_bits1(gb)) {
209		✗	prob = get_bits(gb, 12);
210			} else {
211		✗	prob = get_bits(gb, 3);
212			}
213
214		✗	if (prob) {
215		✗	s->symb[i] = symbol;
216		✗	s->prob[i] = prob;
217		✗	i++;
218			}
219			}
220
221		✗	if (get_bits_left(gb) < avctx->height * avctx->width)
222		✗	return AVERROR_INVALIDDATA;
223
224		✗	ret = build_vlc(avctx, &s->vlc);
225		✗	if (ret < 0)
226		✗	return ret;
227
228		✗	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
229		✗	return ret;
230
231		✗	for (int p = 0; p < 3; p++) {
232		✗	int width = avctx->width >> (p > 0);
233		✗	ptrdiff_t stride = frame->linesize[p];
234			uint8_t *dst;
235
236		✗	dst = frame->data[p] + (avctx->height - 1) * frame->linesize[p];
237		✗	for (int y = 0; y < avctx->height; y++) {
238		✗	if (get_bits_left(gb) < width)
239		✗	return AVERROR_INVALIDDATA;
240		✗	for (int x = 0; x < width; x++) {
241		✗	int v = get_vlc2(gb, s->vlc.table, s->vlc.bits, 3);
242
243		✗	if (v < 0)
244		✗	return AVERROR_INVALIDDATA;
245
246		✗	dst[x] = v;
247			}
248		✗	dst -= stride;
249			}
250			}
251			} else {
252		✗	return AVERROR_INVALIDDATA;
253			}
254
255		✗	for (int p = 0; p < 3; p++) {
256			int left, lefttop;
257		✗	int width = avctx->width >> (p > 0);
258		✗	ptrdiff_t stride = frame->linesize[p];
259			uint8_t *dst;
260
261		✗	dst = frame->data[p] + (avctx->height - 1) * frame->linesize[p];
262		✗	s->llviddsp.add_left_pred(dst, dst, width, 0);
263		✗	if (avctx->height > 1) {
264		✗	dst -= stride;
265		✗	lefttop = left = dst[0];
266		✗	for (int y = 1; y < avctx->height; y++) {
267		✗	s->llviddsp.add_median_pred(dst, dst + stride, dst, width, &left, &lefttop);
268		✗	lefttop = left = dst[0];
269		✗	dst -= stride;
270			}
271			}
272			}
273
274		✗	frame->pict_type = AV_PICTURE_TYPE_I;
275		✗	frame->flags |= AV_FRAME_FLAG_KEY;
276		✗	*got_frame = 1;
277
278		✗	return avpkt->size;
279			}
280
281		✗	static av_cold int decode_init(AVCodecContext *avctx)
282			{
283		✗	MVHAContext *s = avctx->priv_data;
284
285		✗	avctx->pix_fmt = AV_PIX_FMT_YUV422P;
286
287		✗	ff_llviddsp_init(&s->llviddsp);
288
289		✗	return ff_inflate_init(&s->zstream, avctx);
290			}
291
292		✗	static av_cold int decode_close(AVCodecContext *avctx)
293			{
294		✗	MVHAContext *s = avctx->priv_data;
295
296		✗	ff_inflate_end(&s->zstream);
297		✗	ff_vlc_free(&s->vlc);
298
299		✗	return 0;
300			}
301
302			const FFCodec ff_mvha_decoder = {
303			.p.name = "mvha",
304			CODEC_LONG_NAME("MidiVid Archive Codec"),
305			.p.type = AVMEDIA_TYPE_VIDEO,
306			.p.id = AV_CODEC_ID_MVHA,
307			.priv_data_size = sizeof(MVHAContext),
308			.init = decode_init,
309			.close = decode_close,
310			FF_CODEC_DECODE_CB(decode_frame),
311			.p.capabilities = AV_CODEC_CAP_DR1,
312			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
313			};
314