FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
tdsc.c
Go to the documentation of this file.
1 /*
2  * TDSC decoder
3  * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
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  */
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;
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 interaction */
61  uLongf deflatelen;
62 
63  /* All that is cursor */
68 } TDSCContext;
69 
70 /* 1 byte bits, 1 byte planes, 2 bytes format (probably) */
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);
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 */
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. */
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 ret;
347 
348  /* Prepare a packet and send to the MJPEG decoder */
349  av_init_packet(&jpkt);
350  jpkt.data = ctx->tilebuffer;
351  jpkt.size = tile_size;
352 
353  ret = avcodec_send_packet(ctx->jpeg_avctx, &jpkt);
354  if (ret < 0) {
355  av_log(avctx, AV_LOG_ERROR, "Error submitting a packet for decoding\n");
356  return ret;
357  }
358 
359  ret = avcodec_receive_frame(ctx->jpeg_avctx, ctx->jpgframe);
360  if (ret < 0 || ctx->jpgframe->format != AV_PIX_FMT_YUVJ420P) {
361  av_log(avctx, AV_LOG_ERROR,
362  "JPEG decoding error (%d).\n", ret);
363 
364  /* Normally skip, error if explode */
365  if (avctx->err_recognition & AV_EF_EXPLODE)
366  return AVERROR_INVALIDDATA;
367  else
368  return 0;
369  }
370 
371  /* Let's paint onto the buffer */
372  tdsc_blit(ctx->refframe->data[0] + x * 3 + ctx->refframe->linesize[0] * y,
373  ctx->refframe->linesize[0],
374  ctx->jpgframe->data[0], ctx->jpgframe->linesize[0],
375  ctx->jpgframe->data[1], ctx->jpgframe->data[2],
376  ctx->jpgframe->linesize[1], w, h);
377 
378  av_frame_unref(ctx->jpgframe);
379 
380  return 0;
381 }
382 
383 /* Parse frame and either copy data or decode JPEG. */
384 static int tdsc_decode_tiles(AVCodecContext *avctx, int number_tiles)
385 {
386  TDSCContext *ctx = avctx->priv_data;
387  int i;
388 
389  /* Iterate over the number of tiles */
390  for (i = 0; i < number_tiles; i++) {
391  int tile_size;
392  int tile_mode;
393  int x, y, w, h;
394  int ret;
395 
396  if (bytestream2_get_bytes_left(&ctx->gbc) < 4 ||
397  bytestream2_get_le32(&ctx->gbc) != MKTAG('T','D','S','B') ||
399  av_log(avctx, AV_LOG_ERROR, "TDSB tag is too small.\n");
400  return AVERROR_INVALIDDATA;
401  }
402 
403  tile_size = bytestream2_get_le32(&ctx->gbc);
404  if (bytestream2_get_bytes_left(&ctx->gbc) < tile_size)
405  return AVERROR_INVALIDDATA;
406 
407  tile_mode = bytestream2_get_le32(&ctx->gbc);
408  bytestream2_skip(&ctx->gbc, 4); // unknown
409  x = bytestream2_get_le32(&ctx->gbc);
410  y = bytestream2_get_le32(&ctx->gbc);
411  w = bytestream2_get_le32(&ctx->gbc) - x;
412  h = bytestream2_get_le32(&ctx->gbc) - y;
413 
414  if (x >= ctx->width || y >= ctx->height) {
415  av_log(avctx, AV_LOG_ERROR,
416  "Invalid tile position (%d.%d outside %dx%d).\n",
417  x, y, ctx->width, ctx->height);
418  return AVERROR_INVALIDDATA;
419  }
420  if (x + w > ctx->width || y + h > ctx->height) {
421  av_log(avctx, AV_LOG_ERROR,
422  "Invalid tile size %dx%d\n", w, h);
423  return AVERROR_INVALIDDATA;
424  }
425 
426  ret = av_reallocp(&ctx->tilebuffer, tile_size);
427  if (!ctx->tilebuffer)
428  return ret;
429 
430  bytestream2_get_buffer(&ctx->gbc, ctx->tilebuffer, tile_size);
431 
432  if (tile_mode == MKTAG('G','E','P','J')) {
433  /* Decode JPEG tile and copy it in the reference frame */
434  ret = tdsc_decode_jpeg_tile(avctx, tile_size, x, y, w, h);
435  if (ret < 0)
436  return ret;
437  } else if (tile_mode == MKTAG(' ','W','A','R')) {
438  /* Just copy the buffer to output */
439  av_image_copy_plane(ctx->refframe->data[0] + x * 3 +
440  ctx->refframe->linesize[0] * y,
441  ctx->refframe->linesize[0], ctx->tilebuffer,
442  w * 3, w * 3, h);
443  } else {
444  av_log(avctx, AV_LOG_ERROR, "Unknown tile type %08x.\n", tile_mode);
445  return AVERROR_INVALIDDATA;
446  }
447  av_log(avctx, AV_LOG_DEBUG, "Tile %d, %dx%d (%d.%d)\n", i, w, h, x, y);
448  }
449 
450  return 0;
451 }
452 
453 static int tdsc_parse_tdsf(AVCodecContext *avctx, int number_tiles)
454 {
455  TDSCContext *ctx = avctx->priv_data;
456  int ret, w, h, init_refframe = !ctx->refframe->data[0];
457 
458  /* BITMAPINFOHEADER
459  * http://msdn.microsoft.com/en-us/library/windows/desktop/dd183376.aspx */
460  if (bytestream2_get_le32(&ctx->gbc) != BITMAPINFOHEADER_SIZE)
461  return AVERROR_INVALIDDATA;
462 
463  /* Store size, but wait for context reinit before updating avctx */
464  w = bytestream2_get_le32(&ctx->gbc);
465  h = -bytestream2_get_le32(&ctx->gbc);
466 
467  if (bytestream2_get_le16(&ctx->gbc) != 1 || // 1 plane
468  bytestream2_get_le16(&ctx->gbc) != 24) // BGR24
469  return AVERROR_INVALIDDATA;
470 
471  bytestream2_skip(&ctx->gbc, 24); // unused fields
472 
473  /* Update sizes */
474  if (avctx->width != w || avctx->height != h) {
475  av_log(avctx, AV_LOG_DEBUG, "Size update %dx%d -> %d%d.\n",
476  avctx->width, avctx->height, ctx->width, ctx->height);
477  ret = ff_set_dimensions(avctx, w, h);
478  if (ret < 0)
479  return ret;
480  init_refframe = 1;
481  }
482  ctx->refframe->width = ctx->width = w;
483  ctx->refframe->height = ctx->height = h;
484 
485  /* Allocate the reference frame if not already done or on size change */
486  if (init_refframe) {
487  ret = av_frame_get_buffer(ctx->refframe, 32);
488  if (ret < 0)
489  return ret;
490  }
491 
492  /* Decode all tiles in a frame */
493  return tdsc_decode_tiles(avctx, number_tiles);
494 }
495 
496 static int tdsc_parse_dtsm(AVCodecContext *avctx)
497 {
498  TDSCContext *ctx = avctx->priv_data;
499  int ret;
500  int action = bytestream2_get_le32(&ctx->gbc);
501 
502  bytestream2_skip(&ctx->gbc, 4); // some kind of ID or version maybe?
503 
504  if (action == 2 || action == 3) {
505  /* Load cursor coordinates */
506  ctx->cursor_x = bytestream2_get_le32(&ctx->gbc);
507  ctx->cursor_y = bytestream2_get_le32(&ctx->gbc);
508 
509  /* Load a full cursor sprite */
510  if (action == 3) {
511  ret = tdsc_load_cursor(avctx);
512  /* Do not consider cursor errors fatal unless in explode mode */
513  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
514  return ret;
515  }
516  } else {
517  avpriv_request_sample(avctx, "Cursor action %d", action);
518  }
519 
520  return 0;
521 }
522 
523 static int tdsc_decode_frame(AVCodecContext *avctx, void *data,
524  int *got_frame, AVPacket *avpkt)
525 {
526  TDSCContext *ctx = avctx->priv_data;
527  AVFrame *frame = data;
528  int ret, tag_header, keyframe = 0;
529  uLongf dlen;
530 
531  /* Resize deflate buffer on resolution change */
532  if (ctx->width != avctx->width || ctx->height != avctx->height) {
533  ctx->deflatelen = avctx->width * avctx->height * (3 + 1);
534  ret = av_reallocp(&ctx->deflatebuffer, ctx->deflatelen);
535  if (ret < 0)
536  return ret;
537  }
538  dlen = ctx->deflatelen;
539 
540  /* Frames are deflated, need to inflate them first */
541  ret = uncompress(ctx->deflatebuffer, &dlen, avpkt->data, avpkt->size);
542  if (ret) {
543  av_log(avctx, AV_LOG_ERROR, "Deflate error %d.\n", ret);
544  return AVERROR_UNKNOWN;
545  }
546 
547  bytestream2_init(&ctx->gbc, ctx->deflatebuffer, dlen);
548 
549  /* Check for tag and for size info */
550  if (bytestream2_get_bytes_left(&ctx->gbc) < 4 + 4) {
551  av_log(avctx, AV_LOG_ERROR, "Frame is too small.\n");
552  return AVERROR_INVALIDDATA;
553  }
554 
555  /* Read tag */
556  tag_header = bytestream2_get_le32(&ctx->gbc);
557 
558  if (tag_header == MKTAG('T','D','S','F')) {
559  int number_tiles;
561  av_log(avctx, AV_LOG_ERROR, "TDSF tag is too small.\n");
562  return AVERROR_INVALIDDATA;
563  }
564  /* First 4 bytes here are the number of GEPJ/WAR tiles in this frame */
565  number_tiles = bytestream2_get_le32(&ctx->gbc);
566 
567  bytestream2_skip(&ctx->gbc, 4); // internal timestamp maybe?
568  keyframe = bytestream2_get_le32(&ctx->gbc) == 0x30;
569 
570  ret = tdsc_parse_tdsf(avctx, number_tiles);
571  if (ret < 0)
572  return ret;
573 
574  /* Check if there is anything else we are able to parse */
575  if (bytestream2_get_bytes_left(&ctx->gbc) >= 4 + 4)
576  tag_header = bytestream2_get_le32(&ctx->gbc);
577  }
578 
579  /* This tag can be after a TDSF block or on its own frame */
580  if (tag_header == MKTAG('D','T','S','M')) {
581  /* First 4 bytes here are the total size in bytes for this frame */
582  int tag_size = bytestream2_get_le32(&ctx->gbc);
583 
584  if (bytestream2_get_bytes_left(&ctx->gbc) < tag_size) {
585  av_log(avctx, AV_LOG_ERROR, "DTSM tag is too small.\n");
586  return AVERROR_INVALIDDATA;
587  }
588 
589  ret = tdsc_parse_dtsm(avctx);
590  if (ret < 0)
591  return ret;
592  }
593 
594  /* Get the output frame and copy the reference frame */
595  ret = ff_get_buffer(avctx, frame, 0);
596  if (ret < 0)
597  return ret;
598 
599  ret = av_frame_copy(frame, ctx->refframe);
600  if (ret < 0)
601  return ret;
602 
603  /* Paint the cursor on the output frame */
604  tdsc_paint_cursor(avctx, frame->data[0], frame->linesize[0]);
605 
606  /* Frame is ready to be output */
607  if (keyframe) {
608  frame->pict_type = AV_PICTURE_TYPE_I;
609  frame->key_frame = 1;
610  } else {
611  frame->pict_type = AV_PICTURE_TYPE_P;
612  }
613  *got_frame = 1;
614 
615  return avpkt->size;
616 }
617 
619  .name = "tdsc",
620  .long_name = NULL_IF_CONFIG_SMALL("TDSC"),
621  .type = AVMEDIA_TYPE_VIDEO,
622  .id = AV_CODEC_ID_TDSC,
623  .init = tdsc_init,
624  .decode = tdsc_decode_frame,
625  .close = tdsc_close,
626  .priv_data_size = sizeof(TDSCContext),
627  .capabilities = AV_CODEC_CAP_DR1,
628  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
630 };
#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
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int tdsc_decode_tiles(AVCodecContext *avctx, int number_tiles)
Definition: tdsc.c:384
static float alpha(float a)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
int dct_algo
DCT algorithm, see FF_DCT_* below.
Definition: avcodec.h:2670
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
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:196
int size
Definition: avcodec.h:1401
#define TDSF_HEADER_SIZE
Definition: tdsc.c:46
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1697
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
int height
Definition: tdsc.c:52
int cursor_h
Definition: tdsc.c:66
int width
Definition: tdsc.c:52
AVCodec.
Definition: avcodec.h:3351
static av_cold int tdsc_init(AVCodecContext *avctx)
Definition: tdsc.c:91
AVCodecContext * jpeg_avctx
Definition: tdsc.c:50
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
#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
uint8_t
#define av_cold
Definition: attributes.h:82
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
#define BITMAPINFOHEADER_SIZE
Definition: tdsc.c:45
#define Y
Definition: vf_boxblur.c:76
static int tdsc_parse_dtsm(AVCodecContext *avctx)
Definition: tdsc.c:496
static AVFrame * frame
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
#define height
uint8_t * data
Definition: avcodec.h:1400
uint8_t * cursor
Definition: tdsc.c:64
int cursor_stride
Definition: tdsc.c:65
static av_cold int tdsc_close(AVCodecContext *avctx)
Definition: tdsc.c:77
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
#define U(x)
Definition: vp56_arith.h:37
int width
Definition: frame.h:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
TDSCCursorFormat
Definition: tdsc.c:71
int cursor_hot_y
Definition: tdsc.c:67
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:602
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:163
static int tdsc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: tdsc.c:523
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
AVFrame * refframe
Definition: tdsc.c:55
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:709
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:263
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
int cursor_x
Definition: tdsc.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1568
Definition: graph2dot.c:48
uint16_t width
Definition: gdv.c:47
const char * name
Name of the codec implementation.
Definition: avcodec.h:3358
static int tdsc_parse_tdsf(AVCodecContext *avctx, int number_tiles)
Definition: tdsc.c:453
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:746
uLongf deflatelen
Definition: tdsc.c:61
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:284
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:2612
GetByteContext gbc
Definition: tdsc.c:53
#define FFMIN(a, b)
Definition: common.h:96
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:74
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:157
uint8_t * deflatebuffer
Definition: tdsc.c:60
int width
picture width / height.
Definition: avcodec.h:1660
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:2683
AVFormatContext * ctx
Definition: movenc.c:48
static int tdsc_decode_jpeg_tile(AVCodecContext *avctx, int tile_size, int x, int y, int w, int h)
Definition: tdsc.c:341
AVFrame * jpgframe
Definition: tdsc.c:56
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:2623
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:65
int cursor_y
Definition: tdsc.c:66
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:274
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:642
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:163
int cursor_hot_x
Definition: tdsc.c:67
static void tdsc_paint_cursor(AVCodecContext *avctx, uint8_t *dst, int stride)
Definition: tdsc.c:142
Libavcodec external API header.
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:172
uint8_t * tilebuffer
Definition: tdsc.c:57
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:232
main external API structure.
Definition: avcodec.h:1488
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:1251
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1886
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
int cursor_w
Definition: tdsc.c:66
#define TDSB_HEADER_SIZE
Definition: tdsc.c:47
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:283
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:510
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
common internal api header.
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
void * priv_data
Definition: avcodec.h:1515
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:279
#define APPLY_ALPHA(src, new, alpha)
Definition: tdsc.c:138
static void tdsc_yuv2rgb(uint8_t *out, int Y, int U, int V)
Definition: tdsc.c:314
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1575
AVCodec ff_tdsc_decoder
Definition: tdsc.c:618
int height
Definition: frame.h:259
FILE * out
Definition: movenc.c:54
static int tdsc_load_cursor(AVCodecContext *avctx)
Definition: tdsc.c:187
#define av_freep(p)
#define av_always_inline
Definition: attributes.h:39
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:338
#define stride
#define MKTAG(a, b, c, d)
Definition: common.h:366
This structure stores compressed data.
Definition: avcodec.h:1377
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:956
Predicted.
Definition: avutil.h:275
#define V
Definition: avdct.c:30