FFmpeg: libavcodec/flashsv.c Source File

FFmpeg

[フレーム]

libavcodec

flashsv.c

Go to the documentation of this file.

1 /*

2 * Flash Screen Video decoder

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 /**

24 * @file

25 * Flash Screen Video decoder

26 * @author Alex Beregszaszi

27 * @author Benjamin Larsson

28 * @author Daniel Verkamp

29 * @author Konstantin Shishkov

30 *

31 * A description of the bitstream format for Flash Screen Video version 1/2

32 * is part of the SWF File Format Specification (version 10), which can be

33 * downloaded from http://www.adobe.com/devnet/swf.html.

34 */

36 #include "config_components.h"

38 #include <stddef.h>

39 #include <zlib.h>

41 #include "libavutil/intreadwrite.h"

42 #include "libavutil/mem.h"

43 #include "avcodec.h"

44 #include "bytestream.h"

45 #include "codec_internal.h"

46 #include "decode.h"

47 #include "get_bits.h"

48 #include "zlib_wrapper.h"

50 typedef struct BlockInfo {

51 const uint8_t *pos;

52 int size;

53 } BlockInfo;

55 typedef struct FlashSVContext {

56 AVCodecContext *avctx;

57 AVFrame *frame;

58 int image_width, image_height;

59 int block_width, block_height;

60 uint8_t *tmpblock;

61 int block_size;

62 int ver;

63 const uint32_t *pal;

64 int is_keyframe;

65 const uint8_t *keyframedata;

66 AVBufferRef *keyframedata_buf;

67 uint8_t *keyframe;

68 BlockInfo *blocks;

69 int color_depth;

70 int zlibprime_curr, zlibprime_prev;

71 int diff_start, diff_height;

72 FFZStream zstream;

73 uint8_t tmp[UINT16_MAX];

74 } FlashSVContext;

76 static int decode_hybrid(const uint8_t *sptr, const uint8_t *sptr_end, uint8_t *dptr, int dx, int dy,

77 int h, int w, int stride, const uint32_t *pal)

78 {

79 int x, y;

80 const uint8_t *orig_src = sptr;

82 for (y = dx + h; y > dx; y--) {

83 uint8_t *dst = dptr + (y * stride) + dy * 3;

84 for (x = 0; x < w; x++) {

85 if (sptr >= sptr_end)

86 return AVERROR_INVALIDDATA;

87 if (*sptr & 0x80) {

88 /* 15-bit color */

89 unsigned c = AV_RB16(sptr) & ~0x8000;

90 unsigned b = c & 0x1F;

91 unsigned g = (c >> 5) & 0x1F;

92 unsigned r = c >> 10;

93 /* 000aaabb -> aaabbaaa */

94 *dst++ = (b << 3) | (b >> 2);

95 *dst++ = (g << 3) | (g >> 2);

96 *dst++ = (r << 3) | (r >> 2);

97 sptr += 2;

98 } else {

99 /* palette index */

100 uint32_t c = pal[*sptr++];

101 bytestream_put_le24(&dst, c);

102 }

103 }

104 }

105 return sptr - orig_src;

106 }

107

108 static av_cold int flashsv_decode_end(AVCodecContext *avctx)

109 {

110 FlashSVContext *s = avctx->priv_data;

111

112 ff_inflate_end(&s->zstream);

113 /* release the frame if needed */

114 av_frame_free(&s->frame);

115

116 /* free the tmpblock */

117 av_freep(&s->tmpblock);

118

119 return 0;

120 }

121

122 static av_cold int flashsv_decode_init(AVCodecContext *avctx)

123 {

124 FlashSVContext *s = avctx->priv_data;

125

126 s->avctx = avctx;

127 avctx->pix_fmt = AV_PIX_FMT_BGR24;

128

129 s->frame = av_frame_alloc();

130 if (!s->frame) {

131 return AVERROR(ENOMEM);

132 }

133

134 return ff_inflate_init(&s->zstream, avctx);

135 }

