FFmpeg: libavcodec/tdsc.c Source File

FFmpeg

[フレーム]

libavcodec

tdsc.c

Go to the documentation of this file.

1 /*

2 * TDSC decoder

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 * TDSC decoder

25 *

26 * Fourcc: TSDC

27 *

28 * TDSC is very simple. It codes picture by tiles, storing them in raw BGR24

29 * format or compressing them in JPEG. Frames can be full pictures or just

30 * updates to the previous frame. Cursor is found in its own frame or at the

31 * bottom of the picture. Every frame is then packed with zlib.

32 *

33 * Supports: BGR24

34 */

36 #include <stdint.h>

37 #include <zlib.h>

39 #include "libavutil/imgutils.h"

41 #include "avcodec.h"

42 #include "bytestream.h"

43 #include "internal.h"

45 #define BITMAPINFOHEADER_SIZE 0x28

46 #define TDSF_HEADER_SIZE 0x56

47 #define TDSB_HEADER_SIZE 0x08

49 typedef struct TDSCContext {

50 AVCodecContext *jpeg_avctx; // wrapper context for MJPEG

52 int width, height;

53 GetByteContext gbc;

55 AVFrame *refframe; // full decoded frame (without cursor)

56 AVFrame *jpgframe; // decoded JPEG tile

57 uint8_t *tilebuffer; // buffer containing tile data

59 /* zlib interation */

60 uint8_t *deflatebuffer;

61 uLongf deflatelen;

63 /* All that is cursor */

64 uint8_t *cursor;

65 int cursor_stride;

66 int cursor_w, cursor_h, cursor_x, cursor_y;

67 int cursor_hot_x, cursor_hot_y;

68 } TDSCContext;

70 /* 1 byte bits, 1 byte planes, 2 bytes format (probably) */

71 enum TDSCCursorFormat {

72 CUR_FMT_MONO = 0x01010004,

73 CUR_FMT_BGRA = 0x20010004,

74 CUR_FMT_RGBA = 0x20010008,

75 };

77 static av_cold int tdsc_close(AVCodecContext *avctx)

78 {

79 TDSCContext *ctx = avctx->priv_data;

81 av_frame_free(&ctx->refframe);

82 av_frame_free(&ctx->jpgframe);

83 av_freep(&ctx->deflatebuffer);

84 av_freep(&ctx->tilebuffer);

85 av_freep(&ctx->cursor);

86 avcodec_free_context(&ctx->jpeg_avctx);

88 return 0;

89 }

91 static av_cold int tdsc_init(AVCodecContext *avctx)

92 {

93 TDSCContext *ctx = avctx->priv_data;

94 const AVCodec *codec;

95 int ret;

97 avctx->pix_fmt = AV_PIX_FMT_BGR24;

99 /* These needs to be set to estimate buffer and frame size */

100 if (!(avctx->width && avctx->height)) {

101 av_log(avctx, AV_LOG_ERROR, "Video size not set.\n");

102 return AVERROR_INVALIDDATA;

103 }

104

105 /* This value should be large enough for a RAW-only frame plus headers */

106 ctx->deflatelen = avctx->width * avctx->height * (3 + 1);

107 ret = av_reallocp(&ctx->deflatebuffer, ctx->deflatelen);

108 if (ret < 0)

109 return ret;

110

111 /* Allocate reference and JPEG frame */

112 ctx->refframe = av_frame_alloc();

113 ctx->jpgframe = av_frame_alloc();

114 if (!ctx->refframe || !ctx->jpgframe)

115 return AVERROR(ENOMEM);

116

117 /* Prepare everything needed for JPEG decoding */

118 codec = avcodec_find_decoder(AV_CODEC_ID_MJPEG);

119 if (!codec)

120 return AVERROR_BUG;

121 ctx->jpeg_avctx = avcodec_alloc_context3(codec);

122 if (!ctx->jpeg_avctx)

123 return AVERROR(ENOMEM);

124 ctx->jpeg_avctx->flags = avctx->flags;

125 ctx->jpeg_avctx->flags2 = avctx->flags2;

126 ctx->jpeg_avctx->dct_algo = avctx->dct_algo;

127 ctx->jpeg_avctx->idct_algo = avctx->idct_algo;

128 ret = ff_codec_open2_recursive(ctx->jpeg_avctx, codec, NULL);

129 if (ret < 0)

130 return ret;

131

132 /* Set the output pixel format on the reference frame */

133 ctx->refframe->format = avctx->pix_fmt;

134

135 return 0;

136 }

