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  AVPacket *jpkt; // encoded JPEG tile
57  AVFrame *jpgframe; // decoded JPEG tile
58  uint8_t *tilebuffer; // buffer containing tile data
59 
60  /* zlib interaction */
61  uint8_t *deflatebuffer;
62  uLongf deflatelen;
63 
64  /* All that is cursor */
65  uint8_t *cursor;
69 } TDSCContext;
70 
71 /* 1 byte bits, 1 byte planes, 2 bytes format (probably) */
73  CUR_FMT_MONO = 0x01010004,
74  CUR_FMT_BGRA = 0x20010004,
75  CUR_FMT_RGBA = 0x20010008,
76 };
77 
78 static av_cold int tdsc_close(AVCodecContext *avctx)
79 {
80  TDSCContext *ctx = avctx->priv_data;
81 
82  av_frame_free(&ctx->refframe);
83  av_frame_free(&ctx->jpgframe);
84  av_packet_free(&ctx->jpkt);
85  av_freep(&ctx->deflatebuffer);
86  av_freep(&ctx->tilebuffer);
87  av_freep(&ctx->cursor);
88  avcodec_free_context(&ctx->jpeg_avctx);
89 
90  return 0;
91 }
92 
93 static av_cold int tdsc_init(AVCodecContext *avctx)
94 {
95  TDSCContext *ctx = avctx->priv_data;
96  const AVCodec *codec;
97  int ret;
98 
99  avctx->pix_fmt = AV_PIX_FMT_BGR24;
100 
101  /* These needs to be set to estimate buffer and frame size */
102  if (!(avctx->width && avctx->height)) {
103  av_log(avctx, AV_LOG_ERROR, "Video size not set.\n");
104  return AVERROR_INVALIDDATA;
105  }
106 
107  /* This value should be large enough for a RAW-only frame plus headers */
108  ctx->deflatelen = avctx->width * avctx->height * (3 + 1);
109  ret = av_reallocp(&ctx->deflatebuffer, ctx->deflatelen);
110  if (ret < 0)
111  return ret;
112 
113  /* Allocate reference and JPEG frame */
114  ctx->refframe = av_frame_alloc();
115  ctx->jpgframe = av_frame_alloc();
116  ctx->jpkt = av_packet_alloc();
117  if (!ctx->refframe || !ctx->jpgframe || !ctx->jpkt)
118  return AVERROR(ENOMEM);
119 
120  /* Prepare everything needed for JPEG decoding */
122  if (!codec)
123  return AVERROR_BUG;
124  ctx->jpeg_avctx = avcodec_alloc_context3(codec);
125  if (!ctx->jpeg_avctx)
126  return AVERROR(ENOMEM);
127  ctx->jpeg_avctx->flags = avctx->flags;
128  ctx->jpeg_avctx->flags2 = avctx->flags2;
129  ctx->jpeg_avctx->dct_algo = avctx->dct_algo;
130  ctx->jpeg_avctx->idct_algo = avctx->idct_algo;
131  ret = avcodec_open2(ctx->jpeg_avctx, codec, NULL);
132  if (ret < 0)
133  return ret;
134 
135  /* Set the output pixel format on the reference frame */
136  ctx->refframe->format = avctx->pix_fmt;
137 
138  return 0;
139 }
140 
141 #define APPLY_ALPHA(src, new, alpha) \
142  src = (src * (256 - alpha) + new * alpha) >> 8
143 
144 /* Paint a region over a buffer, without drawing out of its bounds. */
145 static void tdsc_paint_cursor(AVCodecContext *avctx, uint8_t *dst, int stride)
146 {
147  TDSCContext *ctx = avctx->priv_data;
148  const uint8_t *cursor = ctx->cursor;
149  int x = ctx->cursor_x - ctx->cursor_hot_x;
150  int y = ctx->cursor_y - ctx->cursor_hot_y;
151  int w = ctx->cursor_w;
152  int h = ctx->cursor_h;
153  int i, j;
154 
155  if (!ctx->cursor)
156  return;
157 
158  if (x + w > ctx->width)
159  w = ctx->width - x;
160  if (y + h > ctx->height)
161  h = ctx->height - y;
162  if (x < 0) {
163  w += x;
164  cursor += -x * 4;
165  } else {
166  dst += x * 3;
167  }
168  if (y < 0) {
169  h += y;
170  cursor += -y * ctx->cursor_stride;
171  } else {
172  dst += y * stride;
173  }
174  if (w < 0 || h < 0)
175  return;
176 
177  for (j = 0; j < h; j++) {
178  for (i = 0; i < w; i++) {
179  uint8_t alpha = cursor[i * 4];
180  APPLY_ALPHA(dst[i * 3 + 0], cursor[i * 4 + 1], alpha);
181  APPLY_ALPHA(dst[i * 3 + 1], cursor[i * 4 + 2], alpha);
182  APPLY_ALPHA(dst[i * 3 + 2], cursor[i * 4 + 3], alpha);
183  }
184  dst += stride;
185  cursor += ctx->cursor_stride;
186  }
187 }
188 
189 /* Load cursor data and store it in ABGR mode. */
191 {
192  TDSCContext *ctx = avctx->priv_data;
193  int i, j, k, ret, cursor_fmt;
194  uint8_t *dst;
195 
196  ctx->cursor_hot_x = bytestream2_get_le16(&ctx->gbc);
197  ctx->cursor_hot_y = bytestream2_get_le16(&ctx->gbc);
198  ctx->cursor_w = bytestream2_get_le16(&ctx->gbc);
199  ctx->cursor_h = bytestream2_get_le16(&ctx->gbc);
200 
201  ctx->cursor_stride = FFALIGN(ctx->cursor_w, 32) * 4;
202  cursor_fmt = bytestream2_get_le32(&ctx->gbc);
203 
204  if (ctx->cursor_x >= avctx->width || ctx->cursor_y >= avctx->height) {
205  av_log(avctx, AV_LOG_ERROR,
206  "Invalid cursor position (%d.%d outside %dx%d).\n",
207  ctx->cursor_x, ctx->cursor_y, avctx->width, avctx->height);
208  return AVERROR_INVALIDDATA;
209  }
210  if (ctx->cursor_w < 1 || ctx->cursor_w > 256 ||
211  ctx->cursor_h < 1 || ctx->cursor_h > 256) {
212  av_log(avctx, AV_LOG_ERROR,
213  "Invalid cursor dimensions %dx%d.\n",
214  ctx->cursor_w, ctx->cursor_h);
215  return AVERROR_INVALIDDATA;
216  }
217  if (ctx->cursor_hot_x > ctx->cursor_w ||
218  ctx->cursor_hot_y > ctx->cursor_h) {
219  av_log(avctx, AV_LOG_WARNING, "Invalid hotspot position %d.%d.\n",
220  ctx->cursor_hot_x, ctx->cursor_hot_y);
221  ctx->cursor_hot_x = FFMIN(ctx->cursor_hot_x, ctx->cursor_w - 1);
222  ctx->cursor_hot_y = FFMIN(ctx->cursor_hot_y, ctx->cursor_h - 1);
223  }
224 
225  ret = av_reallocp(&ctx->cursor, ctx->cursor_stride * ctx->cursor_h);
226  if (ret < 0) {
227  av_log(avctx, AV_LOG_ERROR, "Cannot allocate cursor buffer.\n");
228  return ret;
229  }
230 
231  dst = ctx->cursor;
232  /* here data is packed in BE */
233  switch (cursor_fmt) {
234  case CUR_FMT_MONO:
235  for (j = 0; j < ctx->cursor_h; j++) {
236  for (i = 0; i < ctx->cursor_w; i += 32) {
237  uint32_t bits = bytestream2_get_be32(&ctx->gbc);
238  for (k = 0; k < 32; k++) {
239  dst[0] = !!(bits & 0x80000000);
240  dst += 4;
241  bits <<= 1;
242  }
243  }
244  dst += ctx->cursor_stride - ctx->cursor_w * 4;
245  }
246 
247  dst = ctx->cursor;
248  for (j = 0; j < ctx->cursor_h; j++) {
249  for (i = 0; i < ctx->cursor_w; i += 32) {
250  uint32_t bits = bytestream2_get_be32(&ctx->gbc);
251  for (k = 0; k < 32; k++) {
252  int mask_bit = !!(bits & 0x80000000);
253  switch (dst[0] * 2 + mask_bit) {
254  case 0:
255  dst[0] = 0xFF;
256  dst[1] = 0x00;
257  dst[2] = 0x00;
258  dst[3] = 0x00;
259  break;
260  case 1:
261  dst[0] = 0xFF;
262  dst[1] = 0xFF;
263  dst[2] = 0xFF;
264  dst[3] = 0xFF;
265  break;
266  default:
267  dst[0] = 0x00;
268  dst[1] = 0x00;
269  dst[2] = 0x00;
270  dst[3] = 0x00;
271  }
272  dst += 4;
273  bits <<= 1;
274  }
275  }
276  dst += ctx->cursor_stride - ctx->cursor_w * 4;
277  }
278  break;
279  case CUR_FMT_BGRA:
280  case CUR_FMT_RGBA:
281  /* Skip monochrome version of the cursor */
282  bytestream2_skip(&ctx->gbc,
283  ctx->cursor_h * (FFALIGN(ctx->cursor_w, 32) >> 3));
284  if (cursor_fmt & 8) { // RGBA -> ABGR
285  for (j = 0; j < ctx->cursor_h; j++) {
286  for (i = 0; i < ctx->cursor_w; i++) {
287  int val = bytestream2_get_be32(&ctx->gbc);
288  *dst++ = val >> 24;
289  *dst++ = val >> 16;
290  *dst++ = val >> 8;
291  *dst++ = val >> 0;
292  }
293  dst += ctx->cursor_stride - ctx->cursor_w * 4;
294  }
295  } else { // BGRA -> ABGR
296  for (j = 0; j < ctx->cursor_h; j++) {
297  for (i = 0; i < ctx->cursor_w; i++) {
298  int val = bytestream2_get_be32(&ctx->gbc);
299  *dst++ = val >> 0;
300  *dst++ = val >> 24;
301  *dst++ = val >> 16;
302  *dst++ = val >> 8;
303  }
304  dst += ctx->cursor_stride - ctx->cursor_w * 4;
305  }
306  }
307  break;
308  default:
309  avpriv_request_sample(avctx, "Cursor format %08x", cursor_fmt);
310  return AVERROR_PATCHWELCOME;
311  }
312 
313  return 0;
314 }
315 
316 /* Convert a single YUV pixel to RGB. */
317 static inline void tdsc_yuv2rgb(uint8_t *out, int Y, int U, int V)
318 {
319  out[0] = av_clip_uint8(Y + ( 91881 * V + 32768 >> 16));
320  out[1] = av_clip_uint8(Y + (-22554 * U - 46802 * V + 32768 >> 16));
321  out[2] = av_clip_uint8(Y + (116130 * U + 32768 >> 16));
322 }
323 
324 /* Convert a YUV420 buffer to a RGB buffer. */
325 static av_always_inline void tdsc_blit(uint8_t *dst, int dst_stride,
326  const uint8_t *srcy, int srcy_stride,
327  const uint8_t *srcu, const uint8_t *srcv,
328  int srcuv_stride, int width, int height)
329 {
330  int col, line;
331  for (line = 0; line < height; line++) {
332  for (col = 0; col < width; col++)
333  tdsc_yuv2rgb(dst + col * 3, srcy[col],
334  srcu[col >> 1] - 128, srcv[col >> 1] - 128);
335 
336  dst += dst_stride;
337  srcy += srcy_stride;
338  srcu += srcuv_stride * (line & 1);
339  srcv += srcuv_stride * (line & 1);
340  }
341 }
342 
343 /* Invoke the MJPEG decoder to decode the tile. */
344 static int tdsc_decode_jpeg_tile(AVCodecContext *avctx, int tile_size,
345  int x, int y, int w, int h)
346 {
347  TDSCContext *ctx = avctx->priv_data;
348  int ret;
349 
350  /* Prepare a packet and send to the MJPEG decoder */
351  av_packet_unref(ctx->jpkt);
352  ctx->jpkt->data = ctx->tilebuffer;
353  ctx->jpkt->size = tile_size;
354 
355  ret = avcodec_send_packet(ctx->jpeg_avctx, ctx->jpkt);
356  if (ret < 0) {
357  av_log(avctx, AV_LOG_ERROR, "Error submitting a packet for decoding\n");
358  return ret;
359  }
360 
361  ret = avcodec_receive_frame(ctx->jpeg_avctx, ctx->jpgframe);
362  if (ret < 0 || ctx->jpgframe->format != AV_PIX_FMT_YUVJ420P) {
363  av_log(avctx, AV_LOG_ERROR,
364  "JPEG decoding error (%d).\n", ret);
365 
366  /* Normally skip, error if explode */
367  if (avctx->err_recognition & AV_EF_EXPLODE)
368  return AVERROR_INVALIDDATA;
369  else
370  return 0;
371  }
372 
373  /* Let's paint onto the buffer */
374  tdsc_blit(ctx->refframe->data[0] + x * 3 + ctx->refframe->linesize[0] * y,
375  ctx->refframe->linesize[0],
376  ctx->jpgframe->data[0], ctx->jpgframe->linesize[0],
377  ctx->jpgframe->data[1], ctx->jpgframe->data[2],
378  ctx->jpgframe->linesize[1], w, h);
379 
380  av_frame_unref(ctx->jpgframe);
381 
382  return 0;
383 }
384 
385 /* Parse frame and either copy data or decode JPEG. */
386 static int tdsc_decode_tiles(AVCodecContext *avctx, int number_tiles)
387 {
388  TDSCContext *ctx = avctx->priv_data;
389  int i;
390 
391  /* Iterate over the number of tiles */
392  for (i = 0; i < number_tiles; i++) {
393  int tile_size;
394  int tile_mode;
395  int x, y, x2, y2, w, h;
396  int ret;
397 
398  if (bytestream2_get_bytes_left(&ctx->gbc) < 4 ||
399  bytestream2_get_le32(&ctx->gbc) != MKTAG('T','D','S','B') ||
401  av_log(avctx, AV_LOG_ERROR, "TDSB tag is too small.\n");
402  return AVERROR_INVALIDDATA;
403  }
404 
405  tile_size = bytestream2_get_le32(&ctx->gbc);
406  if (bytestream2_get_bytes_left(&ctx->gbc) < tile_size)
407  return AVERROR_INVALIDDATA;
408 
409  tile_mode = bytestream2_get_le32(&ctx->gbc);
410  bytestream2_skip(&ctx->gbc, 4); // unknown
411  x = bytestream2_get_le32(&ctx->gbc);
412  y = bytestream2_get_le32(&ctx->gbc);
413  x2 = bytestream2_get_le32(&ctx->gbc);
414  y2 = bytestream2_get_le32(&ctx->gbc);
415 
416  if (x < 0 || y < 0 || x2 <= x || y2 <= y ||
417  x2 > ctx->width || y2 > ctx->height
418  ) {
419  av_log(avctx, AV_LOG_ERROR,
420  "Invalid tile position (%d.%d %d.%d outside %dx%d).\n",
421  x, y, x2, y2, ctx->width, ctx->height);
422  return AVERROR_INVALIDDATA;
423  }
424  w = x2 - x;
425  h = y2 - y;
426 
427  ret = av_reallocp(&ctx->tilebuffer, tile_size);
428  if (!ctx->tilebuffer)
429  return ret;
430 
431  bytestream2_get_buffer(&ctx->gbc, ctx->tilebuffer, tile_size);
432 
433  if (tile_mode == MKTAG('G','E','P','J')) {
434  /* Decode JPEG tile and copy it in the reference frame */
435  ret = tdsc_decode_jpeg_tile(avctx, tile_size, x, y, w, h);
436  if (ret < 0)
437  return ret;
438  } else if (tile_mode == MKTAG(' ','W','A','R')) {
439  /* Just copy the buffer to output */
440  av_image_copy_plane(ctx->refframe->data[0] + x * 3 +
441  ctx->refframe->linesize[0] * y,
442  ctx->refframe->linesize[0], ctx->tilebuffer,
443  w * 3, w * 3, h);
444  } else {
445  av_log(avctx, AV_LOG_ERROR, "Unknown tile type %08x.\n", tile_mode);
446  return AVERROR_INVALIDDATA;
447  }
448  av_log(avctx, AV_LOG_DEBUG, "Tile %d, %dx%d (%d.%d)\n", i, w, h, x, y);
449  }
450 
451  return 0;
452 }
453 
454 static int tdsc_parse_tdsf(AVCodecContext *avctx, int number_tiles)
455 {
456  TDSCContext *ctx = avctx->priv_data;
457  int ret, w, h, init_refframe = !ctx->refframe->data[0];
458 
459  /* BITMAPINFOHEADER
460  * http://msdn.microsoft.com/en-us/library/windows/desktop/dd183376.aspx */
461  if (bytestream2_get_le32(&ctx->gbc) != BITMAPINFOHEADER_SIZE)
462  return AVERROR_INVALIDDATA;
463 
464  /* Store size, but wait for context reinit before updating avctx */
465  w = bytestream2_get_le32(&ctx->gbc);
466  h = -bytestream2_get_le32(&ctx->gbc);
467 
468  if (bytestream2_get_le16(&ctx->gbc) != 1 || // 1 plane
469  bytestream2_get_le16(&ctx->gbc) != 24) // BGR24
470  return AVERROR_INVALIDDATA;
471 
472  bytestream2_skip(&ctx->gbc, 24); // unused fields
473 
474  /* Update sizes */
475  if (avctx->width != w || avctx->height != h) {
476  av_log(avctx, AV_LOG_DEBUG, "Size update %dx%d -> %d%d.\n",
477  avctx->width, avctx->height, ctx->width, ctx->height);
478  ret = ff_set_dimensions(avctx, w, h);
479  if (ret < 0)
480  return ret;
481  init_refframe = 1;
482  }
483  ctx->refframe->width = ctx->width = w;
484  ctx->refframe->height = ctx->height = h;
485 
486  /* Allocate the reference frame if not already done or on size change */
487  if (init_refframe) {
488  ret = av_frame_get_buffer(ctx->refframe, 0);
489  if (ret < 0)
490  return ret;
491  }
492 
493  /* Decode all tiles in a frame */
494  return tdsc_decode_tiles(avctx, number_tiles);
495 }
496 
497 static int tdsc_parse_dtsm(AVCodecContext *avctx)
498 {
499  TDSCContext *ctx = avctx->priv_data;
500  int ret;
501  int action = bytestream2_get_le32(&ctx->gbc);
502 
503  bytestream2_skip(&ctx->gbc, 4); // some kind of ID or version maybe?
504 
505  if (action == 2 || action == 3) {
506  /* Load cursor coordinates */
507  ctx->cursor_x = bytestream2_get_le32(&ctx->gbc);
508  ctx->cursor_y = bytestream2_get_le32(&ctx->gbc);
509 
510  /* Load a full cursor sprite */
511  if (action == 3) {
512  ret = tdsc_load_cursor(avctx);
513  /* Do not consider cursor errors fatal unless in explode mode */
514  if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
515  return ret;
516  }
517  } else {
518  avpriv_request_sample(avctx, "Cursor action %d", action);
519  }
520 
521  return 0;
522 }
523 
524 static int tdsc_decode_frame(AVCodecContext *avctx, void *data,
525  int *got_frame, AVPacket *avpkt)
526 {
527  TDSCContext *ctx = avctx->priv_data;
528  AVFrame *frame = data;
529  int ret, tag_header, keyframe = 0;
530  uLongf dlen;
531 
532  /* Resize deflate buffer on resolution change */
533  if (ctx->width != avctx->width || ctx->height != avctx->height) {
534  int deflatelen = avctx->width * avctx->height * (3 + 1);
535  if (deflatelen != ctx->deflatelen) {
536  ctx->deflatelen =deflatelen;
537  ret = av_reallocp(&ctx->deflatebuffer, ctx->deflatelen);
538  if (ret < 0) {
539  ctx->deflatelen = 0;
540  return ret;
541  }
542  }
543  }
544  dlen = ctx->deflatelen;
545 
546  /* Frames are deflated, need to inflate them first */
547  ret = uncompress(ctx->deflatebuffer, &dlen, avpkt->data, avpkt->size);
548  if (ret) {
549  av_log(avctx, AV_LOG_ERROR, "Deflate error %d.\n", ret);
550  return AVERROR_UNKNOWN;
551  }
552 
553  bytestream2_init(&ctx->gbc, ctx->deflatebuffer, dlen);
554 
555  /* Check for tag and for size info */
556  if (bytestream2_get_bytes_left(&ctx->gbc) < 4 + 4) {
557  av_log(avctx, AV_LOG_ERROR, "Frame is too small.\n");
558  return AVERROR_INVALIDDATA;
559  }
560 
561  /* Read tag */
562  tag_header = bytestream2_get_le32(&ctx->gbc);
563 
564  if (tag_header == MKTAG('T','D','S','F')) {
565  int number_tiles;
567  av_log(avctx, AV_LOG_ERROR, "TDSF tag is too small.\n");
568  return AVERROR_INVALIDDATA;
569  }
570  /* First 4 bytes here are the number of GEPJ/WAR tiles in this frame */
571  number_tiles = bytestream2_get_le32(&ctx->gbc);
572 
573  bytestream2_skip(&ctx->gbc, 4); // internal timestamp maybe?
574  keyframe = bytestream2_get_le32(&ctx->gbc) == 0x30;
575 
576  ret = tdsc_parse_tdsf(avctx, number_tiles);
577  if (ret < 0)
578  return ret;
579 
580  /* Check if there is anything else we are able to parse */
581  if (bytestream2_get_bytes_left(&ctx->gbc) >= 4 + 4)
582  tag_header = bytestream2_get_le32(&ctx->gbc);
583  }
584 
585  /* This tag can be after a TDSF block or on its own frame */
586  if (tag_header == MKTAG('D','T','S','M')) {
587  /* First 4 bytes here are the total size in bytes for this frame */
588  int tag_size = bytestream2_get_le32(&ctx->gbc);
589 
590  if (bytestream2_get_bytes_left(&ctx->gbc) < tag_size) {
591  av_log(avctx, AV_LOG_ERROR, "DTSM tag is too small.\n");
592  return AVERROR_INVALIDDATA;
593  }
594 
595  ret = tdsc_parse_dtsm(avctx);
596  if (ret < 0)
597  return ret;
598  }
599 
600  /* Get the output frame and copy the reference frame */
601  ret = ff_get_buffer(avctx, frame, 0);
602  if (ret < 0)
603  return ret;
604 
605  ret = av_frame_copy(frame, ctx->refframe);
606  if (ret < 0)
607  return ret;
608 
609  /* Paint the cursor on the output frame */
610  tdsc_paint_cursor(avctx, frame->data[0], frame->linesize[0]);
611 
612  /* Frame is ready to be output */
613  if (keyframe) {
614  frame->pict_type = AV_PICTURE_TYPE_I;
615  frame->key_frame = 1;
616  } else {
617  frame->pict_type = AV_PICTURE_TYPE_P;
618  }
619  *got_frame = 1;
620 
621  return avpkt->size;
622 }
623 
625  .name = "tdsc",
626  .long_name = NULL_IF_CONFIG_SMALL("TDSC"),
627  .type = AVMEDIA_TYPE_VIDEO,
628  .id = AV_CODEC_ID_TDSC,
629  .init = tdsc_init,
630  .decode = tdsc_decode_frame,
631  .close = tdsc_close,
632  .priv_data_size = sizeof(TDSCContext),
633  .capabilities = AV_CODEC_CAP_DR1,
634  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
636 };
TDSCContext::deflatelen
uLongf deflatelen
Definition: tdsc.c:62
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:404
AVCodec
AVCodec.
Definition: codec.h:197
stride
int stride
Definition: mace.c:144
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
AVERROR
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
APPLY_ALPHA
#define APPLY_ALPHA(src, new, alpha)
Definition: tdsc.c:141
tdsc_yuv2rgb
static void tdsc_yuv2rgb(uint8_t *out, int Y, int U, int V)
Definition: tdsc.c:317
out
FILE * out
Definition: movenc.c:54
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:246
GetByteContext
Definition: bytestream.h:33
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1320
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
w
uint8_t w
Definition: llviddspenc.c:38
TDSCContext::cursor_stride
int cursor_stride
Definition: tdsc.c:66
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
data
const char data[16]
Definition: mxf.c:143
TDSCContext::width
int width
Definition: tdsc.c:52
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
TDSCContext::tilebuffer
uint8_t * tilebuffer
Definition: tdsc.c:58
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
TDSCContext::gbc
GetByteContext gbc
Definition: tdsc.c:53
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:70
av_image_copy_plane
void av_image_copy_plane(uint8_t *dst, int dst_linesize, const uint8_t *src, int src_linesize, int bytewidth, int height)
Copy image plane from src to dst.
Definition: imgutils.c:374
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
U
#define U(x)
Definition: vp56_arith.h:37
TDSCContext::cursor_h
int cursor_h
Definition: tdsc.c:67
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:459
val
static double val(void *priv, double ch)
Definition: aeval.c:75
AVCodecContext::dct_algo
int dct_algo
DCT algorithm, see FF_DCT_* below.
Definition: avcodec.h:1380
tdsc_parse_tdsf
static int tdsc_parse_tdsf(AVCodecContext *avctx, int number_tiles)
Definition: tdsc.c:454
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
tdsc_init
static av_cold int tdsc_init(AVCodecContext *avctx)
Definition: tdsc.c:93
tdsc_paint_cursor
static void tdsc_paint_cursor(AVCodecContext *avctx, uint8_t *dst, int stride)
Definition: tdsc.c:145
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:141
width
#define width
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1225
TDSCContext::jpkt
AVPacket * jpkt
Definition: tdsc.c:56
bits
uint8_t bits
Definition: vp3data.h:141
avcodec_receive_frame
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:639
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
TDSCContext::cursor_hot_x
int cursor_hot_x
Definition: tdsc.c:68
ctx
AVFormatContext * ctx
Definition: movenc.c:48
tdsc_parse_dtsm
static int tdsc_parse_dtsm(AVCodecContext *avctx)
Definition: tdsc.c:497
AV_CODEC_ID_TDSC
@ AV_CODEC_ID_TDSC
Definition: codec_id.h:237
TDSCContext::cursor_x
int cursor_x
Definition: tdsc.c:67
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
TDSB_HEADER_SIZE
#define TDSB_HEADER_SIZE
Definition: tdsc.c:47
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:156
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
V
#define V
Definition: avdct.c:30
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
bytestream2_get_buffer
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
TDSCContext::jpeg_avctx
AVCodecContext * jpeg_avctx
Definition: tdsc.c:50
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:137
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1331
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:915
TDSCCursorFormat
TDSCCursorFormat
Definition: tdsc.c:72
TDSCContext
Definition: tdsc.c:49
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:466
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1648
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:116
av_frame_copy
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:678
av_reallocp
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:167
TDSCContext::cursor_w
int cursor_w
Definition: tdsc.c:67
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
line
Definition: graph2dot.c:48
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:59
tdsc_decode_tiles
static int tdsc_decode_tiles(AVCodecContext *avctx, int number_tiles)
Definition: tdsc.c:386
Y
#define Y
Definition: boxblur.h:37
TDSCContext::deflatebuffer
uint8_t * deflatebuffer
Definition: tdsc.c:61
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:576
TDSCContext::cursor_y
int cursor_y
Definition: tdsc.c:67
TDSCContext::cursor
uint8_t * cursor
Definition: tdsc.c:65
i
int i
Definition: input.c:406
TDSCContext::cursor_hot_y
int cursor_hot_y
Definition: tdsc.c:68
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:50
av_always_inline
#define av_always_inline
Definition: attributes.h:49
CUR_FMT_RGBA
@ CUR_FMT_RGBA
Definition: tdsc.c:75
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:437
AVCodecContext::idct_algo
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1393
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:552
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:589
TDSF_HEADER_SIZE
#define TDSF_HEADER_SIZE
Definition: tdsc.c:46
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
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
Definition: filter_design.txt:264
tdsc_load_cursor
static int tdsc_load_cursor(AVCodecContext *avctx)
Definition: tdsc.c:190
tdsc_decode_frame
static int tdsc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: tdsc.c:524
AVCodecContext
main external API structure.
Definition: avcodec.h:379
CUR_FMT_MONO
@ CUR_FMT_MONO
Definition: tdsc.c:73
tdsc_decode_jpeg_tile
static int tdsc_decode_jpeg_tile(AVCodecContext *avctx, int tile_size, int x, int y, int w, int h)
Definition: tdsc.c:344
av_clip_uint8
#define av_clip_uint8
Definition: common.h:128
TDSCContext::jpgframe
AVFrame * jpgframe
Definition: tdsc.c:57
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:86
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
TDSCContext::height
int height
Definition: tdsc.c:52
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
TDSCContext::refframe
AVFrame * refframe
Definition: tdsc.c:55
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AVPacket
This structure stores compressed data.
Definition: packet.h:350
tdsc_blit
static av_always_inline void tdsc_blit(uint8_t *dst, int dst_stride, const uint8_t *srcy, int srcy_stride, const uint8_t *srcu, const uint8_t *srcv, int srcuv_stride, int width, int height)
Definition: tdsc.c:325
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:552
bytestream.h
imgutils.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
tdsc_close
static av_cold int tdsc_close(AVCodecContext *avctx)
Definition: tdsc.c:78
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
h
h
Definition: vp9dsp_template.c:2038
CUR_FMT_BGRA
@ CUR_FMT_BGRA
Definition: tdsc.c:74
BITMAPINFOHEADER_SIZE
#define BITMAPINFOHEADER_SIZE
Definition: tdsc.c:45
line
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:40
ff_tdsc_decoder
const AVCodec ff_tdsc_decoder
Definition: tdsc.c:624