136

137 static int flashsv2_prime(FlashSVContext *s, const uint8_t *src, int size)

138 {

139 int zret; // Zlib return code

140 static const uint8_t zlib_header[] = { 0x78, 0x01 };

141 z_stream *const zstream = &s->zstream.zstream;

142 uint8_t *data = s->tmpblock;

143 unsigned remaining;

144

145 if (!src)

146 return AVERROR_INVALIDDATA;

147

148 zstream->next_in = src;

149 zstream->avail_in = size;

150 zstream->next_out = data;

151 zstream->avail_out = s->block_size * 3;

152 zret = inflate(zstream, Z_SYNC_FLUSH);

153 if (zret != Z_OK && zret != Z_STREAM_END)

154 return AVERROR_UNKNOWN;

155 remaining = s->block_size * 3 - zstream->avail_out;

156

157 if ((zret = inflateReset(zstream)) != Z_OK) {

158 av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);

159 return AVERROR_UNKNOWN;

160 }

161

162 /* Create input for zlib that is equivalent to encoding the output

163 * from above and decoding it again (the net result of this is that

164 * the dictionary of past decoded data is correctly primed and

165 * the adler32 checksum is correctly initialized).

166 * This is accomplished by synthetizing blocks of uncompressed data

167 * out of the output from above. See section 3.2.4 of RFC 1951. */

168 zstream->next_in = zlib_header;

169 zstream->avail_in = sizeof(zlib_header);

170 zret = inflate(zstream, Z_SYNC_FLUSH);

171 if (zret != Z_OK)

172 return AVERROR_UNKNOWN;

173 while (remaining > 0) {

174 unsigned block_size = FFMIN(UINT16_MAX, remaining);

175 uint8_t header[5];

176 /* Bit 0: Non-last-block, bits 1-2: BTYPE for uncompressed block */

177 header[0] = 0;

178 /* Block size */

179 AV_WL16(header + 1, block_size);

180 /* Block size (one's complement) */

181 AV_WL16(header + 3, block_size ^ 0xFFFF);

182 zstream->next_in = header;

183 zstream->avail_in = sizeof(header);

184 zstream->next_out = s->tmp;

185 zstream->avail_out = sizeof(s->tmp);

186 zret = inflate(zstream, Z_SYNC_FLUSH);

187 if (zret != Z_OK)

188 return AVERROR_UNKNOWN;

189 zstream->next_in = data;

190 zstream->avail_in = block_size;

191 zret = inflate(zstream, Z_SYNC_FLUSH);

192 if (zret != Z_OK)

193 return AVERROR_UNKNOWN;

194 data += block_size;

195 remaining -= block_size;

196 }

197

198 return 0;

199 }

200

201 static int flashsv_decode_block(AVCodecContext *avctx, const AVPacket *avpkt,

202 GetBitContext *gb, int block_size,

203 int width, int height, int x_pos, int y_pos,

204 int blk_idx)

205 {

206 struct FlashSVContext *s = avctx->priv_data;

207 z_stream *const zstream = &s->zstream.zstream;

208 uint8_t *line = s->tmpblock;

209 int k;

210 int ret = inflateReset(zstream);

211 if (ret != Z_OK) {

212 av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);

213 return AVERROR_UNKNOWN;

214 }

215 if (s->zlibprime_curr || s->zlibprime_prev) {

216 ret = flashsv2_prime(s,

217 s->blocks[blk_idx].pos,

218 s->blocks[blk_idx].size);

219 if (ret < 0)

220 return ret;

221 }

222 zstream->next_in = avpkt->data + get_bits_count(gb) / 8;

223 zstream->avail_in = block_size;

224 zstream->next_out = s->tmpblock;

225 zstream->avail_out = s->block_size * 3;

226 ret = inflate(zstream, Z_FINISH);

227 if (ret == Z_DATA_ERROR) {

228 av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");

229 inflateSync(zstream);

230 ret = inflate(zstream, Z_FINISH);

231 }