137

138 #define APPLY_ALPHA(src, new, alpha) \

139 src = (src * (256 - alpha) + new * alpha) >> 8

140

141 /* Paint a region over a buffer, without drawing out of its bounds. */

142 static void tdsc_paint_cursor(AVCodecContext *avctx, uint8_t *dst, int stride)

143 {

144 TDSCContext *ctx = avctx->priv_data;

145 const uint8_t *cursor = ctx->cursor;

146 int x = ctx->cursor_x - ctx->cursor_hot_x;

147 int y = ctx->cursor_y - ctx->cursor_hot_y;

148 int w = ctx->cursor_w;

149 int h = ctx->cursor_h;

150 int i, j;

151

152 if (!ctx->cursor)

153 return;

154

155 if (x + w > ctx->width)

156 w = ctx->width - x;

157 if (y + h > ctx->height)

158 h = ctx->height - y;

159 if (x < 0) {

160 w += x;

161 cursor += -x * 4;

162 } else {

163 dst += x * 3;

164 }

165 if (y < 0) {

166 h += y;

167 cursor += -y * ctx->cursor_stride;

168 } else {

169 dst += y * stride;

170 }

171 if (w < 0 || h < 0)

172 return;

173

174 for (j = 0; j < h; j++) {

175 for (i = 0; i < w; i++) {

176 uint8_t alpha = cursor[i * 4];

177 APPLY_ALPHA(dst[i * 3 + 0], cursor[i * 4 + 1], alpha);

178 APPLY_ALPHA(dst[i * 3 + 1], cursor[i * 4 + 2], alpha);

179 APPLY_ALPHA(dst[i * 3 + 2], cursor[i * 4 + 3], alpha);

180 }

181 dst += stride;

182 cursor += ctx->cursor_stride;

183 }

184 }

185

186 /* Load cursor data and store it in ABGR mode. */

187 static int tdsc_load_cursor(AVCodecContext *avctx)

