e8e0740ddd5f3fa9888a94914aadc4b806d45e73
[ffmpeg.git] / libavcodec / rasc.c
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
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     for (int y = 0; y < avctx->height; y++) {
74         memset(dst, 0, avctx->width * s->bpp);
75         dst += frame->linesize[0];
76     }
77 }
78
79 static void copy_plane(AVCodecContext *avctx, AVFrame *src, AVFrame *dst)
80 {
81     RASCContext *s = avctx->priv_data;
82     uint8_t *srcp = src->data[0];
83     uint8_t *dstp = dst->data[0];
84
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];
89     }
90 }
91
92 static int init_frames(AVCodecContext *avctx)
93 {
94     RASCContext *s = avctx->priv_data;
95     int ret;
96
97     av_frame_unref(s->frame1);
98     av_frame_unref(s->frame2);
99     if ((ret = ff_get_buffer(avctx, s->frame1, 0)) < 0)
100         return ret;
101
102     if ((ret = ff_get_buffer(avctx, s->frame2, 0)) < 0)
103         return ret;
104
105     clear_plane(avctx, s->frame2);
106     clear_plane(avctx, s->frame1);
107
108     return 0;
109 }
110
111 static int decode_fint(AVCodecContext *avctx,
112                        AVPacket *avpkt, unsigned size)
113 {
114     RASCContext *s = avctx->priv_data;
115     GetByteContext *gb = &s->gb;
116     unsigned w, h, fmt;
117     int ret;
118
119     if (bytestream2_peek_le32(gb) != 0x65) {
120         if (!s->frame2->data[0] || !s->frame1->data[0])
121             return AVERROR_INVALIDDATA;
122
123         clear_plane(avctx, s->frame2);
124         clear_plane(avctx, s->frame1);
125         return 0;
126     }
127
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);
134
135     switch (fmt) {
136     case 8:  s->stride = FFALIGN(w, 4);
137              s->bpp    = 1;
138              fmt = AV_PIX_FMT_PAL8; break;
139     case 16: s->stride = w * 2;
140              s->bpp    = 2;
141              fmt = AV_PIX_FMT_RGB555LE; break;
142     case 32: s->stride = w * 4;
143              s->bpp    = 4;
144              fmt = AV_PIX_FMT_BGR0; break;
145     default: return AVERROR_INVALIDDATA;
146     }
147
148     ret = ff_set_dimensions(avctx, w, h);
149     if (ret < 0)
150         return ret;
151     avctx->width  = w;
152     avctx->height = h;
153     avctx->pix_fmt = fmt;
154
155     ret = init_frames(avctx);
156     if (ret < 0)
157         return ret;
158
159     if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
160         uint32_t *pal = (uint32_t *)s->frame2->data[1];
161
162         for (int i = 0; i < 256; i++)
163             pal[i] = bytestream2_get_le32(gb) | 0xFF000000u;
164     }
165
166     return 0;
167 }
168
169 static int decode_zlib(AVCodecContext *avctx, AVPacket *avpkt,
170                        unsigned size, unsigned uncompressed_size)
171 {
172     RASCContext *s = avctx->priv_data;
173     GetByteContext *gb = &s->gb;
174     int zret;
175
176     zret = inflateReset(&s->zstream);
177     if (zret != Z_OK) {
178         av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
179         return AVERROR_EXTERNAL;
180     }
181
182     av_fast_padded_malloc(&s->delta, &s->delta_size, uncompressed_size);
183     if (!s->delta)
184         return AVERROR(ENOMEM);
185
186     s->zstream.next_in  = avpkt->data + bytestream2_tell(gb);
187     s->zstream.avail_in = FFMIN(size, bytestream2_get_bytes_left(gb));
188
189     s->zstream.next_out  = s->delta;
190     s->zstream.avail_out = s->delta_size;
191
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;
197     }
198
199     return 0;
200 }
201
202 static int decode_move(AVCodecContext *avctx,
203                        AVPacket *avpkt, unsigned size)
204 {
205     RASCContext *s = avctx->priv_data;
206     GetByteContext *gb = &s->gb;
207     GetByteContext mc;
208     unsigned pos, compression, nb_moves;
209     unsigned uncompressed_size;
210     int ret;
211
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);
217
218     if (nb_moves > INT32_MAX / 16)
219         return AVERROR_INVALIDDATA;
220
221     uncompressed_size = 16 * nb_moves;
222
223     if (compression == 1) {
224         ret = decode_zlib(avctx, avpkt,
225                           size - (bytestream2_tell(gb) - pos),
226                           uncompressed_size);
227         if (ret < 0)
228             return ret;
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;
236     } else {
237         return AVERROR_INVALIDDATA;
238     }
239
240     if (bytestream2_get_bytes_left(&mc) < uncompressed_size)
241         return AVERROR_INVALIDDATA;
242
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;
246         int w, h;
247
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);
256
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) {
260             continue;
261         }
262
263         if (start_x >= end_x || start_y >= end_y)
264             continue;
265
266         w = end_x - start_x;
267         h = end_y - start_y;
268
269         if (mov_x + w > avctx->width || mov_y + h > avctx->height)
270             continue;
271
272         if (!s->frame2->data[0] || !s->frame1->data[0])
273             return AVERROR_INVALIDDATA;
274
275         b1 = s->frame1->data[0] + s->frame1->linesize[0] * (start_y + h - 1) + start_x * s->bpp;
276         b2 = s->frame2->data[0] + s->frame2->linesize[0] * (start_y + h - 1) + start_x * s->bpp;
277         e2 = s->frame2->data[0] + s->frame2->linesize[0] * (mov_y + h - 1) + mov_x * s->bpp;
278
279         if (type == 2) {
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];
284             }
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];
289             }
290         } else if (type == 0) {
291             uint8_t *buffer;
292
293             av_fast_padded_malloc(&s->delta, &s->delta_size, w * h * s->bpp);
294             buffer = s->delta;
295             if (!buffer)
296                 return AVERROR(ENOMEM);
297
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];
301             }
302
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];
306             }
307         } else {
308             return AVERROR_INVALIDDATA;
309         }
310     }
311
312     bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
313
314     return 0;
315 }
316
317 #define NEXT_LINE                        \
318     if (cx >= w * s->bpp) {              \
319         cx = 0;                          \
320         cy--;                            \
321         b1 -= s->frame1->linesize[0];    \
322         b2 -= s->frame2->linesize[0];    \
323     }                                    \
324     len--;
325
326 static int decode_dlta(AVCodecContext *avctx,
327                        AVPacket *avpkt, unsigned size)
328 {
329     RASCContext *s = avctx->priv_data;
330     GetByteContext *gb = &s->gb;
331     GetByteContext dc;
332     unsigned uncompressed_size, pos;
333     unsigned x, y, w, h;
334     int ret, cx, cy, compression;
335     uint8_t *b1, *b2;
336
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);
344
345     if (x >= avctx->width || y >= avctx->height ||
346         w > avctx->width || h > avctx->height)
347         return AVERROR_INVALIDDATA;
348
349     if (x + w > avctx->width || y + h > avctx->height)
350         return AVERROR_INVALIDDATA;
351
352     bytestream2_skip(gb, 4);
353     compression = bytestream2_get_le32(gb);
354
355     if (compression == 1) {
356         ret = decode_zlib(avctx, avpkt, size, uncompressed_size);
357         if (ret < 0)
358             return ret;
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),
364                          uncompressed_size);
365     } else if (compression == 2) {
366         avpriv_request_sample(avctx, "compression %d", compression);
367         return AVERROR_PATCHWELCOME;
368     } else {
369         return AVERROR_INVALIDDATA;
370     }
371
372     if (!s->frame2->data[0] || !s->frame1->data[0])
373         return AVERROR_INVALIDDATA;
374
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;
377     cx = 0, cy = h;
378     while (bytestream2_get_bytes_left(&dc) > 0) {
379         int type = bytestream2_get_byte(&dc);
380         int len = bytestream2_get_byte(&dc);
381         unsigned fill;
382
383         switch (type) {
384         case 1:
385             while (len > 0 && cy > 0) {
386                 cx++;
387                 NEXT_LINE
388             }
389             break;
390         case 2:
391             while (len > 0 && cy > 0) {
392                 int v0 = b1[cx];
393                 int v1 = b2[cx];
394
395                 b2[cx] = v0;
396                 b1[cx] = v1;
397                 cx++;
398                 NEXT_LINE
399             }
400             break;
401         case 3:
402             while (len > 0 && cy > 0) {
403                 fill = bytestream2_get_byte(&dc);
404                 b1[cx] = b2[cx];
405                 b2[cx] = fill;
406                 cx++;
407                 NEXT_LINE
408             }
409             break;
410         case 4:
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);
415                 cx++;
416                 NEXT_LINE
417             }
418             break;
419         case 7:
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);
424                 cx += 4;
425                 NEXT_LINE
426             }
427             break;
428         case 10:
429             while (len > 0 && cy > 0) {
430                 cx += 4;
431                 NEXT_LINE
432             }
433             break;
434         case 12:
435             while (len > 0 && cy > 0) {
436                 unsigned v0, v1;
437
438                 v0 = AV_RL32(b2 + cx);
439                 v1 = AV_RL32(b1 + cx);
440                 AV_WL32(b2 + cx, v1);
441                 AV_WL32(b1 + cx, v0);
442                 cx += 4;
443                 NEXT_LINE
444             }
445             break;
446         case 13:
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);
451                 cx += 4;
452                 NEXT_LINE
453             }
454             break;
455         default:
456             avpriv_request_sample(avctx, "runlen %d", type);
457             return AVERROR_INVALIDDATA;
458         }
459     }
460
461     bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
462
463     return 0;
464 }
465
466 static int decode_kfrm(AVCodecContext *avctx,
467                        AVPacket *avpkt, unsigned size)
468 {
469     RASCContext *s = avctx->priv_data;
470     GetByteContext *gb = &s->gb;
471     uint8_t *dst;
472     unsigned pos;
473     int zret, ret;
474
475     pos = bytestream2_tell(gb);
476     if (bytestream2_peek_le32(gb) == 0x65) {
477         ret = decode_fint(avctx, avpkt, size);
478         if (ret < 0)
479             return ret;
480     }
481
482     if (!s->frame2->data[0])
483         return AVERROR_INVALIDDATA;
484
485     zret = inflateReset(&s->zstream);
486     if (zret != Z_OK) {
487         av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
488         return AVERROR_EXTERNAL;
489     }
490
491     s->zstream.next_in  = avpkt->data + bytestream2_tell(gb);
492     s->zstream.avail_in = bytestream2_get_bytes_left(gb);
493
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;
498
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;
504         }
505
506         dst -= s->frame2->linesize[0];
507     }
508
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;
513
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;
519         }
520
521         dst -= s->frame1->linesize[0];
522     }
523
524     bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
525
526     return 0;
527 }
528
529 static int decode_mous(AVCodecContext *avctx,
530                        AVPacket *avpkt, unsigned size)
531 {
532     RASCContext *s = avctx->priv_data;
533     GetByteContext *gb = &s->gb;
534     unsigned w, h, pos, uncompressed_size;
535     int ret;
536
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);
543
544     if (w > avctx->width || h > avctx->height)
545         return AVERROR_INVALIDDATA;
546
547     if (uncompressed_size != 3 * w * h)
548         return AVERROR_INVALIDDATA;
549
550     av_fast_padded_malloc(&s->cursor, &s->cursor_size, uncompressed_size);
551     if (!s->cursor)
552         return AVERROR(ENOMEM);
553
554     ret = decode_zlib(avctx, avpkt,
555                       size - (bytestream2_tell(gb) - pos),
556                       uncompressed_size);
557     if (ret < 0)
558         return ret;
559     memcpy(s->cursor, s->delta, uncompressed_size);
560
561     bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
562
563     s->cursor_w = w;
564     s->cursor_h = h;
565
566     return 0;
567 }
568
569 static int decode_mpos(AVCodecContext *avctx,
570                        AVPacket *avpkt, unsigned size)
571 {
572     RASCContext *s = avctx->priv_data;
573     GetByteContext *gb = &s->gb;
574     unsigned pos;
575
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);
580
581     bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
582
583     return 0;
584 }
585
586 static void draw_cursor(AVCodecContext *avctx)
587 {
588     RASCContext *s = avctx->priv_data;
589     uint8_t *dst, *pal;
590
591     if (!s->cursor)
592         return;
593
594     if (s->cursor_x >= avctx->width || s->cursor_y >= avctx->height)
595         return;
596
597     if (s->cursor_x + s->cursor_w > avctx->width ||
598         s->cursor_y + s->cursor_h > avctx->height)
599         return;
600
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];
608                 int best = INT_MAX;
609                 int index = 0;
610                 int dist;
611
612                 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
613                     continue;
614
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];
620
621                     dist = FFABS(cr - pr) + FFABS(cg - pg) + FFABS(cb - pb);
622                     if (dist < best) {
623                         best = dist;
624                         index = k;
625                     }
626                 }
627                 dst[0] = index;
628             }
629         }
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];
636
637                 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
638                     continue;
639
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);
643             }
644         }
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];
651
652                 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
653                     continue;
654
655                 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 4 * (s->cursor_x + j);
656                 dst[0] = cb;
657                 dst[1] = cg;
658                 dst[2] = cr;
659             }
660         }
661     }
662 }
663
664 static int decode_frame(AVCodecContext *avctx,
665                         void *data, int *got_frame,
666                         AVPacket *avpkt)
667 {
668     RASCContext *s = avctx->priv_data;
669     GetByteContext *gb = &s->gb;
670     int ret, intra = 0;
671     AVFrame *frame = data;
672
673     bytestream2_init(gb, avpkt->data, avpkt->size);
674
675     if (bytestream2_peek_le32(gb) == EMPT)
676         return avpkt->size;
677
678     s->frame = frame;
679
680     while (bytestream2_get_bytes_left(gb) > 0) {
681         unsigned type, size = 0;
682
683         type = bytestream2_get_le32(gb);
684         if (type == KBND || type == BNDL) {
685             intra = type == KBND;
686             type = bytestream2_get_le32(gb);
687         }
688
689         size = bytestream2_get_le32(gb);
690         if (bytestream2_get_bytes_left(gb) < size)
691             return AVERROR_INVALIDDATA;
692
693         switch (type) {
694         case FINT:
695         case INIT:
696             ret = decode_fint(avctx, avpkt, size);
697             break;
698         case KFRM:
699             ret = decode_kfrm(avctx, avpkt, size);
700             break;
701         case DLTA:
702             ret = decode_dlta(avctx, avpkt, size);
703             break;
704         case MOVE:
705             ret = decode_move(avctx, avpkt, size);
706             break;
707         case MOUS:
708             ret = decode_mous(avctx, avpkt, size);
709             break;
710         case MPOS:
711             ret = decode_mpos(avctx, avpkt, size);
712             break;
713         default:
714             bytestream2_skip(gb, size);
715         }
716
717         if (ret < 0)
718             return ret;
719     }
720
721     if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
722         return ret;
723
724     if (!s->frame2->data[0] || !s->frame1->data[0])
725         return AVERROR_INVALIDDATA;
726
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);
730     if (!s->skip_cursor)
731         draw_cursor(avctx);
732
733     s->frame->key_frame = intra;
734     s->frame->pict_type = intra ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
735
736     *got_frame = 1;
737
738     return avpkt->size;
739 }
740
741 static av_cold int decode_init(AVCodecContext *avctx)
742 {
743     RASCContext *s = avctx->priv_data;
744     int zret;
745
746     s->zstream.zalloc = Z_NULL;
747     s->zstream.zfree = Z_NULL;
748     s->zstream.opaque = Z_NULL;
749     zret = inflateInit(&s->zstream);
750     if (zret != Z_OK) {
751         av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
752         return AVERROR_EXTERNAL;
753     }
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 0;
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     inflateEnd(&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 AVCodec ff_rasc_decoder = {
799     .name             = "rasc",
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),
804     .init             = decode_init,
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,
812 };