232

233 if (ret != Z_OK && ret != Z_STREAM_END) {

234 //return -1;

235 }

236

237 if (s->is_keyframe) {

238 s->blocks[blk_idx].pos = s->keyframedata + (get_bits_count(gb) / 8);

239 s->blocks[blk_idx].size = block_size;

240 }

241

242 y_pos += s->diff_start;

243

244 if (!s->color_depth) {

245 /* Flash Screen Video stores the image upside down, so copy

246 * lines to destination in reverse order. */

247 for (k = 1; k <= s->diff_height; k++) {

248 memcpy(s->frame->data[0] + x_pos * 3 +

249 (s->image_height - y_pos - k) * s->frame->linesize[0],

250 line, width * 3);

251 /* advance source pointer to next line */

252 line += width * 3;

253 }

254 } else {

255 /* hybrid 15-bit/palette mode */

256 ret = decode_hybrid(s->tmpblock, zstream->next_out,

257 s->frame->data[0],

258 s->image_height - (y_pos + 1 + s->diff_height),

259 x_pos, s->diff_height, width,

260 s->frame->linesize[0], s->pal);

261 if (ret < 0) {

262 av_log(avctx, AV_LOG_ERROR, "decode_hybrid failed\n");

263 return ret;

264 }

265 }

266 skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */

267 return 0;

268 }

269

270 static int flashsv_decode_frame(AVCodecContext *avctx, AVFrame *rframe,

271 int *got_frame, AVPacket *avpkt)

272 {

273 int buf_size = avpkt->size;

274 FlashSVContext *s = avctx->priv_data;

275 int h_blocks, v_blocks, h_part, v_part, i, j, ret;

276 GetBitContext gb;

277 int last_blockwidth = s->block_width;

278 int last_blockheight= s->block_height;

279

280 /* no supplementary picture */

281 if (buf_size == 0)

282 return 0;

283 if (buf_size < 4)

284 return -1;

285

286 if ((ret = init_get_bits8(&gb, avpkt->data, buf_size)) < 0)

287 return ret;

288

289 /* start to parse the bitstream */

290 s->block_width = 16 * (get_bits(&gb, 4) + 1);

291 s->image_width = get_bits(&gb, 12);

292 s->block_height = 16 * (get_bits(&gb, 4) + 1);

293 s->image_height = get_bits(&gb, 12);

294

295 if ( last_blockwidth != s->block_width

296 || last_blockheight!= s->block_height)

297 av_freep(&s->blocks);

298

299 if (s->ver == 2) {

300 skip_bits(&gb, 6);

301 if (get_bits1(&gb)) {

302 avpriv_request_sample(avctx, "iframe");

303 return AVERROR_PATCHWELCOME;

304 }

305 if (get_bits1(&gb)) {

306 avpriv_request_sample(avctx, "Custom palette");

307 return AVERROR_PATCHWELCOME;

308 }

309 }

310

311 /* calculate number of blocks and size of border (partial) blocks */

312 h_blocks = s->image_width / s->block_width;

313 h_part = s->image_width % s->block_width;

314 v_blocks = s->image_height / s->block_height;

315 v_part = s->image_height % s->block_height;

316

317 /* the block size could change between frames, make sure the buffer

318 * is large enough, if not, get a larger one */

319 if (s->block_size < s->block_width * s->block_height) {

320 int tmpblock_size = 3 * s->block_width * s->block_height, err;

321

322 if ((err = av_reallocp(&s->tmpblock, tmpblock_size)) < 0) {

323 s->block_size = 0;

324 av_log(avctx, AV_LOG_ERROR,

325 "Cannot allocate decompression buffer.\n");

326 return err;

327 }

328 }

329 s->block_size = s->block_width * s->block_height;

330

331 /* initialize the image size once */

332 if (avctx->width == 0 && avctx->height == 0) {

333 if ((ret = ff_set_dimensions(avctx, s->image_width, s->image_height)) < 0)

334 return ret;

335 }

336

337 /* check for changes of image width and image height */

338 if (avctx->width != s->image_width || avctx->height != s->image_height) {

339 av_log(avctx, AV_LOG_ERROR,

340 "Frame width or height differs from first frame!\n");

341 av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d vs ch = %d, cv = %d\n",

342 avctx->height, avctx->width, s->image_height, s->image_width);

343 return AVERROR_INVALIDDATA;

344 }