188 {

189 TDSCContext *ctx = avctx->priv_data;

190 int i, j, k, ret, bits, cursor_fmt;

191 uint8_t *dst;

192

193 ctx->cursor_hot_x = bytestream2_get_le16(&ctx->gbc);

194 ctx->cursor_hot_y = bytestream2_get_le16(&ctx->gbc);

195 ctx->cursor_w = bytestream2_get_le16(&ctx->gbc);

196 ctx->cursor_h = bytestream2_get_le16(&ctx->gbc);

197

198 ctx->cursor_stride = FFALIGN(ctx->cursor_w, 32) * 4;

199 cursor_fmt = bytestream2_get_le32(&ctx->gbc);

200

201 if (ctx->cursor_x >= avctx->width || ctx->cursor_y >= avctx->height) {

202 av_log(avctx, AV_LOG_ERROR,

203 "Invalid cursor position (%d.%d outside %dx%d).\n",

204 ctx->cursor_x, ctx->cursor_y, avctx->width, avctx->height);

205 return AVERROR_INVALIDDATA;

206 }

207 if (ctx->cursor_w < 1 || ctx->cursor_w > 256 ||

208 ctx->cursor_h < 1 || ctx->cursor_h > 256) {

209 av_log(avctx, AV_LOG_ERROR,

210 "Invalid cursor dimensions %dx%d.\n",

211 ctx->cursor_w, ctx->cursor_h);

212 return AVERROR_INVALIDDATA;

213 }

214 if (ctx->cursor_hot_x > ctx->cursor_w ||

215 ctx->cursor_hot_y > ctx->cursor_h) {

216 av_log(avctx, AV_LOG_WARNING, "Invalid hotspot position %d.%d.\n",

217 ctx->cursor_hot_x, ctx->cursor_hot_y);

218 ctx->cursor_hot_x = FFMIN(ctx->cursor_hot_x, ctx->cursor_w - 1);

219 ctx->cursor_hot_y = FFMIN(ctx->cursor_hot_y, ctx->cursor_h - 1);

220 }

221

222 ret = av_reallocp(&ctx->cursor, ctx->cursor_stride * ctx->cursor_h);

223 if (ret < 0) {

224 av_log(avctx, AV_LOG_ERROR, "Cannot allocate cursor buffer.\n");

225 return ret;

226 }

227

228 dst = ctx->cursor;

229 /* here data is packed in BE */

230 switch (cursor_fmt) {

231 case CUR_FMT_MONO:

232 for (j = 0; j < ctx->cursor_h; j++) {

233 for (i = 0; i < ctx->cursor_w; i += 32) {

234 bits = bytestream2_get_be32(&ctx->gbc);

235 for (k = 0; k < 32; k++) {

236 dst[0] = !!(bits & 0x80000000);

237 dst += 4;

238 bits <<= 1;

239 }

240 }

241 dst += ctx->cursor_stride - ctx->cursor_w * 4;

242 }

243

244 dst = ctx->cursor;

245 for (j = 0; j < ctx->cursor_h; j++) {

246 for (i = 0; i < ctx->cursor_w; i += 32) {

247 bits = bytestream2_get_be32(&ctx->gbc);

248 for (k = 0; k < 32; k++) {

249 int mask_bit = !!(bits & 0x80000000);

250 switch (dst[0] * 2 + mask_bit) {

251 case 0:

252 dst[0] = 0xFF;

253 dst[1] = 0x00;

254 dst[2] = 0x00;

255 dst[3] = 0x00;

256 break;

257 case 1:

258 dst[0] = 0xFF;

259 dst[1] = 0xFF;

260 dst[2] = 0xFF;

261 dst[3] = 0xFF;

262 break;

263 default:

264 dst[0] = 0x00;

265 dst[1] = 0x00;

266 dst[2] = 0x00;

267 dst[3] = 0x00;

268 }

269 dst += 4;

270 bits <<= 1;

271 }

272 }

273 dst += ctx->cursor_stride - ctx->cursor_w * 4;

274 }

275 break;

276 case CUR_FMT_BGRA:

277 case CUR_FMT_RGBA:

278 /* Skip monochrome version of the cursor */

279 bytestream2_skip(&ctx->gbc,

280 ctx->cursor_h * (FFALIGN(ctx->cursor_w, 32) >> 3));

281 if (cursor_fmt & 8) { // RGBA -> ABGR

282 for (j = 0; j < ctx->cursor_h; j++) {

283 for (i = 0; i < ctx->cursor_w; i++) {

284 int val = bytestream2_get_be32(&ctx->gbc);

285 *dst++ = val >> 24;

286 *dst++ = val >> 16;

287 *dst++ = val >> 8;

288 *dst++ = val >> 0;

289 }

290 dst += ctx->cursor_stride - ctx->cursor_w * 4;

291 }

292 } else { // BGRA -> ABGR

293 for (j = 0; j < ctx->cursor_h; j++) {

294 for (i = 0; i < ctx->cursor_w; i++) {

295 int val = bytestream2_get_be32(&ctx->gbc);

296 *dst++ = val >> 0;

297 *dst++ = val >> 24;

298 *dst++ = val >> 16;

299 *dst++ = val >> 8;

300 }

301 dst += ctx->cursor_stride - ctx->cursor_w * 4;

302 }

303 }

304 break;

305 default:

306 avpriv_request_sample(avctx, "Cursor format %08x", cursor_fmt);

307 return AVERROR_PATCHWELCOME;

308 }

309

310 return 0;

311 }

312

313 /* Convert a single YUV pixel to RGB. */

314 static inline void tdsc_yuv2rgb(uint8_t *out, int Y, int U, int V)

315 {

316 out[0] = av_clip_uint8(Y + ( 91881 * V + 32768 >> 16));

317 out[1] = av_clip_uint8(Y + (-22554 * U - 46802 * V + 32768 >> 16));

318 out[2] = av_clip_uint8(Y + (116130 * U + 32768 >> 16));

319 }

320

321 /* Convert a YUV420 buffer to a RGB buffer. */

322 static av_always_inline void tdsc_blit(uint8_t *dst, int dst_stride,

323 const uint8_t *srcy, int srcy_stride,

324 const uint8_t *srcu, const uint8_t *srcv,

325 int srcuv_stride, int width, int height)

326 {

327 int col, line;

328 for (line = 0; line < height; line++) {

329 for (col = 0; col < width; col++)

330 tdsc_yuv2rgb(dst + col * 3, srcy[col],

331 srcu[col >> 1] - 128, srcv[col >> 1] - 128);

332

333 dst += dst_stride;

334 srcy += srcy_stride;

335 srcu += srcuv_stride * (line & 1);

336 srcv += srcuv_stride * (line & 1);

337 }

338 }

