FFmpeg
rscc.c
Go to the documentation of this file.
1 /*
2  * innoHeim/Rsupport Screen Capture Codec
3  * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * innoHeim/Rsupport Screen Capture Codec decoder
25  *
26  * Fourcc: ISCC, RSCC
27  *
28  * Lossless codec, data stored in tiles, with optional deflate compression.
29  *
30  * Header contains the number of tiles in a frame with the tile coordinates,
31  * and it can be deflated or not. Similarly, pixel data comes after the header
32  * and a variable size value, and it can be deflated or just raw.
33  *
34  * Supports: PAL8, BGRA, BGR24, RGB555
35  */
36 
37 #include <stdint.h>
38 #include <string.h>
39 #include <zlib.h>
40 
41 #include "libavutil/imgutils.h"
42 #include "libavutil/internal.h"
43 
44 #include "avcodec.h"
45 #include "bytestream.h"
46 #include "internal.h"
47 
48 #define TILE_SIZE 8
49 
50 typedef struct Tile {
51  int x, y;
52  int w, h;
53 } Tile;
54 
55 typedef struct RsccContext {
59  unsigned int tiles_size;
61 
63 
64  /* zlib interaction */
66  uLongf inflated_size;
68 } RsccContext;
69 
70 static av_cold int rscc_init(AVCodecContext *avctx)
71 {
72  RsccContext *ctx = avctx->priv_data;
73 
74  /* These needs to be set to estimate uncompressed buffer */
75  int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
76  if (ret < 0) {
77  av_log(avctx, AV_LOG_ERROR, "Invalid image size %dx%d.\n",
78  avctx->width, avctx->height);
79  return ret;
80  }
81 
82  /* Allocate reference frame */
83  ctx->reference = av_frame_alloc();
84  if (!ctx->reference)
85  return AVERROR(ENOMEM);
86 
87  /* Get pixel format and the size of the pixel */
88  if (avctx->codec_tag == MKTAG('I', 'S', 'C', 'C')) {
89  if (avctx->extradata && avctx->extradata_size == 4) {
90  if ((avctx->extradata[0] >> 1) & 1) {
91  avctx->pix_fmt = AV_PIX_FMT_BGRA;
92  ctx->component_size = 4;
93  } else {
94  avctx->pix_fmt = AV_PIX_FMT_BGR24;
95  ctx->component_size = 3;
96  }
97  } else {
98  avctx->pix_fmt = AV_PIX_FMT_BGRA;
99  ctx->component_size = 4;
100  }
101  } else if (avctx->codec_tag == MKTAG('R', 'S', 'C', 'C')) {
102  ctx->component_size = avctx->bits_per_coded_sample / 8;
103  switch (avctx->bits_per_coded_sample) {
104  case 8:
105  avctx->pix_fmt = AV_PIX_FMT_PAL8;
106  break;
107  case 16:
108  avctx->pix_fmt = AV_PIX_FMT_RGB555LE;
109  break;
110  case 24:
111  avctx->pix_fmt = AV_PIX_FMT_BGR24;
112  break;
113  case 32:
114  avctx->pix_fmt = AV_PIX_FMT_BGR0;
115  break;
116  default:
117  av_log(avctx, AV_LOG_ERROR, "Invalid bits per pixel value (%d)\n",
118  avctx->bits_per_coded_sample);
119  return AVERROR_INVALIDDATA;
120  }
121  } else {
122  avctx->pix_fmt = AV_PIX_FMT_BGR0;
123  ctx->component_size = 4;
124  av_log(avctx, AV_LOG_WARNING, "Invalid codec tag\n");
125  }
126 
127  /* Store the value to check for keyframes */
128  ctx->inflated_size = avctx->width * avctx->height * ctx->component_size;
129 
130  /* Allocate maximum size possible, a full frame */
131  ctx->inflated_buf = av_malloc(ctx->inflated_size);
132  if (!ctx->inflated_buf)
133  return AVERROR(ENOMEM);
134 
135  return 0;
136 }
137 
139 {
140  RsccContext *ctx = avctx->priv_data;
141 
142  av_freep(&ctx->tiles);
143  av_freep(&ctx->inflated_buf);
144  av_frame_free(&ctx->reference);
145 
146  return 0;
147 }
148 
149 static int rscc_decode_frame(AVCodecContext *avctx, void *data,
150  int *got_frame, AVPacket *avpkt)
151 {
152  RsccContext *ctx = avctx->priv_data;
153  GetByteContext *gbc = &ctx->gbc;
154  GetByteContext tiles_gbc;
155  AVFrame *frame = data;
156  const uint8_t *pixels, *raw;
157  uint8_t *inflated_tiles = NULL;
158  int tiles_nb, packed_size, pixel_size = 0;
159  int i, ret = 0;
160 
161  bytestream2_init(gbc, avpkt->data, avpkt->size);
162 
163  /* Size check */
164  if (bytestream2_get_bytes_left(gbc) < 12) {
165  av_log(avctx, AV_LOG_ERROR, "Packet too small (%d)\n", avpkt->size);
166  return AVERROR_INVALIDDATA;
167  }
168 
169  /* Read number of tiles, and allocate the array */
170  tiles_nb = bytestream2_get_le16(gbc);
171 
172  if (tiles_nb == 0) {
173  av_log(avctx, AV_LOG_DEBUG, "no tiles\n");
174  return avpkt->size;
175  }
176 
177  av_fast_malloc(&ctx->tiles, &ctx->tiles_size,
178  tiles_nb * sizeof(*ctx->tiles));
179  if (!ctx->tiles) {
180  ret = AVERROR(ENOMEM);
181  goto end;
182  }
183 
184  av_log(avctx, AV_LOG_DEBUG, "Frame with %d tiles.\n", tiles_nb);
185 
186  /* When there are more than 5 tiles, they are packed together with
187  * a size header. When that size does not match the number of tiles
188  * times the tile size, it means it needs to be inflated as well */
189  if (tiles_nb > 5) {
190  uLongf packed_tiles_size;
191 
192  if (tiles_nb < 32)
193  packed_tiles_size = bytestream2_get_byte(gbc);
194  else
195  packed_tiles_size = bytestream2_get_le16(gbc);
196 
197  ff_dlog(avctx, "packed tiles of size %lu.\n", packed_tiles_size);
198 
199  /* If necessary, uncompress tiles, and hijack the bytestream reader */
200  if (packed_tiles_size != tiles_nb * TILE_SIZE) {
201  uLongf length = tiles_nb * TILE_SIZE;
202 
203  if (bytestream2_get_bytes_left(gbc) < packed_tiles_size) {
204  ret = AVERROR_INVALIDDATA;
205  goto end;
206  }
207 
208  inflated_tiles = av_malloc(length);
209  if (!inflated_tiles) {
210  ret = AVERROR(ENOMEM);
211  goto end;
212  }
213 
214  ret = uncompress(inflated_tiles, &length,
215  gbc->buffer, packed_tiles_size);
216  if (ret) {
217  av_log(avctx, AV_LOG_ERROR, "Tile deflate error %d.\n", ret);
218  ret = AVERROR_UNKNOWN;
219  goto end;
220  }
221 
222  /* Skip the compressed tile section in the main byte reader,
223  * and point it to read the newly uncompressed data */
224  bytestream2_skip(gbc, packed_tiles_size);
225  bytestream2_init(&tiles_gbc, inflated_tiles, length);
226  gbc = &tiles_gbc;
227  }
228  }
229 
230  /* Fill in array of tiles, keeping track of how many pixels are updated */
231  for (i = 0; i < tiles_nb; i++) {
232  ctx->tiles[i].x = bytestream2_get_le16(gbc);
233  ctx->tiles[i].w = bytestream2_get_le16(gbc);
234  ctx->tiles[i].y = bytestream2_get_le16(gbc);
235  ctx->tiles[i].h = bytestream2_get_le16(gbc);
236 
237  if (pixel_size + ctx->tiles[i].w * (int64_t)ctx->tiles[i].h * ctx->component_size > INT_MAX) {
238  av_log(avctx, AV_LOG_ERROR, "Invalid tile dimensions\n");
239  ret = AVERROR_INVALIDDATA;
240  goto end;
241  }
242 
243  pixel_size += ctx->tiles[i].w * ctx->tiles[i].h * ctx->component_size;
244 
245  ff_dlog(avctx, "tile %d orig(%d,%d) %dx%d.\n", i,
246  ctx->tiles[i].x, ctx->tiles[i].y,
247  ctx->tiles[i].w, ctx->tiles[i].h);
248 
249  if (ctx->tiles[i].w == 0 || ctx->tiles[i].h == 0) {
250  av_log(avctx, AV_LOG_ERROR,
251  "invalid tile %d at (%d.%d) with size %dx%d.\n", i,
252  ctx->tiles[i].x, ctx->tiles[i].y,
253  ctx->tiles[i].w, ctx->tiles[i].h);
254  ret = AVERROR_INVALIDDATA;
255  goto end;
256  } else if (ctx->tiles[i].x + ctx->tiles[i].w > avctx->width ||
257  ctx->tiles[i].y + ctx->tiles[i].h > avctx->height) {
258  av_log(avctx, AV_LOG_ERROR,
259  "out of bounds tile %d at (%d.%d) with size %dx%d.\n", i,
260  ctx->tiles[i].x, ctx->tiles[i].y,
261  ctx->tiles[i].w, ctx->tiles[i].h);
262  ret = AVERROR_INVALIDDATA;
263  goto end;
264  }
265  }
266 
267  /* Reset the reader in case it had been modified before */
268  gbc = &ctx->gbc;
269 
270  /* Extract how much pixel data the tiles contain */
271  if (pixel_size < 0x100)
272  packed_size = bytestream2_get_byte(gbc);
273  else if (pixel_size < 0x10000)
274  packed_size = bytestream2_get_le16(gbc);
275  else if (pixel_size < 0x1000000)
276  packed_size = bytestream2_get_le24(gbc);
277  else
278  packed_size = bytestream2_get_le32(gbc);
279 
280  ff_dlog(avctx, "pixel_size %d packed_size %d.\n", pixel_size, packed_size);
281 
282  if (packed_size < 0) {
283  av_log(avctx, AV_LOG_ERROR, "Invalid tile size %d\n", packed_size);
284  ret = AVERROR_INVALIDDATA;
285  goto end;
286  }
287 
288  /* Get pixels buffer, it may be deflated or just raw */
289  if (pixel_size == packed_size) {
290  if (bytestream2_get_bytes_left(gbc) < pixel_size) {
291  av_log(avctx, AV_LOG_ERROR, "Insufficient input for %d\n", pixel_size);
292  ret = AVERROR_INVALIDDATA;
293  goto end;
294  }
295  pixels = gbc->buffer;
296  } else {
297  uLongf len = ctx->inflated_size;
298  if (bytestream2_get_bytes_left(gbc) < packed_size) {
299  av_log(avctx, AV_LOG_ERROR, "Insufficient input for %d\n", packed_size);
300  ret = AVERROR_INVALIDDATA;
301  goto end;
302  }
303  ret = uncompress(ctx->inflated_buf, &len, gbc->buffer, packed_size);
304  if (ret) {
305  av_log(avctx, AV_LOG_ERROR, "Pixel deflate error %d.\n", ret);
306  ret = AVERROR_UNKNOWN;
307  goto end;
308  }
309  pixels = ctx->inflated_buf;
310  }
311 
312  /* Allocate when needed */
313  ret = ff_reget_buffer(avctx, ctx->reference);
314  if (ret < 0)
315  goto end;
316 
317  /* Pointer to actual pixels, will be updated when data is consumed */
318  raw = pixels;
319  for (i = 0; i < tiles_nb; i++) {
320  uint8_t *dst = ctx->reference->data[0] + ctx->reference->linesize[0] *
321  (avctx->height - ctx->tiles[i].y - 1) +
322  ctx->tiles[i].x * ctx->component_size;
323  av_image_copy_plane(dst, -1 * ctx->reference->linesize[0],
324  raw, ctx->tiles[i].w * ctx->component_size,
325  ctx->tiles[i].w * ctx->component_size,
326  ctx->tiles[i].h);
327  raw += ctx->tiles[i].w * ctx->component_size * ctx->tiles[i].h;
328  }
329 
330  /* Frame is ready to be output */
331  ret = av_frame_ref(frame, ctx->reference);
332  if (ret < 0)
333  goto end;
334 
335  /* Keyframe when the number of pixels updated matches the whole surface */
336  if (pixel_size == ctx->inflated_size) {
337  frame->pict_type = AV_PICTURE_TYPE_I;
338  frame->key_frame = 1;
339  } else {
340  frame->pict_type = AV_PICTURE_TYPE_P;
341  }
342 
343  /* Palette handling */
344  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
345  int size;
346  const uint8_t *palette = av_packet_get_side_data(avpkt,
348  &size);
349  if (palette && size == AVPALETTE_SIZE) {
350  frame->palette_has_changed = 1;
351  memcpy(ctx->palette, palette, AVPALETTE_SIZE);
352  } else if (palette) {
353  av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
354  }
355  memcpy (frame->data[1], ctx->palette, AVPALETTE_SIZE);
356  }
357  // We only return a picture when enough of it is undamaged, this avoids copying nearly broken frames around
358  if (ctx->valid_pixels < ctx->inflated_size)
359  ctx->valid_pixels += pixel_size;
360  if (ctx->valid_pixels >= ctx->inflated_size * (100 - avctx->discard_damaged_percentage) / 100)
361  *got_frame = 1;
362 
363  ret = avpkt->size;
364 end:
365  av_free(inflated_tiles);
366  return ret;
367 }
368 
370  .name = "rscc",
371  .long_name = NULL_IF_CONFIG_SMALL("innoHeim/Rsupport Screen Capture Codec"),
372  .type = AVMEDIA_TYPE_VIDEO,
373  .id = AV_CODEC_ID_RSCC,
374  .init = rscc_init,
375  .decode = rscc_decode_frame,
376  .close = rscc_close,
377  .priv_data_size = sizeof(RsccContext),
378  .capabilities = AV_CODEC_CAP_DR1,
379  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
381 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
uLongf inflated_size
Definition: rscc.c:66
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:108
int size
Definition: avcodec.h:1478
int component_size
Definition: rscc.c:60
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
static av_cold int rscc_init(AVCodecContext *avctx)
Definition: rscc.c:70
AVCodec.
Definition: avcodec.h:3481
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: decode.c:2011
uint8_t palette[AVPALETTE_SIZE]
Definition: rscc.c:62
unsigned int tiles_size
Definition: rscc.c:59
Tile * tiles
Definition: rscc.c:58
#define TILE_SIZE
Definition: rscc.c:48
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
AVFrame * reference
Definition: rscc.c:57
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
uint8_t * data
Definition: avcodec.h:1477
const uint8_t * buffer
Definition: bytestream.h:34
#define ff_dlog(a,...)
ptrdiff_t size
Definition: opengl_enc.c:100
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2789
#define av_log(a,...)
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int valid_pixels
Definition: rscc.c:67
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1190
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
uint8_t * inflated_buf
Definition: rscc.c:65
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
GLsizei GLsizei * length
Definition: opengl_enc.c:114
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
static int rscc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: rscc.c:149
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:500
GetByteContext gbc
Definition: rscc.c:56
common internal API header
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:282
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
int width
picture width / height.
Definition: avcodec.h:1738
Definition: rscc.c:50
AVFormatContext * ctx
Definition: movenc.c:48
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
int x
Definition: rscc.c:51
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:3372
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
main external API structure.
Definition: avcodec.h:1565
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1590
int h
Definition: rscc.c:52
int extradata_size
Definition: avcodec.h:1667
AVCodec ff_rscc_decoder
Definition: rscc.c:369
static av_cold int rscc_close(AVCodecContext *avctx)
Definition: rscc.c:138
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:452
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
int w
Definition: rscc.c:52
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
common internal api header.
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
void * priv_data
Definition: avcodec.h:1592
#define av_free(p)
int pixels
Definition: avisynth_c.h:390
int len
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
int y
Definition: rscc.c:51
#define av_freep(p)
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:338
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define MKTAG(a, b, c, d)
Definition: common.h:366
This structure stores compressed data.
Definition: avcodec.h:1454
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
Predicted.
Definition: avutil.h:275