FFmpeg: libavcodec/rscc.c Source File

FFmpeg

[フレーム]

libavcodec

rscc.c

Go to the documentation of this file.

1 /*

2 * innoHeim/Rsupport Screen Capture Codec

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 */

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 */

37 #include <stdint.h>

38 #include <string.h>

39 #include <zlib.h>

41 #include "libavutil/imgutils.h"

42 #include "libavutil/internal.h"

44 #include "avcodec.h"

45 #include "bytestream.h"

46 #include "decode.h"

47 #include "internal.h"

49 #define TILE_SIZE 8

51 typedef struct Tile {

52 int x, y;

53 int w, h;

54 } Tile;

56 typedef struct RsccContext {

57 GetByteContext gbc;

58 AVFrame *reference;

59 Tile *tiles;

60 unsigned int tiles_size;

61 int component_size;

63 uint8_t palette[AVPALETTE_SIZE];

65 /* zlib interaction */

66 uint8_t *inflated_buf;

67 uLongf inflated_size;

68 int valid_pixels;

69 } RsccContext;

71 static av_cold int rscc_init(AVCodecContext *avctx)

72 {

73 RsccContext *ctx = avctx->priv_data;

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 }

83 /* Allocate reference frame */

84 ctx->reference = av_frame_alloc();

85 if (!ctx->reference)

86 return AVERROR(ENOMEM);

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

139 static av_cold int rscc_close(AVCodecContext *avctx)

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

150 static int rscc_decode_frame(AVCodecContext *avctx, void *data,

151 int *got_frame, AVPacket *avpkt)