339

340 /* Invoke the MJPEG decoder to decode the tile. */

341 static int tdsc_decode_jpeg_tile(AVCodecContext *avctx, int tile_size,

342 int x, int y, int w, int h)

343 {

344 TDSCContext *ctx = avctx->priv_data;

345 AVPacket jpkt;

346 int got_frame = 0;

347 int ret;

348

349 /* Prepare a packet and send to the MJPEG decoder */

350 av_init_packet(&jpkt);

351 jpkt.data = ctx->tilebuffer;

352 jpkt.size = tile_size;

353

354 ret = avcodec_decode_video2(ctx->jpeg_avctx, ctx->jpgframe,

355 &got_frame, &jpkt);

356 if (ret < 0 || !got_frame || ctx->jpgframe->format != AV_PIX_FMT_YUVJ420P) {

357 av_log(avctx, AV_LOG_ERROR,

358 "JPEG decoding error (%d) for (%d) frame.\n",

359 ret, got_frame);

360

361 /* Normally skip, error if explode */

362 if (avctx->err_recognition & AV_EF_EXPLODE)

363 return AVERROR_INVALIDDATA;

364 else

365 return 0;

366 }

367

368 /* Let's paint ont the buffer */

369 tdsc_blit(ctx->refframe->data[0] + x * 3 + ctx->refframe->linesize[0] * y,

370 ctx->refframe->linesize[0],

371 ctx->jpgframe->data[0], ctx->jpgframe->linesize[0],

372 ctx->jpgframe->data[1], ctx->jpgframe->data[2],

373 ctx->jpgframe->linesize[1], w, h);

374

375 av_frame_unref(ctx->jpgframe);

376

377 return 0;

378 }

379

380 /* Parse frame and either copy data or decode JPEG. */

381 static int tdsc_decode_tiles(AVCodecContext *avctx, int number_tiles)

382 {

383 TDSCContext *ctx = avctx->priv_data;

384 int i;

385

386 /* Iterate over the number of tiles */

387 for (i = 0; i < number_tiles; i++) {

388 int tile_size;

389 int tile_mode;

390 int x, y, w, h;

391 int ret;

392

393 if (bytestream2_get_bytes_left(&ctx->gbc) < 4 ||

394 bytestream2_get_le32(&ctx->gbc) != MKTAG('T','D','S','B') ||

395 bytestream2_get_bytes_left(&ctx->gbc) < TDSB_HEADER_SIZE - 4) {

396 av_log(avctx, AV_LOG_ERROR, "TDSB tag is too small.\n");

397 return AVERROR_INVALIDDATA;

398 }

399

400 tile_size = bytestream2_get_le32(&ctx->gbc);

401 if (bytestream2_get_bytes_left(&ctx->gbc) < tile_size)

402 return AVERROR_INVALIDDATA;

403

404 tile_mode = bytestream2_get_le32(&ctx->gbc);

405 bytestream2_skip(&ctx->gbc, 4); // unknown

406 x = bytestream2_get_le32(&ctx->gbc);

407 y = bytestream2_get_le32(&ctx->gbc);

408 w = bytestream2_get_le32(&ctx->gbc) - x;

409 h = bytestream2_get_le32(&ctx->gbc) - y;

410

411 if (x >= ctx->width || y >= ctx->height) {

412 av_log(avctx, AV_LOG_ERROR,

413 "Invalid tile position (%d.%d outside %dx%d).\n",

414 x, y, ctx->width, ctx->height);

415 return AVERROR_INVALIDDATA;

416 }

417 if (x + w > ctx->width || y + h > ctx->height) {

418 av_log(avctx, AV_LOG_ERROR,

419 "Invalid tile size %dx%d\n", w, h);

420 return AVERROR_INVALIDDATA;

421 }

422

423 ret = av_reallocp(&ctx->tilebuffer, tile_size);

424 if (!ctx->tilebuffer)

425 return ret;

426

427 bytestream2_get_buffer(&ctx->gbc, ctx->tilebuffer, tile_size);

428

429 if (tile_mode == MKTAG('G','E','P','J')) {

430 /* Decode JPEG tile and copy it in the reference frame */

431 ret = tdsc_decode_jpeg_tile(avctx, tile_size, x, y, w, h);

432 if (ret < 0)

433 return ret;

434 } else if (tile_mode == MKTAG(' ','W','A','R')) {

435 /* Just copy the buffer to output */

436 av_image_copy_plane(ctx->refframe->data[0] + x * 3 +

437 ctx->refframe->linesize[0] * y,

438 ctx->refframe->linesize[0], ctx->tilebuffer,

439 w * 3, w * 3, h);

440 } else {

441 av_log(avctx, AV_LOG_ERROR, "Unknown tile type %08x.\n", tile_mode);

442 return AVERROR_INVALIDDATA;

443 }

444 av_log(avctx, AV_LOG_DEBUG, "Tile %d, %dx%d (%d.%d)\n", i, w, h, x, y);

445 }

446

447 return 0;

448 }

