2 * RemotelyAnywhere Screen Capture decoder
4 * Copyright (c) 2018 Paul B Mahol
6 * This file is part of FFmpeg.
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.
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.
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
27 #include "libavutil/avassert.h"
28 #include "libavutil/imgutils.h"
29 #include "libavutil/opt.h"
32 #include "bytestream.h"
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')
48 typedef struct RASCContext {
68 static void clear_plane(AVCodecContext *avctx, AVFrame *frame)
70 RASCContext *s = avctx->priv_data;
71 uint8_t *dst = frame->data[0];
73 for (int y = 0; y < avctx->height; y++) {
74 memset(dst, 0, avctx->width * s->bpp);
75 dst += frame->linesize[0];
79 static void copy_plane(AVCodecContext *avctx, AVFrame *src, AVFrame *dst)
81 RASCContext *s = avctx->priv_data;
82 uint8_t *srcp = src->data[0];
83 uint8_t *dstp = dst->data[0];
85 for (int y = 0; y < avctx->height; y++) {
86 memcpy(dstp, srcp, s->stride);
87 srcp += src->linesize[0];
88 dstp += dst->linesize[0];
92 static int init_frames(AVCodecContext *avctx)
94 RASCContext *s = avctx->priv_data;
97 av_frame_unref(s->frame1);
98 if ((ret = ff_get_buffer(avctx, s->frame1, 0)) < 0)
101 av_frame_unref(s->frame2);
102 if ((ret = ff_get_buffer(avctx, s->frame2, 0)) < 0)
105 clear_plane(avctx, s->frame2);
106 clear_plane(avctx, s->frame1);
111 static int decode_fint(AVCodecContext *avctx,
112 AVPacket *avpkt, unsigned size)
114 RASCContext *s = avctx->priv_data;
115 GetByteContext *gb = &s->gb;
119 if (bytestream2_peek_le32(gb) != 0x65) {
120 if (!s->frame2->data[0] || !s->frame1->data[0])
121 return AVERROR_INVALIDDATA;
123 clear_plane(avctx, s->frame2);
124 clear_plane(avctx, s->frame1);
128 bytestream2_skip(gb, 8);
129 w = bytestream2_get_le32(gb);
130 h = bytestream2_get_le32(gb);
131 bytestream2_skip(gb, 30);
132 fmt = bytestream2_get_le16(gb);
133 bytestream2_skip(gb, 24);
136 case 8: s->stride = FFALIGN(w, 4);
138 fmt = AV_PIX_FMT_PAL8; break;
139 case 16: s->stride = w * 2;
141 fmt = AV_PIX_FMT_RGB555LE; break;
142 case 32: s->stride = w * 4;
144 fmt = AV_PIX_FMT_BGR0; break;
145 default: return AVERROR_INVALIDDATA;
148 ret = ff_set_dimensions(avctx, w, h);
153 avctx->pix_fmt = fmt;
155 ret = init_frames(avctx);
159 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
160 uint32_t *pal = (uint32_t *)s->frame2->data[1];
162 for (int i = 0; i < 256; i++)
163 pal[i] = bytestream2_get_le32(gb) | 0xFF000000u;
169 static int decode_zlib(AVCodecContext *avctx, AVPacket *avpkt,
170 unsigned size, unsigned uncompressed_size)
172 RASCContext *s = avctx->priv_data;
173 GetByteContext *gb = &s->gb;
176 zret = inflateReset(&s->zstream);
178 av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
179 return AVERROR_EXTERNAL;
182 av_fast_padded_malloc(&s->delta, &s->delta_size, uncompressed_size);
184 return AVERROR(ENOMEM);
186 s->zstream.next_in = avpkt->data + bytestream2_tell(gb);
187 s->zstream.avail_in = FFMIN(size, bytestream2_get_bytes_left(gb));
189 s->zstream.next_out = s->delta;
190 s->zstream.avail_out = s->delta_size;
192 zret = inflate(&s->zstream, Z_FINISH);
193 if (zret != Z_STREAM_END) {
194 av_log(avctx, AV_LOG_ERROR,
195 "Inflate failed with return code: %d.\n", zret);
196 return AVERROR_INVALIDDATA;
202 static int decode_move(AVCodecContext *avctx,
203 AVPacket *avpkt, unsigned size)
205 RASCContext *s = avctx->priv_data;
206 GetByteContext *gb = &s->gb;
208 unsigned pos, compression, nb_moves;
209 unsigned uncompressed_size;
212 pos = bytestream2_tell(gb);
213 bytestream2_skip(gb, 8);
214 nb_moves = bytestream2_get_le32(gb);
215 bytestream2_skip(gb, 8);
216 compression = bytestream2_get_le32(gb);
218 if (nb_moves > INT32_MAX / 16)
219 return AVERROR_INVALIDDATA;
221 uncompressed_size = 16 * nb_moves;
223 if (compression == 1) {
224 ret = decode_zlib(avctx, avpkt,
225 size - (bytestream2_tell(gb) - pos),
229 bytestream2_init(&mc, s->delta, uncompressed_size);
230 } else if (compression == 0) {
231 bytestream2_init(&mc, avpkt->data + bytestream2_tell(gb),
232 bytestream2_get_bytes_left(gb));
233 } else if (compression == 2) {
234 avpriv_request_sample(avctx, "compression %d", compression);
235 return AVERROR_PATCHWELCOME;
237 return AVERROR_INVALIDDATA;
240 if (bytestream2_get_bytes_left(&mc) < uncompressed_size)
241 return AVERROR_INVALIDDATA;
243 for (int i = 0; i < nb_moves; i++) {
244 int type, start_x, start_y, end_x, end_y, mov_x, mov_y;
245 uint8_t *e2, *b1, *b2;
248 type = bytestream2_get_le16(&mc);
249 start_x = bytestream2_get_le16(&mc);
250 start_y = bytestream2_get_le16(&mc);
251 end_x = bytestream2_get_le16(&mc);
252 end_y = bytestream2_get_le16(&mc);
253 mov_x = bytestream2_get_le16(&mc);
254 mov_y = bytestream2_get_le16(&mc);
255 bytestream2_skip(&mc, 2);
257 if (start_x >= avctx->width || start_y >= avctx->height ||
258 end_x >= avctx->width || end_y >= avctx->height ||
259 mov_x >= avctx->width || mov_y >= avctx->height) {
263 if (start_x >= end_x || start_y >= end_y)
269 if (mov_x + w > avctx->width || mov_y + h > avctx->height)
272 if (!s->frame2->data[0] || !s->frame1->data[0])
273 return AVERROR_INVALIDDATA;
275 b1 = s->frame1->data[0] + s->frame1->linesize[0] * (start_y + h) + start_x * s->bpp;
276 b2 = s->frame2->data[0] + s->frame2->linesize[0] * (start_y + h) + start_x * s->bpp;
277 e2 = s->frame2->data[0] + s->frame2->linesize[0] * (mov_y + h) + mov_x * s->bpp;
280 for (int j = 0; j < h; j++) {
281 memcpy(b1, b2, w * s->bpp);
282 b1 -= s->frame1->linesize[0];
283 b2 -= s->frame2->linesize[0];
285 } else if (type == 1) {
286 for (int j = 0; j < h; j++) {
287 memset(b2, 0, w * s->bpp);
288 b2 -= s->frame2->linesize[0];
290 } else if (type == 0) {
293 av_fast_padded_malloc(&s->delta, &s->delta_size, w * h * s->bpp);
296 return AVERROR(ENOMEM);
298 for (int j = 0; j < h; j++) {
299 memcpy(buffer + j * w * s->bpp, e2, w * s->bpp);
300 e2 -= s->frame2->linesize[0];
303 for (int j = 0; j < h; j++) {
304 memcpy(b2, buffer + j * w * s->bpp, w * s->bpp);
305 b2 -= s->frame2->linesize[0];
308 return AVERROR_INVALIDDATA;
312 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
318 if (cx >= w * s->bpp) { \
321 b1 -= s->frame1->linesize[0]; \
322 b2 -= s->frame2->linesize[0]; \
326 static int decode_dlta(AVCodecContext *avctx,
327 AVPacket *avpkt, unsigned size)
329 RASCContext *s = avctx->priv_data;
330 GetByteContext *gb = &s->gb;
332 unsigned uncompressed_size, pos;
334 int ret, cx, cy, compression;
337 pos = bytestream2_tell(gb);
338 bytestream2_skip(gb, 12);
339 uncompressed_size = bytestream2_get_le32(gb);
340 x = bytestream2_get_le32(gb);
341 y = bytestream2_get_le32(gb);
342 w = bytestream2_get_le32(gb);
343 h = bytestream2_get_le32(gb);
345 if (x >= avctx->width || y >= avctx->height ||
346 w > avctx->width || h > avctx->height)
347 return AVERROR_INVALIDDATA;
349 if (x + w > avctx->width || y + h > avctx->height)
350 return AVERROR_INVALIDDATA;
352 bytestream2_skip(gb, 4);
353 compression = bytestream2_get_le32(gb);
355 if (compression == 1) {
356 ret = decode_zlib(avctx, avpkt, size, uncompressed_size);
359 bytestream2_init(&dc, s->delta, uncompressed_size);
360 } else if (compression == 0) {
361 if (bytestream2_get_bytes_left(gb) < uncompressed_size)
362 return AVERROR_INVALIDDATA;
363 bytestream2_init(&dc, avpkt->data + bytestream2_tell(gb),
365 } else if (compression == 2) {
366 avpriv_request_sample(avctx, "compression %d", compression);
367 return AVERROR_PATCHWELCOME;
369 return AVERROR_INVALIDDATA;
372 if (!s->frame2->data[0] || !s->frame1->data[0])
373 return AVERROR_INVALIDDATA;
375 b1 = s->frame1->data[0] + s->frame1->linesize[0] * (y + h - 1) + x * s->bpp;
376 b2 = s->frame2->data[0] + s->frame2->linesize[0] * (y + h - 1) + x * s->bpp;
378 while (bytestream2_get_bytes_left(&dc) > 0) {
379 int type = bytestream2_get_byte(&dc);
380 int len = bytestream2_get_byte(&dc);
385 while (len > 0 && cy > 0) {
391 while (len > 0 && cy > 0) {
402 while (len > 0 && cy > 0) {
403 fill = bytestream2_get_byte(&dc);
411 fill = bytestream2_get_byte(&dc);
412 while (len > 0 && cy > 0) {
413 AV_WL32(b1 + cx, AV_RL32(b2 + cx));
414 AV_WL32(b2 + cx, fill);
420 fill = bytestream2_get_le32(&dc);
421 while (len > 0 && cy > 0) {
422 AV_WL32(b1 + cx, AV_RL32(b2 + cx));
423 AV_WL32(b2 + cx, fill);
429 while (len > 0 && cy > 0) {
435 while (len > 0 && cy > 0) {
438 v0 = AV_RL32(b2 + cx);
439 v1 = AV_RL32(b1 + cx);
440 AV_WL32(b2 + cx, v1);
441 AV_WL32(b1 + cx, v0);
447 while (len > 0 && cy > 0) {
448 fill = bytestream2_get_le32(&dc);
449 AV_WL32(b1 + cx, AV_RL32(b2 + cx));
450 AV_WL32(b2 + cx, fill);
456 avpriv_request_sample(avctx, "runlen %d", type);
457 return AVERROR_INVALIDDATA;
461 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
466 static int decode_kfrm(AVCodecContext *avctx,
467 AVPacket *avpkt, unsigned size)
469 RASCContext *s = avctx->priv_data;
470 GetByteContext *gb = &s->gb;
475 pos = bytestream2_tell(gb);
476 if (bytestream2_peek_le32(gb) == 0x65) {
477 ret = decode_fint(avctx, avpkt, size);
482 if (!s->frame2->data[0])
483 return AVERROR_INVALIDDATA;
485 zret = inflateReset(&s->zstream);
487 av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
488 return AVERROR_EXTERNAL;
491 s->zstream.next_in = avpkt->data + bytestream2_tell(gb);
492 s->zstream.avail_in = bytestream2_get_bytes_left(gb);
494 dst = s->frame2->data[0] + (avctx->height - 1) * s->frame2->linesize[0];
495 for (int i = 0; i < avctx->height; i++) {
496 s->zstream.next_out = dst;
497 s->zstream.avail_out = s->stride;
499 zret = inflate(&s->zstream, Z_SYNC_FLUSH);
500 if (zret != Z_OK && zret != Z_STREAM_END) {
501 av_log(avctx, AV_LOG_ERROR,
502 "Inflate failed with return code: %d.\n", zret);
503 return AVERROR_INVALIDDATA;
506 dst -= s->frame2->linesize[0];
509 dst = s->frame1->data[0] + (avctx->height - 1) * s->frame1->linesize[0];
510 for (int i = 0; i < avctx->height; i++) {
511 s->zstream.next_out = dst;
512 s->zstream.avail_out = s->stride;
514 zret = inflate(&s->zstream, Z_SYNC_FLUSH);
515 if (zret != Z_OK && zret != Z_STREAM_END) {
516 av_log(avctx, AV_LOG_ERROR,
517 "Inflate failed with return code: %d.\n", zret);
518 return AVERROR_INVALIDDATA;
521 dst -= s->frame1->linesize[0];
524 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
529 static int decode_mous(AVCodecContext *avctx,
530 AVPacket *avpkt, unsigned size)
532 RASCContext *s = avctx->priv_data;
533 GetByteContext *gb = &s->gb;
534 unsigned w, h, pos, uncompressed_size;
537 pos = bytestream2_tell(gb);
538 bytestream2_skip(gb, 8);
539 w = bytestream2_get_le32(gb);
540 h = bytestream2_get_le32(gb);
541 bytestream2_skip(gb, 12);
542 uncompressed_size = bytestream2_get_le32(gb);
544 if (w > avctx->width || h > avctx->height)
545 return AVERROR_INVALIDDATA;
547 if (uncompressed_size != 3 * w * h)
548 return AVERROR_INVALIDDATA;
550 av_fast_padded_malloc(&s->cursor, &s->cursor_size, uncompressed_size);
552 return AVERROR(ENOMEM);
554 ret = decode_zlib(avctx, avpkt,
555 size - (bytestream2_tell(gb) - pos),
559 memcpy(s->cursor, s->delta, uncompressed_size);
561 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
569 static int decode_mpos(AVCodecContext *avctx,
570 AVPacket *avpkt, unsigned size)
572 RASCContext *s = avctx->priv_data;
573 GetByteContext *gb = &s->gb;
576 pos = bytestream2_tell(gb);
577 bytestream2_skip(gb, 8);
578 s->cursor_x = bytestream2_get_le32(gb);
579 s->cursor_y = bytestream2_get_le32(gb);
581 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
586 static void draw_cursor(AVCodecContext *avctx)
588 RASCContext *s = avctx->priv_data;
594 if (s->cursor_x >= avctx->width || s->cursor_y >= avctx->height)
597 if (s->cursor_x + s->cursor_w > avctx->width ||
598 s->cursor_y + s->cursor_h > avctx->height)
601 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
602 pal = s->frame->data[1];
603 for (int i = 0; i < s->cursor_h; i++) {
604 for (int j = 0; j < s->cursor_w; j++) {
605 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
606 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
607 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
612 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
615 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + (s->cursor_x + j);
616 for (int k = 0; k < 256; k++) {
617 int pr = pal[k * 4 + 0];
618 int pg = pal[k * 4 + 1];
619 int pb = pal[k * 4 + 2];
621 dist = FFABS(cr - pr) + FFABS(cg - pg) + FFABS(cb - pb);
630 } else if (avctx->pix_fmt == AV_PIX_FMT_RGB555LE) {
631 for (int i = 0; i < s->cursor_h; i++) {
632 for (int j = 0; j < s->cursor_w; j++) {
633 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
634 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
635 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
637 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
640 cr >>= 3; cg >>=3; cb >>= 3;
641 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 2 * (s->cursor_x + j);
642 AV_WL16(dst, cr | cg << 5 | cb << 10);
645 } else if (avctx->pix_fmt == AV_PIX_FMT_BGR0) {
646 for (int i = 0; i < s->cursor_h; i++) {
647 for (int j = 0; j < s->cursor_w; j++) {
648 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
649 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
650 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
652 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
655 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 4 * (s->cursor_x + j);
664 static int decode_frame(AVCodecContext *avctx,
665 void *data, int *got_frame,
668 RASCContext *s = avctx->priv_data;
669 GetByteContext *gb = &s->gb;
671 AVFrame *frame = data;
673 bytestream2_init(gb, avpkt->data, avpkt->size);
675 if (bytestream2_peek_le32(gb) == EMPT)
680 while (bytestream2_get_bytes_left(gb) > 0) {
681 unsigned type, size = 0;
683 type = bytestream2_get_le32(gb);
684 if (type == KBND || type == BNDL) {
685 intra = type == KBND;
686 type = bytestream2_get_le32(gb);
689 size = bytestream2_get_le32(gb);
690 if (bytestream2_get_bytes_left(gb) < size)
691 return AVERROR_INVALIDDATA;
696 ret = decode_fint(avctx, avpkt, size);
699 ret = decode_kfrm(avctx, avpkt, size);
702 ret = decode_dlta(avctx, avpkt, size);
705 ret = decode_move(avctx, avpkt, size);
708 ret = decode_mous(avctx, avpkt, size);
711 ret = decode_mpos(avctx, avpkt, size);
714 bytestream2_skip(gb, size);
721 if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
724 if (!s->frame2->data[0] || !s->frame1->data[0])
725 return AVERROR_INVALIDDATA;
727 copy_plane(avctx, s->frame2, s->frame);
728 if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
729 memcpy(s->frame->data[1], s->frame2->data[1], 1024);
733 s->frame->key_frame = intra;
734 s->frame->pict_type = intra ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
741 static av_cold int decode_init(AVCodecContext *avctx)
743 RASCContext *s = avctx->priv_data;
746 s->zstream.zalloc = Z_NULL;
747 s->zstream.zfree = Z_NULL;
748 s->zstream.opaque = Z_NULL;
749 zret = inflateInit(&s->zstream);
751 av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
752 return AVERROR_EXTERNAL;
755 s->frame1 = av_frame_alloc();
756 s->frame2 = av_frame_alloc();
757 if (!s->frame1 || !s->frame2)
758 return AVERROR(ENOMEM);
763 static av_cold int decode_close(AVCodecContext *avctx)
765 RASCContext *s = avctx->priv_data;
767 av_freep(&s->cursor);
771 av_frame_free(&s->frame1);
772 av_frame_free(&s->frame2);
773 inflateEnd(&s->zstream);
778 static void decode_flush(AVCodecContext *avctx)
780 RASCContext *s = avctx->priv_data;
782 clear_plane(avctx, s->frame1);
783 clear_plane(avctx, s->frame2);
786 static const AVOption options[] = {
787 { "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 },
791 static const AVClass rasc_decoder_class = {
792 .class_name = "rasc decoder",
793 .item_name = av_default_item_name,
795 .version = LIBAVUTIL_VERSION_INT,
798 AVCodec ff_rasc_decoder = {
800 .long_name = NULL_IF_CONFIG_SMALL("RemotelyAnywhere Screen Capture"),
801 .type = AVMEDIA_TYPE_VIDEO,
802 .id = AV_CODEC_ID_RASC,
803 .priv_data_size = sizeof(RASCContext),
805 .close = decode_close,
806 .decode = decode_frame,
807 .flush = decode_flush,
808 .capabilities = AV_CODEC_CAP_DR1,
809 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
810 FF_CODEC_CAP_INIT_CLEANUP,
811 .priv_class = &rasc_decoder_class,