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 <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 };