FFmpeg coverage

Line	Branch	Exec	Source
1			/*
2			* RemotelyAnywhere Screen Capture decoder
3			*
4			* Copyright (c) 2018 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			#include <stdio.h>
24			#include <string.h>
25
26			#include "libavutil/mem.h"
27			#include "libavutil/opt.h"
28
29			#include "avcodec.h"
30			#include "bytestream.h"
31			#include "codec_internal.h"
32			#include "decode.h"
33			#include "zlib_wrapper.h"
34
35			#include <zlib.h>
36
37			#define KBND MKTAG('K', 'B', 'N', 'D')
38			#define FINT MKTAG('F', 'I', 'N', 'T')
39			#define INIT MKTAG('I', 'N', 'I', 'T')
40			#define BNDL MKTAG('B', 'N', 'D', 'L')
41			#define KFRM MKTAG('K', 'F', 'R', 'M')
42			#define DLTA MKTAG('D', 'L', 'T', 'A')
43			#define MOUS MKTAG('M', 'O', 'U', 'S')
44			#define MPOS MKTAG('M', 'P', 'O', 'S')
45			#define MOVE MKTAG('M', 'O', 'V', 'E')
46			#define EMPT MKTAG('E', 'M', 'P', 'T')
47
48			typedef struct RASCContext {
49			AVClass *class;
50			int skip_cursor;
51			GetByteContext gb;
52			uint8_t *delta;
53			int delta_size;
54			uint8_t *cursor;
55			int cursor_size;
56			unsigned cursor_w;
57			unsigned cursor_h;
58			unsigned cursor_x;
59			unsigned cursor_y;
60			int stride;
61			int bpp;
62			AVFrame *frame;
63			AVFrame *frame1;
64			AVFrame *frame2;
65			FFZStream zstream;
66			} RASCContext;
67
68		✗	static void clear_plane(AVCodecContext *avctx, AVFrame *frame)
69			{
70		✗	RASCContext *s = avctx->priv_data;
71		✗	uint8_t *dst = frame->data[0];
72
73		✗	if (!dst)
74		✗	return;
75
76		✗	for (int y = 0; y < avctx->height; y++) {
77		✗	memset(dst, 0, avctx->width * s->bpp);
78		✗	dst += frame->linesize[0];
79			}
80			}
81
82		✗	static void copy_plane(AVCodecContext *avctx, AVFrame *src, AVFrame *dst)
83			{
84		✗	RASCContext *s = avctx->priv_data;
85		✗	uint8_t *srcp = src->data[0];
86		✗	uint8_t *dstp = dst->data[0];
87
88		✗	for (int y = 0; y < avctx->height; y++) {
89		✗	memcpy(dstp, srcp, s->stride);
90		✗	srcp += src->linesize[0];
91		✗	dstp += dst->linesize[0];
92			}
93		✗	}
94
95		✗	static int init_frames(AVCodecContext *avctx)
96			{
97		✗	RASCContext *s = avctx->priv_data;
98			int ret;
99
100		✗	av_frame_unref(s->frame1);
101		✗	av_frame_unref(s->frame2);
102		✗	if ((ret = ff_get_buffer(avctx, s->frame1, 0)) < 0)
103		✗	return ret;
104
105		✗	if ((ret = ff_get_buffer(avctx, s->frame2, 0)) < 0)
106		✗	return ret;
107
108		✗	clear_plane(avctx, s->frame2);
109		✗	clear_plane(avctx, s->frame1);
110
111		✗	return 0;
112			}
113
114		✗	static int decode_fint(AVCodecContext *avctx,
115			const AVPacket *avpkt, unsigned size)
116			{
117		✗	RASCContext *s = avctx->priv_data;
118		✗	GetByteContext *gb = &s->gb;
119			unsigned w, h, fmt;
120			int ret;
121
122		✗	if (bytestream2_peek_le32(gb) != 0x65) {
123		✗	if (!s->frame2->data[0] || !s->frame1->data[0])
124		✗	return AVERROR_INVALIDDATA;
125
126		✗	clear_plane(avctx, s->frame2);
127		✗	clear_plane(avctx, s->frame1);
128		✗	return 0;
129			}
130		✗	if (bytestream2_get_bytes_left(gb) < 72)
131		✗	return AVERROR_INVALIDDATA;
132
133		✗	bytestream2_skip(gb, 8);
134		✗	w = bytestream2_get_le32(gb);
135		✗	h = bytestream2_get_le32(gb);
136		✗	bytestream2_skip(gb, 30);
137		✗	fmt = bytestream2_get_le16(gb);
138		✗	bytestream2_skip(gb, 24);
139
140		✗	switch (fmt) {
141		✗	case 8: s->stride = FFALIGN(w, 4);
142		✗	s->bpp = 1;
143		✗	fmt = AV_PIX_FMT_PAL8; break;
144		✗	case 16: s->stride = w * 2;
145		✗	s->bpp = 2;
146		✗	fmt = AV_PIX_FMT_RGB555LE; break;
147		✗	case 32: s->stride = w * 4;
148		✗	s->bpp = 4;
149		✗	fmt = AV_PIX_FMT_BGR0; break;
150		✗	default: return AVERROR_INVALIDDATA;
151			}
152
153		✗	ret = ff_set_dimensions(avctx, w, h);
154		✗	if (ret < 0)
155		✗	return ret;
156		✗	avctx->width = w;
157		✗	avctx->height = h;
158		✗	avctx->pix_fmt = fmt;
159
160		✗	ret = init_frames(avctx);
161		✗	if (ret < 0)
162		✗	return ret;
163
164		✗	if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
165		✗	uint32_t *pal = (uint32_t *)s->frame2->data[1];
166
167		✗	for (int i = 0; i < 256; i++)
168		✗	pal[i] = bytestream2_get_le32(gb) | 0xFF000000u;
169			}
170
171		✗	return 0;
172			}
173
174		✗	static int decode_zlib(AVCodecContext *avctx, const AVPacket *avpkt,
175			unsigned size, unsigned uncompressed_size)
176			{
177		✗	RASCContext *s = avctx->priv_data;
178		✗	z_stream *const zstream = &s->zstream.zstream;
179		✗	GetByteContext *gb = &s->gb;
180			int zret;
181
182		✗	zret = inflateReset(zstream);
183		✗	if (zret != Z_OK) {
184		✗	av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
185		✗	return AVERROR_EXTERNAL;
186			}
187
188		✗	av_fast_padded_malloc(&s->delta, &s->delta_size, uncompressed_size);
189		✗	if (!s->delta)
190		✗	return AVERROR(ENOMEM);
191
192		✗	zstream->next_in = avpkt->data + bytestream2_tell(gb);
193		✗	zstream->avail_in = FFMIN(size, bytestream2_get_bytes_left(gb));
194
195		✗	zstream->next_out = s->delta;
196		✗	zstream->avail_out = s->delta_size;
197
198		✗	zret = inflate(zstream, Z_FINISH);
199		✗	if (zret != Z_STREAM_END) {
200		✗	av_log(avctx, AV_LOG_ERROR,
201			"Inflate failed with return code: %d.\n", zret);
202		✗	return AVERROR_INVALIDDATA;
203			}
204
205		✗	return 0;
206			}
207
208		✗	static int decode_move(AVCodecContext *avctx,
209			const AVPacket *avpkt, unsigned size)
210			{
211		✗	RASCContext *s = avctx->priv_data;
212		✗	GetByteContext *gb = &s->gb;
213			GetByteContext mc;
214			unsigned pos, compression, nb_moves;
215			unsigned uncompressed_size;
216			int ret;
217
218		✗	pos = bytestream2_tell(gb);
219		✗	bytestream2_skip(gb, 8);
220		✗	nb_moves = bytestream2_get_le32(gb);
221		✗	bytestream2_skip(gb, 8);
222		✗	compression = bytestream2_get_le32(gb);
223
224		✗	if (nb_moves > INT32_MAX / 16 || nb_moves > avctx->width * avctx->height)
225		✗	return AVERROR_INVALIDDATA;
226
227		✗	uncompressed_size = 16 * nb_moves;
228
229		✗	if (compression == 1) {
230		✗	ret = decode_zlib(avctx, avpkt,
231		✗	size - (bytestream2_tell(gb) - pos),
232			uncompressed_size);
233		✗	if (ret < 0)
234		✗	return ret;
235		✗	bytestream2_init(&mc, s->delta, uncompressed_size);
236		✗	} else if (compression == 0) {
237		✗	bytestream2_init(&mc, avpkt->data + bytestream2_tell(gb),
238			bytestream2_get_bytes_left(gb));
239		✗	} else if (compression == 2) {
240		✗	avpriv_request_sample(avctx, "compression %d", compression);
241		✗	return AVERROR_PATCHWELCOME;
242			} else {
243		✗	return AVERROR_INVALIDDATA;
244			}
245
246		✗	if (bytestream2_get_bytes_left(&mc) < uncompressed_size)
247		✗	return AVERROR_INVALIDDATA;
248
249		✗	for (int i = 0; i < nb_moves; i++) {
250			int type, start_x, start_y, end_x, end_y, mov_x, mov_y;
251			uint8_t *e2, *b1, *b2;
252			int w, h;
253
254		✗	type = bytestream2_get_le16(&mc);
255		✗	start_x = bytestream2_get_le16(&mc);
256		✗	start_y = bytestream2_get_le16(&mc);
257		✗	end_x = bytestream2_get_le16(&mc);
258		✗	end_y = bytestream2_get_le16(&mc);
259		✗	mov_x = bytestream2_get_le16(&mc);
260		✗	mov_y = bytestream2_get_le16(&mc);
261		✗	bytestream2_skip(&mc, 2);
262
263		✗	if (start_x >= avctx->width || start_y >= avctx->height ||
264		✗	end_x >= avctx->width || end_y >= avctx->height ||
265		✗	mov_x >= avctx->width || mov_y >= avctx->height) {
266		✗	continue;
267			}
268
269		✗	if (start_x >= end_x || start_y >= end_y)
270		✗	continue;
271
272		✗	w = end_x - start_x;
273		✗	h = end_y - start_y;
274
275		✗	if (mov_x + w > avctx->width || mov_y + h > avctx->height)
276		✗	continue;
277
278		✗	if (!s->frame2->data[0] || !s->frame1->data[0])
279		✗	return AVERROR_INVALIDDATA;
280
281		✗	b1 = s->frame1->data[0] + s->frame1->linesize[0] * (start_y + h - 1) + start_x * s->bpp;
282		✗	b2 = s->frame2->data[0] + s->frame2->linesize[0] * (start_y + h - 1) + start_x * s->bpp;
283		✗	e2 = s->frame2->data[0] + s->frame2->linesize[0] * (mov_y + h - 1) + mov_x * s->bpp;
284
285		✗	if (type == 2) {
286		✗	for (int j = 0; j < h; j++) {
287		✗	memcpy(b1, b2, w * s->bpp);
288		✗	b1 -= s->frame1->linesize[0];
289		✗	b2 -= s->frame2->linesize[0];
290			}
291		✗	} else if (type == 1) {
292		✗	for (int j = 0; j < h; j++) {
293		✗	memset(b2, 0, w * s->bpp);
294		✗	b2 -= s->frame2->linesize[0];
295			}
296		✗	} else if (type == 0) {
297			uint8_t *buffer;
298
299		✗	av_fast_padded_malloc(&s->delta, &s->delta_size, w * h * s->bpp);
300		✗	buffer = s->delta;
301		✗	if (!buffer)
302		✗	return AVERROR(ENOMEM);
303
304		✗	for (int j = 0; j < h; j++) {
305		✗	memcpy(buffer + j * w * s->bpp, e2, w * s->bpp);
306		✗	e2 -= s->frame2->linesize[0];
307			}
308
309		✗	for (int j = 0; j < h; j++) {
310		✗	memcpy(b2, buffer + j * w * s->bpp, w * s->bpp);
311		✗	b2 -= s->frame2->linesize[0];
312			}
313			} else {
314		✗	return AVERROR_INVALIDDATA;
315			}
316			}
317
318		✗	bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
319
320		✗	return 0;
321			}
322
323			#define NEXT_LINE \
324			if (cx >= w * s->bpp) { \
325			cx = 0; \
326			cy--; \
327			b1 -= s->frame1->linesize[0]; \
328			b2 -= s->frame2->linesize[0]; \
329			} \
330			len--;
331
332		✗	static int decode_dlta(AVCodecContext *avctx,
333			const AVPacket *avpkt, unsigned size)
334			{
335		✗	RASCContext *s = avctx->priv_data;
336		✗	GetByteContext *gb = &s->gb;
337			GetByteContext dc;
338			unsigned uncompressed_size, pos;
339			unsigned x, y, w, h;
340			int ret, cx, cy, compression;
341			uint8_t *b1, *b2;
342
343		✗	pos = bytestream2_tell(gb);
344		✗	bytestream2_skip(gb, 12);
345		✗	uncompressed_size = bytestream2_get_le32(gb);
346		✗	x = bytestream2_get_le32(gb);
347		✗	y = bytestream2_get_le32(gb);
348		✗	w = bytestream2_get_le32(gb);
349		✗	h = bytestream2_get_le32(gb);
350
351		✗	if (x >= avctx->width || y >= avctx->height ||
352		✗	w > avctx->width || h > avctx->height)
353		✗	return AVERROR_INVALIDDATA;
354
355		✗	if (x + w > avctx->width || y + h > avctx->height)
356		✗	return AVERROR_INVALIDDATA;
357
358		✗	bytestream2_skip(gb, 4);
359		✗	compression = bytestream2_get_le32(gb);
360
361		✗	if (compression == 1) {
362		✗	if (w * h * s->bpp * 3 < uncompressed_size)
363		✗	return AVERROR_INVALIDDATA;
364		✗	ret = decode_zlib(avctx, avpkt, size, uncompressed_size);
365		✗	if (ret < 0)
366		✗	return ret;
367		✗	bytestream2_init(&dc, s->delta, uncompressed_size);
368		✗	} else if (compression == 0) {
369		✗	if (bytestream2_get_bytes_left(gb) < uncompressed_size)
370		✗	return AVERROR_INVALIDDATA;
371		✗	bytestream2_init(&dc, avpkt->data + bytestream2_tell(gb),
372			uncompressed_size);
373		✗	} else if (compression == 2) {
374		✗	avpriv_request_sample(avctx, "compression %d", compression);
375		✗	return AVERROR_PATCHWELCOME;
376			} else {
377		✗	return AVERROR_INVALIDDATA;
378			}
379
380		✗	if (!s->frame2->data[0] || !s->frame1->data[0])
381		✗	return AVERROR_INVALIDDATA;
382
383		✗	b1 = s->frame1->data[0] + s->frame1->linesize[0] * (int)(y + h - 1) + ((int)x) * s->bpp;
384		✗	b2 = s->frame2->data[0] + s->frame2->linesize[0] * (int)(y + h - 1) + ((int)x) * s->bpp;
385		✗	cx = 0, cy = h;
386		✗	while (bytestream2_get_bytes_left(&dc) > 0) {
387		✗	int type = bytestream2_get_byte(&dc);
388		✗	int len = bytestream2_get_byte(&dc);
389			unsigned fill;
390
391		✗	switch (type) {
392		✗	case 1:
393		✗	while (len > 0 && cy > 0) {
394		✗	cx++;
395		✗	NEXT_LINE
396			}
397		✗	break;
398		✗	case 2:
399		✗	while (len > 0 && cy > 0) {
400		✗	int v0 = b1[cx];
401		✗	int v1 = b2[cx];
402
403		✗	b2[cx] = v0;
404		✗	b1[cx] = v1;
405		✗	cx++;
406		✗	NEXT_LINE
407			}
408		✗	break;
409		✗	case 3:
410		✗	while (len > 0 && cy > 0) {
411		✗	fill = bytestream2_get_byte(&dc);
412		✗	b1[cx] = b2[cx];
413		✗	b2[cx] = fill;
414		✗	cx++;
415		✗	NEXT_LINE
416			}
417		✗	break;
418		✗	case 4:
419		✗	fill = bytestream2_get_byte(&dc);
420		✗	while (len > 0 && cy > 0) {
421		✗	AV_WL32(b1 + cx, AV_RL32(b2 + cx));
422		✗	AV_WL32(b2 + cx, fill);
423		✗	cx++;
424		✗	NEXT_LINE
425			}
426		✗	break;
427		✗	case 7:
428		✗	fill = bytestream2_get_le32(&dc);
429		✗	while (len > 0 && cy > 0) {
430		✗	AV_WL32(b1 + cx, AV_RL32(b2 + cx));
431		✗	AV_WL32(b2 + cx, fill);
432		✗	cx += 4;
433		✗	NEXT_LINE
434			}
435		✗	break;
436		✗	case 10:
437		✗	while (len > 0 && cy > 0) {
438		✗	cx += 4;
439		✗	NEXT_LINE
440			}
441		✗	break;
442		✗	case 12:
443		✗	while (len > 0 && cy > 0) {
444			unsigned v0, v1;
445
446		✗	v0 = AV_RL32(b2 + cx);
447		✗	v1 = AV_RL32(b1 + cx);
448		✗	AV_WL32(b2 + cx, v1);
449		✗	AV_WL32(b1 + cx, v0);
450		✗	cx += 4;
451		✗	NEXT_LINE
452			}
453		✗	break;
454		✗	case 13:
455		✗	while (len > 0 && cy > 0) {
456		✗	fill = bytestream2_get_le32(&dc);
457		✗	AV_WL32(b1 + cx, AV_RL32(b2 + cx));
458		✗	AV_WL32(b2 + cx, fill);
459		✗	cx += 4;
460		✗	NEXT_LINE
461			}
462		✗	break;
463		✗	default:
464		✗	avpriv_request_sample(avctx, "runlen %d", type);
465		✗	return AVERROR_INVALIDDATA;
466			}
467			}
468
469		✗	bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
470
471		✗	return 0;
472			}
473
474		✗	static int decode_kfrm(AVCodecContext *avctx,
475			const AVPacket *avpkt, unsigned size)
476			{
477		✗	RASCContext *s = avctx->priv_data;
478		✗	z_stream *const zstream = &s->zstream.zstream;
479		✗	GetByteContext *gb = &s->gb;
480			uint8_t *dst;
481			unsigned pos;
482			int zret, ret;
483
484		✗	pos = bytestream2_tell(gb);
485		✗	if (bytestream2_peek_le32(gb) == 0x65) {
486		✗	ret = decode_fint(avctx, avpkt, size);
487		✗	if (ret < 0)
488		✗	return ret;
489			}
490
491		✗	if (!s->frame2->data[0])
492		✗	return AVERROR_INVALIDDATA;
493
494		✗	zret = inflateReset(zstream);
495		✗	if (zret != Z_OK) {
496		✗	av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
497		✗	return AVERROR_EXTERNAL;
498			}
499
500		✗	zstream->next_in = avpkt->data + bytestream2_tell(gb);
501		✗	zstream->avail_in = bytestream2_get_bytes_left(gb);
502
503		✗	dst = s->frame2->data[0] + (avctx->height - 1) * s->frame2->linesize[0];
504		✗	for (int i = 0; i < avctx->height; i++) {
505		✗	zstream->next_out = dst;
506		✗	zstream->avail_out = s->stride;
507
508		✗	zret = inflate(zstream, Z_SYNC_FLUSH);
509		✗	if (zret != Z_OK && zret != Z_STREAM_END) {
510		✗	av_log(avctx, AV_LOG_ERROR,
511			"Inflate failed with return code: %d.\n", zret);
512		✗	return AVERROR_INVALIDDATA;
513			}
514
515		✗	dst -= s->frame2->linesize[0];
516			}
517
518		✗	dst = s->frame1->data[0] + (avctx->height - 1) * s->frame1->linesize[0];
519		✗	for (int i = 0; i < avctx->height; i++) {
520		✗	zstream->next_out = dst;
521		✗	zstream->avail_out = s->stride;
522
523		✗	zret = inflate(zstream, Z_SYNC_FLUSH);
524		✗	if (zret != Z_OK && zret != Z_STREAM_END) {
525		✗	av_log(avctx, AV_LOG_ERROR,
526			"Inflate failed with return code: %d.\n", zret);
527		✗	return AVERROR_INVALIDDATA;
528			}
529
530		✗	dst -= s->frame1->linesize[0];
531			}
532
533		✗	bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
534
535		✗	return 0;
536			}
537
538		✗	static int decode_mous(AVCodecContext *avctx,
539			const AVPacket *avpkt, unsigned size)
540			{
541		✗	RASCContext *s = avctx->priv_data;
542		✗	GetByteContext *gb = &s->gb;
543			unsigned w, h, pos, uncompressed_size;
544			int ret;
545
546		✗	pos = bytestream2_tell(gb);
547		✗	bytestream2_skip(gb, 8);
548		✗	w = bytestream2_get_le32(gb);
549		✗	h = bytestream2_get_le32(gb);
550		✗	bytestream2_skip(gb, 12);
551		✗	uncompressed_size = bytestream2_get_le32(gb);
552
553		✗	if (w > avctx->width || h > avctx->height)
554		✗	return AVERROR_INVALIDDATA;
555
556		✗	if (uncompressed_size != 3 * w * h)
557		✗	return AVERROR_INVALIDDATA;
558
559		✗	av_fast_padded_malloc(&s->cursor, &s->cursor_size, uncompressed_size);
560		✗	if (!s->cursor)
561		✗	return AVERROR(ENOMEM);
562
563		✗	ret = decode_zlib(avctx, avpkt,
564		✗	size - (bytestream2_tell(gb) - pos),
565			uncompressed_size);
566		✗	if (ret < 0)
567		✗	return ret;
568		✗	memcpy(s->cursor, s->delta, uncompressed_size);
569
570		✗	bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
571
572		✗	s->cursor_w = w;
573		✗	s->cursor_h = h;
574
575		✗	return 0;
576			}
577
578		✗	static int decode_mpos(AVCodecContext *avctx,
579			const AVPacket *avpkt, unsigned size)
580			{
581		✗	RASCContext *s = avctx->priv_data;
582		✗	GetByteContext *gb = &s->gb;
583			unsigned pos;
584
585		✗	pos = bytestream2_tell(gb);
586		✗	bytestream2_skip(gb, 8);
587		✗	s->cursor_x = bytestream2_get_le32(gb);
588		✗	s->cursor_y = bytestream2_get_le32(gb);
589
590		✗	bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
591
592		✗	return 0;
593			}
594
595		✗	static void draw_cursor(AVCodecContext *avctx)
596			{
597		✗	RASCContext *s = avctx->priv_data;
598			uint8_t *dst, *pal;
599
600		✗	if (!s->cursor)
601		✗	return;
602
603		✗	if (s->cursor_x >= avctx->width || s->cursor_y >= avctx->height)
604		✗	return;
605
606		✗	if (s->cursor_x + s->cursor_w > avctx->width ||
607		✗	s->cursor_y + s->cursor_h > avctx->height)
608		✗	return;
609
610		✗	if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
611		✗	pal = s->frame->data[1];
612		✗	for (int i = 0; i < s->cursor_h; i++) {
613		✗	for (int j = 0; j < s->cursor_w; j++) {
614		✗	int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
615		✗	int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
616		✗	int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
617		✗	int best = INT_MAX;
618		✗	int index = 0;
619			int dist;
620
621		✗	if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
622		✗	continue;
623
624		✗	dst = s->frame->data[0] + s->frame->linesize[0] * (int)(s->cursor_y + i) + (int)(s->cursor_x + j);
625		✗	for (int k = 0; k < 256; k++) {
626		✗	int pr = pal[k * 4 + 0];
627		✗	int pg = pal[k * 4 + 1];
628		✗	int pb = pal[k * 4 + 2];
629
630		✗	dist = FFABS(cr - pr) + FFABS(cg - pg) + FFABS(cb - pb);
631		✗	if (dist < best) {
632		✗	best = dist;
633		✗	index = k;
634			}
635			}
636		✗	dst[0] = index;
637			}
638			}
639		✗	} else if (avctx->pix_fmt == AV_PIX_FMT_RGB555LE) {
640		✗	for (int i = 0; i < s->cursor_h; i++) {
641		✗	for (int j = 0; j < s->cursor_w; j++) {
642		✗	int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
643		✗	int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
644		✗	int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
645
646		✗	if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
647		✗	continue;
648
649		✗	cr >>= 3; cg >>=3; cb >>= 3;
650		✗	dst = s->frame->data[0] + s->frame->linesize[0] * (int)(s->cursor_y + i) + 2 * (s->cursor_x + j);
651		✗	AV_WL16(dst, cr | cg << 5 | cb << 10);
652			}
653			}
654		✗	} else if (avctx->pix_fmt == AV_PIX_FMT_BGR0) {
655		✗	for (int i = 0; i < s->cursor_h; i++) {
656		✗	for (int j = 0; j < s->cursor_w; j++) {
657		✗	int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
658		✗	int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
659		✗	int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
660
661		✗	if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
662		✗	continue;
663
664		✗	dst = s->frame->data[0] + s->frame->linesize[0] * (int)(s->cursor_y + i) + 4 * (s->cursor_x + j);
665		✗	dst[0] = cb;
666		✗	dst[1] = cg;
667		✗	dst[2] = cr;
668			}
669			}
670			}
671			}
672
673		✗	static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
674			int *got_frame, AVPacket *avpkt)
675			{
676		✗	RASCContext *s = avctx->priv_data;
677		✗	GetByteContext *gb = &s->gb;
678		✗	int ret, intra = 0;
679
680		✗	bytestream2_init(gb, avpkt->data, avpkt->size);
681
682		✗	if (bytestream2_peek_le32(gb) == EMPT)
683		✗	return avpkt->size;
684
685		✗	s->frame = frame;
686
687		✗	while (bytestream2_get_bytes_left(gb) > 0) {
688		✗	unsigned type, size = 0;
689
690		✗	if (bytestream2_get_bytes_left(gb) < 8)
691		✗	return AVERROR_INVALIDDATA;
692
693		✗	type = bytestream2_get_le32(gb);
694		✗	if (type == KBND || type == BNDL) {
695		✗	intra = type == KBND;
696		✗	type = bytestream2_get_le32(gb);
697			}
698
699		✗	size = bytestream2_get_le32(gb);
700		✗	if (bytestream2_get_bytes_left(gb) < size)
701		✗	return AVERROR_INVALIDDATA;
702
703		✗	switch (type) {
704		✗	case FINT:
705			case INIT:
706		✗	ret = decode_fint(avctx, avpkt, size);
707		✗	break;
708		✗	case KFRM:
709		✗	ret = decode_kfrm(avctx, avpkt, size);
710		✗	break;
711		✗	case DLTA:
712		✗	ret = decode_dlta(avctx, avpkt, size);
713		✗	break;
714		✗	case MOVE:
715		✗	ret = decode_move(avctx, avpkt, size);
716		✗	break;
717		✗	case MOUS:
718		✗	ret = decode_mous(avctx, avpkt, size);
719		✗	break;
720		✗	case MPOS:
721		✗	ret = decode_mpos(avctx, avpkt, size);
722		✗	break;
723		✗	default:
724		✗	bytestream2_skip(gb, size);
725		✗	ret = 0;
726			}
727
728		✗	if (ret < 0)
729		✗	return ret;
730			}
731
732		✗	if (!s->frame2->data[0] || !s->frame1->data[0])
733		✗	return AVERROR_INVALIDDATA;
734
735		✗	if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
736		✗	return ret;
737
738		✗	copy_plane(avctx, s->frame2, s->frame);
739		✗	if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
740		✗	memcpy(s->frame->data[1], s->frame2->data[1], 1024);
741		✗	if (!s->skip_cursor)
742		✗	draw_cursor(avctx);
743
744		✗	if (intra)
745		✗	s->frame->flags |= AV_FRAME_FLAG_KEY;
746			else
747		✗	s->frame->flags &= ~AV_FRAME_FLAG_KEY;
748		✗	s->frame->pict_type = intra ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
749
750		✗	*got_frame = 1;
751
752		✗	return avpkt->size;
753			}
754
755		✗	static av_cold int decode_init(AVCodecContext *avctx)
756			{
757		✗	RASCContext *s = avctx->priv_data;
758
759		✗	s->frame1 = av_frame_alloc();
760		✗	s->frame2 = av_frame_alloc();
761		✗	if (!s->frame1 || !s->frame2)
762		✗	return AVERROR(ENOMEM);
763
764		✗	return ff_inflate_init(&s->zstream, avctx);
765			}
766
767		✗	static av_cold int decode_close(AVCodecContext *avctx)
768			{
769		✗	RASCContext *s = avctx->priv_data;
770
771		✗	av_freep(&s->cursor);
772		✗	s->cursor_size = 0;
773		✗	av_freep(&s->delta);
774		✗	s->delta_size = 0;
775		✗	av_frame_free(&s->frame1);
776		✗	av_frame_free(&s->frame2);
777		✗	ff_inflate_end(&s->zstream);
778
779		✗	return 0;
780			}
781
782		✗	static void decode_flush(AVCodecContext *avctx)
783			{
784		✗	RASCContext *s = avctx->priv_data;
785
786		✗	clear_plane(avctx, s->frame1);
787		✗	clear_plane(avctx, s->frame2);
788		✗	}
789
790			static const AVOption options[] = {
791			{ "skip_cursor", "skip the cursor", offsetof(RASCContext, skip_cursor), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM },
792			{ NULL },
793			};
794
795			static const AVClass rasc_decoder_class = {
796			.class_name = "rasc decoder",
797			.item_name = av_default_item_name,
798			.option = options,
799			.version = LIBAVUTIL_VERSION_INT,
800			};
801
802			const FFCodec ff_rasc_decoder = {
803			.p.name = "rasc",
804			CODEC_LONG_NAME("RemotelyAnywhere Screen Capture"),
805			.p.type = AVMEDIA_TYPE_VIDEO,
806			.p.id = AV_CODEC_ID_RASC,
807			.priv_data_size = sizeof(RASCContext),
808			.init = decode_init,
809			.close = decode_close,
810			FF_CODEC_DECODE_CB(decode_frame),
811			.flush = decode_flush,
812			.p.capabilities = AV_CODEC_CAP_DR1,
813			.caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
814			.p.priv_class = &rasc_decoder_class,
815			};
816