Merge commit '3c27275c1309190f2d6ed69140b67d014215b6c9'
authorMichael Niedermayer <michaelni@gmx.at>
Mon, 15 Dec 2014 21:00:32 +0000 (22:00 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Mon, 15 Dec 2014 21:00:52 +0000 (22:00 +0100)
* commit '3c27275c1309190f2d6ed69140b67d014215b6c9':
  tiff: Check the check_size() return value and forward it

Conflicts:
libavcodec/tiffenc.c

See: d50aa006fb3430bedc3872ba10e028a714499625
Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/tiffenc.c

diff --combined libavcodec/tiffenc.c
index 72219da0d007ee49770e2627cc0eb6effce93c07,e17208ad430c43b2dd6835b3ad41ea79ead2145c..782a2fbfd76145b189593cdd3ff991504fbafa58
@@@ -2,20 -2,20 +2,20 @@@
   * TIFF image encoder
   * Copyright (c) 2007 Bartlomiej Wolowiec
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include <zlib.h>
  #endif
  
 +#include "libavutil/imgutils.h"
  #include "libavutil/log.h"
  #include "libavutil/opt.h"
  #include "libavutil/pixdesc.h"
  #include "avcodec.h"
  #include "bytestream.h"
 +#include "internal.h"
  #include "lzw.h"
  #include "put_bits.h"
  #include "rle.h"
@@@ -45,8 -43,8 +45,8 @@@
  #define TIFF_MAX_ENTRY 32
  
  /** sizes of various TIFF field types (string size = 1)*/
 -static const uint8_t type_sizes2[6] = {
 -    0, 1, 1, 2, 4, 8
 +static const uint8_t type_sizes2[14] = {
 +    0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 4
  };
  
  typedef struct TiffEncoderContext {
      int bpp_tab_size;                       ///< bpp_tab size
      enum TiffPhotometric photometric_interpretation;  ///< photometric interpretation
      int strips;                             ///< number of strips
 +    uint32_t *strip_sizes;
 +    unsigned int strip_sizes_size;
 +    uint32_t *strip_offsets;
 +    unsigned int strip_offsets_size;
 +    uint8_t *yuv_line;
 +    unsigned int yuv_line_size;
      int rps;                                ///< row per strip
      uint8_t entries[TIFF_MAX_ENTRY * 12];   ///< entries in header
      int num_entries;                        ///< number of entries
      int buf_size;                           ///< buffer size
      uint16_t subsampling[2];                ///< YUV subsampling factors
      struct LZWEncodeState *lzws;            ///< LZW encode state
 +    uint32_t dpi;                           ///< image resolution in DPI
  } TiffEncoderContext;
  
  /**
 - * Check free space in buffer
 + * Check free space in buffer.
 + *
   * @param s Tiff context
   * @param need Needed bytes
   * @return 0 - ok, 1 - no free space
@@@ -95,13 -85,13 +95,13 @@@ static inline int check_size(TiffEncode
  }
  
  /**
 - * Put n values to buffer
 + * Put n values to buffer.
   *
 - * @param p Pointer to pointer to output buffer
 - * @param n Number of values
 - * @param val Pointer to values
 - * @param type Type of values
 - * @param flip =0 - normal copy, >0 - flip
 + * @param p pointer to pointer to output buffer
 + * @param n number of values
 + * @param val pointer to values
 + * @param type type of values
 + * @param flip = 0 - normal copy, >0 - flip
   */
  static void tnput(uint8_t **p, int n, const uint8_t *val, enum TiffTypes type,
                    int flip)
  
  /**
   * Add entry to directory in tiff header.
 + *
   * @param s Tiff context
 - * @param tag Tag that identifies the entry
 - * @param type Entry type
 - * @param count The number of values
 - * @param ptr_val Pointer to values
 + * @param tag tag that identifies the entry
 + * @param type entry type
 + * @param count the number of values
 + * @param ptr_val pointer to values
   */
- static void add_entry(TiffEncoderContext *s, enum TiffTags tag,
-                       enum TiffTypes type, int count, const void *ptr_val)
+ static int add_entry(TiffEncoderContext *s, enum TiffTags tag,
+                      enum TiffTypes type, int count, const void *ptr_val)
  {
      uint8_t *entries_ptr = s->entries + 12 * s->num_entries;
  
 -    assert(s->num_entries < TIFF_MAX_ENTRY);
 +    av_assert0(s->num_entries < TIFF_MAX_ENTRY);
  
      bytestream_put_le16(&entries_ptr, tag);
      bytestream_put_le16(&entries_ptr, type);
      bytestream_put_le32(&entries_ptr, count);
  
 -    if (type_sizes[type] * count <= 4) {
 +    if (type_sizes[type] * (int64_t)count <= 4) {
          tnput(&entries_ptr, count, ptr_val, type, 0);
      } else {
          bytestream_put_le32(&entries_ptr, *s->buf - s->buf_start);
-         check_size(s, count * (int64_t)type_sizes2[type]);
 -        if (check_size(s, count * type_sizes2[type]))
++        if (check_size(s, count * (int64_t)type_sizes2[type]))
+             return AVERROR_INVALIDDATA;
          tnput(s->buf, count, ptr_val, type, 0);
      }
  
      s->num_entries++;
+     return 0;
  }
  
- static void add_entry1(TiffEncoderContext *s,
-                        enum TiffTags tag, enum TiffTypes type, int val)
+ static int add_entry1(TiffEncoderContext *s,
+                       enum TiffTags tag, enum TiffTypes type, int val)
  {
      uint16_t w  = val;
      uint32_t dw = val;
-     add_entry(s, tag, type, 1, type == TIFF_SHORT ? (void *)&w : (void *)&dw);
+     return add_entry(s, tag, type, 1,
+                      type == TIFF_SHORT ? (void *)&w : (void *)&dw);
  }
  
  /**
 - * Encode one strip in tiff file
 + * Encode one strip in tiff file.
   *
   * @param s Tiff context
 - * @param src Input buffer
 - * @param dst Output buffer
 - * @param n Size of input buffer
 - * @param compr Compression method
 - * @return Number of output bytes. If an output error is encountered, -1 returned
 + * @param src input buffer
 + * @param dst output buffer
 + * @param n size of input buffer
 + * @param compr compression method
 + * @return number of output bytes. If an output error is encountered, -1 is returned
   */
  static int encode_strip(TiffEncoderContext *s, const int8_t *src,
                          uint8_t *dst, int n, int compr)
@@@ -201,86 -193,98 +204,100 @@@ static void pack_yuv(TiffEncoderContex
      int w       = (s->width - 1) / s->subsampling[0] + 1;
      uint8_t *pu = &p->data[1][lnum / s->subsampling[1] * p->linesize[1]];
      uint8_t *pv = &p->data[2][lnum / s->subsampling[1] * p->linesize[2]];
 -    for (i = 0; i < w; i++) {
 -        for (j = 0; j < s->subsampling[1]; j++)
 -            for (k = 0; k < s->subsampling[0]; k++)
 -                *dst++ = p->data[0][(lnum + j) * p->linesize[0] +
 -                                    i * s->subsampling[0] + k];
 -        *dst++ = *pu++;
 -        *dst++ = *pv++;
 +    if (s->width % s->subsampling[0] || s->height % s->subsampling[1]) {
 +        for (i = 0; i < w; i++) {
 +            for (j = 0; j < s->subsampling[1]; j++)
 +                for (k = 0; k < s->subsampling[0]; k++)
 +                    *dst++ = p->data[0][FFMIN(lnum + j, s->height-1) * p->linesize[0] +
 +                                        FFMIN(i * s->subsampling[0] + k, s->width-1)];
 +            *dst++ = *pu++;
 +            *dst++ = *pv++;
 +        }
 +    }else{
 +        for (i = 0; i < w; i++) {
 +            for (j = 0; j < s->subsampling[1]; j++)
 +                for (k = 0; k < s->subsampling[0]; k++)
 +                    *dst++ = p->data[0][(lnum + j) * p->linesize[0] +
 +                                        i * s->subsampling[0] + k];
 +            *dst++ = *pu++;
 +            *dst++ = *pv++;
 +        }
      }
  }
  
+ #define ADD_ENTRY(s, tag, type, count, ptr_val)         \
+     do {                                                \
+         ret = add_entry(s, tag, type, count, ptr_val);  \
+         if (ret < 0)                                    \
+             goto fail;                                  \
+     } while(0);
+ #define ADD_ENTRY1(s, tag, type, val)           \
+     do {                                        \
+         ret = add_entry1(s, tag, type, val);    \
+         if (ret < 0)                            \
+             goto fail;                          \
+     } while(0);
  static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                          const AVFrame *pict, int *got_packet)
  {
 +    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
      TiffEncoderContext *s = avctx->priv_data;
      const AVFrame *const p = pict;
      int i;
      uint8_t *ptr;
      uint8_t *offset;
      uint32_t strips;
 -    uint32_t *strip_sizes   = NULL;
 -    uint32_t *strip_offsets = NULL;
      int bytes_per_row;
 -    uint32_t res[2]    = { 72, 1 };     // image resolution (72/1)
 -    uint16_t bpp_tab[] = { 8, 8, 8, 8 };
 +    uint32_t res[2] = { s->dpi, 1 };    // image resolution (72/1)
 +    uint16_t bpp_tab[4];
      int ret = 0;
 -    int is_yuv = 0;
 -    uint8_t *yuv_line = NULL;
 +    int is_yuv = 0, alpha = 0;
      int shift_h, shift_v;
      int packet_size;
 -    const AVPixFmtDescriptor *pfd;
 -
 -    s->avctx = avctx;
  
      s->width          = avctx->width;
      s->height         = avctx->height;
      s->subsampling[0] = 1;
      s->subsampling[1] = 1;
  
 +    avctx->bits_per_coded_sample =
 +    s->bpp          = av_get_bits_per_pixel(desc);
 +    s->bpp_tab_size = desc->nb_components;
 +
      switch (avctx->pix_fmt) {
 -    case AV_PIX_FMT_RGB48LE:
 -    case AV_PIX_FMT_GRAY16LE:
 +    case AV_PIX_FMT_RGBA64LE:
      case AV_PIX_FMT_RGBA:
 +        alpha = 1;
 +    case AV_PIX_FMT_RGB48LE:
      case AV_PIX_FMT_RGB24:
 -    case AV_PIX_FMT_GRAY8:
 -    case AV_PIX_FMT_PAL8:
 -        pfd    = av_pix_fmt_desc_get(avctx->pix_fmt);
 -        s->bpp = av_get_bits_per_pixel(pfd);
 -        if (pfd->flags & AV_PIX_FMT_FLAG_PAL)
 -            s->photometric_interpretation = TIFF_PHOTOMETRIC_PALETTE;
 -        else if (pfd->flags & AV_PIX_FMT_FLAG_RGB)
 -            s->photometric_interpretation = TIFF_PHOTOMETRIC_RGB;
 -        else
 -            s->photometric_interpretation = TIFF_PHOTOMETRIC_BLACK_IS_ZERO;
 -        s->bpp_tab_size = pfd->nb_components;
 -        for (i = 0; i < s->bpp_tab_size; i++)
 -            bpp_tab[i] = s->bpp / s->bpp_tab_size;
 +        s->photometric_interpretation = TIFF_PHOTOMETRIC_RGB;
          break;
 +    case AV_PIX_FMT_GRAY8:
 +        avctx->bits_per_coded_sample = 0x28;
 +    case AV_PIX_FMT_GRAY8A:
 +        alpha = avctx->pix_fmt == AV_PIX_FMT_GRAY8A;
 +    case AV_PIX_FMT_GRAY16LE:
      case AV_PIX_FMT_MONOBLACK:
 -        s->bpp                        = 1;
          s->photometric_interpretation = TIFF_PHOTOMETRIC_BLACK_IS_ZERO;
 -        s->bpp_tab_size               = 0;
 +        break;
 +    case AV_PIX_FMT_PAL8:
 +        s->photometric_interpretation = TIFF_PHOTOMETRIC_PALETTE;
          break;
      case AV_PIX_FMT_MONOWHITE:
 -        s->bpp                        = 1;
          s->photometric_interpretation = TIFF_PHOTOMETRIC_WHITE_IS_ZERO;
 -        s->bpp_tab_size               = 0;
          break;
      case AV_PIX_FMT_YUV420P:
      case AV_PIX_FMT_YUV422P:
 +    case AV_PIX_FMT_YUV440P:
      case AV_PIX_FMT_YUV444P:
      case AV_PIX_FMT_YUV410P:
      case AV_PIX_FMT_YUV411P:
          av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &shift_h, &shift_v);
          s->photometric_interpretation = TIFF_PHOTOMETRIC_YCBCR;
 -        s->bpp                        = 8 + (16 >> (shift_h + shift_v));
          s->subsampling[0]             = 1 << shift_h;
          s->subsampling[1]             = 1 << shift_v;
 -        s->bpp_tab_size               = 3;
          is_yuv                        = 1;
          break;
      default:
          return -1;
      }
  
 +    for (i = 0; i < s->bpp_tab_size; i++)
 +        bpp_tab[i] = desc->comp[i].depth_minus1 + 1;
 +
      if (s->compr == TIFF_DEFLATE       ||
          s->compr == TIFF_ADOBE_DEFLATE ||
          s->compr == TIFF_LZW)
  
      strips = (s->height - 1) / s->rps + 1;
  
 -    packet_size = avctx->height * ((avctx->width * s->bpp + 7) >> 3) * 2 +
 +    bytes_per_row = (((s->width - 1) / s->subsampling[0] + 1) * s->bpp *
 +                     s->subsampling[0] * s->subsampling[1] + 7) >> 3;
 +    packet_size = avctx->height * bytes_per_row * 2 +
                    avctx->height * 4 + FF_MIN_BUFFER_SIZE;
  
 -    if (!pkt->data &&
 -        (ret = av_new_packet(pkt, packet_size)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
 +    if ((ret = ff_alloc_packet2(avctx, pkt, packet_size)) < 0)
          return ret;
 -    }
      ptr          = pkt->data;
      s->buf_start = pkt->data;
      s->buf       = &ptr;
      offset = ptr;
      bytestream_put_le32(&ptr, 0);
  
 -    strip_sizes   = av_mallocz_array(strips, sizeof(*strip_sizes));
 -    strip_offsets = av_mallocz_array(strips, sizeof(*strip_offsets));
 -    if (!strip_sizes || !strip_offsets) {
 +    if (strips > INT_MAX / FFMAX(sizeof(s->strip_sizes[0]), sizeof(s->strip_offsets[0]))) {
 +        ret = AVERROR(ENOMEM);
 +        goto fail;
 +    }
 +    av_fast_padded_mallocz(&s->strip_sizes  , &s->strip_sizes_size  , sizeof(s->strip_sizes  [0]) * strips);
 +    av_fast_padded_mallocz(&s->strip_offsets, &s->strip_offsets_size, sizeof(s->strip_offsets[0]) * strips);
 +
 +    if (!s->strip_sizes || !s->strip_offsets) {
          ret = AVERROR(ENOMEM);
          goto fail;
      }
  
 -    bytes_per_row = (((s->width - 1) / s->subsampling[0] + 1) * s->bpp *
 -                     s->subsampling[0] * s->subsampling[1] + 7) >> 3;
      if (is_yuv) {
 -        yuv_line = av_malloc(bytes_per_row);
 -        if (!yuv_line) {
 +        av_fast_padded_malloc(&s->yuv_line, &s->yuv_line_size, bytes_per_row);
 +        if (s->yuv_line == NULL) {
              av_log(s->avctx, AV_LOG_ERROR, "Not enough memory\n");
              ret = AVERROR(ENOMEM);
              goto fail;
              ret = AVERROR(ENOMEM);
              goto fail;
          }
 -        strip_offsets[0] = ptr - pkt->data;
 +        s->strip_offsets[0] = ptr - pkt->data;
          zn               = 0;
          for (j = 0; j < s->rps; j++) {
              if (is_yuv) {
 -                pack_yuv(s, p, yuv_line, j);
 -                memcpy(zbuf + zn, yuv_line, bytes_per_row);
 +                pack_yuv(s, p, s->yuv_line, j);
 +                memcpy(zbuf + zn, s->yuv_line, bytes_per_row);
                  j += s->subsampling[1] - 1;
              } else
                  memcpy(zbuf + j * bytes_per_row,
              goto fail;
          }
          ptr           += ret;
 -        strip_sizes[0] = ptr - pkt->data - strip_offsets[0];
 +        s->strip_sizes[0] = ptr - pkt->data - s->strip_offsets[0];
      } else
  #endif
 +    {
      if (s->compr == TIFF_LZW) {
          s->lzws = av_malloc(ff_lzw_encode_state_size);
          if (!s->lzws) {
          }
      }
      for (i = 0; i < s->height; i++) {
 -        if (strip_sizes[i / s->rps] == 0) {
 +        if (s->strip_sizes[i / s->rps] == 0) {
              if (s->compr == TIFF_LZW) {
                  ff_lzw_encode_init(s->lzws, ptr,
                                     s->buf_size - (*s->buf - s->buf_start),
                                     12, FF_LZW_TIFF, put_bits);
              }
 -            strip_offsets[i / s->rps] = ptr - pkt->data;
 +            s->strip_offsets[i / s->rps] = ptr - pkt->data;
          }
          if (is_yuv) {
 -            pack_yuv(s, p, yuv_line, i);
 -            ret = encode_strip(s, yuv_line, ptr, bytes_per_row, s->compr);
 +            pack_yuv(s, p, s->yuv_line, i);
 +            ret = encode_strip(s, s->yuv_line, ptr, bytes_per_row, s->compr);
              i  += s->subsampling[1] - 1;
          } else
              ret = encode_strip(s, p->data[0] + i * p->linesize[0],
              av_log(s->avctx, AV_LOG_ERROR, "Encode strip failed\n");
              goto fail;
          }
 -        strip_sizes[i / s->rps] += ret;
 +        s->strip_sizes[i / s->rps] += ret;
          ptr                     += ret;
          if (s->compr == TIFF_LZW &&
              (i == s->height - 1 || i % s->rps == s->rps - 1)) {
              ret = ff_lzw_encode_flush(s->lzws, flush_put_bits);
 -            strip_sizes[(i / s->rps)] += ret;
 -            ptr                       += ret;
 +            s->strip_sizes[(i / s->rps)] += ret;
 +            ptr                          += ret;
          }
      }
      if (s->compr == TIFF_LZW)
 -        av_free(s->lzws);
 +        av_freep(&s->lzws);
 +    }
  
      s->num_entries = 0;
  
-     add_entry1(s, TIFF_SUBFILE, TIFF_LONG, 0);
-     add_entry1(s, TIFF_WIDTH,   TIFF_LONG, s->width);
-     add_entry1(s, TIFF_HEIGHT,  TIFF_LONG, s->height);
+     ADD_ENTRY1(s, TIFF_SUBFILE, TIFF_LONG, 0);
+     ADD_ENTRY1(s, TIFF_WIDTH,   TIFF_LONG, s->width);
+     ADD_ENTRY1(s, TIFF_HEIGHT,  TIFF_LONG, s->height);
  
      if (s->bpp_tab_size)
-         add_entry(s, TIFF_BPP, TIFF_SHORT, s->bpp_tab_size, bpp_tab);
+         ADD_ENTRY(s, TIFF_BPP, TIFF_SHORT, s->bpp_tab_size, bpp_tab);
  
-     add_entry1(s, TIFF_COMPR,       TIFF_SHORT, s->compr);
-     add_entry1(s, TIFF_PHOTOMETRIC, TIFF_SHORT, s->photometric_interpretation);
-     add_entry(s,  TIFF_STRIP_OFFS,  TIFF_LONG,  strips, s->strip_offsets);
+     ADD_ENTRY1(s, TIFF_COMPR,       TIFF_SHORT, s->compr);
+     ADD_ENTRY1(s, TIFF_PHOTOMETRIC, TIFF_SHORT, s->photometric_interpretation);
 -    ADD_ENTRY(s,  TIFF_STRIP_OFFS,  TIFF_LONG,  strips, strip_offsets);
++    ADD_ENTRY(s,  TIFF_STRIP_OFFS,  TIFF_LONG,  strips, s->strip_offsets);
  
      if (s->bpp_tab_size)
-         add_entry1(s, TIFF_SAMPLES_PER_PIXEL, TIFF_SHORT, s->bpp_tab_size);
+         ADD_ENTRY1(s, TIFF_SAMPLES_PER_PIXEL, TIFF_SHORT, s->bpp_tab_size);
  
-     add_entry1(s, TIFF_ROWSPERSTRIP, TIFF_LONG,     s->rps);
-     add_entry(s,  TIFF_STRIP_SIZE,   TIFF_LONG,     strips, s->strip_sizes);
-     add_entry(s,  TIFF_XRES,         TIFF_RATIONAL, 1,      res);
+     ADD_ENTRY1(s, TIFF_ROWSPERSTRIP, TIFF_LONG,     s->rps);
 -    ADD_ENTRY(s,  TIFF_STRIP_SIZE,   TIFF_LONG,     strips, strip_sizes);
++    ADD_ENTRY(s,  TIFF_STRIP_SIZE,   TIFF_LONG,     strips, s->strip_sizes);
+     ADD_ENTRY(s,  TIFF_XRES,         TIFF_RATIONAL, 1,      res);
 +    if (avctx->sample_aspect_ratio.num > 0 &&
 +        avctx->sample_aspect_ratio.den > 0) {
 +        AVRational y = av_mul_q(av_make_q(s->dpi, 1),
 +                                avctx->sample_aspect_ratio);
 +        res[0] = y.num;
 +        res[1] = y.den;
 +    }
-     add_entry(s,  TIFF_YRES,         TIFF_RATIONAL, 1,      res);
-     add_entry1(s, TIFF_RES_UNIT,     TIFF_SHORT,    2);
+     ADD_ENTRY(s,  TIFF_YRES,         TIFF_RATIONAL, 1,      res);
+     ADD_ENTRY1(s, TIFF_RES_UNIT,     TIFF_SHORT,    2);
  
      if (!(avctx->flags & CODEC_FLAG_BITEXACT))
-         add_entry(s, TIFF_SOFTWARE_NAME, TIFF_STRING,
+         ADD_ENTRY(s, TIFF_SOFTWARE_NAME, TIFF_STRING,
                    strlen(LIBAVCODEC_IDENT) + 1, LIBAVCODEC_IDENT);
  
      if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
              pal[i + 256] = ((rgb >>  8) & 0xff) * 257;
              pal[i + 512] =  (rgb        & 0xff) * 257;
          }
-         add_entry(s, TIFF_PAL, TIFF_SHORT, 256 * 3, pal);
+         ADD_ENTRY(s, TIFF_PAL, TIFF_SHORT, 256 * 3, pal);
      }
 +    if (alpha)
 +        add_entry1(s,TIFF_EXTRASAMPLES,      TIFF_SHORT,            2);
      if (is_yuv) {
          /** according to CCIR Recommendation 601.1 */
          uint32_t refbw[12] = { 15, 1, 235, 1, 128, 1, 240, 1, 128, 1, 240, 1 };
-         add_entry(s, TIFF_YCBCR_SUBSAMPLING, TIFF_SHORT,    2, s->subsampling);
+         ADD_ENTRY(s, TIFF_YCBCR_SUBSAMPLING, TIFF_SHORT,    2, s->subsampling);
 +        if (avctx->chroma_sample_location == AVCHROMA_LOC_TOPLEFT)
 +            add_entry1(s, TIFF_YCBCR_POSITIONING, TIFF_SHORT, 2);
-         add_entry(s, TIFF_REFERENCE_BW,      TIFF_RATIONAL, 6, refbw);
+         ADD_ENTRY(s, TIFF_REFERENCE_BW,      TIFF_RATIONAL, 6, refbw);
      }
      // write offset to dir
      bytestream_put_le32(&offset, ptr - pkt->data);
      *got_packet = 1;
  
  fail:
 -    av_free(strip_sizes);
 -    av_free(strip_offsets);
 -    av_free(yuv_line);
 -    return ret;
 +    return ret < 0 ? ret : 0;
  }
  
  static av_cold int encode_init(AVCodecContext *avctx)
  {
 +    TiffEncoderContext *s = avctx->priv_data;
 +
      avctx->coded_frame = av_frame_alloc();
      if (!avctx->coded_frame)
          return AVERROR(ENOMEM);
  
      avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
      avctx->coded_frame->key_frame = 1;
 +    s->avctx = avctx;
  
      return 0;
  }
  
  static av_cold int encode_close(AVCodecContext *avctx)
  {
 +    TiffEncoderContext *s = avctx->priv_data;
 +
      av_frame_free(&avctx->coded_frame);
 +    av_freep(&s->strip_sizes);
 +    av_freep(&s->strip_offsets);
 +    av_freep(&s->yuv_line);
 +
      return 0;
  }
  
  #define OFFSET(x) offsetof(TiffEncoderContext, x)
  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
  static const AVOption options[] = {
 +    {"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},
      { "compression_algo", NULL, OFFSET(compr), AV_OPT_TYPE_INT,   { .i64 = TIFF_PACKBITS }, TIFF_RAW, TIFF_DEFLATE, VE, "compression_algo" },
      { "packbits",         NULL, 0,             AV_OPT_TYPE_CONST, { .i64 = TIFF_PACKBITS }, 0,        0,            VE, "compression_algo" },
      { "raw",              NULL, 0,             AV_OPT_TYPE_CONST, { .i64 = TIFF_RAW      }, 0,        0,            VE, "compression_algo" },
@@@ -551,15 -530,14 +568,15 @@@ AVCodec ff_tiff_encoder = 
      .priv_data_size = sizeof(TiffEncoderContext),
      .init           = encode_init,
      .close          = encode_close,
 +    .capabilities   = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
      .encode2        = encode_frame,
      .pix_fmts       = (const enum AVPixelFormat[]) {
 -        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB48LE, AV_PIX_FMT_PAL8,
 -        AV_PIX_FMT_RGBA,
 -        AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16LE,
 +        AV_PIX_FMT_RGB24, AV_PIX_FMT_PAL8, AV_PIX_FMT_GRAY8,
 +        AV_PIX_FMT_GRAY8A, AV_PIX_FMT_GRAY16LE,
          AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_MONOWHITE,
 -        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P,
 -        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P,
 +        AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P,
 +        AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_RGB48LE,
 +        AV_PIX_FMT_RGBA, AV_PIX_FMT_RGBA64LE,
          AV_PIX_FMT_NONE
      },
      .priv_class     = &tiffenc_class,