FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* Cryo Interactive Entertainment HNM4 video decoder
3			*
4			* Copyright (c) 2012 David Kment
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			#include <string.h>
24
25			#include "libavutil/imgutils.h"
26			#include "libavutil/internal.h"
27			#include "libavutil/intreadwrite.h"
28			#include "libavutil/mem.h"
29			#include "avcodec.h"
30			#include "bytestream.h"
31			#include "codec_internal.h"
32			#include "decode.h"
33
34			#define HNM4_CHUNK_ID_PL 19536
35			#define HNM4_CHUNK_ID_IZ 23113
36			#define HNM4_CHUNK_ID_IU 21833
37			#define HNM4_CHUNK_ID_SD 17491
38
39			typedef struct Hnm4VideoContext {
40			uint8_t version;
41			int width;
42			int height;
43			uint8_t *current;
44			uint8_t *previous;
45			uint8_t *buffer1;
46			uint8_t *buffer2;
47			uint8_t *processed;
48			uint32_t palette[256];
49			} Hnm4VideoContext;
50
51		✗	static int getbit(GetByteContext *gb, uint32_t *bitbuf, int *bits)
52			{
53			int ret;
54
55		✗	if (!*bits) {
56		✗	*bitbuf = bytestream2_get_le32(gb);
57		✗	*bits = 32;
58			}
59
60		✗	ret = *bitbuf >> 31;
61		✗	*bitbuf <<= 1;
62		✗	(*bits)--;
63
64		✗	return ret;
65			}
66
67		✗	static void unpack_intraframe(AVCodecContext *avctx, const uint8_t *src,
68			uint32_t size)
69			{
70		✗	Hnm4VideoContext *hnm = avctx->priv_data;
71			GetByteContext gb;
72		✗	uint32_t bitbuf = 0, writeoffset = 0, count = 0;
73			uint16_t word;
74			int32_t offset;
75		✗	int bits = 0;
76
77		✗	bytestream2_init(&gb, src, size);
78
79		✗	while (bytestream2_tell(&gb) < size) {
80		✗	if (getbit(&gb, &bitbuf, &bits)) {
81		✗	if (writeoffset >= hnm->width * hnm->height) {
82		✗	av_log(avctx, AV_LOG_ERROR,
83			"Attempting to write out of bounds\n");
84		✗	break;
85			}
86		✗	hnm->current[writeoffset++] = bytestream2_get_byte(&gb);
87			} else {
88		✗	if (getbit(&gb, &bitbuf, &bits)) {
89		✗	word = bytestream2_get_le16(&gb);
90		✗	count = word & 0x07;
91		✗	offset = (word >> 3) - 0x2000;
92		✗	if (!count)
93		✗	count = bytestream2_get_byte(&gb);
94		✗	if (!count)
95		✗	return;
96			} else {
97		✗	count = getbit(&gb, &bitbuf, &bits) * 2;
98		✗	count += getbit(&gb, &bitbuf, &bits);
99		✗	offset = bytestream2_get_byte(&gb) - 0x0100;
100			}
101		✗	count += 2;
102		✗	offset += writeoffset;
103		✗	if (offset < 0 || offset + count >= hnm->width * hnm->height) {
104		✗	av_log(avctx, AV_LOG_ERROR, "Attempting to read out of bounds\n");
105		✗	break;
106		✗	} else if (writeoffset + count >= hnm->width * hnm->height) {
107		✗	av_log(avctx, AV_LOG_ERROR,
108			"Attempting to write out of bounds\n");
109		✗	break;
110			}
111		✗	while (count--) {
112		✗	hnm->current[writeoffset++] = hnm->current[offset++];
113			}
114			}
115			}
116			}
117
118		✗	static void postprocess_current_frame(AVCodecContext *avctx)
119			{
120		✗	Hnm4VideoContext *hnm = avctx->priv_data;
121			uint32_t x, y, src_y;
122		✗	int width = hnm->width;
123
124		✗	for (y = 0; y < hnm->height; y++) {
125		✗	uint8_t *dst = hnm->processed + y * width;
126		✗	const uint8_t *src = hnm->current;
127		✗	src_y = y - (y % 2);
128		✗	src += src_y * width + (y % 2);
129		✗	for (x = 0; x < width; x++) {
130		✗	dst[x] = *src;
131		✗	src += 2;
132			}
133			}
134		✗	}
135
136		✗	static void copy_processed_frame(AVCodecContext *avctx, AVFrame *frame)
137			{
138		✗	Hnm4VideoContext *hnm = avctx->priv_data;
139		✗	uint8_t *src = hnm->processed;
140		✗	uint8_t *dst = frame->data[0];
141			int y;
142
143		✗	for (y = 0; y < hnm->height; y++) {
144		✗	memcpy(dst, src, hnm->width);
145		✗	src += hnm->width;
146		✗	dst += frame->linesize[0];
147			}
148		✗	}
149
150		✗	static int decode_interframe_v4(AVCodecContext *avctx, const uint8_t *src, uint32_t size)
151			{
152		✗	Hnm4VideoContext *hnm = avctx->priv_data;
153			GetByteContext gb;
154		✗	uint32_t writeoffset = 0;
155			int count, left, offset;
156			uint8_t tag, previous, backline, backward, swap;
157
158		✗	bytestream2_init(&gb, src, size);
159
160		✗	while (bytestream2_tell(&gb) < size) {
161		✗	count = bytestream2_peek_byte(&gb) & 0x1F;
162		✗	if (count == 0) {
163		✗	tag = bytestream2_get_byte(&gb) & 0xE0;
164		✗	tag = tag >> 5;
165
166		✗	if (tag == 0) {
167		✗	if (writeoffset + 2 > hnm->width * hnm->height) {
168		✗	av_log(avctx, AV_LOG_ERROR, "writeoffset out of bounds\n");
169		✗	return AVERROR_INVALIDDATA;
170			}
171		✗	hnm->current[writeoffset++] = bytestream2_get_byte(&gb);
172		✗	hnm->current[writeoffset++] = bytestream2_get_byte(&gb);
173		✗	} else if (tag == 1) {
174		✗	writeoffset += bytestream2_get_byte(&gb) * 2;
175		✗	} else if (tag == 2) {
176		✗	count = bytestream2_get_le16(&gb);
177		✗	count *= 2;
178		✗	writeoffset += count;
179		✗	} else if (tag == 3) {
180		✗	count = bytestream2_get_byte(&gb) * 2;
181		✗	if (writeoffset + count > hnm->width * hnm->height) {
182		✗	av_log(avctx, AV_LOG_ERROR, "writeoffset out of bounds\n");
183		✗	return AVERROR_INVALIDDATA;
184			}
185		✗	while (count > 0) {
186		✗	hnm->current[writeoffset++] = bytestream2_peek_byte(&gb);
187		✗	count--;
188			}
189		✗	bytestream2_skip(&gb, 1);
190			} else {
191		✗	break;
192			}
193		✗	if (writeoffset > hnm->width * hnm->height) {
194		✗	av_log(avctx, AV_LOG_ERROR, "writeoffset out of bounds\n");
195		✗	return AVERROR_INVALIDDATA;
196			}
197			} else {
198		✗	previous = bytestream2_peek_byte(&gb) & 0x20;
199		✗	backline = bytestream2_peek_byte(&gb) & 0x40;
200		✗	backward = bytestream2_peek_byte(&gb) & 0x80;
201		✗	bytestream2_skip(&gb, 1);
202		✗	swap = bytestream2_peek_byte(&gb) & 0x01;
203		✗	offset = bytestream2_get_le16(&gb);
204		✗	offset = (offset >> 1) & 0x7FFF;
205		✗	offset = writeoffset + (offset * 2) - 0x8000;
206
207		✗	left = count;
208
209		✗	if (!backward && offset + 2*count > hnm->width * hnm->height) {
210		✗	av_log(avctx, AV_LOG_ERROR, "Attempting to read out of bounds\n");
211		✗	return AVERROR_INVALIDDATA;
212		✗	} else if (backward && offset + 1 >= hnm->width * hnm->height) {
213		✗	av_log(avctx, AV_LOG_ERROR, "Attempting to read out of bounds\n");
214		✗	return AVERROR_INVALIDDATA;
215		✗	} else if (writeoffset + 2*count > hnm->width * hnm->height) {
216		✗	av_log(avctx, AV_LOG_ERROR,
217			"Attempting to write out of bounds\n");
218		✗	return AVERROR_INVALIDDATA;
219
220			}
221		✗	if(backward) {
222		✗	if (offset < (!!backline)*(2 * hnm->width - 1) + 2*(left-1)) {
223		✗	av_log(avctx, AV_LOG_ERROR, "Attempting to read out of bounds\n");
224		✗	return AVERROR_INVALIDDATA;
225			}
226			} else {
227		✗	if (offset < (!!backline)*(2 * hnm->width - 1)) {
228		✗	av_log(avctx, AV_LOG_ERROR, "Attempting to read out of bounds\n");
229		✗	return AVERROR_INVALIDDATA;
230			}
231			}
232
233		✗	if (previous) {
234		✗	while (left > 0) {
235		✗	if (backline) {
236		✗	hnm->current[writeoffset++] = hnm->previous[offset - (2 * hnm->width) + 1];
237		✗	hnm->current[writeoffset++] = hnm->previous[offset++];
238		✗	offset++;
239			} else {
240		✗	hnm->current[writeoffset++] = hnm->previous[offset++];
241		✗	hnm->current[writeoffset++] = hnm->previous[offset++];
242			}
243		✗	if (backward)
244		✗	offset -= 4;
245		✗	left--;
246			}
247			} else {
248		✗	while (left > 0) {
249		✗	if (backline) {
250		✗	hnm->current[writeoffset++] = hnm->current[offset - (2 * hnm->width) + 1];
251		✗	hnm->current[writeoffset++] = hnm->current[offset++];
252		✗	offset++;
253			} else {
254		✗	hnm->current[writeoffset++] = hnm->current[offset++];
255		✗	hnm->current[writeoffset++] = hnm->current[offset++];
256			}
257		✗	if (backward)
258		✗	offset -= 4;
259		✗	left--;
260			}
261			}
262
263		✗	if (swap) {
264		✗	left = count;
265		✗	writeoffset -= count * 2;
266		✗	while (left > 0) {
267		✗	swap = hnm->current[writeoffset];
268		✗	hnm->current[writeoffset] = hnm->current[writeoffset + 1];
269		✗	hnm->current[writeoffset + 1] = swap;
270		✗	left--;
271		✗	writeoffset += 2;
272			}
273			}
274			}
275			}
276		✗	return 0;
277			}
278
279		✗	static void decode_interframe_v4a(AVCodecContext *avctx, const uint8_t *src,
280			uint32_t size)
281			{
282		✗	Hnm4VideoContext *hnm = avctx->priv_data;
283			GetByteContext gb;
284		✗	uint32_t writeoffset = 0, offset;
285			uint8_t tag, count, previous, delta;
286
287		✗	bytestream2_init(&gb, src, size);
288
289		✗	while (bytestream2_tell(&gb) < size) {
290		✗	count = bytestream2_peek_byte(&gb) & 0x3F;
291		✗	if (count == 0) {
292		✗	tag = bytestream2_get_byte(&gb) & 0xC0;
293		✗	tag = tag >> 6;
294		✗	if (tag == 0) {
295		✗	writeoffset += bytestream2_get_byte(&gb);
296		✗	} else if (tag == 1) {
297		✗	if (writeoffset + hnm->width >= hnm->width * hnm->height) {
298		✗	av_log(avctx, AV_LOG_ERROR, "writeoffset out of bounds\n");
299		✗	break;
300			}
301		✗	hnm->current[writeoffset] = bytestream2_get_byte(&gb);
302		✗	hnm->current[writeoffset + hnm->width] = bytestream2_get_byte(&gb);
303		✗	writeoffset++;
304		✗	} else if (tag == 2) {
305		✗	writeoffset += hnm->width;
306		✗	} else if (tag == 3) {
307		✗	break;
308			}
309		✗	if (writeoffset > hnm->width * hnm->height) {
310		✗	av_log(avctx, AV_LOG_ERROR, "writeoffset out of bounds\n");
311		✗	break;
312			}
313			} else {
314		✗	delta = bytestream2_peek_byte(&gb) & 0x80;
315		✗	previous = bytestream2_peek_byte(&gb) & 0x40;
316		✗	bytestream2_skip(&gb, 1);
317
318		✗	offset = writeoffset;
319		✗	offset += bytestream2_get_le16(&gb);
320
321		✗	if (delta) {
322		✗	if (offset < 0x10000) {
323		✗	av_log(avctx, AV_LOG_ERROR, "Attempting to read out of bounds\n");
324		✗	break;
325			}
326		✗	offset -= 0x10000;
327			}
328
329		✗	if (offset + hnm->width + count >= hnm->width * hnm->height) {
330		✗	av_log(avctx, AV_LOG_ERROR, "Attempting to read out of bounds\n");
331		✗	break;
332		✗	} else if (writeoffset + hnm->width + count >= hnm->width * hnm->height) {
333		✗	av_log(avctx, AV_LOG_ERROR, "Attempting to write out of bounds\n");
334		✗	break;
335			}
336
337		✗	if (previous) {
338		✗	while (count > 0) {
339		✗	hnm->current[writeoffset] = hnm->previous[offset];
340		✗	hnm->current[writeoffset + hnm->width] = hnm->previous[offset + hnm->width];
341		✗	writeoffset++;
342		✗	offset++;
343		✗	count--;
344			}
345			} else {
346		✗	while (count > 0) {
347		✗	hnm->current[writeoffset] = hnm->current[offset];
348		✗	hnm->current[writeoffset + hnm->width] = hnm->current[offset + hnm->width];
349		✗	writeoffset++;
350		✗	offset++;
351		✗	count--;
352			}
353			}
354			}
355			}
356		✗	}
357
358		✗	static void hnm_update_palette(AVCodecContext *avctx, const uint8_t *src,
359			uint32_t size)
360			{
361		✗	Hnm4VideoContext *hnm = avctx->priv_data;
362			GetByteContext gb;
363			uint8_t start, writeoffset;
364			uint16_t count;
365			int eight_bit_colors;
366
367		✗	eight_bit_colors = src[7] & 0x80 && hnm->version == 0x4a;
368
369			// skip first 8 bytes
370		✗	bytestream2_init(&gb, src + 8, size - 8);
371
372		✗	while (bytestream2_tell(&gb) < size - 8) {
373		✗	start = bytestream2_get_byte(&gb);
374		✗	count = bytestream2_get_byte(&gb);
375		✗	if (start == 255 && count == 255)
376		✗	break;
377		✗	if (count == 0)
378		✗	count = 256;
379		✗	writeoffset = start;
380		✗	while (count > 0) {
381		✗	hnm->palette[writeoffset] = bytestream2_get_be24(&gb);
382		✗	if (!eight_bit_colors)
383		✗	hnm->palette[writeoffset] <<= 2;
384		✗	hnm->palette[writeoffset] |= (0xFFU << 24);
385		✗	count--;
386		✗	writeoffset++;
387			}
388			}
389		✗	}
390
391		✗	static int hnm_decode_frame(AVCodecContext *avctx, AVFrame *frame,
392			int *got_frame, AVPacket *avpkt)
393			{
394		✗	Hnm4VideoContext *hnm = avctx->priv_data;
395			int ret;
396			uint16_t chunk_id;
397
398		✗	if (avpkt->size < 8) {
399		✗	av_log(avctx, AV_LOG_ERROR, "packet too small\n");
400		✗	return AVERROR_INVALIDDATA;
401			}
402
403		✗	chunk_id = AV_RL16(avpkt->data + 4);
404
405		✗	if (chunk_id == HNM4_CHUNK_ID_PL) {
406		✗	hnm_update_palette(avctx, avpkt->data, avpkt->size);
407		✗	} else if (chunk_id == HNM4_CHUNK_ID_IZ) {
408		✗	if (avpkt->size < 12) {
409		✗	av_log(avctx, AV_LOG_ERROR, "packet too small\n");
410		✗	return AVERROR_INVALIDDATA;
411			}
412		✗	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
413		✗	return ret;
414
415		✗	unpack_intraframe(avctx, avpkt->data + 12, avpkt->size - 12);
416		✗	memcpy(hnm->previous, hnm->current, hnm->width * hnm->height);
417		✗	if (hnm->version == 0x4a)
418		✗	memcpy(hnm->processed, hnm->current, hnm->width * hnm->height);
419			else
420		✗	postprocess_current_frame(avctx);
421		✗	copy_processed_frame(avctx, frame);
422		✗	frame->pict_type = AV_PICTURE_TYPE_I;
423		✗	frame->flags |= AV_FRAME_FLAG_KEY;
424		✗	memcpy(frame->data[1], hnm->palette, 256 * 4);
425		✗	*got_frame = 1;
426		✗	} else if (chunk_id == HNM4_CHUNK_ID_IU) {
427		✗	if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
428		✗	return ret;
429
430		✗	if (hnm->version == 0x4a) {
431		✗	decode_interframe_v4a(avctx, avpkt->data + 8, avpkt->size - 8);
432		✗	memcpy(hnm->processed, hnm->current, hnm->width * hnm->height);
433			} else {
434		✗	int ret = decode_interframe_v4(avctx, avpkt->data + 8, avpkt->size - 8);
435		✗	if (ret < 0)
436		✗	return ret;
437		✗	postprocess_current_frame(avctx);
438			}
439		✗	copy_processed_frame(avctx, frame);
440		✗	frame->pict_type = AV_PICTURE_TYPE_P;
441		✗	frame->flags &= ~AV_FRAME_FLAG_KEY;
442		✗	memcpy(frame->data[1], hnm->palette, 256 * 4);
443		✗	*got_frame = 1;
444		✗	FFSWAP(uint8_t *, hnm->current, hnm->previous);
445			} else {
446		✗	av_log(avctx, AV_LOG_ERROR, "invalid chunk id: %d\n", chunk_id);
447		✗	return AVERROR_INVALIDDATA;
448			}
449
450		✗	return avpkt->size;
451			}
452
453		✗	static av_cold int hnm_decode_init(AVCodecContext *avctx)
454			{
455		✗	Hnm4VideoContext *hnm = avctx->priv_data;
456			int ret;
457
458		✗	if (avctx->extradata_size < 1) {
459		✗	av_log(avctx, AV_LOG_ERROR,
460			"Extradata missing, decoder requires version number\n");
461		✗	return AVERROR_INVALIDDATA;
462			}
463
464		✗	ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
465		✗	if (ret < 0)
466		✗	return ret;
467		✗	if (avctx->height & 1)
468		✗	return AVERROR(EINVAL);
469
470		✗	hnm->version = avctx->extradata[0];
471		✗	avctx->pix_fmt = AV_PIX_FMT_PAL8;
472		✗	hnm->width = avctx->width;
473		✗	hnm->height = avctx->height;
474		✗	hnm->buffer1 = av_mallocz(avctx->width * avctx->height);
475		✗	hnm->buffer2 = av_mallocz(avctx->width * avctx->height);
476		✗	hnm->processed = av_mallocz(avctx->width * avctx->height);
477
478		✗	if (!hnm->buffer1 || !hnm->buffer2 || !hnm->processed) {
479		✗	av_log(avctx, AV_LOG_ERROR, "av_mallocz() failed\n");
480		✗	return AVERROR(ENOMEM);
481			}
482
483		✗	hnm->current = hnm->buffer1;
484		✗	hnm->previous = hnm->buffer2;
485
486		✗	return 0;
487			}
488
489		✗	static av_cold int hnm_decode_end(AVCodecContext *avctx)
490			{
491		✗	Hnm4VideoContext *hnm = avctx->priv_data;
492
493		✗	av_freep(&hnm->buffer1);
494		✗	av_freep(&hnm->buffer2);
495		✗	av_freep(&hnm->processed);
496
497		✗	return 0;
498			}
499
500			const FFCodec ff_hnm4_video_decoder = {
501			.p.name = "hnm4video",
502			CODEC_LONG_NAME("HNM 4 video"),
503			.p.type = AVMEDIA_TYPE_VIDEO,
504			.p.id = AV_CODEC_ID_HNM4_VIDEO,
505			.priv_data_size = sizeof(Hnm4VideoContext),
506			.init = hnm_decode_init,
507			.close = hnm_decode_end,
508			FF_CODEC_DECODE_CB(hnm_decode_frame),
509			.p.capabilities = AV_CODEC_CAP_DR1,
510			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
511			};
512