FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* CRI image decoder
3			*
4			* Copyright (c) 2020 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			/**
24			* @file
25			* Cintel RAW image decoder
26			*/
27
28			#define BITSTREAM_READER_LE
29
30			#include "libavutil/attributes_internal.h"
31			#include "libavutil/intfloat.h"
32			#include "libavutil/display.h"
33			#include "avcodec.h"
34			#include "bytestream.h"
35			#include "codec_internal.h"
36			#include "decode.h"
37			#include "get_bits.h"
38			#include "thread.h"
39
40			typedef struct CRIContext {
41			AVCodecContext *jpeg_avctx; // wrapper context for MJPEG
42			AVPacket *jpkt; // encoded JPEG tile
43			AVFrame *jpgframe; // decoded JPEG tile
44
45			GetByteContext gb;
46			int color_model;
47			const uint8_t *data;
48			unsigned data_size;
49			uint64_t tile_size[4];
50			} CRIContext;
51
52		✗	static av_cold int cri_decode_init(AVCodecContext *avctx)
53			{
54		✗	CRIContext *s = avctx->priv_data;
55			int ret;
56
57		✗	s->jpgframe = av_frame_alloc();
58		✗	if (!s->jpgframe)
59		✗	return AVERROR(ENOMEM);
60
61		✗	s->jpkt = av_packet_alloc();
62		✗	if (!s->jpkt)
63		✗	return AVERROR(ENOMEM);
64
65			EXTERN const FFCodec ff_mjpeg_decoder;
66		✗	s->jpeg_avctx = avcodec_alloc_context3(&ff_mjpeg_decoder.p);
67		✗	if (!s->jpeg_avctx)
68		✗	return AVERROR(ENOMEM);
69		✗	s->jpeg_avctx->flags = avctx->flags;
70		✗	s->jpeg_avctx->flags2 = avctx->flags2;
71		✗	s->jpeg_avctx->idct_algo = avctx->idct_algo;
72		✗	ret = avcodec_open2(s->jpeg_avctx, NULL, NULL);
73		✗	if (ret < 0)
74		✗	return ret;
75
76		✗	return 0;
77			}
78
79		✗	static void unpack_10bit(GetByteContext *gb, uint16_t *dst, int shift,
80			int w, int h, ptrdiff_t stride)
81			{
82		✗	int count = w * h;
83		✗	int pos = 0;
84
85		✗	while (count > 0) {
86			uint32_t a0, a1, a2, a3;
87		✗	if (bytestream2_get_bytes_left(gb) < 4)
88		✗	break;
89		✗	a0 = bytestream2_get_le32(gb);
90		✗	a1 = bytestream2_get_le32(gb);
91		✗	a2 = bytestream2_get_le32(gb);
92		✗	a3 = bytestream2_get_le32(gb);
93		✗	dst[pos] = (((a0 >> 1) & 0xE00) | (a0 & 0x1FF)) << shift;
94		✗	pos++;
95		✗	if (pos >= w) {
96		✗	if (count == 1)
97		✗	break;
98		✗	dst += stride;
99		✗	pos = 0;
100			}
101		✗	dst[pos] = (((a0 >> 13) & 0x3F) | ((a0 >> 14) & 0xFC0)) << shift;
102		✗	pos++;
103		✗	if (pos >= w) {
104		✗	if (count == 2)
105		✗	break;
106		✗	dst += stride;
107		✗	pos = 0;
108			}
109		✗	dst[pos] = (((a0 >> 26) & 7) | ((a1 & 0x1FF) << 3)) << shift;
110		✗	pos++;
111		✗	if (pos >= w) {
112		✗	if (count == 3)
113		✗	break;
114		✗	dst += stride;
115		✗	pos = 0;
116			}
117		✗	dst[pos] = (((a1 >> 10) & 0x1FF) | ((a1 >> 11) & 0xE00)) << shift;
118		✗	pos++;
119		✗	if (pos >= w) {
120		✗	if (count == 4)
121		✗	break;
122		✗	dst += stride;
123		✗	pos = 0;
124			}
125		✗	dst[pos] = (((a1 >> 23) & 0x3F) | ((a2 & 0x3F) << 6)) << shift;
126		✗	pos++;
127		✗	if (pos >= w) {
128		✗	if (count == 5)
129		✗	break;
130		✗	dst += stride;
131		✗	pos = 0;
132			}
133		✗	dst[pos] = (((a2 >> 7) & 0xFF8) | ((a2 >> 6) & 7)) << shift;
134		✗	pos++;
135		✗	if (pos >= w) {
136		✗	if (count == 6)
137		✗	break;
138		✗	dst += stride;
139		✗	pos = 0;
140			}
141		✗	dst[pos] = (((a3 & 7) << 9) | ((a2 >> 20) & 0x1FF)) << shift;
142		✗	pos++;
143		✗	if (pos >= w) {
144		✗	if (count == 7)
145		✗	break;
146		✗	dst += stride;
147		✗	pos = 0;
148			}
149		✗	dst[pos] = (((a3 >> 4) & 0xFC0) | ((a3 >> 3) & 0x3F)) << shift;
150		✗	pos++;
151		✗	if (pos >= w) {
152		✗	if (count == 8)
153		✗	break;
154		✗	dst += stride;
155		✗	pos = 0;
156			}
157		✗	dst[pos] = (((a3 >> 16) & 7) | ((a3 >> 17) & 0xFF8)) << shift;
158		✗	pos++;
159		✗	if (pos >= w) {
160		✗	if (count == 9)
161		✗	break;
162		✗	dst += stride;
163		✗	pos = 0;
164			}
165
166		✗	count -= 9;
167			}
168		✗	}
169
170		✗	static int cri_decode_frame(AVCodecContext *avctx, AVFrame *p,
171			int *got_frame, AVPacket *avpkt)
172			{
173		✗	CRIContext *s = avctx->priv_data;
174		✗	GetByteContext *gb = &s->gb;
175		✗	int ret, bps, hflip = 0, vflip = 0;
176			AVFrameSideData *rotation;
177		✗	int compressed = 0;
178
179		✗	s->data = NULL;
180		✗	s->data_size = 0;
181
182		✗	bytestream2_init(gb, avpkt->data, avpkt->size);
183
184		✗	while (bytestream2_get_bytes_left(gb) > 8) {
185			char codec_name[1024];
186			uint32_t key, length;
187			float framerate;
188			int width, height;
189
190		✗	key = bytestream2_get_le32(gb);
191		✗	length = bytestream2_get_le32(gb);
192
193		✗	switch (key) {
194		✗	case 1:
195		✗	if (length != 4)
196		✗	return AVERROR_INVALIDDATA;
197
198		✗	if (bytestream2_get_le32(gb) != MKTAG('D', 'V', 'C', 'C'))
199		✗	return AVERROR_INVALIDDATA;
200		✗	break;
201		✗	case 100:
202		✗	if (length < 16)
203		✗	return AVERROR_INVALIDDATA;
204		✗	width = bytestream2_get_le32(gb);
205		✗	height = bytestream2_get_le32(gb);
206		✗	s->color_model = bytestream2_get_le32(gb);
207		✗	if (bytestream2_get_le32(gb) != 1)
208		✗	return AVERROR_INVALIDDATA;
209		✗	ret = ff_set_dimensions(avctx, width, height);
210		✗	if (ret < 0)
211		✗	return ret;
212		✗	length -= 16;
213		✗	goto skip;
214		✗	case 101:
215		✗	if (length != 4)
216		✗	return AVERROR_INVALIDDATA;
217
218		✗	if (bytestream2_get_le32(gb) != 0)
219		✗	return AVERROR_INVALIDDATA;
220		✗	break;
221		✗	case 102:
222		✗	bytestream2_get_buffer(gb, codec_name, FFMIN(length, sizeof(codec_name) - 1));
223		✗	length -= FFMIN(length, sizeof(codec_name) - 1);
224		✗	if (strncmp(codec_name, "cintel_craw", FFMIN(length, sizeof(codec_name) - 1)))
225		✗	return AVERROR_INVALIDDATA;
226		✗	compressed = 1;
227		✗	goto skip;
228		✗	case 103:
229		✗	if (bytestream2_get_bytes_left(gb) < length)
230		✗	return AVERROR_INVALIDDATA;
231		✗	s->data = gb->buffer;
232		✗	s->data_size = length;
233		✗	goto skip;
234		✗	case 105:
235		✗	if (length <= 0)
236		✗	return AVERROR_INVALIDDATA;
237		✗	hflip = bytestream2_get_byte(gb) != 0;
238		✗	length--;
239		✗	goto skip;
240		✗	case 106:
241		✗	if (length <= 0)
242		✗	return AVERROR_INVALIDDATA;
243		✗	vflip = bytestream2_get_byte(gb) != 0;
244		✗	length--;
245		✗	goto skip;
246		✗	case 107:
247		✗	if (length != 4)
248		✗	return AVERROR_INVALIDDATA;
249		✗	framerate = av_int2float(bytestream2_get_le32(gb));
250		✗	avctx->framerate.num = framerate * 1000;
251		✗	avctx->framerate.den = 1000;
252		✗	break;
253		✗	case 119:
254		✗	if (length != 32)
255		✗	return AVERROR_INVALIDDATA;
256
257		✗	for (int i = 0; i < 4; i++)
258		✗	s->tile_size[i] = bytestream2_get_le64(gb);
259		✗	break;
260		✗	default:
261		✗	av_log(avctx, AV_LOG_DEBUG, "skipping unknown key %u of length %u\n", key, length);
262		✗	skip:
263		✗	bytestream2_skip(gb, length);
264			}
265			}
266
267		✗	switch (s->color_model) {
268		✗	case 76:
269			case 88:
270		✗	avctx->pix_fmt = AV_PIX_FMT_BAYER_BGGR16;
271		✗	break;
272		✗	case 77:
273			case 89:
274		✗	avctx->pix_fmt = AV_PIX_FMT_BAYER_GBRG16;
275		✗	break;
276		✗	case 78:
277			case 90:
278		✗	avctx->pix_fmt = AV_PIX_FMT_BAYER_RGGB16;
279		✗	break;
280		✗	case 45:
281			case 79:
282			case 91:
283		✗	avctx->pix_fmt = AV_PIX_FMT_BAYER_GRBG16;
284		✗	break;
285			}
286
287		✗	switch (s->color_model) {
288		✗	case 45:
289		✗	bps = 10;
290		✗	break;
291		✗	case 76:
292			case 77:
293			case 78:
294			case 79:
295		✗	bps = 12;
296		✗	break;
297		✗	case 88:
298			case 89:
299			case 90:
300			case 91:
301		✗	bps = 16;
302		✗	break;
303		✗	default:
304		✗	return AVERROR_INVALIDDATA;
305			}
306
307		✗	if (compressed) {
308		✗	for (int i = 0; i < 4; i++) {
309		✗	if (s->tile_size[i] >= s->data_size)
310		✗	return AVERROR_INVALIDDATA;
311			}
312
313		✗	if (s->tile_size[0] + s->tile_size[1] + s->tile_size[2] + s->tile_size[3] !=
314		✗	s->data_size)
315		✗	return AVERROR_INVALIDDATA;
316			}
317
318		✗	if (!s->data || !s->data_size)
319		✗	return AVERROR_INVALIDDATA;
320
321		✗	if (avctx->skip_frame >= AVDISCARD_ALL)
322		✗	return avpkt->size;
323
324		✗	if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0)
325		✗	return ret;
326
327		✗	avctx->bits_per_raw_sample = bps;
328
329		✗	if (!compressed && s->color_model == 45) {
330		✗	uint16_t *dst = (uint16_t *)p->data[0];
331			GetByteContext gb;
332
333		✗	bytestream2_init(&gb, s->data, s->data_size);
334		✗	unpack_10bit(&gb, dst, 4, avctx->width, avctx->height, p->linesize[0] / 2);
335		✗	} else if (!compressed) {
336			GetBitContext gbit;
337		✗	const int shift = 16 - bps;
338
339		✗	ret = init_get_bits8(&gbit, s->data, s->data_size);
340		✗	if (ret < 0)
341		✗	return ret;
342
343		✗	for (int y = 0; y < avctx->height; y++) {
344		✗	uint16_t *dst = (uint16_t *)(p->data[0] + y * p->linesize[0]);
345
346		✗	if (get_bits_left(&gbit) < avctx->width * bps)
347		✗	break;
348
349		✗	for (int x = 0; x < avctx->width; x++)
350		✗	dst[x] = get_bits(&gbit, bps) << shift;
351			}
352			} else {
353		✗	unsigned offset = 0;
354
355		✗	for (int tile = 0; tile < 4; tile++) {
356		✗	av_packet_unref(s->jpkt);
357		✗	s->jpkt->data = (uint8_t *)s->data + offset;
358		✗	s->jpkt->size = s->tile_size[tile];
359
360		✗	ret = avcodec_send_packet(s->jpeg_avctx, s->jpkt);
361		✗	if (ret < 0) {
362		✗	av_log(avctx, AV_LOG_ERROR, "Error submitting a packet for decoding\n");
363		✗	return ret;
364			}
365
366		✗	ret = avcodec_receive_frame(s->jpeg_avctx, s->jpgframe);
367		✗	if (ret < 0 || s->jpgframe->format != AV_PIX_FMT_GRAY16 ||
368		✗	s->jpeg_avctx->width * 2 != avctx->width ||
369		✗	s->jpeg_avctx->height * 2 != avctx->height) {
370		✗	if (ret < 0) {
371		✗	av_log(avctx, AV_LOG_ERROR,
372			"JPEG decoding error (%d).\n", ret);
373			} else {
374		✗	av_log(avctx, AV_LOG_ERROR,
375			"JPEG invalid format.\n");
376		✗	ret = AVERROR_INVALIDDATA;
377			}
378
379			/* Normally skip, if error explode */
380		✗	if (avctx->err_recognition & AV_EF_EXPLODE)
381		✗	return ret;
382			else
383		✗	return 0;
384			}
385
386		✗	for (int y = 0; y < s->jpeg_avctx->height; y++) {
387		✗	const int hw = s->jpgframe->width / 2;
388		✗	uint16_t *dst = (uint16_t *)(p->data[0] + (y * 2) * p->linesize[0] + tile * hw * 2);
389		✗	const uint16_t *src = (const uint16_t *)(s->jpgframe->data[0] + y * s->jpgframe->linesize[0]);
390
391		✗	memcpy(dst, src, hw * 2);
392		✗	src += hw;
393		✗	dst += p->linesize[0] / 2;
394		✗	memcpy(dst, src, hw * 2);
395			}
396
397		✗	av_frame_unref(s->jpgframe);
398		✗	offset += s->tile_size[tile];
399			}
400			}
401
402		✗	if (hflip || vflip) {
403		✗	ff_frame_new_side_data(avctx, p, AV_FRAME_DATA_DISPLAYMATRIX,
404			sizeof(int32_t) * 9, &rotation);
405		✗	if (rotation) {
406		✗	av_display_rotation_set((int32_t *)rotation->data, 0.f);
407		✗	av_display_matrix_flip((int32_t *)rotation->data, hflip, vflip);
408			}
409			}
410
411		✗	*got_frame = 1;
412
413		✗	return 0;
414			}
415
416		✗	static av_cold int cri_decode_close(AVCodecContext *avctx)
417			{
418		✗	CRIContext *s = avctx->priv_data;
419
420		✗	av_frame_free(&s->jpgframe);
421		✗	av_packet_free(&s->jpkt);
422		✗	avcodec_free_context(&s->jpeg_avctx);
423
424		✗	return 0;
425			}
426
427			const FFCodec ff_cri_decoder = {
428			.p.name = "cri",
429			.p.type = AVMEDIA_TYPE_VIDEO,
430			.p.id = AV_CODEC_ID_CRI,
431			.priv_data_size = sizeof(CRIContext),
432			.init = cri_decode_init,
433			FF_CODEC_DECODE_CB(cri_decode_frame),
434			.close = cri_decode_close,
435			.p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
436			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
437			FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
438			CODEC_LONG_NAME("Cintel RAW"),
439			};
440