FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Copyright (c) 2021 Paul B Mahol
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/common.h"
22			#include "libavutil/mem.h"
23			#include "avcodec.h"
24			#include "get_bits.h"
25			#include "bytestream.h"
26			#include "codec_internal.h"
27			#include "decode.h"
28
29			#define PALDATA_FOLLOWS_TILEDATA 4
30			#define HAVE_COMPRESSED_TILEMAP 32
31			#define HAVE_TILEMAP 128
32
33			typedef struct SGAVideoContext {
34			GetByteContext gb;
35
36			int metadata_size;
37			int tiledata_size;
38			int tiledata_offset;
39			int tilemapdata_size;
40			int tilemapdata_offset;
41			int paldata_size;
42			int paldata_offset;
43			int palmapdata_offset;
44			int palmapdata_size;
45
46			int flags;
47			int nb_pal;
48			int nb_tiles;
49			int tiles_w, tiles_h;
50			int shift;
51			int plus;
52			int swap;
53
54			uint32_t pal[256];
55			uint8_t *tileindex_data;
56			unsigned tileindex_size;
57			uint8_t *palmapindex_data;
58			unsigned palmapindex_size;
59			uint8_t uncompressed[65536];
60			} SGAVideoContext;
61
62		✗	static av_cold int sga_decode_init(AVCodecContext *avctx)
63			{
64		✗	avctx->pix_fmt = AV_PIX_FMT_PAL8;
65		✗	return 0;
66			}
67
68		✗	static int decode_palette(GetByteContext *gb, uint32_t *pal)
69			{
70			GetBitContext gbit;
71
72		✗	if (bytestream2_get_bytes_left(gb) < 18)
73		✗	return AVERROR_INVALIDDATA;
74
75		✗	memset(pal, 0, 16 * sizeof(*pal));
76		✗	(void)init_get_bits8(&gbit, gb->buffer, 18);
77
78		✗	for (int RGBIndex = 0; RGBIndex < 3; RGBIndex++) {
79		✗	for (int index = 0; index < 16; index++) {
80		✗	unsigned color = get_bits1(&gbit) << RGBIndex;
81		✗	pal[15 - index] |= color << (5 + 16);
82			}
83			}
84
85		✗	for (int RGBIndex = 0; RGBIndex < 3; RGBIndex++) {
86		✗	for (int index = 0; index < 16; index++) {
87		✗	unsigned color = get_bits1(&gbit) << RGBIndex;
88		✗	pal[15 - index] |= color << (5 + 8);
89			}
90			}
91
92		✗	for (int RGBIndex = 0; RGBIndex < 3; RGBIndex++) {
93		✗	for (int index = 0; index < 16; index++) {
94		✗	unsigned color = get_bits1(&gbit) << RGBIndex;
95		✗	pal[15 - index] |= color << (5 + 0);
96			}
97			}
98
99		✗	for (int index = 0; index < 16; index++)
100		✗	pal[index] = (0xFFU << 24) | pal[index] | (pal[index] >> 3);
101
102		✗	bytestream2_skip(gb, 18);
103
104		✗	return 0;
105			}
106
107		✗	static int decode_index_palmap(SGAVideoContext *s, AVFrame *frame)
108			{
109		✗	const uint8_t *tt = s->tileindex_data;
110
111		✗	for (int y = 0; y < s->tiles_h; y++) {
112		✗	for (int x = 0; x < s->tiles_w; x++) {
113		✗	int pal_idx = s->palmapindex_data[y * s->tiles_w + x] * 16;
114		✗	uint8_t *dst = frame->data[0] + y * 8 * frame->linesize[0] + x * 8;
115
116		✗	for (int yy = 0; yy < 8; yy++) {
117		✗	for (int xx = 0; xx < 8; xx++)
118		✗	dst[xx] = pal_idx + tt[xx];
119		✗	tt += 8;
120
121		✗	dst += frame->linesize[0];
122			}
123			}
124			}
125
126		✗	return 0;
127			}
128
129		✗	static int decode_index_tilemap(SGAVideoContext *s, AVFrame *frame)
130			{
131		✗	GetByteContext *gb = &s->gb, gb2;
132
133		✗	bytestream2_seek(gb, s->tilemapdata_offset, SEEK_SET);
134		✗	if (bytestream2_get_bytes_left(gb) < s->tilemapdata_size)
135		✗	return AVERROR_INVALIDDATA;
136
137		✗	gb2 = *gb;
138
139		✗	for (int y = 0; y < s->tiles_h; y++) {
140		✗	for (int x = 0; x < s->tiles_w; x++) {
141			uint8_t tile[64];
142		✗	int tilemap = bytestream2_get_be16u(&gb2);
143		✗	int flip_x = (tilemap >> 11) & 1;
144		✗	int flip_y = (tilemap >> 12) & 1;
145		✗	int tindex = av_clip((tilemap & 511) - 1, 0, s->nb_tiles - 1);
146		✗	const uint8_t *tt = s->tileindex_data + tindex * 64;
147		✗	int pal_idx = ((tilemap >> 13) & 3) * 16;
148		✗	uint8_t *dst = frame->data[0] + y * 8 * frame->linesize[0] + x * 8;
149
150		✗	if (!flip_x && !flip_y) {
151		✗	memcpy(tile, tt, 64);
152		✗	} else if (flip_x && flip_y) {
153		✗	for (int i = 0; i < 8; i++) {
154		✗	for (int j = 0; j < 8; j++)
155		✗	tile[i * 8 + j] = tt[(7 - i) * 8 + 7 - j];
156			}
157		✗	} else if (flip_x) {
158		✗	for (int i = 0; i < 8; i++) {
159		✗	for (int j = 0; j < 8; j++)
160		✗	tile[i * 8 + j] = tt[i * 8 + 7 - j];
161			}
162			} else {
163		✗	for (int i = 0; i < 8; i++) {
164		✗	for (int j = 0; j < 8; j++)
165		✗	tile[i * 8 + j] = tt[(7 - i) * 8 + j];
166			}
167			}
168
169		✗	for (int yy = 0; yy < 8; yy++) {
170		✗	for (int xx = 0; xx < 8; xx++)
171		✗	dst[xx] = pal_idx + tile[xx + yy * 8];
172
173		✗	dst += frame->linesize[0];
174			}
175			}
176			}
177
178		✗	return 0;
179			}
180
181		✗	static int decode_index(SGAVideoContext *s, AVFrame *frame)
182			{
183		✗	const uint8_t *src = s->tileindex_data;
184		✗	uint8_t *dst = frame->data[0];
185
186		✗	for (int y = 0; y < frame->height; y += 8) {
187		✗	for (int x = 0; x < frame->width; x += 8) {
188		✗	for (int yy = 0; yy < 8; yy++) {
189		✗	for (int xx = 0; xx < 8; xx++)
190		✗	dst[x + xx + yy * frame->linesize[0]] = src[xx];
191		✗	src += 8;
192			}
193			}
194
195		✗	dst += 8 * frame->linesize[0];
196			}
197
198		✗	return 0;
199			}
200
201		✗	static int lzss_decompress(AVCodecContext *avctx,
202			GetByteContext *gb, uint8_t *dst,
203			int dst_size, int shift, int plus)
204			{
205		✗	int oi = 0;
206
207		✗	while (bytestream2_get_bytes_left(gb) > 0 && oi < dst_size) {
208		✗	uint16_t displace, header = bytestream2_get_be16(gb);
209			int count, offset;
210
211		✗	for (int i = 0; i < 16; i++) {
212		✗	switch (header >> 15) {
213		✗	case 0:
214		✗	if (oi + 2 < dst_size) {
215		✗	dst[oi++] = bytestream2_get_byte(gb);
216		✗	dst[oi++] = bytestream2_get_byte(gb);
217			}
218		✗	break;
219		✗	case 1:
220		✗	displace = bytestream2_get_be16(gb);
221		✗	count = displace >> shift;
222		✗	offset = displace & ((1 << shift) - 1);
223
224		✗	if (displace == 0) {
225		✗	while (bytestream2_get_bytes_left(gb) > 0 &&
226			oi < dst_size)
227		✗	dst[oi++] = bytestream2_get_byte(gb);
228		✗	return oi;
229			}
230
231		✗	count += plus;
232
233		✗	if (offset <= 0)
234		✗	offset = 1;
235		✗	if (oi < offset || oi + count * 2 > dst_size)
236		✗	return AVERROR_INVALIDDATA;
237		✗	for (int j = 0; j < count * 2; j++) {
238		✗	dst[oi] = dst[oi - offset];
239		✗	oi++;
240			}
241		✗	break;
242			}
243
244		✗	header <<= 1;
245			}
246			}
247
248		✗	return AVERROR_INVALIDDATA;
249			}
250
251		✗	static int decode_palmapdata(AVCodecContext *avctx)
252			{
253		✗	SGAVideoContext *s = avctx->priv_data;
254		✗	const int bits = (s->nb_pal + 1) / 2;
255		✗	GetByteContext *gb = &s->gb;
256			GetBitContext pm;
257			av_unused int ret;
258
259		✗	bytestream2_seek(gb, s->palmapdata_offset, SEEK_SET);
260		✗	if (bytestream2_get_bytes_left(gb) < s->palmapdata_size)
261		✗	return AVERROR_INVALIDDATA;
262		✗	ret = init_get_bits8(&pm, gb->buffer, s->palmapdata_size);
263			av_assert1(ret >= 0);
264
265		✗	for (int y = 0; y < s->tiles_h; y++) {
266		✗	uint8_t *dst = s->palmapindex_data + y * s->tiles_w;
267
268		✗	for (int x = 0; x < s->tiles_w; x++)
269		✗	dst[x] = get_bits(&pm, bits);
270
271		✗	dst += s->tiles_w;
272			}
273
274		✗	return 0;
275			}
276
277		✗	static int decode_tiledata(AVCodecContext *avctx)
278			{
279		✗	SGAVideoContext *s = avctx->priv_data;
280		✗	GetByteContext *gb = &s->gb;
281			GetBitContext tm;
282			av_unused int ret;
283
284		✗	bytestream2_seek(gb, s->tiledata_offset, SEEK_SET);
285		✗	if (bytestream2_get_bytes_left(gb) < s->tiledata_size)
286		✗	return AVERROR_INVALIDDATA;
287		✗	ret = init_get_bits8(&tm, gb->buffer, s->tiledata_size);
288			av_assert1(ret >= 0);
289
290		✗	for (int n = 0; n < s->nb_tiles; n++) {
291		✗	uint8_t *dst = s->tileindex_data + n * 64;
292
293		✗	for (int yy = 0; yy < 8; yy++) {
294		✗	for (int xx = 0; xx < 8; xx++)
295		✗	dst[xx] = get_bits(&tm, 4);
296
297		✗	dst += 8;
298			}
299			}
300
301		✗	for (int i = 0; i < s->nb_tiles && s->swap; i++) {
302		✗	uint8_t *dst = s->tileindex_data + i * 64;
303
304		✗	for (int j = 8; j < 64; j += 16) {
305		✗	for (int k = 0; k < 8; k += 2)
306		✗	FFSWAP(uint8_t, dst[j + k], dst[j+k+1]);
307			}
308			}
309
310		✗	return 0;
311			}
312
313		✗	static int sga_decode_frame(AVCodecContext *avctx, AVFrame *frame,
314			int *got_frame, AVPacket *avpkt)
315			{
316		✗	SGAVideoContext *s = avctx->priv_data;
317		✗	GetByteContext *gb = &s->gb;
318			int ret, type;
319
320		✗	if (avpkt->size <= 14)
321		✗	return AVERROR_INVALIDDATA;
322
323		✗	s->flags = avpkt->data[8];
324		✗	s->nb_pal = avpkt->data[9];
325		✗	s->tiles_w = avpkt->data[10];
326		✗	s->tiles_h = avpkt->data[11];
327
328		✗	if (s->nb_pal > 4)
329		✗	return AVERROR_INVALIDDATA;
330
331		✗	if ((ret = ff_set_dimensions(avctx,
332		✗	s->tiles_w * 8,
333		✗	s->tiles_h * 8)) < 0)
334		✗	return ret;
335
336		✗	av_fast_padded_malloc(&s->tileindex_data, &s->tileindex_size,
337		✗	avctx->width * avctx->height);
338		✗	if (!s->tileindex_data)
339		✗	return AVERROR(ENOMEM);
340
341		✗	av_fast_padded_malloc(&s->palmapindex_data, &s->palmapindex_size,
342		✗	s->tiles_w * s->tiles_h);
343		✗	if (!s->palmapindex_data)
344		✗	return AVERROR(ENOMEM);
345
346		✗	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
347		✗	return ret;
348
349		✗	bytestream2_init(gb, avpkt->data, avpkt->size);
350
351		✗	type = bytestream2_get_byte(gb);
352		✗	s->metadata_size = 12 + ((!!(s->flags & HAVE_TILEMAP)) * 2);
353		✗	s->nb_tiles = s->flags & HAVE_TILEMAP ? AV_RB16(avpkt->data + 12) : s->tiles_w * s->tiles_h;
354		✗	if (s->nb_tiles > s->tiles_w * s->tiles_h)
355		✗	return AVERROR_INVALIDDATA;
356
357		✗	av_log(avctx, AV_LOG_DEBUG, "type: %X flags: %X nb_tiles: %d\n", type, s->flags, s->nb_tiles);
358
359		✗	switch (type) {
360		✗	case 0xE7:
361			case 0xCB:
362			case 0xCD:
363		✗	s->swap = 1;
364		✗	s->shift = 12;
365		✗	s->plus = 1;
366		✗	break;
367		✗	case 0xC9:
368		✗	s->swap = 1;
369		✗	s->shift = 13;
370		✗	s->plus = 1;
371		✗	break;
372		✗	case 0xC8:
373		✗	s->swap = 1;
374		✗	s->shift = 13;
375		✗	s->plus = 0;
376		✗	break;
377		✗	case 0xC7:
378		✗	s->swap = 0;
379		✗	s->shift = 13;
380		✗	s->plus = 1;
381		✗	break;
382		✗	case 0xC6:
383		✗	s->swap = 0;
384		✗	s->shift = 13;
385		✗	s->plus = 0;
386		✗	break;
387			}
388
389		✗	if (type == 0xE7) {
390		✗	int offset = s->metadata_size, left;
391			int sizes[3];
392
393		✗	bytestream2_seek(gb, s->metadata_size, SEEK_SET);
394
395		✗	for (int i = 0; i < 3; i++)
396		✗	sizes[i] = bytestream2_get_be16(gb);
397
398		✗	for (int i = 0; i < 3; i++) {
399		✗	int size = sizes[i];
400		✗	int raw = size >> 15;
401
402		✗	size &= (1 << 15) - 1;
403
404		✗	if (raw) {
405		✗	if (bytestream2_get_bytes_left(gb) < size)
406		✗	return AVERROR_INVALIDDATA;
407
408		✗	if (sizeof(s->uncompressed) - offset < size)
409		✗	return AVERROR_INVALIDDATA;
410
411		✗	memcpy(s->uncompressed + offset, gb->buffer, size);
412		✗	bytestream2_skip(gb, size);
413			} else {
414			GetByteContext gb2;
415
416		✗	if (bytestream2_get_bytes_left(gb) < size)
417		✗	return AVERROR_INVALIDDATA;
418
419		✗	bytestream2_init(&gb2, gb->buffer, size);
420		✗	ret = lzss_decompress(avctx, &gb2, s->uncompressed + offset,
421		✗	sizeof(s->uncompressed) - offset, s->shift, s->plus);
422		✗	if (ret < 0)
423		✗	return ret;
424		✗	bytestream2_skip(gb, size);
425		✗	size = ret;
426			}
427
428		✗	offset += size;
429			}
430
431		✗	left = bytestream2_get_bytes_left(gb);
432		✗	if (sizeof(s->uncompressed) - offset < left)
433		✗	return AVERROR_INVALIDDATA;
434
435		✗	bytestream2_get_buffer(gb, s->uncompressed + offset, left);
436
437		✗	offset += left;
438		✗	bytestream2_init(gb, s->uncompressed, offset);
439			}
440
441		✗	switch (type) {
442		✗	case 0xCD:
443			case 0xCB:
444			case 0xC9:
445			case 0xC8:
446			case 0xC7:
447			case 0xC6:
448		✗	bytestream2_seek(gb, s->metadata_size, SEEK_SET);
449		✗	ret = lzss_decompress(avctx, gb, s->uncompressed + s->metadata_size,
450		✗	sizeof(s->uncompressed) - s->metadata_size, s->shift, s->plus);
451		✗	if (ret < 0)
452		✗	return ret;
453		✗	bytestream2_init(gb, s->uncompressed, ret + s->metadata_size);
454			av_fallthrough;
455		✗	case 0xE7:
456			case 0xC1:
457		✗	s->tiledata_size = s->nb_tiles * 32;
458		✗	s->paldata_size = s->nb_pal * 18;
459		✗	s->tiledata_offset = s->flags & PALDATA_FOLLOWS_TILEDATA ? s->metadata_size : s->metadata_size + s->paldata_size;
460		✗	s->paldata_offset = s->flags & PALDATA_FOLLOWS_TILEDATA ? s->metadata_size + s->tiledata_size : s->metadata_size;
461		✗	s->palmapdata_offset = (s->flags & HAVE_TILEMAP) ? -1 : s->paldata_offset + s->paldata_size;
462		✗	s->palmapdata_size = (s->flags & HAVE_TILEMAP) || s->nb_pal < 2 ? 0 : (s->tiles_w * s->tiles_h * ((s->nb_pal + 1) / 2) + 7) / 8;
463		✗	s->tilemapdata_size = (s->flags & HAVE_TILEMAP) ? s->tiles_w * s->tiles_h * 2 : 0;
464		✗	s->tilemapdata_offset = (s->flags & HAVE_TILEMAP) ? s->paldata_offset + s->paldata_size: -1;
465
466		✗	bytestream2_seek(gb, s->paldata_offset, SEEK_SET);
467		✗	for (int n = 0; n < s->nb_pal; n++) {
468		✗	ret = decode_palette(gb, s->pal + 16 * n);
469		✗	if (ret < 0)
470		✗	return ret;
471			}
472
473		✗	if (s->tiledata_size > 0) {
474		✗	ret = decode_tiledata(avctx);
475		✗	if (ret < 0)
476		✗	return ret;
477			}
478
479		✗	if (s->palmapdata_size > 0) {
480		✗	ret = decode_palmapdata(avctx);
481		✗	if (ret < 0)
482		✗	return ret;
483			}
484
485		✗	if (s->palmapdata_size > 0 && s->tiledata_size > 0) {
486		✗	ret = decode_index_palmap(s, frame);
487		✗	if (ret < 0)
488		✗	return ret;
489		✗	} else if (s->tilemapdata_size > 0 && s->tiledata_size > 0) {
490		✗	ret = decode_index_tilemap(s, frame);
491		✗	if (ret < 0)
492		✗	return ret;
493		✗	} else if (s->tiledata_size > 0) {
494		✗	ret = decode_index(s, frame);
495		✗	if (ret < 0)
496		✗	return ret;
497			}
498		✗	break;
499		✗	default:
500		✗	av_log(avctx, AV_LOG_ERROR, "Unknown type: %X\n", type);
501		✗	return AVERROR_INVALIDDATA;
502			}
503
504		✗	memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
505		✗	frame->pict_type = AV_PICTURE_TYPE_I;
506		✗	frame->flags |= AV_FRAME_FLAG_KEY;
507
508		✗	*got_frame = 1;
509
510		✗	return avpkt->size;
511			}
512
513		✗	static av_cold int sga_decode_end(AVCodecContext *avctx)
514			{
515		✗	SGAVideoContext *s = avctx->priv_data;
516
517		✗	av_freep(&s->tileindex_data);
518		✗	s->tileindex_size = 0;
519
520		✗	av_freep(&s->palmapindex_data);
521		✗	s->palmapindex_size = 0;
522
523		✗	return 0;
524			}
525
526			const FFCodec ff_sga_decoder = {
527			.p.name = "sga",
528			CODEC_LONG_NAME("Digital Pictures SGA Video"),
529			.p.type = AVMEDIA_TYPE_VIDEO,
530			.p.id = AV_CODEC_ID_SGA_VIDEO,
531			.priv_data_size = sizeof(SGAVideoContext),
532			.init = sga_decode_init,
533			FF_CODEC_DECODE_CB(sga_decode_frame),
534			.close = sga_decode_end,
535			.p.capabilities = AV_CODEC_CAP_DR1,
536			};
537