FFmpeg
tiffenc.c
Go to the documentation of this file.
1 /*
2  * TIFF image encoder
3  * Copyright (c) 2007 Bartlomiej Wolowiec
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  * TIFF image encoder
25  * @author Bartlomiej Wolowiec
26  */
27 
28 #include "config.h"
29 #if CONFIG_ZLIB
30 #include <zlib.h>
31 #endif
32 
33 #include "libavutil/imgutils.h"
34 #include "libavutil/log.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/pixdesc.h"
37 #include "avcodec.h"
38 #include "bytestream.h"
39 #include "encode.h"
40 #include "internal.h"
41 #include "lzw.h"
42 #include "put_bits.h"
43 #include "rle.h"
44 #include "tiff.h"
45 
46 #define TIFF_MAX_ENTRY 32
47 
48 /** sizes of various TIFF field types (string size = 1)*/
49 static const uint8_t type_sizes2[14] = {
50  0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 4
51 };
52 
53 typedef struct TiffEncoderContext {
54  AVClass *class; ///< for private options
56 
57  int width; ///< picture width
58  int height; ///< picture height
59  unsigned int bpp; ///< bits per pixel
60  int compr; ///< compression level
61  int bpp_tab_size; ///< bpp_tab size
62  enum TiffPhotometric photometric_interpretation; ///< photometric interpretation
63  int strips; ///< number of strips
64  uint32_t *strip_sizes;
65  unsigned int strip_sizes_size;
66  uint32_t *strip_offsets;
67  unsigned int strip_offsets_size;
68  uint8_t *yuv_line;
69  unsigned int yuv_line_size;
70  int rps; ///< row per strip
71  uint8_t entries[TIFF_MAX_ENTRY * 12]; ///< entries in header
72  int num_entries; ///< number of entries
73  uint8_t **buf; ///< actual position in buffer
74  uint8_t *buf_start; ///< pointer to first byte in buffer
75  int buf_size; ///< buffer size
76  uint16_t subsampling[2]; ///< YUV subsampling factors
77  struct LZWEncodeState *lzws; ///< LZW encode state
78  uint32_t dpi; ///< image resolution in DPI
80 
81 /**
82  * Check free space in buffer.
83  *
84  * @param s Tiff context
85  * @param need Needed bytes
86  * @return 0 - ok, 1 - no free space
87  */
88 static inline int check_size(TiffEncoderContext *s, uint64_t need)
89 {
90  if (s->buf_size < *s->buf - s->buf_start + need) {
91  *s->buf = s->buf_start + s->buf_size + 1;
92  av_log(s->avctx, AV_LOG_ERROR, "Buffer is too small\n");
93  return 1;
94  }
95  return 0;
96 }
97 
98 /**
99  * Put n values to buffer.
100  *
101  * @param p pointer to pointer to output buffer
102  * @param n number of values
103  * @param val pointer to values
104  * @param type type of values
105  * @param flip = 0 - normal copy, >0 - flip
106  */
107 static void tnput(uint8_t **p, int n, const uint8_t *val, enum TiffTypes type,
108  int flip)
109 {
110  int i;
111 #if HAVE_BIGENDIAN
112  flip ^= ((int[]) { 0, 0, 0, 1, 3, 3 })[type];
113 #endif
114  for (i = 0; i < n * type_sizes2[type]; i++)
115  *(*p)++ = val[i ^ flip];
116 }
117 
118 /**
119  * Add entry to directory in tiff header.
120  *
121  * @param s Tiff context
122  * @param tag tag that identifies the entry
123  * @param type entry type
124  * @param count the number of values
125  * @param ptr_val pointer to values
126  */
128  enum TiffTypes type, int count, const void *ptr_val)
129 {
130  uint8_t *entries_ptr = s->entries + 12 * s->num_entries;
131 
132  av_assert0(s->num_entries < TIFF_MAX_ENTRY);
133 
134  bytestream_put_le16(&entries_ptr, tag);
135  bytestream_put_le16(&entries_ptr, type);
136  bytestream_put_le32(&entries_ptr, count);
137 
138  if (type_sizes[type] * (int64_t)count <= 4) {
139  tnput(&entries_ptr, count, ptr_val, type, 0);
140  } else {
141  bytestream_put_le32(&entries_ptr, *s->buf - s->buf_start);
142  if (check_size(s, count * (int64_t)type_sizes2[type]))
143  return AVERROR_INVALIDDATA;
144  tnput(s->buf, count, ptr_val, type, 0);
145  }
146 
147  s->num_entries++;
148  return 0;
149 }
150 
152  enum TiffTags tag, enum TiffTypes type, int val)
153 {
154  uint16_t w = val;
155  uint32_t dw = val;
156  return add_entry(s, tag, type, 1,
157  type == TIFF_SHORT ? (void *)&w : (void *)&dw);
158 }
159 
160 /**
161  * Encode one strip in tiff file.
162  *
163  * @param s Tiff context
164  * @param src input buffer
165  * @param dst output buffer
166  * @param n size of input buffer
167  * @param compr compression method
168  * @return number of output bytes. If an output error is encountered, a negative
169  * value corresponding to an AVERROR error code is returned.
170  */
171 static int encode_strip(TiffEncoderContext *s, const int8_t *src,
172  uint8_t *dst, int n, int compr)
173 {
174  switch (compr) {
175 #if CONFIG_ZLIB
176  case TIFF_DEFLATE:
177  case TIFF_ADOBE_DEFLATE:
178  {
179  unsigned long zlen = s->buf_size - (*s->buf - s->buf_start);
180  if (compress(dst, &zlen, src, n) != Z_OK) {
181  av_log(s->avctx, AV_LOG_ERROR, "Compressing failed\n");
182  return AVERROR_EXTERNAL;
183  }
184  return zlen;
185  }
186 #endif
187  case TIFF_RAW:
188  if (check_size(s, n))
189  return AVERROR(EINVAL);
190  memcpy(dst, src, n);
191  return n;
192  case TIFF_PACKBITS:
193  return ff_rle_encode(dst, s->buf_size - (*s->buf - s->buf_start),
194  src, 1, n, 2, 0xff, -1, 0);
195  case TIFF_LZW:
196  return ff_lzw_encode(s->lzws, src, n);
197  default:
198  av_log(s->avctx, AV_LOG_ERROR, "Unsupported compression method: %d\n",
199  compr);
200  return AVERROR(EINVAL);
201  }
202 }
203 
204 static void pack_yuv(TiffEncoderContext *s, const AVFrame *p,
205  uint8_t *dst, int lnum)
206 {
207  int i, j, k;
208  int w = (s->width - 1) / s->subsampling[0] + 1;
209  uint8_t *pu = &p->data[1][lnum / s->subsampling[1] * p->linesize[1]];
210  uint8_t *pv = &p->data[2][lnum / s->subsampling[1] * p->linesize[2]];
211  if (s->width % s->subsampling[0] || s->height % s->subsampling[1]) {
212  for (i = 0; i < w; i++) {
213  for (j = 0; j < s->subsampling[1]; j++)
214  for (k = 0; k < s->subsampling[0]; k++)
215  *dst++ = p->data[0][FFMIN(lnum + j, s->height-1) * p->linesize[0] +
216  FFMIN(i * s->subsampling[0] + k, s->width-1)];
217  *dst++ = *pu++;
218  *dst++ = *pv++;
219  }
220  }else{
221  for (i = 0; i < w; i++) {
222  for (j = 0; j < s->subsampling[1]; j++)
223  for (k = 0; k < s->subsampling[0]; k++)
224  *dst++ = p->data[0][(lnum + j) * p->linesize[0] +
225  i * s->subsampling[0] + k];
226  *dst++ = *pu++;
227  *dst++ = *pv++;
228  }
229  }
230 }
231 
232 #define ADD_ENTRY(s, tag, type, count, ptr_val) \
233  do { \
234  ret = add_entry(s, tag, type, count, ptr_val); \
235  if (ret < 0) \
236  goto fail; \
237  } while (0)
238 
239 #define ADD_ENTRY1(s, tag, type, val) \
240  do { \
241  ret = add_entry1(s, tag, type, val); \
242  if (ret < 0) \
243  goto fail; \
244  } while (0)
245 
247  const AVFrame *pict, int *got_packet)
248 {
250  TiffEncoderContext *s = avctx->priv_data;
251  const AVFrame *const p = pict;
252  int i;
253  uint8_t *ptr;
254  uint8_t *offset;
255  uint32_t strips;
256  int bytes_per_row;
257  uint32_t res[2] = { s->dpi, 1 }; // image resolution (72/1)
258  uint16_t bpp_tab[4];
259  int ret = 0;
260  int is_yuv = 0, alpha = 0;
261  int shift_h, shift_v;
262  int packet_size;
263 
264  s->width = avctx->width;
265  s->height = avctx->height;
266  s->subsampling[0] = 1;
267  s->subsampling[1] = 1;
268 
269  if (!desc)
270  return AVERROR(EINVAL);
271 
272  avctx->bits_per_coded_sample =
273  s->bpp = av_get_bits_per_pixel(desc);
274  s->bpp_tab_size = desc->nb_components;
275 
276  switch (avctx->pix_fmt) {
277  case AV_PIX_FMT_RGBA64LE:
278  case AV_PIX_FMT_RGBA:
279  alpha = 1;
280  case AV_PIX_FMT_RGB48LE:
281  case AV_PIX_FMT_RGB24:
282  s->photometric_interpretation = TIFF_PHOTOMETRIC_RGB;
283  break;
284  case AV_PIX_FMT_GRAY8:
285  avctx->bits_per_coded_sample = 0x28;
286  case AV_PIX_FMT_GRAY8A:
287  case AV_PIX_FMT_YA16LE:
288  alpha = avctx->pix_fmt == AV_PIX_FMT_GRAY8A || avctx->pix_fmt == AV_PIX_FMT_YA16LE;
289  case AV_PIX_FMT_GRAY16LE:
291  s->photometric_interpretation = TIFF_PHOTOMETRIC_BLACK_IS_ZERO;
292  break;
293  case AV_PIX_FMT_PAL8:
294  s->photometric_interpretation = TIFF_PHOTOMETRIC_PALETTE;
295  break;
297  s->photometric_interpretation = TIFF_PHOTOMETRIC_WHITE_IS_ZERO;
298  break;
299  case AV_PIX_FMT_YUV420P:
300  case AV_PIX_FMT_YUV422P:
301  case AV_PIX_FMT_YUV440P:
302  case AV_PIX_FMT_YUV444P:
303  case AV_PIX_FMT_YUV410P:
304  case AV_PIX_FMT_YUV411P:
305  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &shift_h, &shift_v);
306  s->photometric_interpretation = TIFF_PHOTOMETRIC_YCBCR;
307  s->subsampling[0] = 1 << shift_h;
308  s->subsampling[1] = 1 << shift_v;
309  is_yuv = 1;
310  break;
311  default:
312  av_log(s->avctx, AV_LOG_ERROR,
313  "This colors format is not supported\n");
314  return AVERROR(EINVAL);
315  }
316 
317  for (i = 0; i < s->bpp_tab_size; i++)
318  bpp_tab[i] = desc->comp[i].depth;
319 
320  if (s->compr == TIFF_DEFLATE ||
321  s->compr == TIFF_ADOBE_DEFLATE ||
322  s->compr == TIFF_LZW)
323  // best choice for DEFLATE
324  s->rps = s->height;
325  else
326  // suggest size of strip
327  s->rps = FFMAX(8192 / (((s->width * s->bpp) >> 3) + 1), 1);
328  // round rps up
329  s->rps = ((s->rps - 1) / s->subsampling[1] + 1) * s->subsampling[1];
330 
331  strips = (s->height - 1) / s->rps + 1;
332 
333  bytes_per_row = (((s->width - 1) / s->subsampling[0] + 1) * s->bpp *
334  s->subsampling[0] * s->subsampling[1] + 7) >> 3;
335  packet_size = avctx->height * bytes_per_row * 2 +
336  avctx->height * 4 + AV_INPUT_BUFFER_MIN_SIZE;
337 
338  if ((ret = ff_alloc_packet(avctx, pkt, packet_size)) < 0)
339  return ret;
340  ptr = pkt->data;
341  s->buf_start = pkt->data;
342  s->buf = &ptr;
343  s->buf_size = pkt->size;
344 
345  if (check_size(s, 8)) {
346  ret = AVERROR(EINVAL);
347  goto fail;
348  }
349 
350  // write header
351  bytestream_put_le16(&ptr, 0x4949);
352  bytestream_put_le16(&ptr, 42);
353 
354  offset = ptr;
355  bytestream_put_le32(&ptr, 0);
356 
357  if (strips > INT_MAX / FFMAX(sizeof(s->strip_sizes[0]), sizeof(s->strip_offsets[0]))) {
358  ret = AVERROR(ENOMEM);
359  goto fail;
360  }
361  av_fast_padded_mallocz(&s->strip_sizes , &s->strip_sizes_size , sizeof(s->strip_sizes [0]) * strips);
362  av_fast_padded_mallocz(&s->strip_offsets, &s->strip_offsets_size, sizeof(s->strip_offsets[0]) * strips);
363 
364  if (!s->strip_sizes || !s->strip_offsets) {
365  ret = AVERROR(ENOMEM);
366  goto fail;
367  }
368 
369  if (is_yuv) {
370  av_fast_padded_malloc(&s->yuv_line, &s->yuv_line_size, bytes_per_row);
371  if (s->yuv_line == NULL) {
372  av_log(s->avctx, AV_LOG_ERROR, "Not enough memory\n");
373  ret = AVERROR(ENOMEM);
374  goto fail;
375  }
376  }
377 
378 #if CONFIG_ZLIB
379  if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE) {
380  uint8_t *zbuf;
381  int zlen, zn;
382  int j;
383 
384  zlen = bytes_per_row * s->rps;
385  zbuf = av_malloc(zlen);
386  if (!zbuf) {
387  ret = AVERROR(ENOMEM);
388  goto fail;
389  }
390  s->strip_offsets[0] = ptr - pkt->data;
391  zn = 0;
392  for (j = 0; j < s->rps; j++) {
393  if (is_yuv) {
394  pack_yuv(s, p, s->yuv_line, j);
395  memcpy(zbuf + zn, s->yuv_line, bytes_per_row);
396  j += s->subsampling[1] - 1;
397  } else
398  memcpy(zbuf + j * bytes_per_row,
399  p->data[0] + j * p->linesize[0], bytes_per_row);
400  zn += bytes_per_row;
401  }
402  ret = encode_strip(s, zbuf, ptr, zn, s->compr);
403  av_free(zbuf);
404  if (ret < 0) {
405  av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");
406  goto fail;
407  }
408  ptr += ret;
409  s->strip_sizes[0] = ptr - pkt->data - s->strip_offsets[0];
410  } else
411 #endif
412  {
413  if (s->compr == TIFF_LZW) {
415  if (!s->lzws) {
416  ret = AVERROR(ENOMEM);
417  goto fail;
418  }
419  }
420  for (i = 0; i < s->height; i++) {
421  if (s->strip_sizes[i / s->rps] == 0) {
422  if (s->compr == TIFF_LZW) {
423  ff_lzw_encode_init(s->lzws, ptr,
424  s->buf_size - (*s->buf - s->buf_start),
425  12, FF_LZW_TIFF, 0);
426  }
427  s->strip_offsets[i / s->rps] = ptr - pkt->data;
428  }
429  if (is_yuv) {
430  pack_yuv(s, p, s->yuv_line, i);
431  ret = encode_strip(s, s->yuv_line, ptr, bytes_per_row, s->compr);
432  i += s->subsampling[1] - 1;
433  } else
434  ret = encode_strip(s, p->data[0] + i * p->linesize[0],
435  ptr, bytes_per_row, s->compr);
436  if (ret < 0) {
437  av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");
438  goto fail;
439  }
440  s->strip_sizes[i / s->rps] += ret;
441  ptr += ret;
442  if (s->compr == TIFF_LZW &&
443  (i == s->height - 1 || i % s->rps == s->rps - 1)) {
444  ret = ff_lzw_encode_flush(s->lzws);
445  s->strip_sizes[(i / s->rps)] += ret;
446  ptr += ret;
447  }
448  }
449  if (s->compr == TIFF_LZW)
450  av_freep(&s->lzws);
451  }
452 
453  s->num_entries = 0;
454 
456  ADD_ENTRY1(s, TIFF_WIDTH, TIFF_LONG, s->width);
457  ADD_ENTRY1(s, TIFF_HEIGHT, TIFF_LONG, s->height);
458 
459  if (s->bpp_tab_size)
460  ADD_ENTRY(s, TIFF_BPP, TIFF_SHORT, s->bpp_tab_size, bpp_tab);
461 
462  ADD_ENTRY1(s, TIFF_COMPR, TIFF_SHORT, s->compr);
463  ADD_ENTRY1(s, TIFF_PHOTOMETRIC, TIFF_SHORT, s->photometric_interpretation);
464  ADD_ENTRY(s, TIFF_STRIP_OFFS, TIFF_LONG, strips, s->strip_offsets);
465 
466  if (s->bpp_tab_size)
467  ADD_ENTRY1(s, TIFF_SAMPLES_PER_PIXEL, TIFF_SHORT, s->bpp_tab_size);
468 
470  ADD_ENTRY(s, TIFF_STRIP_SIZE, TIFF_LONG, strips, s->strip_sizes);
471  ADD_ENTRY(s, TIFF_XRES, TIFF_RATIONAL, 1, res);
472  if (avctx->sample_aspect_ratio.num > 0 &&
473  avctx->sample_aspect_ratio.den > 0) {
474  AVRational y = av_mul_q(av_make_q(s->dpi, 1),
475  avctx->sample_aspect_ratio);
476  res[0] = y.num;
477  res[1] = y.den;
478  }
479  ADD_ENTRY(s, TIFF_YRES, TIFF_RATIONAL, 1, res);
481 
482  if (!(avctx->flags & AV_CODEC_FLAG_BITEXACT))
484  strlen(LIBAVCODEC_IDENT) + 1, LIBAVCODEC_IDENT);
485 
486  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
487  uint16_t pal[256 * 3];
488  for (i = 0; i < 256; i++) {
489  uint32_t rgb = *(uint32_t *) (p->data[1] + i * 4);
490  pal[i] = ((rgb >> 16) & 0xff) * 257;
491  pal[i + 256] = ((rgb >> 8) & 0xff) * 257;
492  pal[i + 512] = (rgb & 0xff) * 257;
493  }
494  ADD_ENTRY(s, TIFF_PAL, TIFF_SHORT, 256 * 3, pal);
495  }
496  if (alpha)
498  if (is_yuv) {
499  /** according to CCIR Recommendation 601.1 */
500  uint32_t refbw[12] = { 15, 1, 235, 1, 128, 1, 240, 1, 128, 1, 240, 1 };
501  ADD_ENTRY(s, TIFF_YCBCR_SUBSAMPLING, TIFF_SHORT, 2, s->subsampling);
505  }
506  // write offset to dir
507  bytestream_put_le32(&offset, ptr - pkt->data);
508 
509  if (check_size(s, 6 + s->num_entries * 12)) {
510  ret = AVERROR(EINVAL);
511  goto fail;
512  }
513  bytestream_put_le16(&ptr, s->num_entries); // write tag count
514  bytestream_put_buffer(&ptr, s->entries, s->num_entries * 12);
515  bytestream_put_le32(&ptr, 0);
516 
517  pkt->size = ptr - pkt->data;
519  *got_packet = 1;
520 
521 fail:
522  return ret < 0 ? ret : 0;
523 }
524 
526 {
527  TiffEncoderContext *s = avctx->priv_data;
528 
529 #if !CONFIG_ZLIB
530  if (s->compr == TIFF_DEFLATE) {
531  av_log(avctx, AV_LOG_ERROR,
532  "Deflate compression needs zlib compiled in\n");
533  return AVERROR(ENOSYS);
534  }
535 #endif
536 
537  s->avctx = avctx;
538 
539  return 0;
540 }
541 
543 {
544  TiffEncoderContext *s = avctx->priv_data;
545 
546  av_freep(&s->strip_sizes);
547  av_freep(&s->strip_offsets);
548  av_freep(&s->yuv_line);
549 
550  return 0;
551 }
552 
553 #define OFFSET(x) offsetof(TiffEncoderContext, x)
554 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
555 static const AVOption options[] = {
556  {"dpi", "set the image resolution (in dpi)", OFFSET(dpi), AV_OPT_TYPE_INT, {.i64 = 72}, 1, 0x10000, AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_ENCODING_PARAM},
557  { "compression_algo", NULL, OFFSET(compr), AV_OPT_TYPE_INT, { .i64 = TIFF_PACKBITS }, TIFF_RAW, TIFF_DEFLATE, VE, "compression_algo" },
558  { "packbits", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TIFF_PACKBITS }, 0, 0, VE, "compression_algo" },
559  { "raw", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TIFF_RAW }, 0, 0, VE, "compression_algo" },
560  { "lzw", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TIFF_LZW }, 0, 0, VE, "compression_algo" },
561  { "deflate", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = TIFF_DEFLATE }, 0, 0, VE, "compression_algo" },
562  { NULL },
563 };
564 
565 static const AVClass tiffenc_class = {
566  .class_name = "TIFF encoder",
567  .item_name = av_default_item_name,
568  .option = options,
569  .version = LIBAVUTIL_VERSION_INT,
570 };
571 
573  .name = "tiff",
574  .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
575  .type = AVMEDIA_TYPE_VIDEO,
576  .id = AV_CODEC_ID_TIFF,
577  .priv_data_size = sizeof(TiffEncoderContext),
578  .init = encode_init,
579  .close = encode_close,
580  .capabilities = AV_CODEC_CAP_FRAME_THREADS,
581  .encode2 = encode_frame,
582  .pix_fmts = (const enum AVPixelFormat[]) {
590  },
591  .priv_class = &tiffenc_class,
592  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
593 };
encode_close
static av_cold int encode_close(AVCodecContext *avctx)
Definition: tiffenc.c:542
AVCodec
AVCodec.
Definition: codec.h:197
TiffTypes
TiffTypes
data type identifiers for TIFF tags
Definition: tiff_common.h:36
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
check_size
static int check_size(TiffEncoderContext *s, uint64_t need)
Check free space in buffer.
Definition: tiffenc.c:88
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
opt.h
encode_strip
static int encode_strip(TiffEncoderContext *s, const int8_t *src, uint8_t *dst, int n, int compr)
Encode one strip in tiff file.
Definition: tiffenc.c:171
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:280
LIBAVCODEC_IDENT
#define LIBAVCODEC_IDENT
Definition: version.h:42
rle.h
TiffEncoderContext::entries
uint8_t entries[TIFF_MAX_ENTRY *12]
entries in header
Definition: tiffenc.c:71
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2540
TiffEncoderContext::bpp_tab_size
int bpp_tab_size
bpp_tab size
Definition: tiffenc.c:61
TIFF_YCBCR_POSITIONING
@ TIFF_YCBCR_POSITIONING
Definition: tiff.h:87
TiffEncoderContext::strip_sizes_size
unsigned int strip_sizes_size
Definition: tiffenc.c:65
TiffEncoderContext::width
int width
picture width
Definition: tiffenc.c:57
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
pixdesc.h
w
uint8_t w
Definition: llviddspenc.c:38
TIFF_ADOBE_DEFLATE
@ TIFF_ADOBE_DEFLATE
Definition: tiff.h:128
LZWEncodeState
LZW encode state.
Definition: lzwenc.c:51
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
TIFF_LONG
@ TIFF_LONG
Definition: tiff_common.h:40
encode.h
TiffTags
TiffTags
abridged list of TIFF and TIFF/EP tags
Definition: tiff.h:47
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:75
ff_lzw_encode_init
void ff_lzw_encode_init(struct LZWEncodeState *s, uint8_t *outbuf, int outsize, int maxbits, enum FF_LZW_MODES mode, int little_endian)
Initialize LZW encoder.
Definition: lzwenc.c:206
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2492
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
TIFF_ROWSPERSTRIP
@ TIFF_ROWSPERSTRIP
Definition: tiff.h:61
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
TiffEncoderContext::avctx
AVCodecContext * avctx
Definition: tiffenc.c:55
TIFF_RAW
@ TIFF_RAW
Definition: tiff.h:121
TiffEncoderContext::subsampling
uint16_t subsampling[2]
YUV subsampling factors.
Definition: tiffenc.c:76
TIFF_PHOTOMETRIC_WHITE_IS_ZERO
@ TIFF_PHOTOMETRIC_WHITE_IS_ZERO
Definition: tiff.h:185
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:425
TIFF_PACKBITS
@ TIFF_PACKBITS
Definition: tiff.h:129
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
TiffEncoderContext::yuv_line_size
unsigned int yuv_line_size
Definition: tiffenc.c:69
rgb
Definition: rpzaenc.c:59
add_entry1
static int add_entry1(TiffEncoderContext *s, enum TiffTags tag, enum TiffTypes type, int val)
Definition: tiffenc.c:151
fail
#define fail()
Definition: checkasm.h:127
TIFF_YCBCR_SUBSAMPLING
@ TIFF_YCBCR_SUBSAMPLING
Definition: tiff.h:86
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:459
val
static double val(void *priv, double ch)
Definition: aeval.c:76
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2568
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
OFFSET
#define OFFSET(x)
Definition: tiffenc.c:553
TiffEncoderContext::num_entries
int num_entries
number of entries
Definition: tiffenc.c:72
TIFF_SOFTWARE_NAME
@ TIFF_SOFTWARE_NAME
Definition: tiff.h:73
FF_LZW_TIFF
@ FF_LZW_TIFF
Definition: lzw.h:39
AVRational::num
int num
Numerator.
Definition: rational.h:59
TIFF_SHORT
@ TIFF_SHORT
Definition: tiff_common.h:39
ADD_ENTRY1
#define ADD_ENTRY1(s, tag, type, val)
Definition: tiffenc.c:239
VE
#define VE
Definition: tiffenc.c:554
pkt
AVPacket * pkt
Definition: movenc.c:59
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
TIFF_SUBFILE
@ TIFF_SUBFILE
Definition: tiff.h:48
TIFF_RES_UNIT
@ TIFF_RES_UNIT
Definition: tiff.h:71
type_sizes2
static const uint8_t type_sizes2[14]
sizes of various TIFF field types (string size = 1)
Definition: tiffenc.c:49
s
#define s(width, name)
Definition: cbs_vp9.c:257
TiffEncoderContext::strips
int strips
number of strips
Definition: tiffenc.c:63
AV_OPT_FLAG_ENCODING_PARAM
#define AV_OPT_FLAG_ENCODING_PARAM
a generic parameter which can be set by the user for muxing or encoding
Definition: opt.h:277
TIFF_STRIP_SIZE
@ TIFF_STRIP_SIZE
Definition: tiff.h:62
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
TIFF_STRING
@ TIFF_STRING
Definition: tiff_common.h:38
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:185
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
need
must be printed separately If there s no standard function for printing the type you need
Definition: tablegen.txt:45
AV_PIX_FMT_GRAY8A
@ AV_PIX_FMT_GRAY8A
alias for AV_PIX_FMT_YA8
Definition: pixfmt.h:136
ADD_ENTRY
#define ADD_ENTRY(s, tag, type, count, ptr_val)
Definition: tiffenc.c:232
TIFF_LZW
@ TIFF_LZW
Definition: tiff.h:125
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
TIFF_PHOTOMETRIC_YCBCR
@ TIFF_PHOTOMETRIC_YCBCR
Definition: tiff.h:191
TiffEncoderContext::buf
uint8_t ** buf
actual position in buffer
Definition: tiffenc.c:73
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVCHROMA_LOC_TOPLEFT
@ AVCHROMA_LOC_TOPLEFT
ITU-R 601, SMPTE 274M 296M S314M(DV 4:1:1), mpeg2 4:2:2.
Definition: pixfmt.h:599
AV_PIX_FMT_RGB48LE
@ AV_PIX_FMT_RGB48LE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as lit...
Definition: pixfmt.h:103
AV_PIX_FMT_YA16LE
@ AV_PIX_FMT_YA16LE
16 bits gray, 16 bits alpha (little-endian)
Definition: pixfmt.h:203
AV_PIX_FMT_MONOBLACK
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:76
tiff.h
TIFF_PHOTOMETRIC_PALETTE
@ TIFF_PHOTOMETRIC_PALETTE
Definition: tiff.h:188
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AV_PIX_FMT_RGBA64LE
@ AV_PIX_FMT_RGBA64LE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:196
src
#define src
Definition: vp8dsp.c:255
TiffEncoderContext
Definition: tiffenc.c:53
TiffEncoderContext::dpi
uint32_t dpi
image resolution in DPI
Definition: tiffenc.c:78
TIFF_PAL
@ TIFF_PAL
Definition: tiff.h:78
TiffEncoderContext::strip_offsets
uint32_t * strip_offsets
Definition: tiffenc.c:66
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
TIFF_SAMPLES_PER_PIXEL
@ TIFF_SAMPLES_PER_PIXEL
Definition: tiff.h:60
TiffEncoderContext::lzws
struct LZWEncodeState * lzws
LZW encode state.
Definition: tiffenc.c:77
TIFF_WIDTH
@ TIFF_WIDTH
Definition: tiff.h:49
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:131
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:117
TIFF_EXTRASAMPLES
@ TIFF_EXTRASAMPLES
Definition: tiff.h:84
add_entry
static int add_entry(TiffEncoderContext *s, enum TiffTags tag, enum TiffTypes type, int count, const void *ptr_val)
Add entry to directory in tiff header.
Definition: tiffenc.c:127
lzw.h
LZW decoding routines.
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: tiffenc.c:246
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
TiffEncoderContext::strip_sizes
uint32_t * strip_sizes
Definition: tiffenc.c:64
TiffEncoderContext::buf_size
int buf_size
buffer size
Definition: tiffenc.c:75
TiffEncoderContext::compr
int compr
compression level
Definition: tiffenc.c:60
tiffenc_class
static const AVClass tiffenc_class
Definition: tiffenc.c:565
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
TIFF_COMPR
@ TIFF_COMPR
Definition: tiff.h:52
TIFF_HEIGHT
@ TIFF_HEIGHT
Definition: tiff.h:50
tnput
static void tnput(uint8_t **p, int n, const uint8_t *val, enum TiffTypes type, int flip)
Put n values to buffer.
Definition: tiffenc.c:107
TiffEncoderContext::photometric_interpretation
enum TiffPhotometric photometric_interpretation
photometric interpretation
Definition: tiffenc.c:62
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1414
bytestream_put_buffer
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
i
int i
Definition: input.c:406
log.h
TIFF_PHOTOMETRIC_BLACK_IS_ZERO
@ TIFF_PHOTOMETRIC_BLACK_IS_ZERO
Definition: tiff.h:186
ff_tiff_encoder
const AVCodec ff_tiff_encoder
Definition: tiffenc.c:572
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:50
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
ff_lzw_encode_flush
int ff_lzw_encode_flush(struct LZWEncodeState *s)
Write end code and flush bitstream.
Definition: lzwenc.c:263
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:970
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
TIFF_STRIP_OFFS
@ TIFF_STRIP_OFFS
Definition: tiff.h:59
TIFF_MAX_ENTRY
#define TIFF_MAX_ENTRY
Definition: tiffenc.c:46
avcodec.h
pv
#define pv
Definition: regdef.h:60
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
tag
uint32_t tag
Definition: movenc.c:1597
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
TIFF_BPP
@ TIFF_BPP
Definition: tiff.h:51
ff_rle_encode
int ff_rle_encode(uint8_t *outbuf, int out_size, const uint8_t *ptr, int bpp, int w, int add_rep, int xor_rep, int add_raw, int xor_raw)
RLE compress the row, with maximum size of out_size.
Definition: rle.c:53
TIFF_PHOTOMETRIC
@ TIFF_PHOTOMETRIC
Definition: tiff.h:53
TiffPhotometric
TiffPhotometric
list of TIFF, TIFF/AP and DNG PhotometricInterpretation (TIFF_PHOTOMETRIC) values
Definition: tiff.h:183
AVCodecContext
main external API structure.
Definition: avcodec.h:379
TiffEncoderContext::bpp
unsigned int bpp
bits per pixel
Definition: tiffenc.c:59
options
static const AVOption options[]
Definition: tiffenc.c:555
TIFF_RATIONAL
@ TIFF_RATIONAL
Definition: tiff_common.h:41
TiffEncoderContext::yuv_line
uint8_t * yuv_line
Definition: tiffenc.c:68
AVRational::den
int den
Denominator.
Definition: rational.h:60
TiffEncoderContext::strip_offsets_size
unsigned int strip_offsets_size
Definition: tiffenc.c:67
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
av_fast_padded_mallocz
void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_padded_malloc except that buffer will always be 0-initialized after call.
Definition: utils.c:63
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
TIFF_YRES
@ TIFF_YRES
Definition: tiff.h:64
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
TiffEncoderContext::height
int height
picture height
Definition: tiffenc.c:58
AV_PIX_FMT_GRAY16LE
@ AV_PIX_FMT_GRAY16LE
Y , 16bpp, little-endian.
Definition: pixfmt.h:98
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
TiffEncoderContext::rps
int rps
row per strip
Definition: tiffenc.c:70
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:268
pack_yuv
static void pack_yuv(TiffEncoderContext *s, const AVFrame *p, uint8_t *dst, int lnum)
Definition: tiffenc.c:204
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
TIFF_DEFLATE
@ TIFF_DEFLATE
Definition: tiff.h:130
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
TIFF_PHOTOMETRIC_RGB
@ TIFF_PHOTOMETRIC_RGB
Definition: tiff.h:187
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
AVPacket
This structure stores compressed data.
Definition: packet.h:350
TiffEncoderContext::buf_start
uint8_t * buf_start
pointer to first byte in buffer
Definition: tiffenc.c:74
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
ff_lzw_encode_state_size
const int ff_lzw_encode_state_size
Definition: lzwenc.c:68
TIFF_XRES
@ TIFF_XRES
Definition: tiff.h:63
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:552
bytestream.h
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
TIFF_REFERENCE_BW
@ TIFF_REFERENCE_BW
Definition: tiff.h:88
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: tiffenc.c:525
AV_CODEC_ID_TIFF
@ AV_CODEC_ID_TIFF
Definition: codec_id.h:146
type_sizes
static const uint8_t type_sizes[14]
sizes of various TIFF field types (string size = 100)
Definition: tiff_common.h:53
ff_lzw_encode
int ff_lzw_encode(struct LZWEncodeState *s, const uint8_t *inbuf, int insize)
LZW main compress function.
Definition: lzwenc.c:230
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:34
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:749