449

450 static int tdsc_parse_tdsf(AVCodecContext *avctx, int number_tiles)

451 {

452 TDSCContext *ctx = avctx->priv_data;

453 int ret, w, h, init_refframe = !ctx->refframe->data[0];

454

455 /* BITMAPINFOHEADER

456 * http://msdn.microsoft.com/en-us/library/windows/desktop/dd183376.aspx */

457 if (bytestream2_get_le32(&ctx->gbc) != BITMAPINFOHEADER_SIZE)

458 return AVERROR_INVALIDDATA;

459

460 /* Store size, but wait for context reinit before updating avctx */

461 w = bytestream2_get_le32(&ctx->gbc);

462 h = -bytestream2_get_le32(&ctx->gbc);

463

464 if (bytestream2_get_le16(&ctx->gbc) != 1 || // 1 plane

465 bytestream2_get_le16(&ctx->gbc) != 24) // BGR24

466 return AVERROR_INVALIDDATA;

467

468 bytestream2_skip(&ctx->gbc, 24); // unused fields

469

470 /* Update sizes */

471 if (avctx->width != w || avctx->height != h) {

472 av_log(avctx, AV_LOG_DEBUG, "Size update %dx%d -> %d%d.\n",

473 avctx->width, avctx->height, ctx->width, ctx->height);

474 ret = ff_set_dimensions(avctx, w, h);

475 if (ret < 0)

476 return ret;

477 init_refframe = 1;

478 }

479 ctx->refframe->width = ctx->width = w;

480 ctx->refframe->height = ctx->height = h;

481

482 /* Allocate the reference frame if not already done or on size change */

483 if (init_refframe) {

484 ret = av_frame_get_buffer(ctx->refframe, 32);

485 if (ret < 0)

486 return ret;

487 }

488

489 /* Decode all tiles in a frame */

490 return tdsc_decode_tiles(avctx, number_tiles);

491 }

492

493 static int tdsc_parse_dtsm(AVCodecContext *avctx)

494 {

495 TDSCContext *ctx = avctx->priv_data;

496 int ret;

497 int action = bytestream2_get_le32(&ctx->gbc);

498

499 bytestream2_skip(&ctx->gbc, 4); // some kind of ID or version maybe?

500

501 if (action == 2 || action == 3) {

502 /* Load cursor coordinates */

503 ctx->cursor_x = bytestream2_get_le32(&ctx->gbc);

504 ctx->cursor_y = bytestream2_get_le32(&ctx->gbc);

505

506 /* Load a full cursor sprite */

507 if (action == 3) {

508 ret = tdsc_load_cursor(avctx);

509 /* Do not consider cursor errors fatal unless in explode mode */

510 if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))

511 return ret;

512 }

513 } else {

514 avpriv_request_sample(avctx, "Cursor action %d", action);

515 }

516

517 return 0;

518 }

519

520 static int tdsc_decode_frame(AVCodecContext *avctx, void *data,

521 int *got_frame, AVPacket *avpkt)

