RepoMirrors/ffmpeg
1
0
Fork 0
mirror of https://git.ffmpeg.org/ffmpeg.git synced 2024-12-27 01:42:20 +00:00
Code Issues Projects Releases Wiki Activity
072496ca40
ffmpeg/libavcodec/rasc.c
Andreas Rheinhardt a247ac640d avcodec: Constify AVCodecs 
Given that the AVCodec.next pointer has now been removed, most of the
AVCodecs are not modified at all any more and can therefore be made
const (as this patch does); the only exceptions are the very few codecs
for external libraries that have a init_static_data callback.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@gmail.com>
Signed-off-by: James Almer <jamrial@gmail.com>
2021-04-27 10:43:15 -03:00

823 lines
24 KiB
C
Raw Blame History

/*
* 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];
if (!dst)
return;
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);
av_frame_unref(s->frame2);
if ((ret = ff_get_buffer(avctx, s->frame1, 0)) < 0)
return ret;
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,
const 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;
}
if (bytestream2_get_bytes_left(gb) < 72)
return AVERROR_INVALIDDATA;
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, const 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,
const 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 || nb_moves > avctx->width * avctx->height)
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 - 1) + start_x * s->bpp;
b2 = s->frame2->data[0] + s->frame2->linesize[0] * (start_y + h - 1) + start_x * s->bpp;
e2 = s->frame2->data[0] + s->frame2->linesize[0] * (mov_y + h - 1) + 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,
const 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) {
if (w * h * s->bpp * 3 < uncompressed_size)
return AVERROR_INVALIDDATA;
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,
const 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,
const 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,
const 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;
if (bytestream2_get_bytes_left(gb) < 8)
return AVERROR_INVALIDDATA;
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 (!s->frame2->data[0] || !s->frame1->data[0])
return AVERROR_INVALIDDATA;
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,
};
const 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,
};
Reference in New Issue View Git Blame Copy Permalink