345

346 /* we care for keyframes only in Screen Video v2 */

347 s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);

348 if (s->is_keyframe) {

349 int err = av_buffer_replace(&s->keyframedata_buf, avpkt->buf);

350 if (err < 0)

351 return err;

352 s->keyframedata = avpkt->data;

353 if (s->blocks)

354 memset(s->blocks, 0, (v_blocks + !!v_part) * (h_blocks + !!h_part) *

355 sizeof(s->blocks[0]));

356 }

357 if(s->ver == 2 && !s->blocks)

358 s->blocks = av_mallocz((v_blocks + !!v_part) * (h_blocks + !!h_part) *

359 sizeof(s->blocks[0]));

360

361 ff_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",

362 s->image_width, s->image_height, s->block_width, s->block_height,

363 h_blocks, v_blocks, h_part, v_part);

364

365 if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0)

366 return ret;

367

368 /* loop over all block columns */

369 for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {

370

371 int y_pos = j * s->block_height; // vertical position in frame

372 int cur_blk_height = (j < v_blocks) ? s->block_height : v_part;

373

374 /* loop over all block rows */

375 for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {

376 int x_pos = i * s->block_width; // horizontal position in frame

377 int cur_blk_width = (i < h_blocks) ? s->block_width : h_part;

378 int has_diff = 0;

379

380 /* get the size of the compressed zlib chunk */

381 int size = get_bits(&gb, 16);

382

383 s->color_depth = 0;

384 s->zlibprime_curr = 0;

385 s->zlibprime_prev = 0;

386 s->diff_start = 0;

387 s->diff_height = cur_blk_height;

388

389 if (8 * size > get_bits_left(&gb)) {

390 av_frame_unref(s->frame);

391 return AVERROR_INVALIDDATA;

392 }

393

394 if (s->ver == 2 && size) {

395 skip_bits(&gb, 3);

396 s->color_depth = get_bits(&gb, 2);

397 has_diff = get_bits1(&gb);

398 s->zlibprime_curr = get_bits1(&gb);

399 s->zlibprime_prev = get_bits1(&gb);

400

401 if (s->color_depth != 0 && s->color_depth != 2) {

402 av_log(avctx, AV_LOG_ERROR,

403 "%dx%d invalid color depth %d\n",

404 i, j, s->color_depth);

405 return AVERROR_INVALIDDATA;

406 }

407

408 if (has_diff) {

409 if (size < 3) {

410 av_log(avctx, AV_LOG_ERROR, "size too small for diff\n");

411 return AVERROR_INVALIDDATA;

412 }

413 if (!s->keyframe) {

414 av_log(avctx, AV_LOG_ERROR,

415 "Inter frame without keyframe\n");

416 return AVERROR_INVALIDDATA;

417 }

418 s->diff_start = get_bits(&gb, 8);

419 s->diff_height = get_bits(&gb, 8);

420 if (s->diff_start + s->diff_height > cur_blk_height) {

421 av_log(avctx, AV_LOG_ERROR,

422 "Block parameters invalid: %d + %d > %d\n",

423 s->diff_start, s->diff_height, cur_blk_height);

424 return AVERROR_INVALIDDATA;

425 }

426 av_log(avctx, AV_LOG_DEBUG,

427 "%dx%d diff start %d height %d\n",

428 i, j, s->diff_start, s->diff_height);

429 size -= 2;

430 }

431

432 if (s->zlibprime_prev)

433 av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);

434

435 if (s->zlibprime_curr) {

436 int col = get_bits(&gb, 8);

437 int row = get_bits(&gb, 8);

438 av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",

439 i, j, col, row);

440 if (size < 3) {

441 av_log(avctx, AV_LOG_ERROR, "size too small for zlibprime_curr\n");

442 return AVERROR_INVALIDDATA;

443 }

444 size -= 2;

445 avpriv_request_sample(avctx, "zlibprime_curr");

446 return AVERROR_PATCHWELCOME;

447 }

448 if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {

449 av_log(avctx, AV_LOG_ERROR,

450 "no data available for zlib priming\n");

451 return AVERROR_INVALIDDATA;

452 }

453 size--; // account for flags byte

454 }