522 {

523 TDSCContext *ctx = avctx->priv_data;

524 AVFrame *frame = data;

525 int ret, tag_header, keyframe = 0;

526 uLongf dlen;

527

528 /* Resize deflate buffer on resolution change */

529 if (ctx->width != avctx->width || ctx->height != avctx->height) {

530 ctx->deflatelen = avctx->width * avctx->height * (3 + 1);

531 ret = av_reallocp(&ctx->deflatebuffer, ctx->deflatelen);

532 if (ret < 0)

533 return ret;

534 }

535 dlen = ctx->deflatelen;

536

537 /* Frames are deflated, need to inflate them first */

538 ret = uncompress(ctx->deflatebuffer, &dlen, avpkt->data, avpkt->size);

539 if (ret) {

540 av_log(avctx, AV_LOG_ERROR, "Deflate error %d.\n", ret);

541 return AVERROR_UNKNOWN;

542 }

543

544 bytestream2_init(&ctx->gbc, ctx->deflatebuffer, dlen);

545

546 /* Check for tag and for size info */

547 if (bytestream2_get_bytes_left(&ctx->gbc) < 4 + 4) {

548 av_log(avctx, AV_LOG_ERROR, "Frame is too small.\n");

549 return AVERROR_INVALIDDATA;

550 }

551

552 /* Read tag */

553 tag_header = bytestream2_get_le32(&ctx->gbc);

554

555 if (tag_header == MKTAG('T','D','S','F')) {

556 int number_tiles;

557 if (bytestream2_get_bytes_left(&ctx->gbc) < TDSF_HEADER_SIZE) {

558 av_log(avctx, AV_LOG_ERROR, "TDSF tag is too small.\n");

559 return AVERROR_INVALIDDATA;

560 }

561 /* First 4 bytes here are the number of GEPJ/WAR tiles in this frame */

562 number_tiles = bytestream2_get_le32(&ctx->gbc);

563

564 bytestream2_skip(&ctx->gbc, 4); // internal timestamp maybe?

565 keyframe = bytestream2_get_le32(&ctx->gbc) == 0x30;

566

567 ret = tdsc_parse_tdsf(avctx, number_tiles);

568 if (ret < 0)

569 return ret;

570

571 /* Check if there is anything else we are able to parse */

572 if (bytestream2_get_bytes_left(&ctx->gbc) >= 4 + 4)

573 tag_header = bytestream2_get_le32(&ctx->gbc);

574 }

575

576 /* This tag can be after a TDSF block or on its own frame */

577 if (tag_header == MKTAG('D','T','S','M')) {

578 /* First 4 bytes here are the total size in bytes for this frame */

579 int tag_size = bytestream2_get_le32(&ctx->gbc);

580

581 if (bytestream2_get_bytes_left(&ctx->gbc) < tag_size) {

582 av_log(avctx, AV_LOG_ERROR, "DTSM tag is too small.\n");

583 return AVERROR_INVALIDDATA;

584 }

585

586 ret = tdsc_parse_dtsm(avctx);

587 if (ret < 0)

588 return ret;

589 }

590

591 /* Get the output frame and copy the reference frame */

592 ret = ff_get_buffer(avctx, frame, 0);

593 if (ret < 0)

594 return ret;

595

596 ret = av_frame_copy(frame, ctx->refframe);

597 if (ret < 0)

598 return ret;

599

600 /* Paint the cursor on the output frame */

601 tdsc_paint_cursor(avctx, frame->data[0], frame->linesize[0]);

602

603 /* Frame is ready to be output */

604 if (keyframe) {

605 frame->pict_type = AV_PICTURE_TYPE_I;

606 frame->key_frame = 1;

607 } else {

608 frame->pict_type = AV_PICTURE_TYPE_P;

609 }

610 *got_frame = 1;

611

612 return 0;

613 }

614

615 AVCodec ff_tdsc_decoder = {

616 .name = "tdsc",

617 .long_name = NULL_IF_CONFIG_SMALL("TDSC"),

618 .type = AVMEDIA_TYPE_VIDEO,

619 .id = AV_CODEC_ID_TDSC,

620 .init = tdsc_init,

621 .decode = tdsc_decode_frame,

622 .close = tdsc_close,

623 .priv_data_size = sizeof(TDSCContext),

624 .capabilities = AV_CODEC_CAP_DR1,

625 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |

626 FF_CODEC_CAP_INIT_CLEANUP,

627 };

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

NULL

#define NULL

Definition: coverity.c:32

val

const char const char void * val

Definition: avisynth_c.h:634

GetByteContext

Definition: bytestream.h:33

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

tdsc_decode_tiles

static int tdsc_decode_tiles(AVCodecContext *avctx, int number_tiles)

Definition: tdsc.c:381

AVFrame

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

Definition: frame.h:181

Definition: vp9dsp_template.c:2093

AVCodecContext::dct_algo

int dct_algo

DCT algorithm, see FF_DCT_* below.

Definition: avcodec.h:2869

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

ctx

AVFormatContext * ctx

Definition: movenc-test.c:48

imgutils.h

misc image utilities

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:182

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

AVPacket::size

