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: BGRA
35 */
36
37 #include <stdint.h>
38 #include <string.h>
39 #include <zlib.h>
40
43
47
49
54
60
61 /* zlib interaction */
65
67 {
69
70 /* These needs to be set to estimate uncompressed buffer */
72 if (ret < 0) {
75 return ret;
76 }
77
78 /* Allocate reference frame */
82
85 } else {
87 }
88
89 /* Store the value to check for keyframes */
91
92 /* Allocate maximum size possible, a full frame */
96
97 return 0;
98 }
99
101 {
103
107
108 return 0;
109 }
110
113 {
120 int tiles_nb, packed_size, pixel_size = 0;
121 int i, ret = 0;
122
124
125 /* Size check */
129 }
130
131 /* Read number of tiles, and allocate the array */
132 tiles_nb = bytestream2_get_le16(gbc);
134 tiles_nb *
sizeof(*ctx->
tiles));
138 }
139
141
142 /* When there are more than 5 tiles, they are packed together with
143 * a size header. When that size does not match the number of tiles
144 * times the tile size, it means it needs to be inflated as well */
145 if (tiles_nb > 5) {
146 uLongf packed_tiles_size;
147
148 if (tiles_nb < 32)
149 packed_tiles_size = bytestream2_get_byte(gbc);
150 else
151 packed_tiles_size = bytestream2_get_le16(gbc);
152
153 ff_dlog(avctx,
"packed tiles of size %lu.\n", packed_tiles_size);
154
155 /* If necessary, uncompress tiles, and hijack the bytestream reader */
156 if (packed_tiles_size != tiles_nb *
TILE_SIZE) {
159 if (!inflated_tiles) {
162 }
163
164 ret = uncompress(inflated_tiles, &length,
165 gbc->
buffer, packed_tiles_size);
166 if (ret) {
170 }
171
172 /* Skip the compressed tile section in the main byte reader,
173 * and point it to read the newly uncompressed data */
176 gbc = &tiles_gbc;
177 }
178 }
179
180 /* Fill in array of tiles, keeping track of how many pixels are updated */
181 for (i = 0; i < tiles_nb; i++) {
182 ctx->
tiles[i].
x = bytestream2_get_le16(gbc);
183 ctx->
tiles[i].
w = bytestream2_get_le16(gbc);
184 ctx->
tiles[i].
y = bytestream2_get_le16(gbc);
185 ctx->
tiles[i].
h = bytestream2_get_le16(gbc);
186
188
189 ff_dlog(avctx,
"tile %d orig(%d,%d) %dx%d.\n", i,
192
195 "invalid tile %d at (%d.%d) with size %dx%d.\n", i,
203 "out of bounds tile %d at (%d.%d) with size %dx%d.\n", i,
208 }
209 }
210
211 /* Reset the reader in case it had been modified before */
213
214 /* Extract how much pixel data the tiles contain */
215 if (pixel_size < 0x100)
216 packed_size = bytestream2_get_byte(gbc);
217 else if (pixel_size < 0x10000)
218 packed_size = bytestream2_get_le16(gbc);
219 else if (pixel_size < 0x1000000)
220 packed_size = bytestream2_get_le24(gbc);
221 else
222 packed_size = bytestream2_get_le32(gbc);
223
224 ff_dlog(avctx,
"pixel_size %d packed_size %d.\n", pixel_size, packed_size);
225
226 /* Get pixels buffer, it may be deflated or just raw */
227 if (pixel_size == packed_size) {
232 }
234 } else {
237 if (ret) {
241 }
243 }
244
245 /* Allocate when needed */
247 if (ret < 0)
249
250 /* Pointer to actual pixels, will be updated when data is consumed */
252 for (i = 0; i < tiles_nb; i++) {
260 }
261
262 /* Frame is ready to be output */
264 if (ret < 0)
266
267 /* Keyframe when the number of pixels updated matches the whole surface */
271 } else {
273 }
274 *got_frame = 1;
275
278 return ret;
279 }
280
293 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
ptrdiff_t const GLvoid * data
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static av_cold int rscc_init(AVCodecContext *avctx)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static av_cold int end(AVCodecContext *avctx)
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
const char * name
Name of the codec implementation.
static int rscc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
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...
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...
enum AVPictureType pict_type
Picture type of the frame.
int width
picture width / height.
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
static av_cold int rscc_close(AVCodecContext *avctx)
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
common internal api header.
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
int key_frame
1 -> keyframe, 0-> not
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.
#define MKTAG(a, b, c, d)
This structure stores compressed data.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.