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 */
62  uLongf deflatelen;
63 
64  /* All that is 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);
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 };
#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:49
#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:386
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
int dct_algo
DCT algorithm, see FF_DCT_* below.
Definition: avcodec.h:1706
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:84
#define avpriv_request_sample(...)
int size
Definition: packet.h:370
#define TDSF_HEADER_SIZE
Definition: tdsc.c:46
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
int height
Definition: tdsc.c:52
int cursor_h
Definition: tdsc.c:67
AVPacket * jpkt
Definition: tdsc.c:56
int width
Definition: tdsc.c:52
AVCodec.
Definition: codec.h:197
static av_cold int tdsc_init(AVCodecContext *avctx)
Definition: tdsc.c:93
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:41
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:75
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:191
#define BITMAPINFOHEADER_SIZE
Definition: tdsc.c:45
static int tdsc_parse_dtsm(AVCodecContext *avctx)
Definition: tdsc.c:497
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
uint8_t * data
Definition: packet.h:369
uint8_t * cursor
Definition: tdsc.c:65
int cursor_stride
Definition: tdsc.c:66
static av_cold int tdsc_close(AVCodecContext *avctx)
Definition: tdsc.c:78
#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:158
#define U(x)
Definition: vp56_arith.h:37
int width
Definition: frame.h:376
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
TDSCCursorFormat
Definition: tdsc.c:72
int cursor_hot_y
Definition: tdsc.c:68
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:204
static int tdsc_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: tdsc.c:524
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
AVFrame * refframe
Definition: tdsc.c:55
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:643
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
int cursor_x
Definition: tdsc.c:67
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
const char * name
Name of the codec implementation.
Definition: codec.h:204
uint8_t bits
Definition: vp3data.h:141
static int tdsc_parse_tdsf(AVCodecContext *avctx, int number_tiles)
Definition: tdsc.c:454
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
Definition: frame.c:800
uLongf deflatelen
Definition: tdsc.c:62
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
#define Y
Definition: boxblur.h:38
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1645
GetByteContext gbc
Definition: tdsc.c:53
#define FFMIN(a, b)
Definition: common.h:105
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:170
uint8_t * deflatebuffer
Definition: tdsc.c:61
int width
picture width / height.
Definition: avcodec.h:709
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1719
uint8_t w
Definition: llviddspenc.c:39
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:344
AVFrame * jpgframe
Definition: tdsc.c:57
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:1656
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
int cursor_y
Definition: tdsc.c:67
#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:391
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:580
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:68
static void tdsc_paint_cursor(AVCodecContext *avctx, uint8_t *dst, int stride)
Definition: tdsc.c:145
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:185
uint8_t * tilebuffer
Definition: tdsc.c:58
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:536
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:634
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1893
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
int cursor_w
Definition: tdsc.c:67
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:142
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:946
#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:338
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
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.
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
void * priv_data
Definition: avcodec.h:563
#define av_clip_uint8
Definition: common.h:128
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:64
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
#define APPLY_ALPHA(src, new, alpha)
Definition: tdsc.c:141
static void tdsc_yuv2rgb(uint8_t *out, int Y, int U, int V)
Definition: tdsc.c:317
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:623
AVCodec ff_tdsc_decoder
Definition: tdsc.c:624
int height
Definition: frame.h:376
FILE * out
Definition: movenc.c:54
static int tdsc_load_cursor(AVCodecContext *avctx)
Definition: tdsc.c:190
#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:478
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:346
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators...
Definition: codec.h:52
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
#define V
Definition: avdct.c:30