diff options
Diffstat (limited to 'libavcodec/rasc.c')
-rw-r--r-- | libavcodec/rasc.c | 812 |
1 files changed, 812 insertions, 0 deletions
diff --git a/libavcodec/rasc.c b/libavcodec/rasc.c new file mode 100644 index 0000000000..fbbb134f4b --- /dev/null +++ b/libavcodec/rasc.c @@ -0,0 +1,812 @@ +/* + * 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) +{ + RASCContext *s = avctx->priv_data; + uint8_t *dst = frame->data[0]; + + for (int y = 0; y < avctx->height; y++) { + memset(dst, 0, avctx->width * s->bpp); + 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) { + if (!s->frame2->data[0] || !s->frame1->data[0]) + return AVERROR_INVALIDDATA; + + 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_RGB555LE; 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: + avpriv_request_sample(avctx, "runlen %d", type); + 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 w, h, pos, uncompressed_size; + int ret; + + pos = bytestream2_tell(gb); + bytestream2_skip(gb, 8); + w = bytestream2_get_le32(gb); + h = bytestream2_get_le32(gb); + bytestream2_skip(gb, 12); + uncompressed_size = bytestream2_get_le32(gb); + + if (w > avctx->width || h > avctx->height) + return AVERROR_INVALIDDATA; + + if (uncompressed_size != 3 * w * 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)); + + s->cursor_w = w; + s->cursor_h = h; + + 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) + return; + + 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_RGB555LE) { + 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; + + cr >>= 3; cg >>=3; cb >>= 3; + dst = s->frame->data[0] + s->frame->linesize[0] * (s->cursor_y + i) + 2 * (s->cursor_x + j); + AV_WL16(dst, cr | cg << 5 | cb << 10); + } + } + } 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; + + if (!s->frame2->data[0] || !s->frame1->data[0]) + return AVERROR_INVALIDDATA; + + 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, +}; |