@@ -2719,6 +2719,7 @@ qdm2_decoder_select="mdct rdft mpegaudiodsp"
ra_144_decoder_select="audiodsp"
ra_144_encoder_select="audio_frame_queue lpc audiodsp"
ralf_decoder_select="golomb"
+rasc_decoder_deps="zlib"
rawvideo_decoder_select="bswapdsp"
rscc_decoder_deps="zlib"
rtjpeg_decoder_select="me_cmp"
@@ -536,6 +536,7 @@ OBJS-$(CONFIG_RA_144_DECODER) += ra144dec.o ra144.o celp_filters.o
OBJS-$(CONFIG_RA_144_ENCODER) += ra144enc.o ra144.o celp_filters.o
OBJS-$(CONFIG_RA_288_DECODER) += ra288.o celp_filters.o
OBJS-$(CONFIG_RALF_DECODER) += ralf.o
+OBJS-$(CONFIG_RASC_DECODER) += rasc.o
OBJS-$(CONFIG_RAWVIDEO_DECODER) += rawdec.o
OBJS-$(CONFIG_RAWVIDEO_ENCODER) += rawenc.o
OBJS-$(CONFIG_REALTEXT_DECODER) += realtextdec.o ass.o
@@ -248,6 +248,7 @@ extern AVCodec ff_r10k_encoder;
extern AVCodec ff_r10k_decoder;
extern AVCodec ff_r210_encoder;
extern AVCodec ff_r210_decoder;
+extern AVCodec ff_rasc_decoder;
extern AVCodec ff_rawvideo_encoder;
extern AVCodec ff_rawvideo_decoder;
extern AVCodec ff_rl2_decoder;
@@ -451,6 +451,7 @@ enum AVCodecID {
AV_CODEC_ID_PROSUMER,
AV_CODEC_ID_MWSC,
AV_CODEC_ID_WCMV,
+ AV_CODEC_ID_RASC,
/* various PCM "codecs" */
AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
@@ -1682,6 +1682,13 @@ static const AVCodecDescriptor codec_descriptors[] = {
.long_name = NULL_IF_CONFIG_SMALL("WinCAM Motion Video"),
.props = AV_CODEC_PROP_LOSSLESS,
},
+ {
+ .id = AV_CODEC_ID_RASC,
+ .type = AVMEDIA_TYPE_VIDEO,
+ .name = "rasc",
+ .long_name = NULL_IF_CONFIG_SMALL("RemotelyAnywhere Screen Capture"),
+ .props = AV_CODEC_PROP_LOSSY,
+ },
/* various PCM "codecs" */
{
new file mode 100644
@@ -0,0 +1,789 @@
+/*
+ * RemotelyAnywhere Screen Capture decoder
+ *
+ * Copyright (c) 2018 Paul B Mahol
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "libavutil/avassert.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
+
+#include "avcodec.h"
+#include "bytestream.h"
+#include "internal.h"
+
+#include <zlib.h>
+
+#define KBND MKTAG('K', 'B', 'N', 'D')
+#define FINT MKTAG('F', 'I', 'N', 'T')
+#define INIT MKTAG('I', 'N', 'I', 'T')
+#define BNDL MKTAG('B', 'N', 'D', 'L')
+#define KFRM MKTAG('K', 'F', 'R', 'M')
+#define DLTA MKTAG('D', 'L', 'T', 'A')
+#define MOUS MKTAG('M', 'O', 'U', 'S')
+#define MPOS MKTAG('M', 'P', 'O', 'S')
+#define MOVE MKTAG('M', 'O', 'V', 'E')
+#define EMPT MKTAG('E', 'M', 'P', 'T')
+
+typedef struct RASCContext {
+ AVClass *class;
+ int skip_cursor;
+ GetByteContext gb;
+ uint8_t *delta;
+ int delta_size;
+ uint8_t *cursor;
+ int cursor_size;
+ unsigned cursor_w;
+ unsigned cursor_h;
+ unsigned cursor_x;
+ unsigned cursor_y;
+ int stride;
+ int bpp;
+ z_stream zstream;
+ AVFrame *frame;
+ AVFrame *frame1;
+ AVFrame *frame2;
+} RASCContext;
+
+static void clear_plane(AVCodecContext *avctx, AVFrame *frame)
+{
+ uint8_t *dst = frame->data[0];
+
+ for (int y = 0; y < avctx->height; y++) {
+ memset(dst, 0, avctx->width);
+ dst += frame->linesize[0];
+ }
+}
+
+static void copy_plane(AVCodecContext *avctx, AVFrame *src, AVFrame *dst)
+{
+ RASCContext *s = avctx->priv_data;
+ uint8_t *srcp = src->data[0];
+ uint8_t *dstp = dst->data[0];
+
+ for (int y = 0; y < avctx->height; y++) {
+ memcpy(dstp, srcp, s->stride);
+ srcp += src->linesize[0];
+ dstp += dst->linesize[0];
+ }
+}
+
+static int init_frames(AVCodecContext *avctx)
+{
+ RASCContext *s = avctx->priv_data;
+ int ret;
+
+ av_frame_unref(s->frame1);
+ if ((ret = ff_get_buffer(avctx, s->frame1, 0)) < 0)
+ return ret;
+
+ av_frame_unref(s->frame2);
+ if ((ret = ff_get_buffer(avctx, s->frame2, 0)) < 0)
+ return ret;
+
+ clear_plane(avctx, s->frame2);
+ clear_plane(avctx, s->frame1);
+
+ return 0;
+}
+
+static int decode_fint(AVCodecContext *avctx,
+ AVPacket *avpkt, unsigned size)
+{
+ RASCContext *s = avctx->priv_data;
+ GetByteContext *gb = &s->gb;
+ unsigned w, h, fmt;
+ int ret;
+
+ if (bytestream2_peek_le32(gb) != 0x65) {
+ clear_plane(avctx, s->frame2);
+ clear_plane(avctx, s->frame1);
+ return 0;
+ }
+
+ bytestream2_skip(gb, 8);
+ w = bytestream2_get_le32(gb);
+ h = bytestream2_get_le32(gb);
+ bytestream2_skip(gb, 30);
+ fmt = bytestream2_get_le16(gb);
+ bytestream2_skip(gb, 24);
+
+ switch (fmt) {
+ case 8: s->stride = FFALIGN(w, 4);
+ s->bpp = 1;
+ fmt = AV_PIX_FMT_PAL8; break;
+ case 16: s->stride = w * 2;
+ s->bpp = 2;
+ fmt = AV_PIX_FMT_RGB555; break;
+ case 32: s->stride = w * 4;
+ s->bpp = 4;
+ fmt = AV_PIX_FMT_BGR0; break;
+ default: return AVERROR_INVALIDDATA;
+ }
+
+ ret = ff_set_dimensions(avctx, w, h);
+ if (ret < 0)
+ return ret;
+ avctx->width = w;
+ avctx->height = h;
+ avctx->pix_fmt = fmt;
+
+ ret = init_frames(avctx);
+ if (ret < 0)
+ return ret;
+
+ if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
+ uint32_t *pal = (uint32_t *)s->frame2->data[1];
+
+ for (int i = 0; i < 256; i++)
+ pal[i] = bytestream2_get_le32(gb) | 0xFF000000u;
+ }
+
+ return 0;
+}
+
+static int decode_zlib(AVCodecContext *avctx, AVPacket *avpkt,
+ unsigned size, unsigned uncompressed_size)
+{
+ RASCContext *s = avctx->priv_data;
+ GetByteContext *gb = &s->gb;
+ int zret;
+
+ zret = inflateReset(&s->zstream);
+ if (zret != Z_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
+ return AVERROR_EXTERNAL;
+ }
+
+ av_fast_padded_malloc(&s->delta, &s->delta_size, uncompressed_size);
+ if (!s->delta)
+ return AVERROR(ENOMEM);
+
+ s->zstream.next_in = avpkt->data + bytestream2_tell(gb);
+ s->zstream.avail_in = FFMIN(size, bytestream2_get_bytes_left(gb));
+
+ s->zstream.next_out = s->delta;
+ s->zstream.avail_out = s->delta_size;
+
+ zret = inflate(&s->zstream, Z_FINISH);
+ if (zret != Z_STREAM_END) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Inflate failed with return code: %d.\n", zret);
+ return AVERROR_INVALIDDATA;
+ }
+
+ return 0;
+}
+
+static int decode_move(AVCodecContext *avctx,
+ AVPacket *avpkt, unsigned size)
+{
+ RASCContext *s = avctx->priv_data;
+ GetByteContext *gb = &s->gb;
+ GetByteContext mc;
+ unsigned pos, compression, nb_moves;
+ unsigned uncompressed_size;
+ int ret;
+
+ pos = bytestream2_tell(gb);
+ bytestream2_skip(gb, 8);
+ nb_moves = bytestream2_get_le32(gb);
+ bytestream2_skip(gb, 8);
+ compression = bytestream2_get_le32(gb);
+
+ if (nb_moves > INT32_MAX / 16)
+ return AVERROR_INVALIDDATA;
+
+ uncompressed_size = 16 * nb_moves;
+
+ if (compression == 1) {
+ ret = decode_zlib(avctx, avpkt,
+ size - (bytestream2_tell(gb) - pos),
+ uncompressed_size);
+ if (ret < 0)
+ return ret;
+ bytestream2_init(&mc, s->delta, uncompressed_size);
+ } else if (compression == 0) {
+ bytestream2_init(&mc, avpkt->data + bytestream2_tell(gb),
+ bytestream2_get_bytes_left(gb));
+ } else if (compression == 2) {
+ avpriv_request_sample(avctx, "compression %d", compression);
+ return AVERROR_PATCHWELCOME;
+ } else {
+ return AVERROR_INVALIDDATA;
+ }
+
+ if (bytestream2_get_bytes_left(&mc) < uncompressed_size)
+ return AVERROR_INVALIDDATA;
+
+ for (int i = 0; i < nb_moves; i++) {
+ int type, start_x, start_y, end_x, end_y, mov_x, mov_y;
+ uint8_t *e2, *b1, *b2;
+ int w, h;
+
+ type = bytestream2_get_le16(&mc);
+ start_x = bytestream2_get_le16(&mc);
+ start_y = bytestream2_get_le16(&mc);
+ end_x = bytestream2_get_le16(&mc);
+ end_y = bytestream2_get_le16(&mc);
+ mov_x = bytestream2_get_le16(&mc);
+ mov_y = bytestream2_get_le16(&mc);
+ bytestream2_skip(&mc, 2);
+
+ if (start_x >= avctx->width || start_y >= avctx->height ||
+ end_x >= avctx->width || end_y >= avctx->height ||
+ mov_x >= avctx->width || mov_y >= avctx->height) {
+ continue;
+ }
+
+ if (start_x >= end_x || start_y >= end_y)
+ continue;
+
+ w = end_x - start_x;
+ h = end_y - start_y;
+
+ if (mov_x + w > avctx->width || mov_y + h > avctx->height)
+ continue;
+
+ if (!s->frame2->data[0] || !s->frame1->data[0])
+ return AVERROR_INVALIDDATA;
+
+ b1 = s->frame1->data[0] + s->frame1->linesize[0] * (start_y + h) + start_x * s->bpp;
+ b2 = s->frame2->data[0] + s->frame2->linesize[0] * (start_y + h) + start_x * s->bpp;
+ e2 = s->frame2->data[0] + s->frame2->linesize[0] * (mov_y + h) + mov_x * s->bpp;
+
+ if (type == 2) {
+ for (int j = 0; j < h; j++) {
+ memcpy(b1, b2, w * s->bpp);
+ b1 -= s->frame1->linesize[0];
+ b2 -= s->frame2->linesize[0];
+ }
+ } else if (type == 1) {
+ for (int j = 0; j < h; j++) {
+ memset(b2, 0, w * s->bpp);
+ b2 -= s->frame2->linesize[0];
+ }
+ } else if (type == 0) {
+ uint8_t *buffer;
+
+ av_fast_padded_malloc(&s->delta, &s->delta_size, w * h * s->bpp);
+ buffer = s->delta;
+ if (!buffer)
+ return AVERROR(ENOMEM);
+
+ for (int j = 0; j < h; j++) {
+ memcpy(buffer + j * w * s->bpp, e2, w * s->bpp);
+ e2 -= s->frame2->linesize[0];
+ }
+
+ for (int j = 0; j < h; j++) {
+ memcpy(b2, buffer + j * w * s->bpp, w * s->bpp);
+ b2 -= s->frame2->linesize[0];
+ }
+ } else {
+ return AVERROR_INVALIDDATA;
+ }
+ }
+
+ bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
+
+ return 0;
+}
+
+#define NEXT_LINE \
+ if (cx >= w * s->bpp) { \
+ cx = 0; \
+ cy--; \
+ b1 -= s->frame1->linesize[0]; \
+ b2 -= s->frame2->linesize[0]; \
+ } \
+ len--;
+
+static int decode_dlta(AVCodecContext *avctx,
+ AVPacket *avpkt, unsigned size)
+{
+ RASCContext *s = avctx->priv_data;
+ GetByteContext *gb = &s->gb;
+ GetByteContext dc;
+ unsigned uncompressed_size, pos;
+ unsigned x, y, w, h;
+ int ret, cx, cy, compression;
+ uint8_t *b1, *b2;
+
+ pos = bytestream2_tell(gb);
+ bytestream2_skip(gb, 12);
+ uncompressed_size = bytestream2_get_le32(gb);
+ x = bytestream2_get_le32(gb);
+ y = bytestream2_get_le32(gb);
+ w = bytestream2_get_le32(gb);
+ h = bytestream2_get_le32(gb);
+
+ if (x >= avctx->width || y >= avctx->height ||
+ w > avctx->width || h > avctx->height)
+ return AVERROR_INVALIDDATA;
+
+ if (x + w > avctx->width || y + h > avctx->height)
+ return AVERROR_INVALIDDATA;
+
+ bytestream2_skip(gb, 4);
+ compression = bytestream2_get_le32(gb);
+
+ if (compression == 1) {
+ ret = decode_zlib(avctx, avpkt, size, uncompressed_size);
+ if (ret < 0)
+ return ret;
+ bytestream2_init(&dc, s->delta, uncompressed_size);
+ } else if (compression == 0) {
+ if (bytestream2_get_bytes_left(gb) < uncompressed_size)
+ return AVERROR_INVALIDDATA;
+ bytestream2_init(&dc, avpkt->data + bytestream2_tell(gb),
+ uncompressed_size);
+ } else if (compression == 2) {
+ avpriv_request_sample(avctx, "compression %d", compression);
+ return AVERROR_PATCHWELCOME;
+ } else {
+ return AVERROR_INVALIDDATA;
+ }
+
+ if (!s->frame2->data[0] || !s->frame1->data[0])
+ return AVERROR_INVALIDDATA;
+
+ b1 = s->frame1->data[0] + s->frame1->linesize[0] * (y + h - 1) + x * s->bpp;
+ b2 = s->frame2->data[0] + s->frame2->linesize[0] * (y + h - 1) + x * s->bpp;
+ cx = 0, cy = h;
+ while (bytestream2_get_bytes_left(&dc) > 0) {
+ int type = bytestream2_get_byte(&dc);
+ int len = bytestream2_get_byte(&dc);
+ unsigned fill;
+
+ switch (type) {
+ case 1:
+ while (len > 0 && cy > 0) {
+ cx++;
+ NEXT_LINE
+ }
+ break;
+ case 2:
+ while (len > 0 && cy > 0) {
+ int v0 = b1[cx];
+ int v1 = b2[cx];
+
+ b2[cx] = v0;
+ b1[cx] = v1;
+ cx++;
+ NEXT_LINE
+ }
+ break;
+ case 3:
+ while (len > 0 && cy > 0) {
+ fill = bytestream2_get_byte(&dc);
+ b1[cx] = b2[cx];
+ b2[cx] = fill;
+ cx++;
+ NEXT_LINE
+ }
+ break;
+ case 4:
+ fill = bytestream2_get_byte(&dc);
+ while (len > 0 && cy > 0) {
+ AV_WL32(b1 + cx, AV_RL32(b2 + cx));
+ AV_WL32(b2 + cx, fill);
+ cx++;
+ NEXT_LINE
+ }
+ break;
+ case 7:
+ fill = bytestream2_get_le32(&dc);
+ while (len > 0 && cy > 0) {
+ AV_WL32(b1 + cx, AV_RL32(b2 + cx));
+ AV_WL32(b2 + cx, fill);
+ cx += 4;
+ NEXT_LINE
+ }
+ break;
+ case 10:
+ while (len > 0 && cy > 0) {
+ cx += 4;
+ NEXT_LINE
+ }
+ break;
+ case 12:
+ while (len > 0 && cy > 0) {
+ unsigned v0, v1;
+
+ v0 = AV_RL32(b2 + cx);
+ v1 = AV_RL32(b1 + cx);
+ AV_WL32(b2 + cx, v1);
+ AV_WL32(b1 + cx, v0);
+ cx += 4;
+ NEXT_LINE
+ }
+ break;
+ case 13:
+ while (len > 0 && cy > 0) {
+ fill = bytestream2_get_le32(&dc);
+ AV_WL32(b1 + cx, AV_RL32(b2 + cx));
+ AV_WL32(b2 + cx, fill);
+ cx += 4;
+ NEXT_LINE
+ }
+ break;
+ default:
+ printf("%d %d\n", type, bytestream2_tell(&dc));
+ bytestream2_seek(&dc, 0, SEEK_SET);
+ for (int i = 0; bytestream2_get_bytes_left(&dc) > 0; i++)
+ printf("%02X ", bytestream2_get_byte(&dc));
+ printf("\n");
+ return AVERROR_INVALIDDATA;
+ }
+ }
+
+ bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
+
+ return 0;
+}
+
+static int decode_kfrm(AVCodecContext *avctx,
+ AVPacket *avpkt, unsigned size)
+{
+ RASCContext *s = avctx->priv_data;
+ GetByteContext *gb = &s->gb;
+ uint8_t *dst;
+ unsigned pos;
+ int zret, ret;
+
+ pos = bytestream2_tell(gb);
+ if (bytestream2_peek_le32(gb) == 0x65) {
+ ret = decode_fint(avctx, avpkt, size);
+ if (ret < 0)
+ return ret;
+ }
+
+ if (!s->frame2->data[0])
+ return AVERROR_INVALIDDATA;
+
+ zret = inflateReset(&s->zstream);
+ if (zret != Z_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
+ return AVERROR_EXTERNAL;
+ }
+
+ s->zstream.next_in = avpkt->data + bytestream2_tell(gb);
+ s->zstream.avail_in = bytestream2_get_bytes_left(gb);
+
+ dst = s->frame2->data[0] + (avctx->height - 1) * s->frame2->linesize[0];
+ for (int i = 0; i < avctx->height; i++) {
+ s->zstream.next_out = dst;
+ s->zstream.avail_out = s->stride;
+
+ zret = inflate(&s->zstream, Z_SYNC_FLUSH);
+ if (zret != Z_OK && zret != Z_STREAM_END) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Inflate failed with return code: %d.\n", zret);
+ return AVERROR_INVALIDDATA;
+ }
+
+ dst -= s->frame2->linesize[0];
+ }
+
+ dst = s->frame1->data[0] + (avctx->height - 1) * s->frame1->linesize[0];
+ for (int i = 0; i < avctx->height; i++) {
+ s->zstream.next_out = dst;
+ s->zstream.avail_out = s->stride;
+
+ zret = inflate(&s->zstream, Z_SYNC_FLUSH);
+ if (zret != Z_OK && zret != Z_STREAM_END) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Inflate failed with return code: %d.\n", zret);
+ return AVERROR_INVALIDDATA;
+ }
+
+ dst -= s->frame1->linesize[0];
+ }
+
+ bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
+
+ return 0;
+}
+
+static int decode_mous(AVCodecContext *avctx,
+ AVPacket *avpkt, unsigned size)
+{
+ RASCContext *s = avctx->priv_data;
+ GetByteContext *gb = &s->gb;
+ unsigned pos, uncompressed_size;
+ int ret;
+
+ pos = bytestream2_tell(gb);
+ bytestream2_skip(gb, 8);
+ s->cursor_w = bytestream2_get_le32(gb);
+ s->cursor_h = bytestream2_get_le32(gb);
+ bytestream2_skip(gb, 12);
+ uncompressed_size = bytestream2_get_le32(gb);
+
+ if (s->cursor_w > avctx->width ||
+ s->cursor_h > avctx->height)
+ return AVERROR_INVALIDDATA;
+
+ if (uncompressed_size < 3 * s->cursor_w * s->cursor_h)
+ return AVERROR_INVALIDDATA;
+
+ av_fast_padded_malloc(&s->cursor, &s->cursor_size, uncompressed_size);
+ if (!s->cursor)
+ return AVERROR(ENOMEM);
+
+ ret = decode_zlib(avctx, avpkt,
+ size - (bytestream2_tell(gb) - pos),
+ uncompressed_size);
+ if (ret < 0)
+ return ret;
+ memcpy(s->cursor, s->delta, uncompressed_size);
+
+ bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
+
+ return 0;
+}
+
+static int decode_mpos(AVCodecContext *avctx,
+ AVPacket *avpkt, unsigned size)
+{
+ RASCContext *s = avctx->priv_data;
+ GetByteContext *gb = &s->gb;
+ unsigned pos;
+
+ pos = bytestream2_tell(gb);
+ bytestream2_skip(gb, 8);
+ s->cursor_x = bytestream2_get_le32(gb);
+ s->cursor_y = bytestream2_get_le32(gb);
+
+ bytestream2_skip(gb, size - (bytestream2_tell(gb) - pos));
+
+ return 0;
+}
+
+static void draw_cursor(AVCodecContext *avctx)
+{
+ RASCContext *s = avctx->priv_data;
+ uint8_t *dst, *pal;
+
+ if (s->cursor_x >= avctx->width || s->cursor_y >= avctx->height)
+ return;
+
+ if (s->cursor_x + s->cursor_w > avctx->width ||
+ s->cursor_y + s->cursor_h > avctx->height)
+ return;
+
+ if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
+ pal = s->frame->data[1];
+ for (int i = 0; i < s->cursor_h; i++) {
+ for (int j = 0; j < s->cursor_w; j++) {
+ int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
+ int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
+ int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
+ int best = INT_MAX;
+ int index = 0;
+ int dist;
+
+ if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
+ continue;
+
+ dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + (s->cursor_x + j);
+ for (int k = 0; k < 256; k++) {
+ int pr = pal[k * 4 + 0];
+ int pg = pal[k * 4 + 1];
+ int pb = pal[k * 4 + 2];
+
+ dist = FFABS(cr - pr) + FFABS(cg - pg) + FFABS(cb - pb);
+ if (dist < best) {
+ best = dist;
+ index = k;
+ }
+ }
+ dst[0] = index;
+ }
+ }
+ } else if (avctx->pix_fmt == AV_PIX_FMT_BGR0) {
+ for (int i = 0; i < s->cursor_h; i++) {
+ for (int j = 0; j < s->cursor_w; j++) {
+ int cr = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 0];
+ int cg = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 1];
+ int cb = s->cursor[3 * s->cursor_w * (s->cursor_h - i - 1) + 3 * j + 2];
+
+ if (cr == s->cursor[0] && cg == s->cursor[1] && cb == s->cursor[2])
+ continue;
+
+ dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 4 * (s->cursor_x + j);
+ dst[0] = cb;
+ dst[1] = cg;
+ dst[2] = cr;
+ }
+ }
+ }
+}
+
+static int decode_frame(AVCodecContext *avctx,
+ void *data, int *got_frame,
+ AVPacket *avpkt)
+{
+ RASCContext *s = avctx->priv_data;
+ GetByteContext *gb = &s->gb;
+ int ret, intra = 0;
+ AVFrame *frame = data;
+
+ bytestream2_init(gb, avpkt->data, avpkt->size);
+
+ if (bytestream2_peek_le32(gb) == EMPT)
+ return avpkt->size;
+
+ s->frame = frame;
+
+ while (bytestream2_get_bytes_left(gb) > 0) {
+ unsigned type, size = 0;
+
+ type = bytestream2_get_le32(gb);
+ if (type == KBND || type == BNDL) {
+ intra = type == KBND;
+ type = bytestream2_get_le32(gb);
+ }
+
+ size = bytestream2_get_le32(gb);
+ if (bytestream2_get_bytes_left(gb) < size)
+ return AVERROR_INVALIDDATA;
+
+ switch (type) {
+ case FINT:
+ case INIT:
+ ret = decode_fint(avctx, avpkt, size);
+ break;
+ case KFRM:
+ ret = decode_kfrm(avctx, avpkt, size);
+ break;
+ case DLTA:
+ ret = decode_dlta(avctx, avpkt, size);
+ break;
+ case MOVE:
+ ret = decode_move(avctx, avpkt, size);
+ break;
+ case MOUS:
+ ret = decode_mous(avctx, avpkt, size);
+ break;
+ case MPOS:
+ ret = decode_mpos(avctx, avpkt, size);
+ break;
+ default:
+ bytestream2_skip(gb, size);
+ }
+
+ if (ret < 0)
+ return ret;
+ }
+
+ if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
+ return ret;
+
+ copy_plane(avctx, s->frame2, s->frame);
+ if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
+ memcpy(s->frame->data[1], s->frame2->data[1], 1024);
+ if (!s->skip_cursor)
+ draw_cursor(avctx);
+
+ s->frame->key_frame = intra;
+ s->frame->pict_type = intra ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
+
+ *got_frame = 1;
+
+ return avpkt->size;
+}
+
+static av_cold int decode_init(AVCodecContext *avctx)
+{
+ RASCContext *s = avctx->priv_data;
+ int zret;
+
+ s->zstream.zalloc = Z_NULL;
+ s->zstream.zfree = Z_NULL;
+ s->zstream.opaque = Z_NULL;
+ zret = inflateInit(&s->zstream);
+ if (zret != Z_OK) {
+ av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
+ return AVERROR_EXTERNAL;
+ }
+
+ s->frame1 = av_frame_alloc();
+ s->frame2 = av_frame_alloc();
+ if (!s->frame1 || !s->frame2)
+ return AVERROR(ENOMEM);
+
+ return 0;
+}
+
+static av_cold int decode_close(AVCodecContext *avctx)
+{
+ RASCContext *s = avctx->priv_data;
+
+ av_freep(&s->cursor);
+ s->cursor_size = 0;
+ av_freep(&s->delta);
+ s->delta_size = 0;
+ av_frame_free(&s->frame1);
+ av_frame_free(&s->frame2);
+ inflateEnd(&s->zstream);
+
+ return 0;
+}
+
+static void decode_flush(AVCodecContext *avctx)
+{
+ RASCContext *s = avctx->priv_data;
+
+ clear_plane(avctx, s->frame1);
+ clear_plane(avctx, s->frame2);
+}
+
+static const AVOption options[] = {
+{ "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 },
+{ NULL },
+};
+
+static const AVClass rasc_decoder_class = {
+ .class_name = "rasc decoder",
+ .item_name = av_default_item_name,
+ .option = options,
+ .version = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_rasc_decoder = {
+ .name = "rasc",
+ .long_name = NULL_IF_CONFIG_SMALL("RemotelyAnywhere Screen Capture"),
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_RASC,
+ .priv_data_size = sizeof(RASCContext),
+ .init = decode_init,
+ .close = decode_close,
+ .decode = decode_frame,
+ .flush = decode_flush,
+ .capabilities = AV_CODEC_CAP_DR1,
+ .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
+ FF_CODEC_CAP_INIT_CLEANUP,
+ .priv_class = &rasc_decoder_class,
+};
@@ -474,6 +474,7 @@ const AVCodecTag ff_codec_bmp_tags[] = {
{ AV_CODEC_ID_PROSUMER, MKTAG('B', 'T', '2', '0') },
{ AV_CODEC_ID_MWSC, MKTAG('M', 'W', 'S', 'C') },
{ AV_CODEC_ID_WCMV, MKTAG('W', 'C', 'M', 'V') },
+ { AV_CODEC_ID_RASC, MKTAG('R', 'A', 'S', 'C') },
{ AV_CODEC_ID_NONE, 0 }
};
Signed-off-by: Paul B Mahol <onemda@gmail.com> --- configure | 1 + libavcodec/Makefile | 1 + libavcodec/allcodecs.c | 1 + libavcodec/avcodec.h | 1 + libavcodec/codec_desc.c | 7 + libavcodec/rasc.c | 789 ++++++++++++++++++++++++++++++++++++++++ libavformat/riff.c | 1 + 7 files changed, 801 insertions(+) create mode 100644 libavcodec/rasc.c