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 "codec_internal.h"
47 #include "decode.h"
48 
49 #define TILE_SIZE 8
50 
51 typedef struct Tile {
52  int x, y;
53  int w, h;
54 } Tile;
55 
56 typedef struct RsccContext {
60  unsigned int tiles_size;
62 
64 
65  /* zlib interaction */
66  uint8_t *inflated_buf;
67  uLongf inflated_size;
69 } RsccContext;
70 
71 static av_cold int rscc_init(AVCodecContext *avctx)
72 {
73  RsccContext *ctx = avctx->priv_data;
74 
75  /* These needs to be set to estimate uncompressed buffer */
76  int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
77  if (ret < 0) {
78  av_log(avctx, AV_LOG_ERROR, "Invalid image size %dx%d.\n",
79  avctx->width, avctx->height);
80  return ret;
81  }
82 
83  /* Allocate reference frame */
84  ctx->reference = av_frame_alloc();
85  if (!ctx->reference)
86  return AVERROR(ENOMEM);
87 
88  /* Get pixel format and the size of the pixel */
89  if (avctx->codec_tag == MKTAG('I', 'S', 'C', 'C')) {
90  if (avctx->extradata && avctx->extradata_size == 4) {
91  if ((avctx->extradata[0] >> 1) & 1) {
92  avctx->pix_fmt = AV_PIX_FMT_BGRA;
93  ctx->component_size = 4;
94  } else {
95  avctx->pix_fmt = AV_PIX_FMT_BGR24;
96  ctx->component_size = 3;
97  }
98  } else {
99  avctx->pix_fmt = AV_PIX_FMT_BGRA;
100  ctx->component_size = 4;
101  }
102  } else if (avctx->codec_tag == MKTAG('R', 'S', 'C', 'C')) {
103  ctx->component_size = avctx->bits_per_coded_sample / 8;
104  switch (avctx->bits_per_coded_sample) {
105  case 8:
106  avctx->pix_fmt = AV_PIX_FMT_PAL8;
107  break;
108  case 16:
109  avctx->pix_fmt = AV_PIX_FMT_RGB555LE;
110  break;
111  case 24:
112  avctx->pix_fmt = AV_PIX_FMT_BGR24;
113  break;
114  case 32:
115  avctx->pix_fmt = AV_PIX_FMT_BGR0;
116  break;
117  default:
118  av_log(avctx, AV_LOG_ERROR, "Invalid bits per pixel value (%d)\n",
119  avctx->bits_per_coded_sample);
120  return AVERROR_INVALIDDATA;
121  }
122  } else {
123  avctx->pix_fmt = AV_PIX_FMT_BGR0;
124  ctx->component_size = 4;
125  av_log(avctx, AV_LOG_WARNING, "Invalid codec tag\n");
126  }
127 
128  /* Store the value to check for keyframes */
129  ctx->inflated_size = avctx->width * avctx->height * ctx->component_size;
130 
131  /* Allocate maximum size possible, a full frame */
132  ctx->inflated_buf = av_malloc(ctx->inflated_size);
133  if (!ctx->inflated_buf)
134  return AVERROR(ENOMEM);
135 
136  return 0;
137 }
138 
140 {
141  RsccContext *ctx = avctx->priv_data;
142 
143  av_freep(&ctx->tiles);
144  av_freep(&ctx->inflated_buf);
145  av_frame_free(&ctx->reference);
146 
147  return 0;
148 }
149 
151  int *got_frame, AVPacket *avpkt)
152 {
153  RsccContext *ctx = avctx->priv_data;
154  GetByteContext *gbc = &ctx->gbc;
155  GetByteContext tiles_gbc;
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) {
343  } else {
345  }
346 
347  /* Palette handling */
348  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
349 #if FF_API_PALETTE_HAS_CHANGED
352 #endif
353  ff_copy_palette(ctx->palette, avpkt, avctx);
354 #if FF_API_PALETTE_HAS_CHANGED
356 #endif
357  memcpy(frame->data[1], ctx->palette, AVPALETTE_SIZE);
358  }
359  // We only return a picture when enough of it is undamaged, this avoids copying nearly broken frames around
360  if (ctx->valid_pixels < ctx->inflated_size)
361  ctx->valid_pixels += pixel_size;
362  if (ctx->valid_pixels >= ctx->inflated_size * (100 - avctx->discard_damaged_percentage) / 100)
363  *got_frame = 1;
364 
365  ret = avpkt->size;
366 end:
367  av_free(inflated_tiles);
368  return ret;
369 }
370 
372  .p.name = "rscc",
373  CODEC_LONG_NAME("innoHeim/Rsupport Screen Capture Codec"),
374  .p.type = AVMEDIA_TYPE_VIDEO,
375  .p.id = AV_CODEC_ID_RSCC,
376  .init = rscc_init,
378  .close = rscc_close,
379  .priv_data_size = sizeof(RsccContext),
380  .p.capabilities = AV_CODEC_CAP_DR1,
381  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
382 };
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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: codec_internal.h:42
AVFrame::palette_has_changed
attribute_deprecated int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:546
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
GetByteContext
Definition: bytestream.h:33
ff_rscc_decoder
const FFCodec ff_rscc_decoder
Definition: rscc.c:371
rscc_decode_frame
static int rscc_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: rscc.c:150
Tile::y
int y
Definition: rscc.c:52
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
AVPacket::data
uint8_t * data
Definition: packet.h:491
FFCodec
Definition: codec_internal.h:127
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
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AV_CODEC_ID_RSCC
@ AV_CODEC_ID_RSCC
Definition: codec_id.h:245
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
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:374
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:60
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:88
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:628
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:543
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_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:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode.h
rscc_close
static av_cold int rscc_close(AVCodecContext *avctx)
Definition: rscc.c:139
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
RsccContext::tiles
Tile * tiles
Definition: rscc.c:59
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:279
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:258
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:28
Tile::x
int x
Definition: rscc.c:52
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
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:71
Tile
Definition: rscc.c:51
AVPacket::size
int size
Definition: packet.h:492
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:361
codec_internal.h
Tile::h
int h
Definition: rscc.c:53
RsccContext::inflated_buf
uint8_t * inflated_buf
Definition: rscc.c:66
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1510
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
Tile::w
int w
Definition: rscc.c:53
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:542
internal.h
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:621
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:658
RsccContext::component_size
int component_size
Definition: rscc.c:61
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:1735
ret
ret
Definition: filter_design.txt:187
RsccContext::reference
AVFrame * reference
Definition: rscc.c:58
AVCodecContext
main external API structure.
Definition: avcodec.h:441
RsccContext::palette
uint8_t palette[AVPALETTE_SIZE]
Definition: rscc.c:63
AVCodecContext::discard_damaged_percentage
int discard_damaged_percentage
The percentage of damaged samples to discard a frame.
Definition: avcodec.h:2039
TILE_SIZE
#define TILE_SIZE
Definition: rscc.c:49
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:466
RsccContext::gbc
GetByteContext gbc
Definition: rscc.c:57
AVPacket
This structure stores compressed data.
Definition: packet.h:468
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:468
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
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:555
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:621
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:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
RsccContext::inflated_size
uLongf inflated_size
Definition: rscc.c:67
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
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:318
ff_copy_palette
int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
Check whether the side-data of src contains a palette of size AVPALETTE_SIZE; if so,...
Definition: decode.c:1823
RsccContext
Definition: rscc.c:56
RsccContext::valid_pixels
int valid_pixels
Definition: rscc.c:68