152 {

153 RsccContext *ctx = avctx->priv_data;

154 GetByteContext *gbc = &ctx->gbc;

155 GetByteContext tiles_gbc;

156 AVFrame *frame = data;

157 const uint8_t *pixels, *raw;

158 uint8_t *inflated_tiles = NULL;

159 int tiles_nb, packed_size, pixel_size = 0;

160 int i, ret = 0;

161

162 bytestream2_init(gbc, avpkt->data, avpkt->size);

163

164 /* Size check */

165 if (bytestream2_get_bytes_left(gbc) < 12) {

166 av_log(avctx, AV_LOG_ERROR, "Packet too small (%d)\n", avpkt->size);

167 return AVERROR_INVALIDDATA;

168 }

169

170 /* Read number of tiles, and allocate the array */

171 tiles_nb = bytestream2_get_le16(gbc);

172

173 if (tiles_nb == 0) {

174 av_log(avctx, AV_LOG_DEBUG, "no tiles\n");

175 return avpkt->size;

176 }

177

178 av_fast_malloc(&ctx->tiles, &ctx->tiles_size,

179 tiles_nb * sizeof(*ctx->tiles));

180 if (!ctx->tiles) {

181 ret = AVERROR(ENOMEM);

182 goto end;

183 }

184

185 av_log(avctx, AV_LOG_DEBUG, "Frame with %d tiles.\n", tiles_nb);

186

187 /* When there are more than 5 tiles, they are packed together with

188 * a size header. When that size does not match the number of tiles

189 * times the tile size, it means it needs to be inflated as well */

190 if (tiles_nb > 5) {

191 uLongf packed_tiles_size;

192

193 if (tiles_nb < 32)

194 packed_tiles_size = bytestream2_get_byte(gbc);

195 else

196 packed_tiles_size = bytestream2_get_le16(gbc);

197

198 ff_dlog(avctx, "packed tiles of size %lu.\n", packed_tiles_size);

199

200 /* If necessary, uncompress tiles, and hijack the bytestream reader */

201 if (packed_tiles_size != tiles_nb * TILE_SIZE) {

202 uLongf length = tiles_nb * TILE_SIZE;

203

204 if (bytestream2_get_bytes_left(gbc) < packed_tiles_size) {

205 ret = AVERROR_INVALIDDATA;

206 goto end;

207 }

208

209 inflated_tiles = av_malloc(length);

210 if (!inflated_tiles) {

211 ret = AVERROR(ENOMEM);

212 goto end;

213 }

214

215 ret = uncompress(inflated_tiles, &length,

216 gbc->buffer, packed_tiles_size);

217 if (ret) {

218 av_log(avctx, AV_LOG_ERROR, "Tile deflate error %d.\n", ret);

219 ret = AVERROR_UNKNOWN;

220 goto end;

221 }

222

223 /* Skip the compressed tile section in the main byte reader,

224 * and point it to read the newly uncompressed data */

225 bytestream2_skip(gbc, packed_tiles_size);

226 bytestream2_init(&tiles_gbc, inflated_tiles, length);

227 gbc = &tiles_gbc;

228 }

229 }

230

231 /* Fill in array of tiles, keeping track of how many pixels are updated */

232 for (i = 0; i < tiles_nb; i++) {

233 ctx->tiles[i].x = bytestream2_get_le16(gbc);

234 ctx->tiles[i].w = bytestream2_get_le16(gbc);

235 ctx->tiles[i].y = bytestream2_get_le16(gbc);

236 ctx->tiles[i].h = bytestream2_get_le16(gbc);

237

238 if (pixel_size + ctx->tiles[i].w * (int64_t)ctx->tiles[i].h * ctx->component_size > INT_MAX) {

239 av_log(avctx, AV_LOG_ERROR, "Invalid tile dimensions\n");

240 ret = AVERROR_INVALIDDATA;

241 goto end;

242 }

243

244 pixel_size += ctx->tiles[i].w * ctx->tiles[i].h * ctx->component_size;

245

246 ff_dlog(avctx, "tile %d orig(%d,%d) %dx%d.\n", i,

247 ctx->tiles[i].x, ctx->tiles[i].y,

248 ctx->tiles[i].w, ctx->tiles[i].h);

249

250 if (ctx->tiles[i].w == 0 || ctx->tiles[i].h == 0) {

251 av_log(avctx, AV_LOG_ERROR,

252 "invalid tile %d at (%d.%d) with size %dx%d.\n", i,

253 ctx->tiles[i].x, ctx->tiles[i].y,

254 ctx->tiles[i].w, ctx->tiles[i].h);

255 ret = AVERROR_INVALIDDATA;

256 goto end;

257 } else if (ctx->tiles[i].x + ctx->tiles[i].w > avctx->width ||

258 ctx->tiles[i].y + ctx->tiles[i].h > avctx->height) {

259 av_log(avctx, AV_LOG_ERROR,

260 "out of bounds tile %d at (%d.%d) with size %dx%d.\n", i,

261 ctx->tiles[i].x, ctx->tiles[i].y,

262 ctx->tiles[i].w, ctx->tiles[i].h);

263 ret = AVERROR_INVALIDDATA;

264 goto end;

265 }

266 }

267

268 /* Reset the reader in case it had been modified before */

269 gbc = &ctx->gbc;

270

271 /* Extract how much pixel data the tiles contain */

272 if (pixel_size < 0x100)

273 packed_size = bytestream2_get_byte(gbc);

274 else if (pixel_size < 0x10000)

275 packed_size = bytestream2_get_le16(gbc);

276 else if (pixel_size < 0x1000000)

277 packed_size = bytestream2_get_le24(gbc);

278 else

279 packed_size = bytestream2_get_le32(gbc);

280

281 ff_dlog(avctx, "pixel_size %d packed_size %d.\n", pixel_size, packed_size);

282

283 if (packed_size < 0) {

284 av_log(avctx, AV_LOG_ERROR, "Invalid tile size %d\n", packed_size);

285 ret = AVERROR_INVALIDDATA;

286 goto end;

287 }

288

289 /* Get pixels buffer, it may be deflated or just raw */

290 if (pixel_size == packed_size) {

291 if (bytestream2_get_bytes_left(gbc) < pixel_size) {

292 av_log(avctx, AV_LOG_ERROR, "Insufficient input for %d\n", pixel_size);

293 ret = AVERROR_INVALIDDATA;

294 goto end;

295 }

296 pixels = gbc->buffer;

297 } else {

298 uLongf len = ctx->inflated_size;

299 if (bytestream2_get_bytes_left(gbc) < packed_size) {

300 av_log(avctx, AV_LOG_ERROR, "Insufficient input for %d\n", packed_size);

301 ret = AVERROR_INVALIDDATA;

302 goto end;

303 }

304 if (ctx->inflated_size < pixel_size) {

305 ret = AVERROR_INVALIDDATA;

306 goto end;

307 }

308 ret = uncompress(ctx->inflated_buf, &len, gbc->buffer, packed_size);

309 if (ret) {

310 av_log(avctx, AV_LOG_ERROR, "Pixel deflate error %d.\n", ret);

311 ret = AVERROR_UNKNOWN;

312 goto end;

313 }

314 pixels = ctx->inflated_buf;

315 }

316

317 /* Allocate when needed */

318 ret = ff_reget_buffer(avctx, ctx->reference, 0);

319 if (ret < 0)

320 goto end;

321

322 /* Pointer to actual pixels, will be updated when data is consumed */

323 raw = pixels;

324 for (i = 0; i < tiles_nb; i++) {

325 uint8_t *dst = ctx->reference->data[0] + ctx->reference->linesize[0] *

326 (avctx->height - ctx->tiles[i].y - 1) +

327 ctx->tiles[i].x * ctx->component_size;

328 av_image_copy_plane(dst, -1 * ctx->reference->linesize[0],

329 raw, ctx->tiles[i].w * ctx->component_size,

330 ctx->tiles[i].w * ctx->component_size,

331 ctx->tiles[i].h);

332 raw += ctx->tiles[i].w * ctx->component_size * ctx->tiles[i].h;

333 }

334

335 /* Frame is ready to be output */

336 ret = av_frame_ref(frame, ctx->reference);

337 if (ret < 0)

338 goto end;

339

340 /* Keyframe when the number of pixels updated matches the whole surface */

341 if (pixel_size == ctx->inflated_size) {

342 frame->pict_type = AV_PICTURE_TYPE_I;

343 frame->key_frame = 1;

344 } else {

345 frame->pict_type = AV_PICTURE_TYPE_P;

346 }

347

348 /* Palette handling */

349 if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {

350 frame->palette_has_changed = ff_copy_palette(ctx->palette, avpkt, avctx);

351 memcpy(frame->data[1], ctx->palette, AVPALETTE_SIZE);

352 }

353 // We only return a picture when enough of it is undamaged, this avoids copying nearly broken frames around

354 if (ctx->valid_pixels < ctx->inflated_size)

355 ctx->valid_pixels += pixel_size;

356 if (ctx->valid_pixels >= ctx->inflated_size * (100 - avctx->discard_damaged_percentage) / 100)

357 *got_frame = 1;

358

359 ret = avpkt->size;

360 end:

361 av_free(inflated_tiles);

362 return ret;

363 }

