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 "codec_internal.h"

47 #include "decode.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, AVFrame *frame,

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) {

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 if (ctx->inflated_size < pixel_size) {

304 ret = AVERROR_INVALIDDATA;

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);

310 ret = AVERROR_UNKNOWN;

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) {

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

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

351 }

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

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

354 ctx->valid_pixels += pixel_size;

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

356 *got_frame = 1;

357

358 ret = avpkt->size;

359 end:

360 av_free(inflated_tiles);

361 return ret;

362 }

363

364 const FFCodec ff_rscc_decoder = {

365 .p.name = "rscc",

366 CODEC_LONG_NAME("innoHeim/Rsupport Screen Capture Codec"),

367 .p.type = AVMEDIA_TYPE_VIDEO,

368 .p.id = AV_CODEC_ID_RSCC,

369 .init = rscc_init,

370 FF_CODEC_DECODE_CB(rscc_decode_frame),

371 .close = rscc_close,

372 .priv_data_size = sizeof(RsccContext),

373 .p.capabilities = AV_CODEC_CAP_DR1,

374 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

375 };

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

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

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

AVFrame

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

Definition: frame.h:330

AVPacket::data

uint8_t * data

Definition: packet.h:374

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

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

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

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

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

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

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

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

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

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

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:527

internal.h

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:191

len

int len

Definition: vorbis_enc_data.h:426

AVCodecContext::height

int height

Definition: avcodec.h:598

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:635

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

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

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

TILE_SIZE