[FFmpeg-cvslog] TDSC decoder
Vittorio Giovara
git at videolan.org
Fri Mar 13 23:43:40 CET 2015
ffmpeg | branch: master | Vittorio Giovara <vittorio.giovara at gmail.com> | Wed Mar 11 20:44:00 2015 +0000| [247e370e2a913db52ca079b347a174c8d393b171] | committer: Vittorio Giovara
TDSC decoder
Signed-off-by: Vittorio Giovara <vittorio.giovara at gmail.com>
> http://git.videolan.org/gitweb.cgi/ffmpeg.git/?a=commit;h=247e370e2a913db52ca079b347a174c8d393b171
---
Changelog | 1 +
configure | 2 +
doc/general.texi | 1 +
libavcodec/Makefile | 1 +
libavcodec/allcodecs.c | 1 +
libavcodec/avcodec.h | 1 +
libavcodec/codec_desc.c | 7 +
libavcodec/tdsc.c | 627 +++++++++++++++++++++++++++++++++++++++++++++++
libavcodec/version.h | 2 +-
libavformat/riff.c | 1 +
tests/fate/video.mak | 3 +
tests/ref/fate/tdsc | 42 ++++
12 files changed, 688 insertions(+), 1 deletion(-)
diff --git a/Changelog b/Changelog
index 31a550d..7dc4d7c 100644
--- a/Changelog
+++ b/Changelog
@@ -22,6 +22,7 @@ version <next>:
- Canopus HQX decoder
- RTP depacketization of T.140 text (RFC 4103)
- VP9 RTP payload format (draft 0) experimental depacketizer
+- TDSC decoder
version 11:
diff --git a/configure b/configure
index f5e8b67..c237979 100755
--- a/configure
+++ b/configure
@@ -1906,6 +1906,8 @@ svq1_encoder_select="aandcttables hpeldsp me_cmp mpegvideoenc"
svq3_decoder_select="h264_decoder hpeldsp tpeldsp"
svq3_decoder_suggest="zlib"
tak_decoder_select="audiodsp"
+tdsc_decoder_deps="zlib"
+tdsc_decoder_select="mjpeg_decoder"
theora_decoder_select="vp3_decoder"
thp_decoder_select="mjpeg_decoder"
tiff_decoder_suggest="zlib"
diff --git a/doc/general.texi b/doc/general.texi
index 21e5fe8..58ce1dc 100644
--- a/doc/general.texi
+++ b/doc/general.texi
@@ -409,6 +409,7 @@ library:
@item Sony Wave64 (W64) @tab @tab X
@item SoX native format @tab X @tab X
@item SUN AU format @tab X @tab X
+ at item TDSC @tab @tab X
@item Text files @tab @tab X
@item THP @tab @tab X
@tab Used on the Nintendo GameCube.
diff --git a/libavcodec/Makefile b/libavcodec/Makefile
index 1c50f99..b132021 100644
--- a/libavcodec/Makefile
+++ b/libavcodec/Makefile
@@ -377,6 +377,7 @@ OBJS-$(CONFIG_SVQ3_DECODER) += svq3.o svq13.o mpegutils.o
OBJS-$(CONFIG_TAK_DECODER) += takdec.o tak.o
OBJS-$(CONFIG_TARGA_DECODER) += targa.o
OBJS-$(CONFIG_TARGA_ENCODER) += targaenc.o rle.o
+OBJS-$(CONFIG_TDSC_DECODER) += tdsc.o
OBJS-$(CONFIG_TIERTEXSEQVIDEO_DECODER) += tiertexseqv.o
OBJS-$(CONFIG_TIFF_DECODER) += tiff.o lzw.o faxcompr.o
OBJS-$(CONFIG_TIFF_ENCODER) += tiffenc.o rle.o lzwenc.o
diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c
index 392a2c9..4cba5fb 100644
--- a/libavcodec/allcodecs.c
+++ b/libavcodec/allcodecs.c
@@ -243,6 +243,7 @@ void avcodec_register_all(void)
REGISTER_ENCDEC (SVQ1, svq1);
REGISTER_DECODER(SVQ3, svq3);
REGISTER_ENCDEC (TARGA, targa);
+ REGISTER_DECODER(TDSC, tdsc);
REGISTER_DECODER(THEORA, theora);
REGISTER_DECODER(THP, thp);
REGISTER_DECODER(TIERTEXSEQVIDEO, tiertexseqvideo);
diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h
index 3cd24b1..de8fc20 100644
--- a/libavcodec/avcodec.h
+++ b/libavcodec/avcodec.h
@@ -294,6 +294,7 @@ enum AVCodecID {
AV_CODEC_ID_MVC1,
AV_CODEC_ID_MVC2,
AV_CODEC_ID_HQX,
+ AV_CODEC_ID_TDSC,
/* various PCM "codecs" */
AV_CODEC_ID_FIRST_AUDIO = 0x10000, ///< A dummy id pointing at the start of audio codecs
diff --git a/libavcodec/codec_desc.c b/libavcodec/codec_desc.c
index 747ebe8..de46704 100644
--- a/libavcodec/codec_desc.c
+++ b/libavcodec/codec_desc.c
@@ -1286,6 +1286,13 @@ static const AVCodecDescriptor codec_descriptors[] = {
.props = AV_CODEC_PROP_INTRA_ONLY | AV_CODEC_PROP_LOSSLESS,
},
{
+ .id = AV_CODEC_ID_TDSC,
+ .type = AVMEDIA_TYPE_VIDEO,
+ .name = "tdsc",
+ .long_name = NULL_IF_CONFIG_SMALL("TDSC"),
+ .props = AV_CODEC_PROP_LOSSY,
+ },
+ {
.id = AV_CODEC_ID_TIFF,
.type = AVMEDIA_TYPE_VIDEO,
.name = "tiff",
diff --git a/libavcodec/tdsc.c b/libavcodec/tdsc.c
new file mode 100644
index 0000000..b46a3c1
--- /dev/null
+++ b/libavcodec/tdsc.c
@@ -0,0 +1,627 @@
+/*
+ * TDSC decoder
+ * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara at gmail.com>
+ *
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * TDSC decoder
+ *
+ * Fourcc: TSDC
+ *
+ * TDSC is very simple. It codes picture by tiles, storing them in raw BGR24
+ * format or compressing them in JPEG. Frames can be full pictures or just
+ * updates to the previous frame. Cursor is found in its own frame or at the
+ * bottom of the picture. Every frame is then packed with zlib.
+ *
+ * Supports: BGR24
+ */
+
+#include <stdint.h>
+#include <zlib.h>
+
+#include "libavutil/imgutils.h"
+
+#include "avcodec.h"
+#include "bytestream.h"
+#include "internal.h"
+
+#define BITMAPINFOHEADER_SIZE 0x28
+#define TDSF_HEADER_SIZE 0x56
+#define TDSB_HEADER_SIZE 0x08
+
+typedef struct TDSCContext {
+ AVCodecContext *jpeg_avctx; // wrapper context for MJPEG
+
+ int width, height;
+ GetByteContext gbc;
+
+ AVFrame *refframe; // full decoded frame (without cursor)
+ AVFrame *jpgframe; // decoded JPEG tile
+ uint8_t *tilebuffer; // buffer containing tile data
+
+ /* zlib interation */
+ uint8_t *deflatebuffer;
+ uLongf deflatelen;
+
+ /* All that is cursor */
+ uint8_t *cursor;
+ int cursor_stride;
+ int cursor_w, cursor_h, cursor_x, cursor_y;
+ int cursor_hot_x, cursor_hot_y;
+} TDSCContext;
+
+/* 1 byte bits, 1 byte planes, 2 bytes format (probably) */
+enum TDSCCursorFormat {
+ CUR_FMT_MONO = 0x01010004,
+ CUR_FMT_BGRA = 0x20010004,
+ CUR_FMT_RGBA = 0x20010008,
+};
+
+static av_cold int tdsc_close(AVCodecContext *avctx)
+{
+ TDSCContext *ctx = avctx->priv_data;
+
+ av_frame_free(&ctx->refframe);
+ av_frame_free(&ctx->jpgframe);
+ av_freep(&ctx->deflatebuffer);
+ av_freep(&ctx->tilebuffer);
+ av_freep(&ctx->cursor);
+ avcodec_free_context(&ctx->jpeg_avctx);
+
+ return 0;
+}
+
+static av_cold int tdsc_init(AVCodecContext *avctx)
+{
+ TDSCContext *ctx = avctx->priv_data;
+ const AVCodec *codec;
+ int ret;
+
+ avctx->pix_fmt = AV_PIX_FMT_BGR24;
+
+ /* These needs to be set to estimate buffer and frame size */
+ if (!(avctx->width && avctx->height)) {
+ av_log(avctx, AV_LOG_ERROR, "Video size not set.\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ /* This value should be large enough for a RAW-only frame plus headers */
+ ctx->deflatelen = avctx->width * avctx->height * (3 + 1);
+ ret = av_reallocp(&ctx->deflatebuffer, ctx->deflatelen);
+ if (ret < 0)
+ return ret;
+
+ /* Allocate reference and JPEG frame */
+ ctx->refframe = av_frame_alloc();
+ ctx->jpgframe = av_frame_alloc();
+ if (!ctx->refframe || !ctx->jpgframe)
+ return AVERROR(ENOMEM);
+
+ /* Prepare everything needed for JPEG decoding */
+ codec = avcodec_find_decoder(AV_CODEC_ID_MJPEG);
+ if (!codec)
+ return AVERROR_BUG;
+ ctx->jpeg_avctx = avcodec_alloc_context3(codec);
+ if (!ctx->jpeg_avctx)
+ return AVERROR(ENOMEM);
+ ctx->jpeg_avctx->flags = avctx->flags;
+ ctx->jpeg_avctx->flags2 = avctx->flags2;
+ ctx->jpeg_avctx->dct_algo = avctx->dct_algo;
+ ctx->jpeg_avctx->idct_algo = avctx->idct_algo;;
+ ret = avcodec_open2(ctx->jpeg_avctx, codec, NULL);
+ if (ret < 0)
+ return ret;
+
+ /* Set the output pixel format on the reference frame */
+ ctx->refframe->format = avctx->pix_fmt;
+
+ return 0;
+}
+
+#define APPLY_ALPHA(src, new, alpha) \
+ src = (src * (256 - alpha) + new * alpha) >> 8
+
+/* Paint a region over a buffer, without drawing out of its bounds. */
+static void tdsc_paint_cursor(AVCodecContext *avctx, uint8_t *dst, int stride)
+{
+ TDSCContext *ctx = avctx->priv_data;
+ const uint8_t *cursor = ctx->cursor;
+ int x = ctx->cursor_x - ctx->cursor_hot_x;
+ int y = ctx->cursor_y - ctx->cursor_hot_y;
+ int w = ctx->cursor_w;
+ int h = ctx->cursor_h;
+ int i, j;
+
+ if (!ctx->cursor)
+ return;
+
+ if (x + w > ctx->width)
+ w = ctx->width - x;
+ if (y + h > ctx->height)
+ h = ctx->height - y;
+ if (x < 0) {
+ w += x;
+ cursor += -x * 4;
+ } else {
+ dst += x * 3;
+ }
+ if (y < 0) {
+ h += y;
+ cursor += -y * ctx->cursor_stride;
+ } else {
+ dst += y * stride;
+ }
+ if (w < 0 || h < 0)
+ return;
+
+ for (j = 0; j < h; j++) {
+ for (i = 0; i < w; i++) {
+ uint8_t alpha = cursor[i * 4];
+ APPLY_ALPHA(dst[i * 3 + 0], cursor[i * 4 + 1], alpha);
+ APPLY_ALPHA(dst[i * 3 + 1], cursor[i * 4 + 2], alpha);
+ APPLY_ALPHA(dst[i * 3 + 2], cursor[i * 4 + 3], alpha);
+ }
+ dst += stride;
+ cursor += ctx->cursor_stride;
+ }
+}
+
+/* Load cursor data and store it in ABGR mode. */
+static int tdsc_load_cursor(AVCodecContext *avctx)
+{
+ TDSCContext *ctx = avctx->priv_data;
+ int i, j, k, ret, bits, cursor_fmt;
+ uint8_t *dst;
+
+ ctx->cursor_hot_x = bytestream2_get_le16(&ctx->gbc);
+ ctx->cursor_hot_y = bytestream2_get_le16(&ctx->gbc);
+ ctx->cursor_w = bytestream2_get_le16(&ctx->gbc);
+ ctx->cursor_h = bytestream2_get_le16(&ctx->gbc);
+
+ ctx->cursor_stride = FFALIGN(ctx->cursor_w, 32) * 4;
+ cursor_fmt = bytestream2_get_le32(&ctx->gbc);
+
+ if (ctx->cursor_x >= avctx->width || ctx->cursor_y >= avctx->height) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Invalid cursor position (%d.%d outside %dx%d).\n",
+ ctx->cursor_x, ctx->cursor_y, avctx->width, avctx->height);
+ return AVERROR_INVALIDDATA;
+ }
+ if (ctx->cursor_w < 1 || ctx->cursor_w > 256 ||
+ ctx->cursor_h < 1 || ctx->cursor_h > 256) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Invalid cursor dimensions %dx%d.\n",
+ ctx->cursor_w, ctx->cursor_h);
+ return AVERROR_INVALIDDATA;
+ }
+ if (ctx->cursor_hot_x > ctx->cursor_w ||
+ ctx->cursor_hot_y > ctx->cursor_h) {
+ av_log(avctx, AV_LOG_WARNING, "Invalid hotspot position %d.%d.\n",
+ ctx->cursor_hot_x, ctx->cursor_hot_y);
+ ctx->cursor_hot_x = FFMIN(ctx->cursor_hot_x, ctx->cursor_w - 1);
+ ctx->cursor_hot_y = FFMIN(ctx->cursor_hot_y, ctx->cursor_h - 1);
+ }
+
+ ret = av_reallocp(&ctx->cursor, ctx->cursor_stride * ctx->cursor_h);
+ if (ret < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Cannot allocate cursor buffer.\n");
+ return ret;
+ }
+
+ dst = ctx->cursor;
+ /* here data is packed in BE */
+ switch (cursor_fmt) {
+ case CUR_FMT_MONO:
+ for (j = 0; j < ctx->cursor_h; j++) {
+ for (i = 0; i < ctx->cursor_w; i += 32) {
+ bits = bytestream2_get_be32(&ctx->gbc);
+ for (k = 0; k < 32; k++) {
+ dst[0] = !!(bits & 0x80000000);
+ dst += 4;
+ bits <<= 1;
+ }
+ }
+ dst += ctx->cursor_stride - ctx->cursor_w * 4;
+ }
+
+ dst = ctx->cursor;
+ for (j = 0; j < ctx->cursor_h; j++) {
+ for (i = 0; i < ctx->cursor_w; i += 32) {
+ bits = bytestream2_get_be32(&ctx->gbc);
+ for (k = 0; k < 32; k++) {
+ int mask_bit = !!(bits & 0x80000000);
+ switch (dst[0] * 2 + mask_bit) {
+ case 0:
+ dst[0] = 0xFF;
+ dst[1] = 0x00;
+ dst[2] = 0x00;
+ dst[3] = 0x00;
+ break;
+ case 1:
+ dst[0] = 0xFF;
+ dst[1] = 0xFF;
+ dst[2] = 0xFF;
+ dst[3] = 0xFF;
+ break;
+ default:
+ dst[0] = 0x00;
+ dst[1] = 0x00;
+ dst[2] = 0x00;
+ dst[3] = 0x00;
+ }
+ dst += 4;
+ bits <<= 1;
+ }
+ }
+ dst += ctx->cursor_stride - ctx->cursor_w * 4;
+ }
+ break;
+ case CUR_FMT_BGRA:
+ case CUR_FMT_RGBA:
+ /* Skip monochrome version of the cursor */
+ bytestream2_skip(&ctx->gbc,
+ ctx->cursor_h * (FFALIGN(ctx->cursor_w, 32) >> 3));
+ if (cursor_fmt & 8) { // RGBA -> ABGR
+ for (j = 0; j < ctx->cursor_h; j++) {
+ for (i = 0; i < ctx->cursor_w; i++) {
+ int val = bytestream2_get_be32(&ctx->gbc);
+ *dst++ = val >> 24;
+ *dst++ = val >> 16;
+ *dst++ = val >> 8;
+ *dst++ = val >> 0;
+ }
+ dst += ctx->cursor_stride - ctx->cursor_w * 4;
+ }
+ } else { // BGRA -> ABGR
+ for (j = 0; j < ctx->cursor_h; j++) {
+ for (i = 0; i < ctx->cursor_w; i++) {
+ int val = bytestream2_get_be32(&ctx->gbc);
+ *dst++ = val >> 0;
+ *dst++ = val >> 24;
+ *dst++ = val >> 16;
+ *dst++ = val >> 8;
+ }
+ dst += ctx->cursor_stride - ctx->cursor_w * 4;
+ }
+ }
+ break;
+ default:
+ avpriv_request_sample(avctx, "Cursor format %08x", cursor_fmt);
+ return AVERROR_PATCHWELCOME;
+ }
+
+ return 0;
+}
+
+/* Convert a single YUV pixel to RGB. */
+static inline void tdsc_yuv2rgb(uint8_t *out, int Y, int U, int V)
+{
+ out[0] = av_clip_uint8(Y + ( 91881 * V + 32768 >> 16));
+ out[1] = av_clip_uint8(Y + (-22554 * U - 46802 * V + 32768 >> 16));
+ out[2] = av_clip_uint8(Y + (116130 * U + 32768 >> 16));
+}
+
+/* Convert a YUV420 buffer to a RGB buffer. */
+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)
+{
+ int col, line;
+ for (line = 0; line < height; line++) {
+ for (col = 0; col < width; col++)
+ tdsc_yuv2rgb(dst + col * 3, srcy[col],
+ srcu[col >> 1] - 128, srcv[col >> 1] - 128);
+
+ dst += dst_stride;
+ srcy += srcy_stride;
+ srcu += srcuv_stride * (line & 1);
+ srcv += srcuv_stride * (line & 1);
+ }
+}
+
+/* Invoke the MJPEG decoder to decode the tile. */
+static int tdsc_decode_jpeg_tile(AVCodecContext *avctx, int tile_size,
+ int x, int y, int w, int h)
+{
+ TDSCContext *ctx = avctx->priv_data;
+ AVPacket jpkt;
+ int got_frame = 0;
+ int ret;
+
+ /* Prepare a packet and send to the MJPEG decoder */
+ av_init_packet(&jpkt);
+ jpkt.data = ctx->tilebuffer;
+ jpkt.size = tile_size;
+
+ ret = avcodec_decode_video2(ctx->jpeg_avctx, ctx->jpgframe,
+ &got_frame, &jpkt);
+ if (ret < 0 || !got_frame || ctx->jpgframe->format != AV_PIX_FMT_YUVJ420P) {
+ av_log(avctx, AV_LOG_ERROR,
+ "JPEG decoding error (%d) for (%d) frame.\n",
+ ret, got_frame);
+
+ /* Normally skip, error if explode */
+ if (avctx->err_recognition & AV_EF_EXPLODE)
+ return AVERROR_INVALIDDATA;
+ else
+ return 0;
+ }
+
+ /* Let's paint ont the buffer */
+ tdsc_blit(ctx->refframe->data[0] + x * 3 + ctx->refframe->linesize[0] * y,
+ ctx->refframe->linesize[0],
+ ctx->jpgframe->data[0], ctx->jpgframe->linesize[0],
+ ctx->jpgframe->data[1], ctx->jpgframe->data[2],
+ ctx->jpgframe->linesize[1], w, h);
+
+ av_frame_unref(ctx->jpgframe);
+
+ return 0;
+}
+
+/* Parse frame and either copy data or decode JPEG. */
+static int tdsc_decode_tiles(AVCodecContext *avctx, int number_tiles)
+{
+ TDSCContext *ctx = avctx->priv_data;
+ int i;
+
+ /* Iterate over the number of tiles */
+ for (i = 0; i < number_tiles; i++) {
+ int tile_size;
+ int tile_mode;
+ int x, y, w, h;
+ int ret;
+
+ if (bytestream2_get_bytes_left(&ctx->gbc) < 4 ||
+ bytestream2_get_le32(&ctx->gbc) != MKTAG('T','D','S','B') ||
+ bytestream2_get_bytes_left(&ctx->gbc) < TDSB_HEADER_SIZE - 4) {
+ av_log(avctx, AV_LOG_ERROR, "TDSB tag is too small.\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ tile_size = bytestream2_get_le32(&ctx->gbc);
+ if (bytestream2_get_bytes_left(&ctx->gbc) < tile_size)
+ return AVERROR_INVALIDDATA;
+
+ tile_mode = bytestream2_get_le32(&ctx->gbc);
+ bytestream2_skip(&ctx->gbc, 4); // unknown
+ x = bytestream2_get_le32(&ctx->gbc);
+ y = bytestream2_get_le32(&ctx->gbc);
+ w = bytestream2_get_le32(&ctx->gbc) - x;
+ h = bytestream2_get_le32(&ctx->gbc) - y;
+
+ if (x >= ctx->width || y >= ctx->height) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Invalid tile position (%d.%d outside %dx%d).\n",
+ x, y, ctx->width, ctx->height);
+ return AVERROR_INVALIDDATA;
+ }
+ if (x + w > ctx->width || y + h > ctx->height) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Invalid tile size %dx%d\n", w, h);
+ return AVERROR_INVALIDDATA;
+ }
+
+ ret = av_reallocp(&ctx->tilebuffer, tile_size);
+ if (!ctx->tilebuffer)
+ return ret;
+
+ bytestream2_get_buffer(&ctx->gbc, ctx->tilebuffer, tile_size);
+
+ if (tile_mode == MKTAG('G','E','P','J')) {
+ /* Decode JPEG tile and copy it in the reference frame */
+ ret = tdsc_decode_jpeg_tile(avctx, tile_size, x, y, w, h);
+ if (ret < 0)
+ return ret;
+ } else if (tile_mode == MKTAG(' ','W','A','R')) {
+ /* Just copy the buffer to output */
+ av_image_copy_plane(ctx->refframe->data[0] + x * 3 +
+ ctx->refframe->linesize[0] * y,
+ ctx->refframe->linesize[0], ctx->tilebuffer,
+ w * 3, w * 3, h);
+ } else {
+ av_log(avctx, AV_LOG_ERROR, "Unknown tile type %08x.\n", tile_mode);
+ return AVERROR_INVALIDDATA;
+ }
+ av_log(avctx, AV_LOG_DEBUG, "Tile %d, %dx%d (%d.%d)\n", i, w, h, x, y);
+ }
+
+ return 0;
+}
+
+static int tdsc_parse_tdsf(AVCodecContext *avctx, int number_tiles)
+{
+ TDSCContext *ctx = avctx->priv_data;
+ int ret, w, h, init_refframe = !ctx->refframe->data[0];
+
+ /* BITMAPINFOHEADER
+ * http://msdn.microsoft.com/en-us/library/windows/desktop/dd183376.aspx */
+ if (bytestream2_get_le32(&ctx->gbc) != BITMAPINFOHEADER_SIZE)
+ return AVERROR_INVALIDDATA;
+
+ /* Store size, but wait for context reinit before updating avctx */
+ w = bytestream2_get_le32(&ctx->gbc);
+ h = -bytestream2_get_le32(&ctx->gbc);
+
+ if (bytestream2_get_le16(&ctx->gbc) != 1 || // 1 plane
+ bytestream2_get_le16(&ctx->gbc) != 24) // BGR24
+ return AVERROR_INVALIDDATA;
+
+ bytestream2_skip(&ctx->gbc, 24); // unused fields
+
+ /* Update sizes */
+ if (avctx->width != w || avctx->height != h) {
+ av_log(avctx, AV_LOG_DEBUG, "Size update %dx%d -> %d%d.\n",
+ avctx->width, avctx->height, ctx->width, ctx->height);
+ ret = ff_set_dimensions(avctx, w, h);
+ if (ret < 0)
+ return ret;
+ init_refframe = 1;
+ }
+ ctx->refframe->width = ctx->width = w;
+ ctx->refframe->height = ctx->height = h;
+
+ /* Allocate the reference frame if not already done or on size change */
+ if (init_refframe) {
+ ret = av_frame_get_buffer(ctx->refframe, 32);
+ if (ret < 0)
+ return ret;
+ }
+
+ /* Decode all tiles in a frame */
+ return tdsc_decode_tiles(avctx, number_tiles);
+}
+
+static int tdsc_parse_dtsm(AVCodecContext *avctx)
+{
+ TDSCContext *ctx = avctx->priv_data;
+ int ret;
+ int action = bytestream2_get_le32(&ctx->gbc);
+
+ bytestream2_skip(&ctx->gbc, 4); // some kind of ID or version maybe?
+
+ if (action == 2 || action == 3) {
+ /* Load cursor coordinates */
+ ctx->cursor_x = bytestream2_get_le32(&ctx->gbc);
+ ctx->cursor_y = bytestream2_get_le32(&ctx->gbc);
+
+ /* Load a full cursor sprite */
+ if (action == 3) {
+ ret = tdsc_load_cursor(avctx);
+ /* Do not consider cursor errors fatal unless in explode mode */
+ if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
+ return ret;
+ }
+ } else {
+ avpriv_request_sample(avctx, "Cursor action %d", action);
+ }
+
+ return 0;
+}
+
+static int tdsc_decode_frame(AVCodecContext *avctx, void *data,
+ int *got_frame, AVPacket *avpkt)
+{
+ TDSCContext *ctx = avctx->priv_data;
+ AVFrame *frame = data;
+ int ret, tag_header, keyframe = 0;
+ uLongf dlen;
+
+ /* Resize deflate buffer on resolution change */
+ if (ctx->width != avctx->width || ctx->height != avctx->height) {
+ ctx->deflatelen = avctx->width * avctx->height * (3 + 1);
+ ret = av_reallocp(&ctx->deflatebuffer, ctx->deflatelen);
+ if (ret < 0)
+ return ret;
+ }
+ dlen = ctx->deflatelen;
+
+ /* Frames are deflated, need to inflate them first */
+ ret = uncompress(ctx->deflatebuffer, &dlen, avpkt->data, avpkt->size);
+ if (ret) {
+ av_log(avctx, AV_LOG_ERROR, "Deflate error %d.\n", ret);
+ return AVERROR_UNKNOWN;
+ }
+
+ bytestream2_init(&ctx->gbc, ctx->deflatebuffer, dlen);
+
+ /* Check for tag and for size info */
+ if (bytestream2_get_bytes_left(&ctx->gbc) < 4 + 4) {
+ av_log(avctx, AV_LOG_ERROR, "Frame is too small.\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ /* Read tag */
+ tag_header = bytestream2_get_le32(&ctx->gbc);
+
+ if (tag_header == MKTAG('T','D','S','F')) {
+ int number_tiles;
+ if (bytestream2_get_bytes_left(&ctx->gbc) < TDSF_HEADER_SIZE) {
+ av_log(avctx, AV_LOG_ERROR, "TDSF tag is too small.\n");
+ return AVERROR_INVALIDDATA;
+ }
+ /* First 4 bytes here are the number of GEPJ/WAR tiles in this frame */
+ number_tiles = bytestream2_get_le32(&ctx->gbc);
+
+ bytestream2_skip(&ctx->gbc, 4); // internal timestamp maybe?
+ keyframe = bytestream2_get_le32(&ctx->gbc) == 0x30;
+
+ ret = tdsc_parse_tdsf(avctx, number_tiles);
+ if (ret < 0)
+ return ret;
+
+ /* Check if there is anything else we are able to parse */
+ if (bytestream2_get_bytes_left(&ctx->gbc) >= 4 + 4)
+ tag_header = bytestream2_get_le32(&ctx->gbc);
+ }
+
+ /* This tag can be after a TDSF block or on its own frame */
+ if (tag_header == MKTAG('D','T','S','M')) {
+ /* First 4 bytes here are the total size in bytes for this frame */
+ int tag_size = bytestream2_get_le32(&ctx->gbc);
+
+ if (bytestream2_get_bytes_left(&ctx->gbc) < tag_size) {
+ av_log(avctx, AV_LOG_ERROR, "DTSM tag is too small.\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ ret = tdsc_parse_dtsm(avctx);
+ if (ret < 0)
+ return ret;
+ }
+
+ /* Get the output frame and copy the reference frame */
+ ret = ff_get_buffer(avctx, frame, 0);
+ if (ret < 0)
+ return ret;
+
+ ret = av_frame_copy(frame, ctx->refframe);
+ if (ret < 0)
+ return ret;
+
+ /* Paint the cursor on the output frame */
+ tdsc_paint_cursor(avctx, frame->data[0], frame->linesize[0]);
+
+ /* Frame is ready to be output */
+ if (keyframe) {
+ frame->pict_type = AV_PICTURE_TYPE_I;
+ frame->key_frame = 1;
+ } else {
+ frame->pict_type = AV_PICTURE_TYPE_P;
+ }
+ *got_frame = 1;
+
+ return 0;
+}
+
+AVCodec ff_tdsc_decoder = {
+ .name = "tdsc",
+ .long_name = NULL_IF_CONFIG_SMALL("TDSC"),
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_TDSC,
+ .init = tdsc_init,
+ .decode = tdsc_decode_frame,
+ .close = tdsc_close,
+ .priv_data_size = sizeof(TDSCContext),
+ .capabilities = CODEC_CAP_DR1,
+ .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
+ FF_CODEC_CAP_INIT_CLEANUP,
+};
diff --git a/libavcodec/version.h b/libavcodec/version.h
index 5392e05..816d7ea 100644
--- a/libavcodec/version.h
+++ b/libavcodec/version.h
@@ -29,7 +29,7 @@
#include "libavutil/version.h"
#define LIBAVCODEC_VERSION_MAJOR 56
-#define LIBAVCODEC_VERSION_MINOR 17
+#define LIBAVCODEC_VERSION_MINOR 18
#define LIBAVCODEC_VERSION_MICRO 0
#define LIBAVCODEC_VERSION_INT AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \
diff --git a/libavformat/riff.c b/libavformat/riff.c
index d5b3346..db91749 100644
--- a/libavformat/riff.c
+++ b/libavformat/riff.c
@@ -352,6 +352,7 @@ const AVCodecTag ff_codec_bmp_tags[] = {
{ AV_CODEC_ID_PRORES, MKTAG('A', 'P', 'C', 'H') },
{ AV_CODEC_ID_QTRLE, MKTAG('r', 'l', 'e', ' ') },
{ AV_CODEC_ID_HQX, MKTAG('C', 'H', 'Q', 'X') },
+ { AV_CODEC_ID_TDSC, MKTAG('T', 'D', 'S', 'C') },
{ AV_CODEC_ID_NONE, 0 }
};
diff --git a/tests/fate/video.mak b/tests/fate/video.mak
index 1080c1c..821d599 100644
--- a/tests/fate/video.mak
+++ b/tests/fate/video.mak
@@ -248,6 +248,9 @@ fate-sp5x: CMD = framecrc -idct simple -i $(TARGET_SAMPLES)/sp5x/sp5x_problem.av
FATE_SAMPLES_AVCONV-$(call DEMDEC, SRT, SRT) += fate-sub-srt
fate-sub-srt: CMD = md5 -i $(TARGET_SAMPLES)/sub/SubRip_capability_tester.srt -f ass
+FATE_SAMPLES_AVCONV-$(call DEMDEC, ASF, TDSC) += fate-tdsc
+fate-tdsc: CMD = framecrc -idct simple -i $(TARGET_SAMPLES)/tdsc/tdsc.asf -an -pix_fmt bgr24
+
FATE_SAMPLES_AVCONV-$(call DEMDEC, THP, THP) += fate-thp
fate-thp: CMD = framecrc -idct simple -i $(TARGET_SAMPLES)/thp/pikmin2-opening1-partial.thp -an
diff --git a/tests/ref/fate/tdsc b/tests/ref/fate/tdsc
new file mode 100644
index 0000000..945933f
--- /dev/null
+++ b/tests/ref/fate/tdsc
@@ -0,0 +1,42 @@
+#tb 0: 1/1000
+0, 0, 0, 0, 3888000, 0x9c498657
+0, 233, 233, 0, 3888000, 0x72a2ae22
+0, 266, 266, 0, 3888000, 0x72a2ae22
+0, 333, 333, 0, 3888000, 0x72a2ae22
+0, 533, 533, 0, 3888000, 0x72a2ae22
+0, 566, 566, 0, 3888000, 0x72a2ae22
+0, 666, 666, 0, 3888000, 0x550e417b
+0, 966, 966, 0, 3888000, 0x550e417b
+0, 999, 999, 0, 3888000, 0x550e417b
+0, 1033, 1033, 0, 3888000, 0x550e417b
+0, 1066, 1066, 0, 3888000, 0x550e417b
+0, 1133, 1133, 0, 3888000, 0x550e417b
+0, 1166, 1166, 0, 3888000, 0x38dcde13
+0, 1566, 1566, 0, 3888000, 0x2b7c0edd
+0, 1599, 1599, 0, 3888000, 0xaaaf3c7b
+0, 1633, 1633, 0, 3888000, 0x26d1710f
+0, 1666, 1666, 0, 3888000, 0xa6609f3f
+0, 1699, 1699, 0, 3888000, 0xaa41c6f3
+0, 1733, 1733, 0, 3888000, 0xc0ffd4d5
+0, 1766, 1766, 0, 3888000, 0x44d4f383
+0, 1833, 1833, 0, 3888000, 0x517047eb
+0, 1866, 1866, 0, 3888000, 0x1d5a4d5b
+0, 1899, 1899, 0, 3888000, 0x7d2da2f6
+0, 1933, 1933, 0, 3888000, 0x27f7a2f6
+0, 1966, 1966, 0, 3888000, 0x9de49edb
+0, 1999, 1999, 0, 3888000, 0x5ccb9f38
+0, 2033, 2033, 0, 3888000, 0x88069fb2
+0, 2066, 2066, 0, 3888000, 0x1d059fd3
+0, 2099, 2099, 0, 3888000, 0xe16d9fd3
+0, 2133, 2133, 0, 3888000, 0xb6a69fd3
+0, 2166, 2166, 0, 3888000, 0xb6a69fd3
+0, 2199, 2199, 0, 3888000, 0x61709fd3
+0, 2233, 2233, 0, 3888000, 0xb6f59fd3
+0, 2266, 2266, 0, 3888000, 0x5c7b9fd3
+0, 2299, 2299, 0, 3888000, 0x57869fd3
+0, 2333, 2333, 0, 3888000, 0x9d3f9fd3
+0, 2433, 2433, 0, 3888000, 0x5e6082a5
+0, 2466, 2466, 0, 3888000, 0x5e6082a5
+0, 2499, 2499, 0, 3888000, 0x5e6082a5
+0, 2533, 2533, 0, 3888000, 0x48ce82f3
+0, 2566, 2566, 0, 3888000, 0x4c5ebeaf
More information about the ffmpeg-cvslog
mailing list