455

456 if (has_diff) {

457 int k;

458 int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];

459

460 for (k = 0; k < cur_blk_height; k++) {

461 int x = off - k * s->frame->linesize[0] + x_pos * 3;

462 memcpy(s->frame->data[0] + x, s->keyframe + x,

463 cur_blk_width * 3);

464 }

465 }

466

467 /* skip unchanged blocks, which have size 0 */

468 if (size) {

469 if (flashsv_decode_block(avctx, avpkt, &gb, size,

470 cur_blk_width, cur_blk_height,

471 x_pos, y_pos,

472 i + j * (h_blocks + !!h_part)))

473 av_log(avctx, AV_LOG_ERROR,

474 "error in decompression of block %dx%d\n", i, j);

475 }

476 }

477 }

478 if (s->is_keyframe && s->ver == 2) {

479 if (!s->keyframe) {

480 s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);

481 if (!s->keyframe) {

482 av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");

483 return AVERROR(ENOMEM);

484 }

485 }

486 memcpy(s->keyframe, s->frame->data[0],

487 s->frame->linesize[0] * avctx->height);

488 }

489

490 if ((ret = av_frame_ref(rframe, s->frame)) < 0)

491 return ret;

492

493 *got_frame = 1;

494

495 if ((get_bits_count(&gb) / 8) != buf_size)

496 av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",

497 buf_size, (get_bits_count(&gb) / 8));

498

499 /* report that the buffer was completely consumed */

500 return buf_size;

501 }

502

503 #if CONFIG_FLASHSV_DECODER

504 const FFCodec ff_flashsv_decoder = {

505 .p.name = "flashsv",

506 CODEC_LONG_NAME("Flash Screen Video v1"),

507 .p.type = AVMEDIA_TYPE_VIDEO,

508 .p.id = AV_CODEC_ID_FLASHSV,

509 .priv_data_size = sizeof(FlashSVContext),

510 .init = flashsv_decode_init,

511 .close = flashsv_decode_end,

512 FF_CODEC_DECODE_CB(flashsv_decode_frame),

513 .p.capabilities = AV_CODEC_CAP_DR1,

514 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

515 };

516 #endif /* CONFIG_FLASHSV_DECODER */

517

518 #if CONFIG_FLASHSV2_DECODER

519 static const uint32_t ff_flashsv2_default_palette[128] = {

520 0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,

521 0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,

522 0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,

523 0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,

524 0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,

525 0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,

526 0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,

527 0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,

528 0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,

529 0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,

530 0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,

531 0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,

532 0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,

533 0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,

534 0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,

535 0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,

536 0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,

537 0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,

538 0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,

539 0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,

540 0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,

541 0xDDDDDD, 0xEEEEEE

542 };

543

544 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)

545 {

546 FlashSVContext *s = avctx->priv_data;

547 int ret;

548

549 ret = flashsv_decode_init(avctx);

550 if (ret < 0)

551 return ret;

552 s->pal = ff_flashsv2_default_palette;

553 s->ver = 2;

554

555 return 0;

556 }

557

558 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)

559 {

560 FlashSVContext *s = avctx->priv_data;

561

562 av_buffer_unref(&s->keyframedata_buf);

563 s->keyframedata = NULL;

564 av_freep(&s->blocks);

565 av_freep(&s->keyframe);

566 flashsv_decode_end(avctx);

567

568 return 0;

569 }