364

365 const AVCodec ff_rscc_decoder = {

366 .name = "rscc",

367 .long_name = NULL_IF_CONFIG_SMALL("innoHeim/Rsupport Screen Capture Codec"),

368 .type = AVMEDIA_TYPE_VIDEO,

369 .id = AV_CODEC_ID_RSCC,

370 .init = rscc_init,

371 .decode = rscc_decode_frame,

372 .close = rscc_close,

373 .priv_data_size = sizeof(RsccContext),

374 .capabilities = AV_CODEC_CAP_DR1,

375 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |

376 FF_CODEC_CAP_INIT_CLEANUP,

377 };

AVCodec

AVCodec.

Definition: codec.h:202

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

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:42

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

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:109

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:317

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

data

const char data[16]

Definition: mxf.c:143

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:73

AV_CODEC_ID_RSCC

@ AV_CODEC_ID_RSCC

Definition: codec_id.h:243

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:374

rscc_decode_frame

static int rscc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)

Definition: rscc.c:150

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

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:97

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

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:485

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

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:274

AV_PIX_FMT_BGR0

@ AV_PIX_FMT_BGR0

packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined

Definition: pixfmt.h:230

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:52

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:374

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:325

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:1418

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

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:271

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:484

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:50

internal.h

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:209

len

int len

Definition: vorbis_enc_data.h:426

AVCodecContext::height

int height

Definition: avcodec.h:556

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:593

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:1759

ret

Definition: filter_design.txt:187

RsccContext::reference

AVFrame * reference

Definition: rscc.c:58

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:383

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:1966

TILE_SIZE