FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/rasc.c
Date: 2022-11-26 13:19:19
Exec Total Coverage
Lines: 0 468 0.0%
Branches: 0 298 0.0%

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/opt.h"
27
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "codec_internal.h"
31 #include "decode.h"
32 #include "zlib_wrapper.h"
33
34 #include <zlib.h>
35
36 #define KBND MKTAG('K', 'B', 'N', 'D')
37 #define FINT MKTAG('F', 'I', 'N', 'T')
38 #define INIT MKTAG('I', 'N', 'I', 'T')
39 #define BNDL MKTAG('B', 'N', 'D', 'L')
40 #define KFRM MKTAG('K', 'F', 'R', 'M')
41 #define DLTA MKTAG('D', 'L', 'T', 'A')
42 #define MOUS MKTAG('M', 'O', 'U', 'S')
43 #define MPOS MKTAG('M', 'P', 'O', 'S')
44 #define MOVE MKTAG('M', 'O', 'V', 'E')
45 #define EMPT MKTAG('E', 'M', 'P', 'T')
46
47 typedef struct RASCContext {
48 AVClass *class;
49 int skip_cursor;
50 GetByteContext gb;
51 uint8_t *delta;
52 int delta_size;
53 uint8_t *cursor;
54 int cursor_size;
55 unsigned cursor_w;
56 unsigned cursor_h;
57 unsigned cursor_x;
58 unsigned cursor_y;
59 int stride;
60 int bpp;
61 AVFrame *frame;
62 AVFrame *frame1;
63 AVFrame *frame2;
64 FFZStream zstream;
65 } RASCContext;
66
67 static void clear_plane(AVCodecContext *avctx, AVFrame *frame)
68 {
69 RASCContext *s = avctx->priv_data;
70 uint8_t *dst = frame->data[0];
71
72 if (!dst)
73 return;
74
75 for (int y = 0; y < avctx->height; y++) {
76 memset(dst, 0, avctx->width * s->bpp);
77 dst += frame->linesize[0];
78 }
79 }
80
81 static void copy_plane(AVCodecContext *avctx, AVFrame *src, AVFrame *dst)
82 {
83 RASCContext *s = avctx->priv_data;
84 uint8_t *srcp = src->data[0];
85 uint8_t *dstp = dst->data[0];
86
87 for (int y = 0; y < avctx->height; y++) {
88 memcpy(dstp, srcp, s->stride);
89 srcp += src->linesize[0];
90 dstp += dst->linesize[0];
91 }
92 }
93
94 static int init_frames(AVCodecContext *avctx)
95 {
96 RASCContext *s = avctx->priv_data;
97 int ret;
98
99 av_frame_unref(s->frame1);
100 av_frame_unref(s->frame2);
101 if ((ret = ff_get_buffer(avctx, s->frame1, 0)) < 0)
102 return ret;
103
104 if ((ret = ff_get_buffer(avctx, s->frame2, 0)) < 0)
105 return ret;
106
107 clear_plane(avctx, s->frame2);
108 clear_plane(avctx, s->frame1);
109
110 return 0;
111 }
112
113 static int decode_fint(AVCodecContext *avctx,
114 const AVPacket *avpkt, unsigned size)
115 {
116 RASCContext *s = avctx->priv_data;
117 GetByteContext *gb = &s->gb;
118 unsigned w, h, fmt;
119 int ret;
120
121 if (bytestream2_peek_le32(gb) != 0x65) {
122 if (!s->frame2->data[0] || !s->frame1->data[0])
123 return AVERROR_INVALIDDATA;
124
125 clear_plane(avctx, s->frame2);
126 clear_plane(avctx, s->frame1);
127 return 0;
128 }
129 if (bytestream2_get_bytes_left(gb) < 72)
130 return AVERROR_INVALIDDATA;
131
132 bytestream2_skip(gb, 8);
133 w = bytestream2_get_le32(gb);
134 h = bytestream2_get_le32(gb);
135 bytestream2_skip(gb, 30);
136 fmt = bytestream2_get_le16(gb);
137 bytestream2_skip(gb, 24);
138
139 switch (fmt) {
140 case 8: s->stride = FFALIGN(w, 4);
141 s->bpp = 1;
142 fmt = AV_PIX_FMT_PAL8; break;
143 case 16: s->stride = w * 2;
144 s->bpp = 2;
145 fmt = AV_PIX_FMT_RGB555LE; break;
146 case 32: s->stride = w * 4;
147 s->bpp = 4;
148 fmt = AV_PIX_FMT_BGR0; break;
149 default: return AVERROR_INVALIDDATA;
150 }
151
152 ret = ff_set_dimensions(avctx, w, h);
153 if (ret < 0)
154 return ret;
155 avctx->width = w;
156 avctx->height = h;
157 avctx->pix_fmt = fmt;
158
159 ret = init_frames(avctx);
160 if (ret < 0)
161 return ret;
162
163 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
164 uint32_t *pal = (uint32_t *)s->frame2->data[1];
165
166 for (int i = 0; i < 256; i++)
167 pal[i] = bytestream2_get_le32(gb) | 0xFF000000u;
168 }
169
170 return 0;
171 }
172
173 static int decode_zlib(AVCodecContext *avctx, const AVPacket *avpkt,
174 unsigned size, unsigned uncompressed_size)
175 {
176 RASCContext *s = avctx->priv_data;
177 z_stream *const zstream = &s->zstream.zstream;
178 GetByteContext *gb = &s->gb;
179 int zret;
180
181 zret = inflateReset(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 zstream->next_in = avpkt->data + bytestream2_tell(gb);
192 zstream->avail_in = FFMIN(size, bytestream2_get_bytes_left(gb));
193
194 zstream->next_out = s->delta;
195 zstream->avail_out = s->delta_size;
196
197 zret = inflate(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
207 static int decode_move(AVCodecContext *avctx,
208 const 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
331 static int decode_dlta(AVCodecContext *avctx,
332 const 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
473 static int decode_kfrm(AVCodecContext *avctx,
474 const AVPacket *avpkt, unsigned size)
475 {
476 RASCContext *s = avctx->priv_data;
477 z_stream *const zstream = &s->zstream.zstream;
478 GetByteContext *gb = &s->gb;
479 uint8_t *dst;
480 unsigned pos;
481 int zret, ret;
482
483 pos = bytestream2_tell(gb);
484 if (bytestream2_peek_le32(gb) == 0x65) {
485 ret = decode_fint(avctx, avpkt, size);
486 if (ret < 0)
487 return ret;
488 }
489
490 if (!s->frame2->data[0])
491 return AVERROR_INVALIDDATA;
492
493 zret = inflateReset(zstream);
494 if (zret != Z_OK) {
495 av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
496 return AVERROR_EXTERNAL;
497 }
498
499 zstream->next_in = avpkt->data + bytestream2_tell(gb);
500 zstream->avail_in = bytestream2_get_bytes_left(gb);
501
502 dst = s->frame2->data[0] + (avctx->height - 1) * s->frame2->linesize[0];
503 for (int i = 0; i < avctx->height; i++) {
504 zstream->next_out = dst;
505 zstream->avail_out = s->stride;
506
507 zret = inflate(zstream, Z_SYNC_FLUSH);
508 if (zret != Z_OK && zret != Z_STREAM_END) {
509 av_log(avctx, AV_LOG_ERROR,
510 "Inflate failed with return code: %d.\n", zret);
511 return AVERROR_INVALIDDATA;
512 }
513
514 dst -= s->frame2->linesize[0];
515 }
516
517 dst = s->frame1->data[0] + (avctx->height - 1) * s->frame1->linesize[0];
518 for (int i = 0; i < avctx->height; i++) {
519 zstream->next_out = dst;
520 zstream->avail_out = s->stride;
521
522 zret = inflate(zstream, Z_SYNC_FLUSH);
523 if (zret != Z_OK && zret != Z_STREAM_END) {
524 av_log(avctx, AV_LOG_ERROR,
525 "Inflate failed with return code: %d.\n", zret);
526 return AVERROR_INVALIDDATA;
527 }
528
529 dst -= s->frame1->linesize[0];
530 }
531
532 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
533
534 return 0;
535 }
536
537 static int decode_mous(AVCodecContext *avctx,
538 const AVPacket *avpkt, unsigned size)
539 {
540 RASCContext *s = avctx->priv_data;
541 GetByteContext *gb = &s->gb;
542 unsigned w, h, pos, uncompressed_size;
543 int ret;
544
545 pos = bytestream2_tell(gb);
546 bytestream2_skip(gb, 8);
547 w = bytestream2_get_le32(gb);
548 h = bytestream2_get_le32(gb);
549 bytestream2_skip(gb, 12);
550 uncompressed_size = bytestream2_get_le32(gb);
551
552 if (w > avctx->width || h > avctx->height)
553 return AVERROR_INVALIDDATA;
554
555 if (uncompressed_size != 3 * w * h)
556 return AVERROR_INVALIDDATA;
557
558 av_fast_padded_malloc(&s->cursor, &s->cursor_size, uncompressed_size);
559 if (!s->cursor)
560 return AVERROR(ENOMEM);
561
562 ret = decode_zlib(avctx, avpkt,
563 size - (bytestream2_tell(gb) - pos),
564 uncompressed_size);
565 if (ret < 0)
566 return ret;
567 memcpy(s->cursor, s->delta, uncompressed_size);
568
569 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
570
571 s->cursor_w = w;
572 s->cursor_h = h;
573
574 return 0;
575 }
576
577 static int decode_mpos(AVCodecContext *avctx,
578 const AVPacket *avpkt, unsigned size)
579 {
580 RASCContext *s = avctx->priv_data;
581 GetByteContext *gb = &s->gb;
582 unsigned pos;
583
584 pos = bytestream2_tell(gb);
585 bytestream2_skip(gb, 8);
586 s->cursor_x = bytestream2_get_le32(gb);
587 s->cursor_y = bytestream2_get_le32(gb);
588
589 bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
590
591 return 0;
592 }
593
594 static void draw_cursor(AVCodecContext *avctx)
595 {
596 RASCContext *s = avctx->priv_data;
597 uint8_t *dst, *pal;
598
599 if (!s->cursor)
600 return;
601
602 if (s->cursor_x >= avctx->width || s->cursor_y >= avctx->height)
603 return;
604
605 if (s->cursor_x + s->cursor_w > avctx->width ||
606 s->cursor_y + s->cursor_h > avctx->height)
607 return;
608
609 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
610 pal = s->frame->data[1];
611 for (int i = 0; i < s->cursor_h; i++) {
612 for (int j = 0; j < s->cursor_w; j++) {
613 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
614 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
615 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
616 int best = INT_MAX;
617 int index = 0;
618 int dist;
619
620 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
621 continue;
622
623 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + (s->cursor_x + j);
624 for (int k = 0; k < 256; k++) {
625 int pr = pal[k * 4 + 0];
626 int pg = pal[k * 4 + 1];
627 int pb = pal[k * 4 + 2];
628
629 dist = FFABS(cr - pr) + FFABS(cg - pg) + FFABS(cb - pb);
630 if (dist < best) {
631 best = dist;
632 index = k;
633 }
634 }
635 dst[0] = index;
636 }
637 }
638 } else if (avctx->pix_fmt == AV_PIX_FMT_RGB555LE) {
639 for (int i = 0; i < s->cursor_h; i++) {
640 for (int j = 0; j < s->cursor_w; j++) {
641 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
642 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
643 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
644
645 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
646 continue;
647
648 cr >>= 3; cg >>=3; cb >>= 3;
649 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 2 * (s->cursor_x + j);
650 AV_WL16(dst, cr | cg << 5 | cb << 10);
651 }
652 }
653 } else if (avctx->pix_fmt == AV_PIX_FMT_BGR0) {
654 for (int i = 0; i < s->cursor_h; i++) {
655 for (int j = 0; j < s->cursor_w; j++) {
656 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
657 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
658 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
659
660 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
661 continue;
662
663 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 4 * (s->cursor_x + j);
664 dst[0] = cb;
665 dst[1] = cg;
666 dst[2] = cr;
667 }
668 }
669 }
670 }
671
672 static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
673 int *got_frame, AVPacket *avpkt)
674 {
675 RASCContext *s = avctx->priv_data;
676 GetByteContext *gb = &s->gb;
677 int ret, intra = 0;
678
679 bytestream2_init(gb, avpkt->data, avpkt->size);
680
681 if (bytestream2_peek_le32(gb) == EMPT)
682 return avpkt->size;
683
684 s->frame = frame;
685
686 while (bytestream2_get_bytes_left(gb) > 0) {
687 unsigned type, size = 0;
688
689 if (bytestream2_get_bytes_left(gb) < 8)
690 return AVERROR_INVALIDDATA;
691
692 type = bytestream2_get_le32(gb);
693 if (type == KBND || type == BNDL) {
694 intra = type == KBND;
695 type = bytestream2_get_le32(gb);
696 }
697
698 size = bytestream2_get_le32(gb);
699 if (bytestream2_get_bytes_left(gb) < size)
700 return AVERROR_INVALIDDATA;
701
702 switch (type) {
703 case FINT:
704 case INIT:
705 ret = decode_fint(avctx, avpkt, size);
706 break;
707 case KFRM:
708 ret = decode_kfrm(avctx, avpkt, size);
709 break;
710 case DLTA:
711 ret = decode_dlta(avctx, avpkt, size);
712 break;
713 case MOVE:
714 ret = decode_move(avctx, avpkt, size);
715 break;
716 case MOUS:
717 ret = decode_mous(avctx, avpkt, size);
718 break;
719 case MPOS:
720 ret = decode_mpos(avctx, avpkt, size);
721 break;
722 default:
723 bytestream2_skip(gb, size);
724 ret = 0;
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
751 static av_cold int decode_init(AVCodecContext *avctx)
752 {
753 RASCContext *s = avctx->priv_data;
754
755 s->frame1 = av_frame_alloc();
756 s->frame2 = av_frame_alloc();
757 if (!s->frame1 || !s->frame2)
758 return AVERROR(ENOMEM);
759
760 return ff_inflate_init(&s->zstream, avctx);
761 }
762
763 static av_cold int decode_close(AVCodecContext *avctx)
764 {
765 RASCContext *s = avctx->priv_data;
766
767 av_freep(&s->cursor);
768 s->cursor_size = 0;
769 av_freep(&s->delta);
770 s->delta_size = 0;
771 av_frame_free(&s->frame1);
772 av_frame_free(&s->frame2);
773 ff_inflate_end(&s->zstream);
774
775 return 0;
776 }
777
778 static void decode_flush(AVCodecContext *avctx)
779 {
780 RASCContext *s = avctx->priv_data;
781
782 clear_plane(avctx, s->frame1);
783 clear_plane(avctx, s->frame2);
784 }
785
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 },
788 { NULL },
789 };
790
791 static const AVClass rasc_decoder_class = {
792 .class_name = "rasc decoder",
793 .item_name = av_default_item_name,
794 .option = options,
795 .version = LIBAVUTIL_VERSION_INT,
796 };
797
798 const FFCodec ff_rasc_decoder = {
799 .p.name = "rasc",
800 CODEC_LONG_NAME("RemotelyAnywhere Screen Capture"),
801 .p.type = AVMEDIA_TYPE_VIDEO,
802 .p.id = AV_CODEC_ID_RASC,
803 .priv_data_size = sizeof(RASCContext),
804 .init = decode_init,
805 .close = decode_close,
806 FF_CODEC_DECODE_CB(decode_frame),
807 .flush = decode_flush,
808 .p.capabilities = AV_CODEC_CAP_DR1,
809 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
810 .p.priv_class = &rasc_decoder_class,
811 };
812