FFmpeg
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, 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  uint32_t 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  uint32_t 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, x2, y2, 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  x2 = bytestream2_get_le32(&ctx->gbc);
412  y2 = bytestream2_get_le32(&ctx->gbc);
413 
414  if (x < 0 || y < 0 || x2 <= x || y2 <= y ||
415  x2 > ctx->width || y2 > ctx->height
416  ) {
417  av_log(avctx, AV_LOG_ERROR,
418  "Invalid tile position (%d.%d %d.%d outside %dx%d).\n",
419  x, y, x2, y2, ctx->width, ctx->height);
420  return AVERROR_INVALIDDATA;
421  }
422  w = x2 - x;
423  h = y2 - y;
424 
425  ret = av_reallocp(&ctx->tilebuffer, tile_size);
426  if (!ctx->tilebuffer)
427  return ret;
428 
429  bytestream2_get_buffer(&ctx->gbc, ctx->tilebuffer, tile_size);
430 
431  if (tile_mode == MKTAG('G','E','P','J')) {
432  /* Decode JPEG tile and copy it in the reference frame */
433  ret = tdsc_decode_jpeg_tile(avctx, tile_size, x, y, w, h);
434  if (ret < 0)
435  return ret;
436  } else if (tile_mode == MKTAG(' ','W','A','R')) {
437  /* Just copy the buffer to output */
438  av_image_copy_plane(ctx->refframe->data[0] + x * 3 +
439  ctx->refframe->linesize[0] * y,
440  ctx->refframe->linesize[0], ctx->tilebuffer,
441  w * 3, w * 3, h);
442  } else {
443  av_log(avctx, AV_LOG_ERROR, "Unknown tile type %08x.\n", tile_mode);
444  return AVERROR_INVALIDDATA;
445  }
446  av_log(avctx, AV_LOG_DEBUG, "Tile %d, %dx%d (%d.%d)\n", i, w, h, x, y);
447  }
448 
449  return 0;
450 }
451 
452 static int tdsc_parse_tdsf(AVCodecContext *avctx, int number_tiles)
453 {
454  TDSCContext *ctx = avctx->priv_data;
455  int ret, w, h, init_refframe = !ctx->refframe->data[0];
456 
457  /* BITMAPINFOHEADER
458  * http://msdn.microsoft.com/en-us/library/windows/desktop/dd183376.aspx */
459  if (bytestream2_get_le32(&ctx->gbc) != BITMAPINFOHEADER_SIZE)
460  return AVERROR_INVALIDDATA;
461 
462  /* Store size, but wait for context reinit before updating avctx */
463  w = bytestream2_get_le32(&ctx->gbc);
464  h = -bytestream2_get_le32(&ctx->gbc);
465 
466  if (bytestream2_get_le16(&ctx->gbc) != 1 || // 1 plane
467  bytestream2_get_le16(&ctx->gbc) != 24) // BGR24
468  return AVERROR_INVALIDDATA;
469 
470  bytestream2_skip(&ctx->gbc, 24); // unused fields
471 
472  /* Update sizes */
473  if (avctx->width != w || avctx->height != h) {
474  av_log(avctx, AV_LOG_DEBUG, "Size update %dx%d -> %d%d.\n",
475  avctx->width, avctx->height, ctx->width, ctx->height);
476  ret = ff_set_dimensions(avctx, w, h);
477  if (ret < 0)
478  return ret;
479  init_refframe = 1;
480  }
481  ctx->refframe->width = ctx->width = w;
482  ctx->refframe->height = ctx->height = h;
483 
484  /* Allocate the reference frame if not already done or on size change */
485  if (init_refframe) {
486  ret = av_frame_get_buffer(ctx->refframe, 0);
487  if (ret < 0)
488  return ret;
489  }
490 
491  /* Decode all tiles in a frame */
492  return tdsc_decode_tiles(avctx, number_tiles);
493 }
494 
495 static int tdsc_parse_dtsm(AVCodecContext *avctx)
496 {
497  TDSCContext *ctx = avctx->priv_data;
498  int ret;
499  int action = bytestream2_get_le32(&ctx->gbc);
500 
501  bytestream2_skip(&ctx->gbc, 4); // some kind of ID or version maybe?
502 
503  if (action == 2 || action == 3) {
504  /* Load cursor coordinates */
505  ctx->cursor_x = bytestream2_get_le32(&ctx->gbc);
506  ctx->cursor_y = bytestream2_get_le32(&ctx->gbc);
507 
508  /* Load a full cursor sprite */
509  if (action == 3) {
510  ret = tdsc_load_cursor(avctx);
511  /* Do not consider cursor errors fatal unless in explode mode */
512  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
513  return ret;
514  }
515  } else {
516  avpriv_request_sample(avctx, "Cursor action %d", action);
517  }
518 
519  return 0;
520 }
521 
522 static int tdsc_decode_frame(AVCodecContext *avctx, void *data,
523  int *got_frame, AVPacket *avpkt)
524 {
525  TDSCContext *ctx = avctx->priv_data;
526  AVFrame *frame = data;
527  int ret, tag_header, keyframe = 0;
528  uLongf dlen;
529 
530  /* Resize deflate buffer on resolution change */
531  if (ctx->width != avctx->width || ctx->height != avctx->height) {
532  int deflatelen = avctx->width * avctx->height * (3 + 1);
533  if (deflatelen != ctx->deflatelen) {
534  ctx->deflatelen =deflatelen;
535  ret = av_reallocp(&ctx->deflatebuffer, ctx->deflatelen);
536  if (ret < 0) {
537  ctx->deflatelen = 0;
538  return ret;
539  }
540  }
541  }
542  dlen = ctx->deflatelen;
543 
544  /* Frames are deflated, need to inflate them first */
545  ret = uncompress(ctx->deflatebuffer, &dlen, avpkt->data, avpkt->size);
546  if (ret) {
547  av_log(avctx, AV_LOG_ERROR, "Deflate error %d.\n", ret);
548  return AVERROR_UNKNOWN;
549  }
550 
551  bytestream2_init(&ctx->gbc, ctx->deflatebuffer, dlen);
552 
553  /* Check for tag and for size info */
554  if (bytestream2_get_bytes_left(&ctx->gbc) < 4 + 4) {
555  av_log(avctx, AV_LOG_ERROR, "Frame is too small.\n");
556  return AVERROR_INVALIDDATA;
557  }
558 
559  /* Read tag */
560  tag_header = bytestream2_get_le32(&ctx->gbc);
561 
562  if (tag_header == MKTAG('T','D','S','F')) {
563  int number_tiles;
565  av_log(avctx, AV_LOG_ERROR, "TDSF tag is too small.\n");
566  return AVERROR_INVALIDDATA;
567  }
568  /* First 4 bytes here are the number of GEPJ/WAR tiles in this frame */
569  number_tiles = bytestream2_get_le32(&ctx->gbc);
570 
571  bytestream2_skip(&ctx->gbc, 4); // internal timestamp maybe?
572  keyframe = bytestream2_get_le32(&ctx->gbc) == 0x30;
573 
574  ret = tdsc_parse_tdsf(avctx, number_tiles);
575  if (ret < 0)
576  return ret;
577 
578  /* Check if there is anything else we are able to parse */
579  if (bytestream2_get_bytes_left(&ctx->gbc) >= 4 + 4)
580  tag_header = bytestream2_get_le32(&ctx->gbc);
581  }
582 
583  /* This tag can be after a TDSF block or on its own frame */
584  if (tag_header == MKTAG('D','T','S','M')) {
585  /* First 4 bytes here are the total size in bytes for this frame */
586  int tag_size = bytestream2_get_le32(&ctx->gbc);
587 
588  if (bytestream2_get_bytes_left(&ctx->gbc) < tag_size) {
589  av_log(avctx, AV_LOG_ERROR, "DTSM tag is too small.\n");
590  return AVERROR_INVALIDDATA;
591  }
592 
593  ret = tdsc_parse_dtsm(avctx);
594  if (ret < 0)
595  return ret;
596  }
597 
598  /* Get the output frame and copy the reference frame */
599  ret = ff_get_buffer(avctx, frame, 0);
600  if (ret < 0)
601  return ret;
602 
603  ret = av_frame_copy(frame, ctx->refframe);
604  if (ret < 0)
605  return ret;
606 
607  /* Paint the cursor on the output frame */
608  tdsc_paint_cursor(avctx, frame->data[0], frame->linesize[0]);
609 
610  /* Frame is ready to be output */
611  if (keyframe) {
612  frame->pict_type = AV_PICTURE_TYPE_I;
613  frame->key_frame = 1;
614  } else {
615  frame->pict_type = AV_PICTURE_TYPE_P;
616  }
617  *got_frame = 1;
618 
619  return avpkt->size;
620 }
621 
623  .name = "tdsc",
624  .long_name = NULL_IF_CONFIG_SMALL("TDSC"),
625  .type = AVMEDIA_TYPE_VIDEO,
626  .id = AV_CODEC_ID_TDSC,
627  .init = tdsc_init,
628  .decode = tdsc_decode_frame,
629  .close = tdsc_close,
630  .priv_data_size = sizeof(TDSCContext),
631  .capabilities = AV_CODEC_CAP_DR1,
632  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
634 };
#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
#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
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
int dct_algo
DCT algorithm, see FF_DCT_* below.
Definition: avcodec.h:1716
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
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:106
#define avpriv_request_sample(...)
int size
Definition: packet.h:364
#define TDSF_HEADER_SIZE
Definition: tdsc.c:46
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
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: codec.h:190
static av_cold int tdsc_init(AVCodecContext *avctx)
Definition: tdsc.c:91
AVCodecContext * jpeg_avctx
Definition: tdsc.c:50
#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:88
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define BITMAPINFOHEADER_SIZE
Definition: tdsc.c:45
static int tdsc_parse_dtsm(AVCodecContext *avctx)
Definition: tdsc.c:495
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
uint8_t * data
Definition: packet.h:363
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,...)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
#define U(x)
Definition: vp56_arith.h:37
int width
Definition: frame.h:366
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:538
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:203
static int tdsc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: tdsc.c:522
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
AVFrame * refframe
Definition: tdsc.c:55
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:662
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:215
int cursor_x
Definition: tdsc.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t bits
Definition: vp3data.h:202
static int tdsc_parse_tdsf(AVCodecContext *avctx, int number_tiles)
Definition: tdsc.c:452
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:812
uLongf deflatelen
Definition: tdsc.c:61
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
#define Y
Definition: boxblur.h:38
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1655
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:78
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:172
uint8_t * deflatebuffer
Definition: tdsc.c:60
int width
picture width / height.
Definition: avcodec.h:699
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1729
uint8_t w
Definition: llviddspenc.c:38
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
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1666
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
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:381
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:599
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:161
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:187
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:339
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:526
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1872
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
int cursor_w
Definition: tdsc.c:66
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:931
#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:337
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:566
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
Definition: swscale.txt:33
common internal api header.
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:35
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
void * priv_data
Definition: avcodec.h:553
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
#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:613
AVCodec ff_tdsc_decoder
Definition: tdsc.c:622
int height
Definition: frame.h:366
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:45
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:373
#define stride
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define MKTAG(a, b, c, d)
Definition: common.h:406
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
#define V
Definition: avdct.c:30