| @@ -0,0 +1,627 @@ |
| | 1 | /* |
| | 2 | * TDSC decoder |
| | 3 | * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com> |
| | 4 | * |
| | 5 | * This file is part of Libav. |
| | 6 | * |
| | 7 | * Libav 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 | * Libav 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 Libav; if not, write to the Free Software |
| | 19 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| | 20 | */ |
| | 21 | |
| | 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 | */ |
| | 35 | |
| | 36 | #include <stdint.h> |
| | 37 | #include <zlib.h> |
| | 38 | |
| | 39 | #include "libavutil/imgutils.h" |
| | 40 | |
| | 41 | #include "avcodec.h" |
| | 42 | #include "bytestream.h" |
| | 43 | #include "internal.h" |
| | 44 | |
| | 45 | #define BITMAPINFOHEADER_SIZE 0x28 |
| | 46 | #define TDSF_HEADER_SIZE 0x56 |
| | 47 | #define TDSB_HEADER_SIZE 0x08 |
| | 48 | |
| | 49 | typedef struct TDSCContext { |
| | 50 | AVCodecContext *jpeg_avctx; // wrapper context for MJPEG |
| | 51 | |
| | 52 | int width, height; |
| | 53 | GetByteContext gbc; |
| | 54 | |
| | 55 | AVFrame *refframe; // full decoded frame (without cursor) |
| | 56 | AVFrame *jpgframe; // decoded JPEG tile |
| | 57 | uint8_t *tilebuffer; // buffer containing tile data |
| | 58 | |
| | 59 | /* zlib interation */ |
| | 60 | uint8_t *deflatebuffer; |
| | 61 | uLongf deflatelen; |
| | 62 | |
| | 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; |
| | 69 | |
| | 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 | }; |
| | 76 | |
| | 77 | static av_cold int tdsc_close(AVCodecContext *avctx) |
| | 78 | { |
| | 79 | TDSCContext *ctx = avctx->priv_data; |
| | 80 | |
| | 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); |
| | 87 | |
| | 88 | return 0; |
| | 89 | } |
| | 90 | |
| | 91 | static av_cold int tdsc_init(AVCodecContext *avctx) |
| | 92 | { |
| | 93 | TDSCContext *ctx = avctx->priv_data; |
| | 94 | const AVCodec *codec; |
| | 95 | int ret; |
| | 96 | |
| | 97 | avctx->pix_fmt = AV_PIX_FMT_BGR24; |
| | 98 | |
| | 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 = avcodec_open2(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 = CODEC_CAP_DR1, |
| | 625 | .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | |
| | 626 | FF_CODEC_CAP_INIT_CLEANUP, |
| | 627 | }; |