int size

Definition: avcodec.h:1468

TDSF_HEADER_SIZE

#define TDSF_HEADER_SIZE

Definition: tdsc.c:46

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1752

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:133

TDSCContext::height

int height

Definition: tdsc.c:52

TDSCContext::cursor_h

int cursor_h

Definition: tdsc.c:66

TDSCContext::width

int width

Definition: tdsc.c:52

AVCodec

AVCodec.

Definition: avcodec.h:3392

tdsc_init

static av_cold int tdsc_init(AVCodecContext *avctx)

Definition: tdsc.c:91

TDSCContext::jpeg_avctx

AVCodecContext * jpeg_avctx

Definition: tdsc.c:50

CUR_FMT_BGRA

Definition: tdsc.c:73

avpriv_request_sample

void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2

Log a generic warning message about a missing feature.

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

bits

uint8_t bits

Definition: crc.c:295

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:141

BITMAPINFOHEADER_SIZE

#define BITMAPINFOHEADER_SIZE

Definition: tdsc.c:45

#define Y

Definition: vf_boxblur.c:76

tdsc_parse_dtsm

static int tdsc_parse_dtsm(AVCodecContext *avctx)

Definition: tdsc.c:493

frame

static AVFrame * frame

Definition: demuxing_decoding.c:53

tdsc_blit

static av_always_inline void tdsc_blit(uint8_t *dst, int dst_stride, const uint8_t *srcy, int srcy_stride, const uint8_t *srcu, const uint8_t *srcv, int srcuv_stride, int width, int height)

Definition: tdsc.c:322

AVPacket::data

uint8_t * data

Definition: avcodec.h:1467

TDSCContext::cursor

uint8_t * cursor

Definition: tdsc.c:64

TDSCContext::cursor_stride

int cursor_stride

Definition: tdsc.c:65

tdsc_close

static av_cold int tdsc_close(AVCodecContext *avctx)

Definition: tdsc.c:77

AV_CODEC_ID_MJPEG

Definition: avcodec.h:114

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:48

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

#define U(x)

Definition: vp56_arith.h:37

alpha

static double alpha(void *priv, double x, double y)

Definition: vf_geq.c:99

AVFrame::width

int width

width and height of the video frame

Definition: frame.h:230

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

TDSCCursorFormat

Definition: tdsc.c:71

avcodec_decode_video2

int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt)

Decode the video frame of size avpkt->size from avpkt->data into picture.

Definition: utils.c:2091

TDSCContext::cursor_hot_y

int cursor_hot_y

Definition: tdsc.c:67

ff_codec_open2_recursive

int ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)

Call avcodec_open2 recursively by decrementing counter, unlocking mutex, calling the function and the...

Definition: utils.c:1158

AVERROR

#define AVERROR(e)

Definition: error.h:43

bytestream2_skip

static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)

Definition: bytestream.h:164

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:154

tdsc_decode_frame

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

Definition: tdsc.c:520

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

TDSCContext::refframe

AVFrame * refframe

Definition: tdsc.c:55

bytestream2_get_buffer

static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)

Definition: bytestream.h:263

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:197

bytestream2_get_bytes_left

static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)

Definition: bytestream.h:154

TDSCContext::cursor_x

int cursor_x

Definition: tdsc.c:66

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:1627

line

Definition: graph2dot.c:48

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3399

tdsc_parse_tdsf

static int tdsc_parse_tdsf(AVCodecContext *avctx, int number_tiles)

Definition: tdsc.c:450

av_frame_copy

int av_frame_copy(AVFrame *dst, const AVFrame *src)

Copy the frame data from src to dst.

Definition: frame.c:695

bytestream.h

TDSCContext::deflatelen

uLongf deflatelen

Definition: tdsc.c:61

AV_CODEC_ID_TDSC

Definition: avcodec.h:294

AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:266

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:252

AVCodecContext::err_recognition

int err_recognition

Error recognition; may misdetect some more or less valid parts as errors.

Definition: avcodec.h:2811

TDSCContext::gbc

GetByteContext gbc

Definition: tdsc.c:53

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

AV_PIX_FMT_YUVJ420P

planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...

Definition: pixfmt.h:75

avcodec_alloc_context3

AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)

Allocate an AVCodecContext and set its fields to default values.

Definition: options.c:149

TDSCContext::deflatebuffer

uint8_t * deflatebuffer

Definition: tdsc.c:60

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1711

