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) {
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);
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");
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);
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);
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);
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);
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);
301  goto end;
302  }
303  if (ctx->inflated_size < pixel_size) {
305  goto end;
306  }
307  ret = uncompress(ctx->inflated_buf, &len, gbc->buffer, packed_size);
308  if (ret) {
309  av_log(avctx, AV_LOG_ERROR, "Pixel deflate error %d.\n", ret);
311  goto end;
312  }
313  pixels = ctx->inflated_buf;
314  }
315 
316  /* Allocate when needed */
317  ret = ff_reget_buffer(avctx, ctx->reference, 0);
318  if (ret < 0)
319  goto end;
320 
321  /* Pointer to actual pixels, will be updated when data is consumed */
322  raw = pixels;
323  for (i = 0; i < tiles_nb; i++) {
324  uint8_t *dst = ctx->reference->data[0] + ctx->reference->linesize[0] *
325  (avctx->height - ctx->tiles[i].y - 1) +
326  ctx->tiles[i].x * ctx->component_size;
327  av_image_copy_plane(dst, -1 * ctx->reference->linesize[0],
328  raw, ctx->tiles[i].w * ctx->component_size,
329  ctx->tiles[i].w * ctx->component_size,
330  ctx->tiles[i].h);
331  raw += ctx->tiles[i].w * ctx->component_size * ctx->tiles[i].h;
332  }
333 
334  /* Frame is ready to be output */
335  ret = av_frame_ref(frame, ctx->reference);
336  if (ret < 0)
337  goto end;
338 
339  /* Keyframe when the number of pixels updated matches the whole surface */
340  if (pixel_size == ctx->inflated_size) {
341  frame->pict_type = AV_PICTURE_TYPE_I;
342  frame->key_frame = 1;
343  } else {
344  frame->pict_type = AV_PICTURE_TYPE_P;
345  }
346 
347  /* Palette handling */
348  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
350  const uint8_t *palette = av_packet_get_side_data(avpkt,
352  &size);
353  if (palette && size == AVPALETTE_SIZE) {
354  frame->palette_has_changed = 1;
355  memcpy(ctx->palette, palette, AVPALETTE_SIZE);
356  } else if (palette) {
357  av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
358  }
359  memcpy (frame->data[1], ctx->palette, AVPALETTE_SIZE);
360  }
361  // We only return a picture when enough of it is undamaged, this avoids copying nearly broken frames around
362  if (ctx->valid_pixels < ctx->inflated_size)
363  ctx->valid_pixels += pixel_size;
364  if (ctx->valid_pixels >= ctx->inflated_size * (100 - avctx->discard_damaged_percentage) / 100)
365  *got_frame = 1;
366 
367  ret = avpkt->size;
368 end:
369  av_free(inflated_tiles);
370  return ret;
371 }
372 
374  .name = "rscc",
375  .long_name = NULL_IF_CONFIG_SMALL("innoHeim/Rsupport Screen Capture Codec"),
376  .type = AVMEDIA_TYPE_VIDEO,
377  .id = AV_CODEC_ID_RSCC,
378  .init = rscc_init,
379  .decode = rscc_decode_frame,
380  .close = rscc_close,
381  .priv_data_size = sizeof(RsccContext),
382  .capabilities = AV_CODEC_CAP_DR1,
383  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
385 };
AVCodec
AVCodec.
Definition: codec.h:197
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
FF_CODEC_CAP_INIT_THREADSAFE
#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:41
AVERROR
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
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t *size)
Definition: avpacket.c:368
GetByteContext
Definition: bytestream.h:33
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
Tile::y
int y
Definition: rscc.c:51
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:369
AV_PKT_DATA_PALETTE
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
Definition: packet.h:46
data
const char data[16]
Definition: mxf.c:142
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:95
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
AV_CODEC_ID_RSCC
@ AV_CODEC_ID_RSCC
Definition: codec_id.h:242
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
av_image_copy_plane
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:373
rscc_decode_frame
static int rscc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: rscc.c:149
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
RsccContext::tiles_size
unsigned int tiles_size
Definition: rscc.c:59
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:638
buffer_size_t
int buffer_size_t
Definition: internal.h:306
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
ctx
AVFormatContext * ctx
Definition: movenc.c:48
rscc_close
static av_cold int rscc_close(AVCodecContext *avctx)
Definition: rscc.c:138
RsccContext::tiles
Tile * tiles
Definition: rscc.c:58
NULL
#define NULL
Definition: coverity.c:32
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:240
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
Tile::x
int x
Definition: rscc.c:51
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
rscc_init
static av_cold int rscc_init(AVCodecContext *avctx)
Definition: rscc.c:70
Tile
Definition: rscc.c:50
AVPacket::size
int size
Definition: packet.h:370
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
av_frame_ref
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
size
int size
Definition: twinvq_data.h:10344
Tile::h
int h
Definition: rscc.c:52
RsccContext::inflated_buf
uint8_t * inflated_buf
Definition: rscc.c:65
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1740
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:108
i
int i
Definition: input.c:407
Tile::w
int w
Definition: rscc.c:52
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
FF_CODEC_CAP_INIT_CLEANUP
#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:49
internal.h
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
len
int len
Definition: vorbis_enc_data.h:452
AVCodecContext::height
int height
Definition: avcodec.h:709
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
RsccContext::component_size
int component_size
Definition: rscc.c:60
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
ff_reget_buffer
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.
Definition: decode.c:2007
ret
ret
Definition: filter_design.txt:187
RsccContext::reference
AVFrame * reference
Definition: rscc.c:57
frame
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
Definition: filter_design.txt:264
AVCodecContext
main external API structure.
Definition: avcodec.h:536
RsccContext::palette
uint8_t palette[AVPALETTE_SIZE]
Definition: rscc.c:62
AVCodecContext::discard_damaged_percentage
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:2328
TILE_SIZE
#define TILE_SIZE
Definition: rscc.c:48
ff_rscc_decoder
AVCodec ff_rscc_decoder
Definition: rscc.c:373
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:561
RsccContext::gbc
GetByteContext gbc
Definition: rscc.c:56
AVPacket
This structure stores compressed data.
Definition: packet.h:346
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:563
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_fast_malloc
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:502
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:709
bytestream.h
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
RsccContext::inflated_size
uLongf inflated_size
Definition: rscc.c:66
av_image_check_size
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:317
RsccContext
Definition: rscc.c:55
RsccContext::valid_pixels
int valid_pixels
Definition: rscc.c:67