falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
94858 Commits
32 Branches
290MB
Tree: d620b1f9de
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'd620b1f9de'
${ noResults }
FFmpeg/libavcodec/rasc.c

818 lines
24KB
Raw Blame History 

  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 || nb_moves > avctx->width * avctx->height)

  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.         if (w * h * s->bpp * 3 < uncompressed_size)

  357.             return AVERROR_INVALIDDATA;

  358.         ret = decode_zlib(avctx, avpkt, size, uncompressed_size);

  359.         if (ret < 0)

  360.             return ret;

  361.         bytestream2_init(&dc, s->delta, uncompressed_size);

  362.     } else if (compression == 0) {

  363.         if (bytestream2_get_bytes_left(gb) < uncompressed_size)

  364.             return AVERROR_INVALIDDATA;

  365.         bytestream2_init(&dc, avpkt->data + bytestream2_tell(gb),

  366.                          uncompressed_size);

  367.     } else if (compression == 2) {

  368.         avpriv_request_sample(avctx, "compression %d", compression);

  369.         return AVERROR_PATCHWELCOME;

  370.     } else {

  371.         return AVERROR_INVALIDDATA;

  372.     }

  373. 

  374.     if (!s->frame2->data[0] || !s->frame1->data[0])

  375.         return AVERROR_INVALIDDATA;

  376. 

  377.     b1  = s->frame1->data[0] + s->frame1->linesize[0] * (y + h - 1) + x * s->bpp;

  378.     b2  = s->frame2->data[0] + s->frame2->linesize[0] * (y + h - 1) + x * s->bpp;

  379.     cx = 0, cy = h;

  380.     while (bytestream2_get_bytes_left(&dc) > 0) {

  381.         int type = bytestream2_get_byte(&dc);

  382.         int len = bytestream2_get_byte(&dc);

  383.         unsigned fill;

  384. 

  385.         switch (type) {

  386.         case 1:

  387.             while (len > 0 && cy > 0) {

  388.                 cx++;

  389.                 NEXT_LINE

  390.             }

  391.             break;

  392.         case 2:

  393.             while (len > 0 && cy > 0) {

  394.                 int v0 = b1[cx];

  395.                 int v1 = b2[cx];

  396. 

  397.                 b2[cx] = v0;

  398.                 b1[cx] = v1;

  399.                 cx++;

  400.                 NEXT_LINE

  401.             }

  402.             break;

  403.         case 3:

  404.             while (len > 0 && cy > 0) {

  405.                 fill = bytestream2_get_byte(&dc);

  406.                 b1[cx] = b2[cx];

  407.                 b2[cx] = fill;

  408.                 cx++;

  409.                 NEXT_LINE

  410.             }

  411.             break;

  412.         case 4:

  413.             fill = bytestream2_get_byte(&dc);

  414.             while (len > 0 && cy > 0) {

  415.                 AV_WL32(b1 + cx, AV_RL32(b2 + cx));

  416.                 AV_WL32(b2 + cx, fill);

  417.                 cx++;

  418.                 NEXT_LINE

  419.             }

  420.             break;

  421.         case 7:

  422.             fill = bytestream2_get_le32(&dc);

  423.             while (len > 0 && cy > 0) {

  424.                 AV_WL32(b1 + cx, AV_RL32(b2 + cx));

  425.                 AV_WL32(b2 + cx, fill);

  426.                 cx += 4;

  427.                 NEXT_LINE

  428.             }

  429.             break;

  430.         case 10:

  431.             while (len > 0 && cy > 0) {

  432.                 cx += 4;

  433.                 NEXT_LINE

  434.             }

  435.             break;

  436.         case 12:

  437.             while (len > 0 && cy > 0) {

  438.                 unsigned v0, v1;

  439. 

  440.                 v0 = AV_RL32(b2 + cx);

  441.                 v1 = AV_RL32(b1 + cx);

  442.                 AV_WL32(b2 + cx, v1);

  443.                 AV_WL32(b1 + cx, v0);

  444.                 cx += 4;

  445.                 NEXT_LINE

  446.             }

  447.             break;

  448.         case 13:

  449.             while (len > 0 && cy > 0) {

  450.                 fill = bytestream2_get_le32(&dc);

  451.                 AV_WL32(b1 + cx, AV_RL32(b2 + cx));

  452.                 AV_WL32(b2 + cx, fill);

  453.                 cx += 4;

  454.                 NEXT_LINE

  455.             }

  456.             break;

  457.         default:

  458.             avpriv_request_sample(avctx, "runlen %d", type);

  459.             return AVERROR_INVALIDDATA;

  460.         }

  461.     }

  462. 

  463.     bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));

  464. 

  465.     return 0;

  466. }

  467. 

  468. static int decode_kfrm(AVCodecContext *avctx,

  469.                        AVPacket *avpkt, unsigned size)

  470. {

  471.     RASCContext *s = avctx->priv_data;

  472.     GetByteContext *gb = &s->gb;

  473.     uint8_t *dst;

  474.     unsigned pos;

  475.     int zret, ret;

  476. 

  477.     pos = bytestream2_tell(gb);

  478.     if (bytestream2_peek_le32(gb) == 0x65) {

  479.         ret = decode_fint(avctx, avpkt, size);

  480.         if (ret < 0)

  481.             return ret;

  482.     }

  483. 

  484.     if (!s->frame2->data[0])

  485.         return AVERROR_INVALIDDATA;

  486. 

  487.     zret = inflateReset(&s->zstream);

  488.     if (zret != Z_OK) {

  489.         av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);

  490.         return AVERROR_EXTERNAL;

  491.     }

  492. 

  493.     s->zstream.next_in  = avpkt->data + bytestream2_tell(gb);

  494.     s->zstream.avail_in = bytestream2_get_bytes_left(gb);

  495. 

  496.     dst = s->frame2->data[0] + (avctx->height - 1) * s->frame2->linesize[0];

  497.     for (int i = 0; i < avctx->height; i++) {

  498.         s->zstream.next_out  = dst;

  499.         s->zstream.avail_out = s->stride;

  500. 

  501.         zret = inflate(&s->zstream, Z_SYNC_FLUSH);

  502.         if (zret != Z_OK && zret != Z_STREAM_END) {

  503.             av_log(avctx, AV_LOG_ERROR,

  504.                    "Inflate failed with return code: %d.\n", zret);

  505.             return AVERROR_INVALIDDATA;

  506.         }

  507. 

  508.         dst -= s->frame2->linesize[0];

  509.     }

  510. 

  511.     dst = s->frame1->data[0] + (avctx->height - 1) * s->frame1->linesize[0];

  512.     for (int i = 0; i < avctx->height; i++) {

  513.         s->zstream.next_out  = dst;

  514.         s->zstream.avail_out = s->stride;

  515. 

  516.         zret = inflate(&s->zstream, Z_SYNC_FLUSH);

  517.         if (zret != Z_OK && zret != Z_STREAM_END) {

  518.             av_log(avctx, AV_LOG_ERROR,

  519.                    "Inflate failed with return code: %d.\n", zret);

  520.             return AVERROR_INVALIDDATA;

  521.         }

  522. 

  523.         dst -= s->frame1->linesize[0];

  524.     }

  525. 

  526.     bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));

  527. 

  528.     return 0;

  529. }

  530. 

  531. static int decode_mous(AVCodecContext *avctx,

  532.                        AVPacket *avpkt, unsigned size)

  533. {

  534.     RASCContext *s = avctx->priv_data;

  535.     GetByteContext *gb = &s->gb;

  536.     unsigned w, h, pos, uncompressed_size;

  537.     int ret;

  538. 

  539.     pos = bytestream2_tell(gb);

  540.     bytestream2_skip(gb, 8);

  541.     w = bytestream2_get_le32(gb);

  542.     h = bytestream2_get_le32(gb);

  543.     bytestream2_skip(gb, 12);

  544.     uncompressed_size = bytestream2_get_le32(gb);

  545. 

  546.     if (w > avctx->width || h > avctx->height)

  547.         return AVERROR_INVALIDDATA;

  548. 

  549.     if (uncompressed_size != 3 * w * h)

  550.         return AVERROR_INVALIDDATA;

  551. 

  552.     av_fast_padded_malloc(&s->cursor, &s->cursor_size, uncompressed_size);

  553.     if (!s->cursor)

  554.         return AVERROR(ENOMEM);

  555. 

  556.     ret = decode_zlib(avctx, avpkt,

  557.                       size - (bytestream2_tell(gb) - pos),

  558.                       uncompressed_size);

  559.     if (ret < 0)

  560.         return ret;

  561.     memcpy(s->cursor, s->delta, uncompressed_size);

  562. 

  563.     bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));

  564. 

  565.     s->cursor_w = w;

  566.     s->cursor_h = h;

  567. 

  568.     return 0;

  569. }

  570. 

  571. static int decode_mpos(AVCodecContext *avctx,

  572.                        AVPacket *avpkt, unsigned size)

  573. {

  574.     RASCContext *s = avctx->priv_data;

  575.     GetByteContext *gb = &s->gb;

  576.     unsigned pos;

  577. 

  578.     pos = bytestream2_tell(gb);

  579.     bytestream2_skip(gb, 8);

  580.     s->cursor_x = bytestream2_get_le32(gb);

  581.     s->cursor_y = bytestream2_get_le32(gb);

  582. 

  583.     bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));

  584. 

  585.     return 0;

  586. }

  587. 

  588. static void draw_cursor(AVCodecContext *avctx)

  589. {

  590.     RASCContext *s = avctx->priv_data;

  591.     uint8_t *dst, *pal;

  592. 

  593.     if (!s->cursor)

  594.         return;

  595. 

  596.     if (s->cursor_x >= avctx->width || s->cursor_y >= avctx->height)

  597.         return;

  598. 

  599.     if (s->cursor_x + s->cursor_w > avctx->width ||

  600.         s->cursor_y + s->cursor_h > avctx->height)

  601.         return;

  602. 

  603.     if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

  604.         pal = s->frame->data[1];

  605.         for (int i = 0; i < s->cursor_h; i++) {

  606.             for (int j = 0; j < s->cursor_w; j++) {

  607.                 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];

  608.                 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];

  609.                 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];

  610.                 int best = INT_MAX;

  611.                 int index = 0;

  612.                 int dist;

  613. 

  614.                 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])

  615.                     continue;

  616. 

  617.                 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + (s->cursor_x + j);

  618.                 for (int k = 0; k < 256; k++) {

  619.                     int pr = pal[k * 4 + 0];

  620.                     int pg = pal[k * 4 + 1];

  621.                     int pb = pal[k * 4 + 2];

  622. 

  623.                     dist = FFABS(cr - pr) + FFABS(cg - pg) + FFABS(cb - pb);

  624.                     if (dist < best) {

  625.                         best = dist;

  626.                         index = k;

  627.                     }

  628.                 }

  629.                 dst[0] = index;

  630.             }

  631.         }

  632.     } else if (avctx->pix_fmt == AV_PIX_FMT_RGB555LE) {

  633.         for (int i = 0; i < s->cursor_h; i++) {

  634.             for (int j = 0; j < s->cursor_w; j++) {

  635.                 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];

  636.                 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];

  637.                 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];

  638. 

  639.                 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])

  640.                     continue;

  641. 

  642.                 cr >>= 3; cg >>=3; cb >>= 3;

  643.                 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 2 * (s->cursor_x + j);

  644.                 AV_WL16(dst, cr | cg << 5 | cb << 10);

  645.             }

  646.         }

  647.     } else if (avctx->pix_fmt == AV_PIX_FMT_BGR0) {

  648.         for (int i = 0; i < s->cursor_h; i++) {

  649.             for (int j = 0; j < s->cursor_w; j++) {

  650.                 int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];

  651.                 int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];

  652.                 int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];

  653. 

  654.                 if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])

  655.                     continue;

  656. 

  657.                 dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 4 * (s->cursor_x + j);

  658.                 dst[0] = cb;

  659.                 dst[1] = cg;

  660.                 dst[2] = cr;

  661.             }

  662.         }

  663.     }

  664. }

  665. 

  666. static int decode_frame(AVCodecContext *avctx,

  667.                         void *data, int *got_frame,

  668.                         AVPacket *avpkt)

  669. {

  670.     RASCContext *s = avctx->priv_data;

  671.     GetByteContext *gb = &s->gb;

  672.     int ret, intra = 0;

  673.     AVFrame *frame = data;

  674. 

  675.     bytestream2_init(gb, avpkt->data, avpkt->size);

  676. 

  677.     if (bytestream2_peek_le32(gb) == EMPT)

  678.         return avpkt->size;

  679. 

  680.     s->frame = frame;

  681. 

  682.     while (bytestream2_get_bytes_left(gb) > 0) {

  683.         unsigned type, size = 0;

  684. 

  685.         if (bytestream2_get_bytes_left(gb) < 8)

  686.             return AVERROR_INVALIDDATA;

  687. 

  688.         type = bytestream2_get_le32(gb);

  689.         if (type == KBND || type == BNDL) {

  690.             intra = type == KBND;

  691.             type = bytestream2_get_le32(gb);

  692.         }

  693. 

  694.         size = bytestream2_get_le32(gb);

  695.         if (bytestream2_get_bytes_left(gb) < size)

  696.             return AVERROR_INVALIDDATA;

  697. 

  698.         switch (type) {

  699.         case FINT:

  700.         case INIT:

  701.             ret = decode_fint(avctx, avpkt, size);

  702.             break;

  703.         case KFRM:

  704.             ret = decode_kfrm(avctx, avpkt, size);

  705.             break;

  706.         case DLTA:

  707.             ret = decode_dlta(avctx, avpkt, size);

  708.             break;

  709.         case MOVE:

  710.             ret = decode_move(avctx, avpkt, size);

  711.             break;

  712.         case MOUS:

  713.             ret = decode_mous(avctx, avpkt, size);

  714.             break;

  715.         case MPOS:

  716.             ret = decode_mpos(avctx, avpkt, size);

  717.             break;

  718.         default:

  719.             bytestream2_skip(gb, size);

  720.         }

  721. 

  722.         if (ret < 0)

  723.             return ret;

  724.     }

  725. 

  726.     if (!s->frame2->data[0] || !s->frame1->data[0])

  727.         return AVERROR_INVALIDDATA;

  728. 

  729.     if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)

  730.         return ret;

  731. 

  732.     copy_plane(avctx, s->frame2, s->frame);

  733.     if (avctx->pix_fmt == AV_PIX_FMT_PAL8)

  734.         memcpy(s->frame->data[1], s->frame2->data[1], 1024);

  735.     if (!s->skip_cursor)

  736.         draw_cursor(avctx);

  737. 

  738.     s->frame->key_frame = intra;

  739.     s->frame->pict_type = intra ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;

  740. 

  741.     *got_frame = 1;

  742. 

  743.     return avpkt->size;

  744. }

  745. 

  746. static av_cold int decode_init(AVCodecContext *avctx)

  747. {

  748.     RASCContext *s = avctx->priv_data;

  749.     int zret;

  750. 

  751.     s->zstream.zalloc = Z_NULL;

  752.     s->zstream.zfree = Z_NULL;

  753.     s->zstream.opaque = Z_NULL;

  754.     zret = inflateInit(&s->zstream);

  755.     if (zret != Z_OK) {

  756.         av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);

  757.         return AVERROR_EXTERNAL;

  758.     }

  759. 

  760.     s->frame1 = av_frame_alloc();

  761.     s->frame2 = av_frame_alloc();

  762.     if (!s->frame1 || !s->frame2)

  763.         return AVERROR(ENOMEM);

  764. 

  765.     return 0;

  766. }

  767. 

  768. static av_cold int decode_close(AVCodecContext *avctx)

  769. {

  770.     RASCContext *s = avctx->priv_data;

  771. 

  772.     av_freep(&s->cursor);

  773.     s->cursor_size = 0;

  774.     av_freep(&s->delta);

  775.     s->delta_size = 0;

  776.     av_frame_free(&s->frame1);

  777.     av_frame_free(&s->frame2);

  778.     inflateEnd(&s->zstream);

  779. 

  780.     return 0;

  781. }

  782. 

  783. static void decode_flush(AVCodecContext *avctx)

  784. {

  785.     RASCContext *s = avctx->priv_data;

  786. 

  787.     clear_plane(avctx, s->frame1);

  788.     clear_plane(avctx, s->frame2);

  789. }

  790. 

  791. static const AVOption options[] = {

  792. { "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 },

  793. { NULL },

  794. };

  795. 

  796. static const AVClass rasc_decoder_class = {

  797.     .class_name = "rasc decoder",

  798.     .item_name  = av_default_item_name,

  799.     .option     = options,

  800.     .version    = LIBAVUTIL_VERSION_INT,

  801. };

  802. 

  803. AVCodec ff_rasc_decoder = {

  804.     .name             = "rasc",

  805.     .long_name        = NULL_IF_CONFIG_SMALL("RemotelyAnywhere Screen Capture"),

  806.     .type             = AVMEDIA_TYPE_VIDEO,

  807.     .id               = AV_CODEC_ID_RASC,

  808.     .priv_data_size   = sizeof(RASCContext),

  809.     .init             = decode_init,

  810.     .close            = decode_close,

  811.     .decode           = decode_frame,

  812.     .flush            = decode_flush,

  813.     .capabilities     = AV_CODEC_CAP_DR1,

  814.     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE |

  815.                         FF_CODEC_CAP_INIT_CLEANUP,

  816.     .priv_class       = &rasc_decoder_class,

  817. };