570

571 const FFCodec ff_flashsv2_decoder = {

572 .p.name = "flashsv2",

573 CODEC_LONG_NAME("Flash Screen Video v2"),

574 .p.type = AVMEDIA_TYPE_VIDEO,

575 .p.id = AV_CODEC_ID_FLASHSV2,

576 .priv_data_size = sizeof(FlashSVContext),

577 .init = flashsv2_decode_init,

578 .close = flashsv2_decode_end,

579 FF_CODEC_DECODE_CB(flashsv_decode_frame),

580 .p.capabilities = AV_CODEC_CAP_DR1,

581 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

582 };

583 #endif /* CONFIG_FLASHSV2_DECODER */

skip_bits_long

static void skip_bits_long(GetBitContext *s, int n)

Skips the specified number of bits.

Definition: get_bits.h:276

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

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:689

const char * r

Definition: vf_curves.c:127

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

FlashSVContext::image_width

int image_width

Definition: flashsv.c:58

flashsv_decode_end

static av_cold int flashsv_decode_end(AVCodecContext *avctx)

Definition: flashsv.c:108

FlashSVContext::keyframedata

const uint8_t * keyframedata

Definition: flashsv.c:65

FlashSVContext::zstream

FFZStream zstream

Definition: flashsv.c:72

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:250

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:64

AVFrame

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

Definition: frame.h:427

FlashSVContext::pal

const uint32_t * pal

Definition: flashsv.c:63

uint8_t w

Definition: llviddspenc.c:38

FlashSVContext::ver

int ver

Definition: flashsv.c:62

AVPacket::data

uint8_t * data

Definition: packet.h:558

#define b

Definition: input.c:42

decode_hybrid

static int decode_hybrid(const uint8_t *sptr, const uint8_t *sptr_end, uint8_t *dptr, int dx, int dy, int h, int w, int stride, const uint32_t *pal)

Definition: flashsv.c:76

data

const char data[16]

Definition: mxf.c:149

FFCodec

Definition: codec_internal.h:127

AV_PIX_FMT_BGR24

@ AV_PIX_FMT_BGR24

packed RGB 8:8:8, 24bpp, BGRBGR...

Definition: pixfmt.h:76

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:73

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:91

AV_PKT_FLAG_KEY

#define AV_PKT_FLAG_KEY

The packet contains a keyframe.

Definition: packet.h:613

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

flashsv_decode_init

static av_cold int flashsv_decode_init(AVCodecContext *avctx)

Definition: flashsv.c:122

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:379

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:135

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:333

flashsv_decode_block

static int flashsv_decode_block(AVCodecContext *avctx, const AVPacket *avpkt, GetBitContext *gb, int block_size, int width, int height, int x_pos, int y_pos, int blk_idx)

Definition: flashsv.c:201

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

inflate

static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)

Definition: vf_neighbor.c:194

GetBitContext

Definition: get_bits.h:109

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:52

flashsv2_prime

static int flashsv2_prime(FlashSVContext *s, const uint8_t *src, int size)

Definition: flashsv.c:137

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

zlib_wrapper.h

av_cold

#define av_cold

Definition: attributes.h:106

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:539

FlashSVContext::tmpblock

uint8_t * tmpblock

Definition: flashsv.c:60

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:346

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:198

const char * g

Definition: vf_curves.c:128

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

decode.h

get_bits.h

FlashSVContext::is_keyframe

int is_keyframe

Definition: flashsv.c:64

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

FlashSVContext::zlibprime_curr

int zlibprime_curr

Definition: flashsv.c:70

AV_CODEC_ID_FLASHSV2

@ AV_CODEC_ID_FLASHSV2

Definition: codec_id.h:183

AVPacket::buf

AVBufferRef * buf

A reference to the reference-counted buffer where the packet data is stored.

Definition: packet.h:541