AVCodecContext::idct_algo

int idct_algo

IDCT algorithm, see FF_IDCT_* below.

Definition: avcodec.h:2882

tdsc_decode_jpeg_tile

static int tdsc_decode_jpeg_tile(AVCodecContext *avctx, int tile_size, int x, int y, int w, int h)

Definition: tdsc.c:341

TDSCContext::jpgframe

AVFrame * jpgframe

Definition: tdsc.c:56

AV_EF_EXPLODE

#define AV_EF_EXPLODE

abort decoding on minor error detection

Definition: avcodec.h:2822

AV_PIX_FMT_BGR24

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

Definition: pixfmt.h:66

AVCodecContext::height

int height

Definition: avcodec.h:1711

TDSCContext::cursor_y

int cursor_y

Definition: tdsc.c:66

out

FILE * out

Definition: movenc-test.c:54

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:62

AVFrame::format

int format

format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...

Definition: frame.h:242

TDSCContext::cursor_hot_x

int cursor_hot_x

Definition: tdsc.c:67

tdsc_paint_cursor

static void tdsc_paint_cursor(AVCodecContext *avctx, uint8_t *dst, int stride)

Definition: tdsc.c:142

avcodec.h

Libavcodec external API header.

avcodec_free_context

void avcodec_free_context(AVCodecContext **avctx)

Free the codec context and everything associated with it and write NULL to the provided pointer...

Definition: options.c:164

TDSCContext::tilebuffer

uint8_t * tilebuffer

Definition: tdsc.c:57

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:209

AVCodecContext

main external API structure.

Definition: avcodec.h:1532

avcodec_find_decoder

AVCodec * avcodec_find_decoder(enum AVCodecID id)

Find a registered decoder with a matching codec ID.

Definition: utils.c:2629

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: utils.c:894

AVERROR_BUG

#define AVERROR_BUG

Internal bug, also see AVERROR_BUG2.

Definition: error.h:50

height

BYTE int const BYTE int int int height

Definition: avisynth_c.h:676

TDSCContext::cursor_w

int cursor_w

Definition: tdsc.c:66

TDSB_HEADER_SIZE

#define TDSB_HEADER_SIZE

Definition: tdsc.c:47

av_frame_get_buffer

int av_frame_get_buffer(AVFrame *frame, int align)

Allocate new buffer(s) for audio or video data.

Definition: frame.c:271

av_frame_unref

void av_frame_unref(AVFrame *frame)

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

Definition: frame.c:474

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:192

stride

GLint GLenum GLboolean GLsizei stride

Definition: opengl_enc.c:105

internal.h

common internal api header.

av_reallocp

int av_reallocp(void *ptr, size_t size)

Allocate or reallocate a block of memory.

Definition: mem.c:187

av_init_packet

void av_init_packet(AVPacket *pkt)

Initialize optional fields of a packet with default values.

Definition: avpacket.c:33

AVERROR_UNKNOWN

#define AVERROR_UNKNOWN

Unknown error, typically from an external library.

Definition: error.h:71

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1574

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:247

APPLY_ALPHA

#define APPLY_ALPHA(src, new, alpha)

Definition: tdsc.c:138

tdsc_yuv2rgb

static void tdsc_yuv2rgb(uint8_t *out, int Y, int U, int V)

Definition: tdsc.c:314

AVCodecContext::flags2

int flags2

AV_CODEC_FLAG2_*.

Definition: avcodec.h:1634

ff_tdsc_decoder

AVCodec ff_tdsc_decoder

Definition: tdsc.c:615

TDSCContext

Definition: tdsc.c:49

AVFrame::height

int height

Definition: frame.h:230

tdsc_load_cursor

static int tdsc_load_cursor(AVCodecContext *avctx)

Definition: tdsc.c:187

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:193

av_always_inline

#define av_always_inline

Definition: attributes.h:39

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

stride

#define stride

MKTAG

#define MKTAG(a, b, c, d)

Definition: common.h:342

CUR_FMT_MONO

Definition: tdsc.c:72

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1444

CUR_FMT_RGBA

Definition: tdsc.c:74

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() for allocating buffers and supports custom allocators.

Definition: avcodec.h:856

AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:267

#define V

Definition: avdct.c:30

width

static int width

Definition: demuxing_decoding.c:39

Generated on Mon Feb 15 2016 15:20:42 for FFmpeg by doxygen 1.8.6