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 <stdlib.h>
25 #include <string.h>
26
27 #include "libavutil/avassert.h"
28 #include "libavutil/imgutils.h"
29 #include "libavutil/opt.h"
30
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "internal.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 z_stream zstream;
63 AVFrame *frame;
64 AVFrame *frame1;
65 AVFrame *frame2;
66 } RASCContext;
67
clear_plane(AVCodecContext * avctx,AVFrame * frame)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
copy_plane(AVCodecContext * avctx,AVFrame * src,AVFrame * dst)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
init_frames(AVCodecContext * avctx)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
decode_fint(AVCodecContext * avctx,AVPacket * avpkt,unsigned size)114 static int decode_fint(AVCodecContext *avctx,
115 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
decode_zlib(AVCodecContext * avctx,AVPacket * avpkt,unsigned size,unsigned uncompressed_size)174 static int decode_zlib(AVCodecContext *avctx, AVPacket *avpkt,
175 unsigned size, unsigned uncompressed_size)
176 {
177 RASCContext *s = avctx->priv_data;
178 GetByteContext *gb = &s->gb;
179 int zret;
180
181 zret = inflateReset(&s->zstream);
182 if (zret != Z_OK) {
183 av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
184 return AVERROR_EXTERNAL;
185 }
186
187 av_fast_padded_malloc(&s->delta, &s->delta_size, uncompressed_size);
188 if (!s->delta)
189 return AVERROR(ENOMEM);
190
191 s->zstream.next_in = avpkt->data + bytestream2_tell(gb);
192 s->zstream.avail_in = FFMIN(size, bytestream2_get_bytes_left(gb));
193
194 s->zstream.next_out = s->delta;
195 s->zstream.avail_out = s->delta_size;
196
197 zret = inflate(&s->zstream, Z_FINISH);
198 if (zret != Z_STREAM_END) {
199 av_log(avctx, AV_LOG_ERROR,
200 "Inflate failed with return code: %d.\n", zret);
201 return AVERROR_INVALIDDATA;
202 }
203
204 return 0;
205 }
206
decode_move(AVCodecContext * avctx,AVPacket * avpkt,unsigned size)207 static int decode_move(AVCodecContext *avctx,
208 AVPacket *avpkt, unsigned size)
209 {
210 RASCContext *s = avctx->priv_data;
211 GetByteContext *gb = &s->gb;
212 GetByteContext mc;
213 unsigned pos, compression, nb_moves;
214 unsigned uncompressed_size;
215 int ret;
216
217 pos = bytestream2_tell(gb);
218 bytestream2_skip(gb, 8);
219 nb_moves = bytestream2_get_le32(gb);
220 bytestream2_skip(gb, 8);
221 compression = bytestream2_get_le32(gb);
222
223 if (nb_moves > INT32_MAX / 16 || nb_moves > avctx->width * avctx->height)
224 return AVERROR_INVALIDDATA;
225
226 uncompressed_size = 16 * nb_moves;
227
228 if (compression == 1) {
229 ret = decode_zlib(avctx, avpkt,
230 size - (bytestream2_tell(gb) - pos),
231 uncompressed_size);
232 if (ret < 0)
233 return ret;
234 bytestream2_init(&mc, s->delta, uncompressed_size);
235 } else if (compression == 0) {
236 bytestream2_init(&mc, avpkt->data + bytestream2_tell(gb),
237 bytestream2_get_bytes_left(gb));
238 } else if (compression == 2) {
239 avpriv_request_sample(avctx, "compression %d", compression);
240 return AVERROR_PATCHWELCOME;
241 } else {
242 return AVERROR_INVALIDDATA;
243 }
244
245 if (bytestream2_get_bytes_left(&mc) < uncompressed_size)
246 return AVERROR_INVALIDDATA;
247
248 for (int i = 0; i < nb_moves; i++) {
249 int type, start_x, start_y, end_x, end_y, mov_x, mov_y;
250 uint8_t *e2, *b1, *b2;
251 int w, h;
252
253 type = bytestream2_get_le16(&mc);
254 start_x = bytestream2_get_le16(&mc);
255 start_y = bytestream2_get_le16(&mc);
256 end_x = bytestream2_get_le16(&mc);
257 end_y = bytestream2_get_le16(&mc);
258 mov_x = bytestream2_get_le16(&mc);
259 mov_y = bytestream2_get_le16(&mc);
260 bytestream2_skip(&mc, 2);
261
262 if (start_x >= avctx->width || start_y >= avctx->height ||
263 end_x >= avctx->width || end_y >= avctx->height ||
264 mov_x >= avctx->width || mov_y >= avctx->height) {
265 continue;
266 }
267
268 if (start_x >= end_x || start_y >= end_y)
269 continue;
270
271 w = end_x - start_x;
272 h = end_y - start_y;
273
274 if (mov_x + w > avctx->width || mov_y + h > avctx->height)
275 continue;
276
277 if (!s->frame2->data[0] || !s->frame1->data[0])
278 return AVERROR_INVALIDDATA;
279
280 b1 = s->frame1->data[0] + s->frame1->linesize[0] * (start_y + h - 1) + start_x * s->bpp;
281 b2 = s->frame2->data[0] + s->frame2->linesize[0] * (start_y + h - 1) + start_x * s->bpp;
282 e2 = s->frame2->data[0] + s->frame2->linesize[0] * (mov_y + h - 1) + mov_x * s->bpp;
283
284 if (type == 2) {
285 for (int j = 0; j < h; j++) {
286 memcpy(b1, b2, w * s->bpp);
287 b1 -= s->frame1->linesize[0];
288 b2 -= s->frame2->linesize[0];
289 }
290 } else if (type == 1) {
291 for (int j = 0; j < h; j++) {
292 memset(b2, 0, w * s->bpp);
293 b2 -= s->frame2->linesize[0];
294 }
295 } else if (type == 0) {
296 uint8_t *buffer;
297
298 av_fast_padded_malloc(&s->delta, &s->delta_size, w * h * s->bpp);
299 buffer = s->delta;
300 if (!buffer)
301 return AVERROR(ENOMEM);
302
303 for (int j = 0; j < h; j++) {
304 memcpy(buffer + j * w * s->bpp, e2, w * s->bpp);
305 e2 -= s->frame2->linesize[0];
306 }
307
308 for (int j = 0; j < h; j++) {
309 memcpy(b2, buffer + j * w * s->bpp, w * s->bpp);
310 b2 -= s->frame2->linesize[0];
311 }
312 } else {
313 return AVERROR_INVALIDDATA;
314 }
315 }
316
317 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
318
319 return 0;
320 }
321
322 #define NEXT_LINE \
323 if (cx >= w * s->bpp) { \
324 cx = 0; \
325 cy--; \
326 b1 -= s->frame1->linesize[0]; \
327 b2 -= s->frame2->linesize[0]; \
328 } \
329 len--;
330
decode_dlta(AVCodecContext * avctx,AVPacket * avpkt,unsigned size)331 static int decode_dlta(AVCodecContext *avctx,
332 AVPacket *avpkt, unsigned size)
333 {
334 RASCContext *s = avctx->priv_data;
335 GetByteContext *gb = &s->gb;
336 GetByteContext dc;
337 unsigned uncompressed_size, pos;
338 unsigned x, y, w, h;
339 int ret, cx, cy, compression;
340 uint8_t *b1, *b2;
341
342 pos = bytestream2_tell(gb);
343 bytestream2_skip(gb, 12);
344 uncompressed_size = bytestream2_get_le32(gb);
345 x = bytestream2_get_le32(gb);
346 y = bytestream2_get_le32(gb);
347 w = bytestream2_get_le32(gb);
348 h = bytestream2_get_le32(gb);
349
350 if (x >= avctx->width || y >= avctx->height ||
351 w > avctx->width || h > avctx->height)
352 return AVERROR_INVALIDDATA;
353
354 if (x + w > avctx->width || y + h > avctx->height)
355 return AVERROR_INVALIDDATA;
356
357 bytestream2_skip(gb, 4);
358 compression = bytestream2_get_le32(gb);
359
360 if (compression == 1) {
361 if (w * h * s->bpp * 3 < uncompressed_size)
362 return AVERROR_INVALIDDATA;
363 ret = decode_zlib(avctx, avpkt, size, uncompressed_size);
364 if (ret < 0)
365 return ret;
366 bytestream2_init(&dc, s->delta, uncompressed_size);
367 } else if (compression == 0) {
368 if (bytestream2_get_bytes_left(gb) < uncompressed_size)
369 return AVERROR_INVALIDDATA;
370 bytestream2_init(&dc, avpkt->data + bytestream2_tell(gb),
371 uncompressed_size);
372 } else if (compression == 2) {
373 avpriv_request_sample(avctx, "compression %d", compression);
374 return AVERROR_PATCHWELCOME;
375 } else {
376 return AVERROR_INVALIDDATA;
377 }
378
379 if (!s->frame2->data[0] || !s->frame1->data[0])
380 return AVERROR_INVALIDDATA;
381
382 b1 = s->frame1->data[0] + s->frame1->linesize[0] * (y + h - 1) + x * s->bpp;
383 b2 = s->frame2->data[0] + s->frame2->linesize[0] * (y + h - 1) + x * s->bpp;
384 cx = 0, cy = h;
385 while (bytestream2_get_bytes_left(&dc) > 0) {
386 int type = bytestream2_get_byte(&dc);
387 int len = bytestream2_get_byte(&dc);
388 unsigned fill;
389
390 switch (type) {
391 case 1:
392 while (len > 0 && cy > 0) {
393 cx++;
394 NEXT_LINE
395 }
396 break;
397 case 2:
398 while (len > 0 && cy > 0) {
399 int v0 = b1[cx];
400 int v1 = b2[cx];
401
402 b2[cx] = v0;
403 b1[cx] = v1;
404 cx++;
405 NEXT_LINE
406 }
407 break;
408 case 3:
409 while (len > 0 && cy > 0) {
410 fill = bytestream2_get_byte(&dc);
411 b1[cx] = b2[cx];
412 b2[cx] = fill;
413 cx++;
414 NEXT_LINE
415 }
416 break;
417 case 4:
418 fill = bytestream2_get_byte(&dc);
419 while (len > 0 && cy > 0) {
420 AV_WL32(b1 + cx, AV_RL32(b2 + cx));
421 AV_WL32(b2 + cx, fill);
422 cx++;
423 NEXT_LINE
424 }
425 break;
426 case 7:
427 fill = bytestream2_get_le32(&dc);
428 while (len > 0 && cy > 0) {
429 AV_WL32(b1 + cx, AV_RL32(b2 + cx));
430 AV_WL32(b2 + cx, fill);
431 cx += 4;
432 NEXT_LINE
433 }
434 break;
435 case 10:
436 while (len > 0 && cy > 0) {
437 cx += 4;
438 NEXT_LINE
439 }
440 break;
441 case 12:
442 while (len > 0 && cy > 0) {
443 unsigned v0, v1;
444
445 v0 = AV_RL32(b2 + cx);
446 v1 = AV_RL32(b1 + cx);
447 AV_WL32(b2 + cx, v1);
448 AV_WL32(b1 + cx, v0);
449 cx += 4;
450 NEXT_LINE
451 }
452 break;
453 case 13:
454 while (len > 0 && cy > 0) {
455 fill = bytestream2_get_le32(&dc);
456 AV_WL32(b1 + cx, AV_RL32(b2 + cx));
457 AV_WL32(b2 + cx, fill);
458 cx += 4;
459 NEXT_LINE
460 }
461 break;
462 default:
463 avpriv_request_sample(avctx, "runlen %d", type);
464 return AVERROR_INVALIDDATA;
465 }
466 }
467
468 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
469
470 return 0;
471 }
472
decode_kfrm(AVCodecContext * avctx,AVPacket * avpkt,unsigned size)473 static int decode_kfrm(AVCodecContext *avctx,
474 AVPacket *avpkt, unsigned size)
475 {
476 RASCContext *s = avctx->priv_data;
477 GetByteContext *gb = &s->gb;
478 uint8_t *dst;
479 unsigned pos;
480 int zret, ret;
481
482 pos = bytestream2_tell(gb);
483 if (bytestream2_peek_le32(gb) == 0x65) {
484 ret = decode_fint(avctx, avpkt, size);
485 if (ret < 0)
486 return ret;
487 }
488
489 if (!s->frame2->data[0])
490 return AVERROR_INVALIDDATA;
491
492 zret = inflateReset(&s->zstream);
493 if (zret != Z_OK) {
494 av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
495 return AVERROR_EXTERNAL;
496 }
497
498 s->zstream.next_in = avpkt->data + bytestream2_tell(gb);
499 s->zstream.avail_in = bytestream2_get_bytes_left(gb);
500
501 dst = s->frame2->data[0] + (avctx->height - 1) * s->frame2->linesize[0];
502 for (int i = 0; i < avctx->height; i++) {
503 s->zstream.next_out = dst;
504 s->zstream.avail_out = s->stride;
505
506 zret = inflate(&s->zstream, Z_SYNC_FLUSH);
507 if (zret != Z_OK && zret != Z_STREAM_END) {
508 av_log(avctx, AV_LOG_ERROR,
509 "Inflate failed with return code: %d.\n", zret);
510 return AVERROR_INVALIDDATA;
511 }
512
513 dst -= s->frame2->linesize[0];
514 }
515
516 dst = s->frame1->data[0] + (avctx->height - 1) * s->frame1->linesize[0];
517 for (int i = 0; i < avctx->height; i++) {
518 s->zstream.next_out = dst;
519 s->zstream.avail_out = s->stride;
520
521 zret = inflate(&s->zstream, Z_SYNC_FLUSH);
522 if (zret != Z_OK && zret != Z_STREAM_END) {
523 av_log(avctx, AV_LOG_ERROR,
524 "Inflate failed with return code: %d.\n", zret);
525 return AVERROR_INVALIDDATA;
526 }
527
528 dst -= s->frame1->linesize[0];
529 }
530
531 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
532
533 return 0;
534 }
535
decode_mous(AVCodecContext * avctx,AVPacket * avpkt,unsigned size)536 static int decode_mous(AVCodecContext *avctx,
537 AVPacket *avpkt, unsigned size)
538 {
539 RASCContext *s = avctx->priv_data;
540 GetByteContext *gb = &s->gb;
541 unsigned w, h, pos, uncompressed_size;
542 int ret;
543
544 pos = bytestream2_tell(gb);
545 bytestream2_skip(gb, 8);
546 w = bytestream2_get_le32(gb);
547 h = bytestream2_get_le32(gb);
548 bytestream2_skip(gb, 12);
549 uncompressed_size = bytestream2_get_le32(gb);
550
551 if (w > avctx->width || h > avctx->height)
552 return AVERROR_INVALIDDATA;
553
554 if (uncompressed_size != 3 * w * h)
555 return AVERROR_INVALIDDATA;
556
557 av_fast_padded_malloc(&s->cursor, &s->cursor_size, uncompressed_size);
558 if (!s->cursor)
559 return AVERROR(ENOMEM);
560
561 ret = decode_zlib(avctx, avpkt,
562 size - (bytestream2_tell(gb) - pos),
563 uncompressed_size);
564 if (ret < 0)
565 return ret;
566 memcpy(s->cursor, s->delta, uncompressed_size);
567
568 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
569
570 s->cursor_w = w;
571 s->cursor_h = h;
572
573 return 0;
574 }
575
decode_mpos(AVCodecContext * avctx,AVPacket * avpkt,unsigned size)576 static int decode_mpos(AVCodecContext *avctx,
577 AVPacket *avpkt, unsigned size)
578 {
579 RASCContext *s = avctx->priv_data;
580 GetByteContext *gb = &s->gb;
581 unsigned pos;
582
583 pos = bytestream2_tell(gb);
584 bytestream2_skip(gb, 8);
585 s->cursor_x = bytestream2_get_le32(gb);
586 s->cursor_y = bytestream2_get_le32(gb);
587
588 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
589
590 return 0;
591 }
592
draw_cursor(AVCodecContext * avctx)593 static void draw_cursor(AVCodecContext *avctx)
594 {
595 RASCContext *s = avctx->priv_data;
596 uint8_t *dst, *pal;
597
598 if (!s->cursor)
599 return;
600
601 if (s->cursor_x >= avctx->width || s->cursor_y >= avctx->height)
602 return;
603
604 if (s->cursor_x + s->cursor_w > avctx->width ||
605 s->cursor_y + s->cursor_h > avctx->height)
606 return;
607
608 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
609 pal = s->frame->data[1];
610 for (int i = 0; i < s->cursor_h; i++) {
611 for (int j = 0; j < s->cursor_w; j++) {
612 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
613 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
614 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
615 int best = INT_MAX;
616 int index = 0;
617 int dist;
618
619 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
620 continue;
621
622 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + (s->cursor_x + j);
623 for (int k = 0; k < 256; k++) {
624 int pr = pal[k * 4 + 0];
625 int pg = pal[k * 4 + 1];
626 int pb = pal[k * 4 + 2];
627
628 dist = FFABS(cr - pr) + FFABS(cg - pg) + FFABS(cb - pb);
629 if (dist < best) {
630 best = dist;
631 index = k;
632 }
633 }
634 dst[0] = index;
635 }
636 }
637 } else if (avctx->pix_fmt == AV_PIX_FMT_RGB555LE) {
638 for (int i = 0; i < s->cursor_h; i++) {
639 for (int j = 0; j < s->cursor_w; j++) {
640 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
641 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
642 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
643
644 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
645 continue;
646
647 cr >>= 3; cg >>=3; cb >>= 3;
648 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 2 * (s->cursor_x + j);
649 AV_WL16(dst, cr | cg << 5 | cb << 10);
650 }
651 }
652 } else if (avctx->pix_fmt == AV_PIX_FMT_BGR0) {
653 for (int i = 0; i < s->cursor_h; i++) {
654 for (int j = 0; j < s->cursor_w; j++) {
655 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
656 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
657 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
658
659 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
660 continue;
661
662 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 4 * (s->cursor_x + j);
663 dst[0] = cb;
664 dst[1] = cg;
665 dst[2] = cr;
666 }
667 }
668 }
669 }
670
decode_frame(AVCodecContext * avctx,void * data,int * got_frame,AVPacket * avpkt)671 static int decode_frame(AVCodecContext *avctx,
672 void *data, int *got_frame,
673 AVPacket *avpkt)
674 {
675 RASCContext *s = avctx->priv_data;
676 GetByteContext *gb = &s->gb;
677 int ret, intra = 0;
678 AVFrame *frame = data;
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 }
726
727 if (ret < 0)
728 return ret;
729 }
730
731 if (!s->frame2->data[0] || !s->frame1->data[0])
732 return AVERROR_INVALIDDATA;
733
734 if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
735 return ret;
736
737 copy_plane(avctx, s->frame2, s->frame);
738 if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
739 memcpy(s->frame->data[1], s->frame2->data[1], 1024);
740 if (!s->skip_cursor)
741 draw_cursor(avctx);
742
743 s->frame->key_frame = intra;
744 s->frame->pict_type = intra ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
745
746 *got_frame = 1;
747
748 return avpkt->size;
749 }
750
decode_init(AVCodecContext * avctx)751 static av_cold int decode_init(AVCodecContext *avctx)
752 {
753 RASCContext *s = avctx->priv_data;
754 int zret;
755
756 s->zstream.zalloc = Z_NULL;
757 s->zstream.zfree = Z_NULL;
758 s->zstream.opaque = Z_NULL;
759 zret = inflateInit(&s->zstream);
760 if (zret != Z_OK) {
761 av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
762 return AVERROR_EXTERNAL;
763 }
764
765 s->frame1 = av_frame_alloc();
766 s->frame2 = av_frame_alloc();
767 if (!s->frame1 || !s->frame2)
768 return AVERROR(ENOMEM);
769
770 return 0;
771 }
772
decode_close(AVCodecContext * avctx)773 static av_cold int decode_close(AVCodecContext *avctx)
774 {
775 RASCContext *s = avctx->priv_data;
776
777 av_freep(&s->cursor);
778 s->cursor_size = 0;
779 av_freep(&s->delta);
780 s->delta_size = 0;
781 av_frame_free(&s->frame1);
782 av_frame_free(&s->frame2);
783 inflateEnd(&s->zstream);
784
785 return 0;
786 }
787
decode_flush(AVCodecContext * avctx)788 static void decode_flush(AVCodecContext *avctx)
789 {
790 RASCContext *s = avctx->priv_data;
791
792 clear_plane(avctx, s->frame1);
793 clear_plane(avctx, s->frame2);
794 }
795
796 static const AVOption options[] = {
797 { "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 },
798 { NULL },
799 };
800
801 static const AVClass rasc_decoder_class = {
802 .class_name = "rasc decoder",
803 .item_name = av_default_item_name,
804 .option = options,
805 .version = LIBAVUTIL_VERSION_INT,
806 };
807
808 AVCodec ff_rasc_decoder = {
809 .name = "rasc",
810 .long_name = NULL_IF_CONFIG_SMALL("RemotelyAnywhere Screen Capture"),
811 .type = AVMEDIA_TYPE_VIDEO,
812 .id = AV_CODEC_ID_RASC,
813 .priv_data_size = sizeof(RASCContext),
814 .init = decode_init,
815 .close = decode_close,
816 .decode = decode_frame,
817 .flush = decode_flush,
818 .capabilities = AV_CODEC_CAP_DR1,
819 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
820 FF_CODEC_CAP_INIT_CLEANUP,
821 .priv_class = &rasc_decoder_class,
822 };
823