NULL

#define NULL

Definition: coverity.c:32

FlashSVContext::frame

AVFrame * frame

Definition: flashsv.c:57

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

FlashSVContext::color_depth

int color_depth

Definition: flashsv.c:69

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:386

FlashSVContext

Definition: flashsv.c:55

FlashSVContext::zlibprime_prev

int zlibprime_prev

Definition: flashsv.c:70

AV_CODEC_ID_FLASHSV

@ AV_CODEC_ID_FLASHSV

Definition: codec_id.h:138

BlockInfo::size

int size

Definition: flashsv.c:52

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

FlashSVContext::keyframedata_buf

AVBufferRef * keyframedata_buf

Definition: flashsv.c:66

BlockInfo

Definition: dvdec.c:57

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

FlashSVContext::blocks

BlockInfo * blocks

Definition: flashsv.c:68

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

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

AVPacket::size

int size

Definition: packet.h:559

height

#define height

Definition: dsp.h:89

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

codec_internal.h

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:424

size

int size

Definition: twinvq_data.h:10344

av_reallocp

int av_reallocp(void *ptr, size_t size)

Allocate, reallocate, or free a block of memory through a pointer to a pointer.

Definition: mem.c:188

ff_flashsv2_decoder

const FFCodec ff_flashsv2_decoder

header

static const uint8_t header[24]

Definition: sdr2.c:68

AV_WL16

#define AV_WL16(p, v)

Definition: intreadwrite.h:408

FlashSVContext::block_height

int block_height

Definition: flashsv.c:59

line

Definition: graph2dot.c:48

AVPacket::flags

int flags

A combination of AV_PKT_FLAG values.

Definition: packet.h:564

FlashSVContext::block_width

int block_width

Definition: flashsv.c:59

FlashSVContext::diff_height

int diff_height

Definition: flashsv.c:71

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

Definition: cbs_h2645.c:256

FlashSVContext::block_size

int block_size

Definition: flashsv.c:61

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

FlashSVContext::image_height

int image_height

Definition: flashsv.c:58

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:496

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:256

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

av_buffer_replace

int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)

Ensure dst refers to the same data as src.

Definition: buffer.c:233

ff_inflate_end

void ff_inflate_end(FFZStream *zstream)

Wrapper around inflateEnd().

AVCodecContext::height

int height

Definition: avcodec.h:592

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:631

avcodec.h

stride

#define stride

Definition: h264pred_template.c:536

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

ret

Definition: filter_design.txt:187

AVCodecContext

main external API structure.

Definition: avcodec.h:431

FlashSVContext::keyframe

uint8_t * keyframe

Definition: flashsv.c:67

FlashSVContext::diff_start

int diff_start

Definition: flashsv.c:71

ff_flashsv_decoder

const FFCodec ff_flashsv_decoder

BlockInfo::pos

const uint8_t * pos

Definition: flashsv.c:51

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:200

FFZStream

Definition: zlib_wrapper.h:27

mem.h

AVBufferRef

A reference to a data buffer.

Definition: buffer.h:82

avpriv_request_sample

#define avpriv_request_sample(...)

Definition: tableprint_vlc.h:37

AVPacket

This structure stores compressed data.

Definition: packet.h:535

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:458

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

ff_inflate_init

int ff_inflate_init(FFZStream *zstream, void *logctx)

Wrapper around inflateInit().

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:592

bytestream.h

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

Definition: vp9dsp_template.c:2070

width

#define width

Definition: dsp.h:89

flashsv_decode_frame

static int flashsv_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)

Definition: flashsv.c:270

FlashSVContext::avctx

AVCodecContext * avctx

Definition: flashsv.c:56

src

#define src

Definition: vp8dsp.c:248

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:98

FlashSVContext::tmp

uint8_t tmp[UINT16_MAX]

Definition: flashsv.c:73

Generated on Sat Oct 18 2025 19:22:04 for FFmpeg by doxygen 1.8.17