git.sesse.net Git - ffmpeg/blob - libavcodec/tiff.c

   1 /*
   2  * Copyright (c) 2006 Konstantin Shishkov
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 /**
  22  * @file
  23  * TIFF image decoder
  24  * @author Konstantin Shishkov
  25  */
  26
  27 #include "config.h"
  28 #if CONFIG_ZLIB
  29 #include <zlib.h>
  30 #endif
  31
  32 #include "libavutil/attributes.h"
  33 #include "libavutil/avstring.h"
  34 #include "libavutil/intreadwrite.h"
  35 #include "libavutil/imgutils.h"
  36 #include "avcodec.h"
  37 #include "bytestream.h"
  38 #include "faxcompr.h"
  39 #include "internal.h"
  40 #include "lzw.h"
  41 #include "mathops.h"
  42 #include "tiff.h"
  43 #include "tiff_data.h"
  44 #include "thread.h"
  45
  46 typedef struct TiffContext {
  47     AVCodecContext *avctx;
  48     GetByteContext gb;
  49
  50     int width, height;
  51     unsigned int bpp, bppcount;
  52     uint32_t palette[256];
  53     int palette_is_set;
  54     int le;
  55     enum TiffCompr compr;
  56     enum TiffPhotometric photometric;
  57     int planar;
  58     int fax_opts;
  59     int predictor;
  60     int fill_order;
  61     uint32_t res[4];
  62
  63     int strips, rps, sstype;
  64     int sot;
  65     int stripsizesoff, stripsize, stripoff, strippos;
  66     LZWState *lzw;
  67
  68     uint8_t *deinvert_buf;
  69     int deinvert_buf_size;
  70
  71     int geotag_count;
  72     TiffGeoTag *geotags;
  73 } TiffContext;
  74
  75 static void free_geotags(TiffContext *const s)
  76 {
  77     int i;
  78     for (i = 0; i < s->geotag_count; i++) {
  79         if (s->geotags[i].val)
  80             av_freep(&s->geotags[i].val);
  81     }
  82     av_freep(&s->geotags);
  83     s->geotag_count = 0;
  84 }
  85
  86 #define RET_GEOKEY(TYPE, array, element)\
  87     if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\
  88         key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_name_type_map))\
  89         return ff_tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].element;
  90
  91 static const char *get_geokey_name(int key)
  92 {
  93     RET_GEOKEY(VERT, vert, name);
  94     RET_GEOKEY(PROJ, proj, name);
  95     RET_GEOKEY(GEOG, geog, name);
  96     RET_GEOKEY(CONF, conf, name);
  97
  98     return NULL;
  99 }
 100
 101 static int get_geokey_type(int key)
 102 {
 103     RET_GEOKEY(VERT, vert, type);
 104     RET_GEOKEY(PROJ, proj, type);
 105     RET_GEOKEY(GEOG, geog, type);
 106     RET_GEOKEY(CONF, conf, type);
 107
 108     return AVERROR_INVALIDDATA;
 109 }
 110
 111 static int cmp_id_key(const void *id, const void *k)
 112 {
 113     return *(const int*)id - ((const TiffGeoTagKeyName*)k)->key;
 114 }
 115
 116 static const char *search_keyval(const TiffGeoTagKeyName *keys, int n, int id)
 117 {
 118     TiffGeoTagKeyName *r = bsearch(&id, keys, n, sizeof(keys[0]), cmp_id_key);
 119     if(r)
 120         return r->name;
 121
 122     return NULL;
 123 }
 124
 125 static char *get_geokey_val(int key, int val)
 126 {
 127     char *ap;
 128
 129     if (val == TIFF_GEO_KEY_UNDEFINED)
 130         return av_strdup("undefined");
 131     if (val == TIFF_GEO_KEY_USER_DEFINED)
 132         return av_strdup("User-Defined");
 133
 134 #define RET_GEOKEY_VAL(TYPE, array)\
 135     if (val >= TIFF_##TYPE##_OFFSET &&\
 136         val - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_codes))\
 137         return av_strdup(ff_tiff_##array##_codes[val - TIFF_##TYPE##_OFFSET]);
 138
 139     switch (key) {
 140     case TIFF_GT_MODEL_TYPE_GEOKEY:
 141         RET_GEOKEY_VAL(GT_MODEL_TYPE, gt_model_type);
 142         break;
 143     case TIFF_GT_RASTER_TYPE_GEOKEY:
 144         RET_GEOKEY_VAL(GT_RASTER_TYPE, gt_raster_type);
 145         break;
 146     case TIFF_GEOG_LINEAR_UNITS_GEOKEY:
 147     case TIFF_PROJ_LINEAR_UNITS_GEOKEY:
 148     case TIFF_VERTICAL_UNITS_GEOKEY:
 149         RET_GEOKEY_VAL(LINEAR_UNIT, linear_unit);
 150         break;
 151     case TIFF_GEOG_ANGULAR_UNITS_GEOKEY:
 152     case TIFF_GEOG_AZIMUTH_UNITS_GEOKEY:
 153         RET_GEOKEY_VAL(ANGULAR_UNIT, angular_unit);
 154         break;
 155     case TIFF_GEOGRAPHIC_TYPE_GEOKEY:
 156         RET_GEOKEY_VAL(GCS_TYPE, gcs_type);
 157         RET_GEOKEY_VAL(GCSE_TYPE, gcse_type);
 158         break;
 159     case TIFF_GEOG_GEODETIC_DATUM_GEOKEY:
 160         RET_GEOKEY_VAL(GEODETIC_DATUM, geodetic_datum);
 161         RET_GEOKEY_VAL(GEODETIC_DATUM_E, geodetic_datum_e);
 162         break;
 163     case TIFF_GEOG_ELLIPSOID_GEOKEY:
 164         RET_GEOKEY_VAL(ELLIPSOID, ellipsoid);
 165         break;
 166     case TIFF_GEOG_PRIME_MERIDIAN_GEOKEY:
 167         RET_GEOKEY_VAL(PRIME_MERIDIAN, prime_meridian);
 168         break;
 169     case TIFF_PROJECTED_CS_TYPE_GEOKEY:
 170         ap = av_strdup(search_keyval(ff_tiff_proj_cs_type_codes, FF_ARRAY_ELEMS(ff_tiff_proj_cs_type_codes), val));
 171         if(ap) return ap;
 172         break;
 173     case TIFF_PROJECTION_GEOKEY:
 174         ap = av_strdup(search_keyval(ff_tiff_projection_codes, FF_ARRAY_ELEMS(ff_tiff_projection_codes), val));
 175         if(ap) return ap;
 176         break;
 177     case TIFF_PROJ_COORD_TRANS_GEOKEY:
 178         RET_GEOKEY_VAL(COORD_TRANS, coord_trans);
 179         break;
 180     case TIFF_VERTICAL_CS_TYPE_GEOKEY:
 181         RET_GEOKEY_VAL(VERT_CS, vert_cs);
 182         RET_GEOKEY_VAL(ORTHO_VERT_CS, ortho_vert_cs);
 183         break;
 184
 185     }
 186
 187     ap = av_malloc(14);
 188     if (ap)
 189         snprintf(ap, 14, "Unknown-%d", val);
 190     return ap;
 191 }
 192
 193 static char *doubles2str(double *dp, int count, const char *sep)
 194 {
 195     int i;
 196     char *ap, *ap0;
 197     uint64_t component_len;
 198     if (!sep) sep = ", ";
 199     component_len = 24LL + strlen(sep);
 200     if (count >= (INT_MAX - 1)/component_len)
 201         return NULL;
 202     ap = av_malloc(component_len * count + 1);
 203     if (!ap)
 204         return NULL;
 205     ap0   = ap;
 206     ap[0] = '\0';
 207     for (i = 0; i < count; i++) {
 208         unsigned l = snprintf(ap, component_len, "%.15g%s", dp[i], sep);
 209         if(l >= component_len) {
 210             av_free(ap0);
 211             return NULL;
 212         }
 213         ap += l;
 214     }
 215     ap0[strlen(ap0) - strlen(sep)] = '\0';
 216     return ap0;
 217 }
 218
 219 static int add_metadata(int count, int type,
 220                         const char *name, const char *sep, TiffContext *s, AVFrame *frame)
 221 {
 222     switch(type) {
 223     case TIFF_DOUBLE: return ff_tadd_doubles_metadata(count, name, sep, &s->gb, s->le, avpriv_frame_get_metadatap(frame));
 224     case TIFF_SHORT : return ff_tadd_shorts_metadata(count, name, sep, &s->gb, s->le, avpriv_frame_get_metadatap(frame));
 225     case TIFF_STRING: return ff_tadd_string_metadata(count, name, &s->gb, s->le, avpriv_frame_get_metadatap(frame));
 226     default         : return AVERROR_INVALIDDATA;
 227     };
 228 }
 229
 230 static void av_always_inline horizontal_fill(unsigned int bpp, uint8_t* dst,
 231                                              int usePtr, const uint8_t *src,
 232                                              uint8_t c, int width, int offset)
 233 {
 234     switch (bpp) {
 235     case 1:
 236         while (--width >= 0) {
 237             dst[(width+offset)*8+7] = (usePtr ? src[width] : c)      & 0x1;
 238             dst[(width+offset)*8+6] = (usePtr ? src[width] : c) >> 1 & 0x1;
 239             dst[(width+offset)*8+5] = (usePtr ? src[width] : c) >> 2 & 0x1;
 240             dst[(width+offset)*8+4] = (usePtr ? src[width] : c) >> 3 & 0x1;
 241             dst[(width+offset)*8+3] = (usePtr ? src[width] : c) >> 4 & 0x1;
 242             dst[(width+offset)*8+2] = (usePtr ? src[width] : c) >> 5 & 0x1;
 243             dst[(width+offset)*8+1] = (usePtr ? src[width] : c) >> 6 & 0x1;
 244             dst[(width+offset)*8+0] = (usePtr ? src[width] : c) >> 7;
 245         }
 246         break;
 247     case 2:
 248         while (--width >= 0) {
 249             dst[(width+offset)*4+3] = (usePtr ? src[width] : c) & 0x3;
 250             dst[(width+offset)*4+2] = (usePtr ? src[width] : c) >> 2 & 0x3;
 251             dst[(width+offset)*4+1] = (usePtr ? src[width] : c) >> 4 & 0x3;
 252             dst[(width+offset)*4+0] = (usePtr ? src[width] : c) >> 6;
 253         }
 254         break;
 255     case 4:
 256         while (--width >= 0) {
 257             dst[(width+offset)*2+1] = (usePtr ? src[width] : c) & 0xF;
 258             dst[(width+offset)*2+0] = (usePtr ? src[width] : c) >> 4;
 259         }
 260         break;
 261     default:
 262         if (usePtr) {
 263             memcpy(dst + offset, src, width);
 264         } else {
 265             memset(dst + offset, c, width);
 266         }
 267     }
 268 }
 269
 270 static int deinvert_buffer(TiffContext *s, const uint8_t *src, int size)
 271 {
 272     int i;
 273
 274     av_fast_padded_malloc(&s->deinvert_buf, &s->deinvert_buf_size, size);
 275     if (!s->deinvert_buf)
 276         return AVERROR(ENOMEM);
 277     for (i = 0; i < size; i++)
 278         s->deinvert_buf[i] = ff_reverse[src[i]];
 279
 280     return 0;
 281 }
 282
 283 #if CONFIG_ZLIB
 284 static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src,
 285                            int size)
 286 {
 287     z_stream zstream = { 0 };
 288     int zret;
 289
 290     zstream.next_in   = (uint8_t *)src;
 291     zstream.avail_in  = size;
 292     zstream.next_out  = dst;
 293     zstream.avail_out = *len;
 294     zret              = inflateInit(&zstream);
 295     if (zret != Z_OK) {
 296         av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
 297         return zret;
 298     }
 299     zret = inflate(&zstream, Z_SYNC_FLUSH);
 300     inflateEnd(&zstream);
 301     *len = zstream.total_out;
 302     return zret == Z_STREAM_END ? Z_OK : zret;
 303 }
 304
 305 static int tiff_unpack_zlib(TiffContext *s, uint8_t *dst, int stride,
 306                             const uint8_t *src, int size,
 307                             int width, int lines)
 308 {
 309     uint8_t *zbuf;
 310     unsigned long outlen;
 311     int ret, line;
 312     outlen = width * lines;
 313     zbuf   = av_malloc(outlen);
 314     if (!zbuf)
 315         return AVERROR(ENOMEM);
 316     if (s->fill_order) {
 317         if ((ret = deinvert_buffer(s, src, size)) < 0) {
 318             av_free(zbuf);
 319             return ret;
 320         }
 321         src = s->deinvert_buf;
 322     }
 323     ret = tiff_uncompress(zbuf, &outlen, src, size);
 324     if (ret != Z_OK) {
 325         av_log(s->avctx, AV_LOG_ERROR,
 326                "Uncompressing failed (%lu of %lu) with error %d\n", outlen,
 327                (unsigned long)width * lines, ret);
 328         av_free(zbuf);
 329         return AVERROR_UNKNOWN;
 330     }
 331     src = zbuf;
 332     for (line = 0; line < lines; line++) {
 333         if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8) {
 334             horizontal_fill(s->bpp, dst, 1, src, 0, width, 0);
 335         } else {
 336             memcpy(dst, src, width);
 337         }
 338         dst += stride;
 339         src += width;
 340     }
 341     av_free(zbuf);
 342     return 0;
 343 }
 344 #endif
 345
 346
 347 static int tiff_unpack_fax(TiffContext *s, uint8_t *dst, int stride,
 348                            const uint8_t *src, int size, int width, int lines)
 349 {
 350     int i, ret = 0;
 351     int line;
 352     uint8_t *src2 = av_malloc((unsigned)size +
 353                               FF_INPUT_BUFFER_PADDING_SIZE);
 354
 355     if (!src2) {
 356         av_log(s->avctx, AV_LOG_ERROR,
 357                "Error allocating temporary buffer\n");
 358         return AVERROR(ENOMEM);
 359     }
 360     if (s->fax_opts & 2) {
 361         avpriv_request_sample(s->avctx, "Uncompressed fax mode");
 362         av_free(src2);
 363         return AVERROR_PATCHWELCOME;
 364     }
 365     if (!s->fill_order) {
 366         memcpy(src2, src, size);
 367     } else {
 368         for (i = 0; i < size; i++)
 369             src2[i] = ff_reverse[src[i]];
 370     }
 371     memset(src2 + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 372     ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride,
 373                           s->compr, s->fax_opts);
 374     if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
 375         for (line = 0; line < lines; line++) {
 376             horizontal_fill(s->bpp, dst, 1, dst, 0, width, 0);
 377             dst += stride;
 378         }
 379     av_free(src2);
 380     return ret;
 381 }
 382
 383 static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
 384                              const uint8_t *src, int size, int lines)
 385 {
 386     PutByteContext pb;
 387     int c, line, pixels, code, ret;
 388     const uint8_t *ssrc = src;
 389     int width = ((s->width * s->bpp) + 7) >> 3;
 390
 391     if (s->planar)
 392         width /= s->bppcount;
 393
 394     if (size <= 0)
 395         return AVERROR_INVALIDDATA;
 396
 397     if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE) {
 398 #if CONFIG_ZLIB
 399         return tiff_unpack_zlib(s, dst, stride, src, size, width, lines);
 400 #else
 401         av_log(s->avctx, AV_LOG_ERROR,
 402                "zlib support not enabled, "
 403                "deflate compression not supported\n");
 404         return AVERROR(ENOSYS);
 405 #endif
 406     }
 407     if (s->compr == TIFF_LZW) {
 408         if (s->fill_order) {
 409             if ((ret = deinvert_buffer(s, src, size)) < 0)
 410                 return ret;
 411             ssrc = src = s->deinvert_buf;
 412         }
 413         if (size > 1 && !src[0] && (src[1]&1)) {
 414             av_log(s->avctx, AV_LOG_ERROR, "Old style LZW is unsupported\n");
 415         }
 416         if ((ret = ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF)) < 0) {
 417             av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n");
 418             return ret;
 419         }
 420         for (line = 0; line < lines; line++) {
 421             pixels = ff_lzw_decode(s->lzw, dst, width);
 422             if (pixels < width) {
 423                 av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n",
 424                        pixels, width);
 425                 return AVERROR_INVALIDDATA;
 426             }
 427             if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8)
 428                 horizontal_fill(s->bpp, dst, 1, dst, 0, width, 0);
 429             dst += stride;
 430         }
 431         return 0;
 432     }
 433     if (s->compr == TIFF_CCITT_RLE ||
 434         s->compr == TIFF_G3        ||
 435         s->compr == TIFF_G4) {
 436         return tiff_unpack_fax(s, dst, stride, src, size, width, lines);
 437     }
 438
 439     bytestream2_init(&s->gb, src, size);
 440     bytestream2_init_writer(&pb, dst, stride * lines);
 441
 442     for (line = 0; line < lines; line++) {
 443         if (src - ssrc > size) {
 444             av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n");
 445             return AVERROR_INVALIDDATA;
 446         }
 447
 448         if (bytestream2_get_bytes_left(&s->gb) == 0 || bytestream2_get_eof(&pb))
 449             break;
 450         bytestream2_seek_p(&pb, stride * line, SEEK_SET);
 451         switch (s->compr) {
 452         case TIFF_RAW:
 453             if (ssrc + size - src < width)
 454                 return AVERROR_INVALIDDATA;
 455
 456             if (!s->fill_order) {
 457                 horizontal_fill(s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8),
 458                                 dst, 1, src, 0, width, 0);
 459             } else {
 460                 int i;
 461                 for (i = 0; i < width; i++)
 462                     dst[i] = ff_reverse[src[i]];
 463             }
 464             src += width;
 465             break;
 466         case TIFF_PACKBITS:
 467             for (pixels = 0; pixels < width;) {
 468                 if (ssrc + size - src < 2) {
 469                     av_log(s->avctx, AV_LOG_ERROR, "Read went out of bounds\n");
 470                     return AVERROR_INVALIDDATA;
 471                 }
 472                 code = s->fill_order ? (int8_t) ff_reverse[*src++]: (int8_t) *src++;
 473                 if (code >= 0) {
 474                     code++;
 475                     if (pixels + code > width ||
 476                         ssrc + size - src < code) {
 477                         av_log(s->avctx, AV_LOG_ERROR,
 478                                "Copy went out of bounds\n");
 479                         return AVERROR_INVALIDDATA;
 480                     }
 481                     horizontal_fill(s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8),
 482                                     dst, 1, src, 0, code, pixels);
 483                     src    += code;
 484                     pixels += code;
 485                 } else if (code != -128) { // -127..-1
 486                     code = (-code) + 1;
 487                     if (pixels + code > width) {
 488                         av_log(s->avctx, AV_LOG_ERROR,
 489                                "Run went out of bounds\n");
 490                         return AVERROR_INVALIDDATA;
 491                     }
 492                     c = *src++;
 493                     horizontal_fill(s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8),
 494                                     dst, 0, NULL, c, code, pixels);
 495                     pixels += code;
 496                 }
 497             }
 498             if (s->fill_order) {
 499                 int i;
 500                 for (i = 0; i < width; i++)
 501                     dst[i] = ff_reverse[dst[i]];
 502             }
 503             break;
 504         }
 505         dst += stride;
 506     }
 507     return 0;
 508 }
 509
 510 static int init_image(TiffContext *s, ThreadFrame *frame)
 511 {
 512     int i, ret;
 513     uint32_t *pal;
 514
 515     switch (s->planar * 1000 + s->bpp * 10 + s->bppcount) {
 516     case 11:
 517         if (!s->palette_is_set) {
 518             s->avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
 519             break;
 520         }
 521     case 21:
 522     case 41:
 523     case 81:
 524         s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
 525         break;
 526     case 243:
 527         s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
 528         break;
 529     case 161:
 530         s->avctx->pix_fmt = s->le ? AV_PIX_FMT_GRAY16LE : AV_PIX_FMT_GRAY16BE;
 531         break;
 532     case 162:
 533         s->avctx->pix_fmt = AV_PIX_FMT_GRAY8A;
 534         break;
 535     case 324:
 536         s->avctx->pix_fmt = AV_PIX_FMT_RGBA;
 537         break;
 538     case 483:
 539         s->avctx->pix_fmt = s->le ? AV_PIX_FMT_RGB48LE  : AV_PIX_FMT_RGB48BE;
 540         break;
 541     case 644:
 542         s->avctx->pix_fmt = s->le ? AV_PIX_FMT_RGBA64LE  : AV_PIX_FMT_RGBA64BE;
 543         break;
 544     case 1243:
 545         s->avctx->pix_fmt = AV_PIX_FMT_GBRP;
 546         break;
 547     case 1324:
 548         s->avctx->pix_fmt = AV_PIX_FMT_GBRAP;
 549         break;
 550     case 1483:
 551         s->avctx->pix_fmt = s->le ? AV_PIX_FMT_GBRP16LE : AV_PIX_FMT_GBRP16BE;
 552         break;
 553     case 1644:
 554         s->avctx->pix_fmt = s->le ? AV_PIX_FMT_GBRAP16LE : AV_PIX_FMT_GBRAP16BE;
 555         break;
 556     default:
 557         av_log(s->avctx, AV_LOG_ERROR,
 558                "This format is not supported (bpp=%d, bppcount=%d)\n",
 559                s->bpp, s->bppcount);
 560         return AVERROR_INVALIDDATA;
 561     }
 562     if (s->width != s->avctx->width || s->height != s->avctx->height) {
 563         ret = ff_set_dimensions(s->avctx, s->width, s->height);
 564         if (ret < 0)
 565             return ret;
 566     }
 567     if ((ret = ff_thread_get_buffer(s->avctx, frame, 0)) < 0)
 568         return ret;
 569     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8) {
 570         if (s->palette_is_set) {
 571             memcpy(frame->f->data[1], s->palette, sizeof(s->palette));
 572         } else {
 573             /* make default grayscale pal */
 574             pal = (uint32_t *) frame->f->data[1];
 575             for (i = 0; i < 1<<s->bpp; i++)
 576                 pal[i] = 0xFFU << 24 | i * 255 / ((1<<s->bpp) - 1) * 0x010101;
 577         }
 578     }
 579     return 0;
 580 }
 581
 582 static void set_sar(TiffContext *s, unsigned tag, unsigned num, unsigned den)
 583 {
 584     int offset = tag == TIFF_YRES ? 2 : 0;
 585     s->res[offset++] = num;
 586     s->res[offset]   = den;
 587     if (s->res[0] && s->res[1] && s->res[2] && s->res[3])
 588         av_reduce(&s->avctx->sample_aspect_ratio.num, &s->avctx->sample_aspect_ratio.den,
 589                   s->res[2] * (uint64_t)s->res[1], s->res[0] * (uint64_t)s->res[3], INT32_MAX);
 590 }
 591
 592 static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
 593 {
 594     unsigned tag, type, count, off, value = 0, value2 = 0;
 595     int i, start;
 596     int pos;
 597     int ret;
 598     double *dp;
 599
 600     ret = ff_tread_tag(&s->gb, s->le, &tag, &type, &count, &start);
 601     if (ret < 0) {
 602         goto end;
 603     }
 604
 605     off = bytestream2_tell(&s->gb);
 606     if (count == 1) {
 607         switch (type) {
 608         case TIFF_BYTE:
 609         case TIFF_SHORT:
 610         case TIFF_LONG:
 611             value = ff_tget(&s->gb, type, s->le);
 612             break;
 613         case TIFF_RATIONAL:
 614             value  = ff_tget(&s->gb, TIFF_LONG, s->le);
 615             value2 = ff_tget(&s->gb, TIFF_LONG, s->le);
 616             break;
 617         case TIFF_STRING:
 618             if (count <= 4) {
 619                 break;
 620             }
 621         default:
 622             value = UINT_MAX;
 623         }
 624     }
 625
 626     switch (tag) {
 627     case TIFF_WIDTH:
 628         s->width = value;
 629         break;
 630     case TIFF_HEIGHT:
 631         s->height = value;
 632         break;
 633     case TIFF_BPP:
 634         s->bppcount = count;
 635         if (count > 4) {
 636             av_log(s->avctx, AV_LOG_ERROR,
 637                    "This format is not supported (bpp=%d, %d components)\n",
 638                    s->bpp, count);
 639             return AVERROR_INVALIDDATA;
 640         }
 641         if (count == 1)
 642             s->bpp = value;
 643         else {
 644             switch (type) {
 645             case TIFF_BYTE:
 646             case TIFF_SHORT:
 647             case TIFF_LONG:
 648                 s->bpp = 0;
 649                 if (bytestream2_get_bytes_left(&s->gb) < type_sizes[type] * count)
 650                     return AVERROR_INVALIDDATA;
 651                 for (i = 0; i < count; i++)
 652                     s->bpp += ff_tget(&s->gb, type, s->le);
 653                 break;
 654             default:
 655                 s->bpp = -1;
 656             }
 657         }
 658         break;
 659     case TIFF_SAMPLES_PER_PIXEL:
 660         if (count != 1) {
 661             av_log(s->avctx, AV_LOG_ERROR,
 662                    "Samples per pixel requires a single value, many provided\n");
 663             return AVERROR_INVALIDDATA;
 664         }
 665         if (value > 4U) {
 666             av_log(s->avctx, AV_LOG_ERROR,
 667                    "Samples per pixel %d is too large\n", value);
 668             return AVERROR_INVALIDDATA;
 669         }
 670         if (s->bppcount == 1)
 671             s->bpp *= value;
 672         s->bppcount = value;
 673         break;
 674     case TIFF_COMPR:
 675         s->compr     = value;
 676         s->predictor = 0;
 677         switch (s->compr) {
 678         case TIFF_RAW:
 679         case TIFF_PACKBITS:
 680         case TIFF_LZW:
 681         case TIFF_CCITT_RLE:
 682             break;
 683         case TIFF_G3:
 684         case TIFF_G4:
 685             s->fax_opts = 0;
 686             break;
 687         case TIFF_DEFLATE:
 688         case TIFF_ADOBE_DEFLATE:
 689 #if CONFIG_ZLIB
 690             break;
 691 #else
 692             av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n");
 693             return AVERROR(ENOSYS);
 694 #endif
 695         case TIFF_JPEG:
 696         case TIFF_NEWJPEG:
 697             avpriv_report_missing_feature(s->avctx, "JPEG compression");
 698             return AVERROR_PATCHWELCOME;
 699         default:
 700             av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n",
 701                    s->compr);
 702             return AVERROR_INVALIDDATA;
 703         }
 704         break;
 705     case TIFF_ROWSPERSTRIP:
 706         if (!value || (type == TIFF_LONG && value == UINT_MAX))
 707             value = s->height;
 708         s->rps = FFMIN(value, s->height);
 709         break;
 710     case TIFF_STRIP_OFFS:
 711         if (count == 1) {
 712             s->strippos = 0;
 713             s->stripoff = value;
 714         } else
 715             s->strippos = off;
 716         s->strips = count;
 717         if (s->strips == 1)
 718             s->rps = s->height;
 719         s->sot = type;
 720         break;
 721     case TIFF_STRIP_SIZE:
 722         if (count == 1) {
 723             s->stripsizesoff = 0;
 724             s->stripsize     = value;
 725             s->strips        = 1;
 726         } else {
 727             s->stripsizesoff = off;
 728         }
 729         s->strips = count;
 730         s->sstype = type;
 731         break;
 732     case TIFF_XRES:
 733     case TIFF_YRES:
 734         set_sar(s, tag, value, value2);
 735         break;
 736     case TIFF_TILE_BYTE_COUNTS:
 737     case TIFF_TILE_LENGTH:
 738     case TIFF_TILE_OFFSETS:
 739     case TIFF_TILE_WIDTH:
 740         av_log(s->avctx, AV_LOG_ERROR, "Tiled images are not supported\n");
 741         return AVERROR_PATCHWELCOME;
 742         break;
 743     case TIFF_PREDICTOR:
 744         s->predictor = value;
 745         break;
 746     case TIFF_PHOTOMETRIC:
 747         switch (value) {
 748         case TIFF_PHOTOMETRIC_WHITE_IS_ZERO:
 749         case TIFF_PHOTOMETRIC_BLACK_IS_ZERO:
 750         case TIFF_PHOTOMETRIC_RGB:
 751         case TIFF_PHOTOMETRIC_PALETTE:
 752             s->photometric = value;
 753             break;
 754         case TIFF_PHOTOMETRIC_ALPHA_MASK:
 755         case TIFF_PHOTOMETRIC_SEPARATED:
 756         case TIFF_PHOTOMETRIC_YCBCR:
 757         case TIFF_PHOTOMETRIC_CIE_LAB:
 758         case TIFF_PHOTOMETRIC_ICC_LAB:
 759         case TIFF_PHOTOMETRIC_ITU_LAB:
 760         case TIFF_PHOTOMETRIC_CFA:
 761         case TIFF_PHOTOMETRIC_LOG_L:
 762         case TIFF_PHOTOMETRIC_LOG_LUV:
 763         case TIFF_PHOTOMETRIC_LINEAR_RAW:
 764             avpriv_report_missing_feature(s->avctx,
 765                                           "PhotometricInterpretation 0x%04X",
 766                                           value);
 767             return AVERROR_PATCHWELCOME;
 768         default:
 769             av_log(s->avctx, AV_LOG_ERROR, "PhotometricInterpretation %u is "
 770                    "unknown\n", value);
 771             return AVERROR_INVALIDDATA;
 772         }
 773         break;
 774     case TIFF_FILL_ORDER:
 775         if (value < 1 || value > 2) {
 776             av_log(s->avctx, AV_LOG_ERROR,
 777                    "Unknown FillOrder value %d, trying default one\n", value);
 778             value = 1;
 779         }
 780         s->fill_order = value - 1;
 781         break;
 782     case TIFF_PAL: {
 783         GetByteContext pal_gb[3];
 784         off = type_sizes[type];
 785         if (count / 3 > 256 ||
 786             bytestream2_get_bytes_left(&s->gb) < count / 3 * off * 3)
 787             return AVERROR_INVALIDDATA;
 788
 789         pal_gb[0] = pal_gb[1] = pal_gb[2] = s->gb;
 790         bytestream2_skip(&pal_gb[1], count / 3 * off);
 791         bytestream2_skip(&pal_gb[2], count / 3 * off * 2);
 792
 793         off = (type_sizes[type] - 1) << 3;
 794         for (i = 0; i < count / 3; i++) {
 795             uint32_t p = 0xFF000000;
 796             p |= (ff_tget(&pal_gb[0], type, s->le) >> off) << 16;
 797             p |= (ff_tget(&pal_gb[1], type, s->le) >> off) << 8;
 798             p |=  ff_tget(&pal_gb[2], type, s->le) >> off;
 799             s->palette[i] = p;
 800         }
 801         s->palette_is_set = 1;
 802         break;
 803     }
 804     case TIFF_PLANAR:
 805         s->planar = value == 2;
 806         break;
 807     case TIFF_T4OPTIONS:
 808         if (s->compr == TIFF_G3)
 809             s->fax_opts = value;
 810         break;
 811     case TIFF_T6OPTIONS:
 812         if (s->compr == TIFF_G4)
 813             s->fax_opts = value;
 814         break;
 815 #define ADD_METADATA(count, name, sep)\
 816     if ((ret = add_metadata(count, type, name, sep, s, frame)) < 0) {\
 817         av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");\
 818         goto end;\
 819     }
 820     case TIFF_MODEL_PIXEL_SCALE:
 821         ADD_METADATA(count, "ModelPixelScaleTag", NULL);
 822         break;
 823     case TIFF_MODEL_TRANSFORMATION:
 824         ADD_METADATA(count, "ModelTransformationTag", NULL);
 825         break;
 826     case TIFF_MODEL_TIEPOINT:
 827         ADD_METADATA(count, "ModelTiepointTag", NULL);
 828         break;
 829     case TIFF_GEO_KEY_DIRECTORY:
 830         ADD_METADATA(1, "GeoTIFF_Version", NULL);
 831         ADD_METADATA(2, "GeoTIFF_Key_Revision", ".");
 832         s->geotag_count   = ff_tget_short(&s->gb, s->le);
 833         if (s->geotag_count > count / 4 - 1) {
 834             s->geotag_count = count / 4 - 1;
 835             av_log(s->avctx, AV_LOG_WARNING, "GeoTIFF key directory buffer shorter than specified\n");
 836         }
 837         if (bytestream2_get_bytes_left(&s->gb) < s->geotag_count * sizeof(int16_t) * 4) {
 838             s->geotag_count = 0;
 839             return -1;
 840         }
 841         s->geotags = av_mallocz(sizeof(TiffGeoTag) * s->geotag_count);
 842         if (!s->geotags) {
 843             av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
 844             s->geotag_count = 0;
 845             goto end;
 846         }
 847         for (i = 0; i < s->geotag_count; i++) {
 848             s->geotags[i].key    = ff_tget_short(&s->gb, s->le);
 849             s->geotags[i].type   = ff_tget_short(&s->gb, s->le);
 850             s->geotags[i].count  = ff_tget_short(&s->gb, s->le);
 851
 852             if (!s->geotags[i].type)
 853                 s->geotags[i].val  = get_geokey_val(s->geotags[i].key, ff_tget_short(&s->gb, s->le));
 854             else
 855                 s->geotags[i].offset = ff_tget_short(&s->gb, s->le);
 856         }
 857         break;
 858     case TIFF_GEO_DOUBLE_PARAMS:
 859         if (count >= INT_MAX / sizeof(int64_t))
 860             return AVERROR_INVALIDDATA;
 861         if (bytestream2_get_bytes_left(&s->gb) < count * sizeof(int64_t))
 862             return AVERROR_INVALIDDATA;
 863         dp = av_malloc(count * sizeof(double));
 864         if (!dp) {
 865             av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
 866             goto end;
 867         }
 868         for (i = 0; i < count; i++)
 869             dp[i] = ff_tget_double(&s->gb, s->le);
 870         for (i = 0; i < s->geotag_count; i++) {
 871             if (s->geotags[i].type == TIFF_GEO_DOUBLE_PARAMS) {
 872                 if (s->geotags[i].count == 0
 873                     || s->geotags[i].offset + s->geotags[i].count > count) {
 874                     av_log(s->avctx, AV_LOG_WARNING, "Invalid GeoTIFF key %d\n", s->geotags[i].key);
 875                 } else {
 876                     char *ap = doubles2str(&dp[s->geotags[i].offset], s->geotags[i].count, ", ");
 877                     if (!ap) {
 878                         av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
 879                         av_freep(&dp);
 880                         return AVERROR(ENOMEM);
 881                     }
 882                     s->geotags[i].val = ap;
 883                 }
 884             }
 885         }
 886         av_freep(&dp);
 887         break;
 888     case TIFF_GEO_ASCII_PARAMS:
 889         pos = bytestream2_tell(&s->gb);
 890         for (i = 0; i < s->geotag_count; i++) {
 891             if (s->geotags[i].type == TIFF_GEO_ASCII_PARAMS) {
 892                 if (s->geotags[i].count == 0
 893                     || s->geotags[i].offset +  s->geotags[i].count > count) {
 894                     av_log(s->avctx, AV_LOG_WARNING, "Invalid GeoTIFF key %d\n", s->geotags[i].key);
 895                 } else {
 896                     char *ap;
 897
 898                     bytestream2_seek(&s->gb, pos + s->geotags[i].offset, SEEK_SET);
 899                     if (bytestream2_get_bytes_left(&s->gb) < s->geotags[i].count)
 900                         return AVERROR_INVALIDDATA;
 901                     ap = av_malloc(s->geotags[i].count);
 902                     if (!ap) {
 903                         av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
 904                         return AVERROR(ENOMEM);
 905                     }
 906                     bytestream2_get_bufferu(&s->gb, ap, s->geotags[i].count);
 907                     ap[s->geotags[i].count - 1] = '\0'; //replace the "|" delimiter with a 0 byte
 908                     s->geotags[i].val = ap;
 909                 }
 910             }
 911         }
 912         break;
 913     case TIFF_ARTIST:
 914         ADD_METADATA(count, "artist", NULL);
 915         break;
 916     case TIFF_COPYRIGHT:
 917         ADD_METADATA(count, "copyright", NULL);
 918         break;
 919     case TIFF_DATE:
 920         ADD_METADATA(count, "date", NULL);
 921         break;
 922     case TIFF_DOCUMENT_NAME:
 923         ADD_METADATA(count, "document_name", NULL);
 924         break;
 925     case TIFF_HOST_COMPUTER:
 926         ADD_METADATA(count, "computer", NULL);
 927         break;
 928     case TIFF_IMAGE_DESCRIPTION:
 929         ADD_METADATA(count, "description", NULL);
 930         break;
 931     case TIFF_MAKE:
 932         ADD_METADATA(count, "make", NULL);
 933         break;
 934     case TIFF_MODEL:
 935         ADD_METADATA(count, "model", NULL);
 936         break;
 937     case TIFF_PAGE_NAME:
 938         ADD_METADATA(count, "page_name", NULL);
 939         break;
 940     case TIFF_PAGE_NUMBER:
 941         ADD_METADATA(count, "page_number", " / ");
 942         break;
 943     case TIFF_SOFTWARE_NAME:
 944         ADD_METADATA(count, "software", NULL);
 945         break;
 946     default:
 947         if (s->avctx->err_recognition & AV_EF_EXPLODE) {
 948             av_log(s->avctx, AV_LOG_ERROR,
 949                    "Unknown or unsupported tag %d/0X%0X\n",
 950                    tag, tag);
 951             return AVERROR_INVALIDDATA;
 952         }
 953     }
 954 end:
 955     bytestream2_seek(&s->gb, start, SEEK_SET);
 956     return 0;
 957 }
 958
 959 static int decode_frame(AVCodecContext *avctx,
 960                         void *data, int *got_frame, AVPacket *avpkt)
 961 {
 962     TiffContext *const s = avctx->priv_data;
 963     AVFrame *const p = data;
 964     ThreadFrame frame = { .f = data };
 965     unsigned off;
 966     int le, ret, plane, planes;
 967     int i, j, entries, stride;
 968     unsigned soff, ssize;
 969     uint8_t *dst;
 970     GetByteContext stripsizes;
 971     GetByteContext stripdata;
 972
 973     bytestream2_init(&s->gb, avpkt->data, avpkt->size);
 974
 975     // parse image header
 976     if ((ret = ff_tdecode_header(&s->gb, &le, &off))) {
 977         av_log(avctx, AV_LOG_ERROR, "Invalid TIFF header\n");
 978         return ret;
 979     } else if (off >= UINT_MAX - 14 || avpkt->size < off + 14) {
 980         av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n");
 981         return AVERROR_INVALIDDATA;
 982     }
 983     s->le          = le;
 984     // TIFF_BPP is not a required tag and defaults to 1
 985     s->bppcount    = s->bpp = 1;
 986     s->photometric = TIFF_PHOTOMETRIC_NONE;
 987     s->compr       = TIFF_RAW;
 988     s->fill_order  = 0;
 989     free_geotags(s);
 990
 991     // Reset these offsets so we can tell if they were set this frame
 992     s->stripsizesoff = s->strippos = 0;
 993     /* parse image file directory */
 994     bytestream2_seek(&s->gb, off, SEEK_SET);
 995     entries = ff_tget_short(&s->gb, le);
 996     if (bytestream2_get_bytes_left(&s->gb) < entries * 12)
 997         return AVERROR_INVALIDDATA;
 998     for (i = 0; i < entries; i++) {
 999         if ((ret = tiff_decode_tag(s, p)) < 0)
1000             return ret;
1001     }
1002
1003     for (i = 0; i<s->geotag_count; i++) {
1004         const char *keyname = get_geokey_name(s->geotags[i].key);
1005         if (!keyname) {
1006             av_log(avctx, AV_LOG_WARNING, "Unknown or unsupported GeoTIFF key %d\n", s->geotags[i].key);
1007             continue;
1008         }
1009         if (get_geokey_type(s->geotags[i].key) != s->geotags[i].type) {
1010             av_log(avctx, AV_LOG_WARNING, "Type of GeoTIFF key %d is wrong\n", s->geotags[i].key);
1011             continue;
1012         }
1013         ret = av_dict_set(avpriv_frame_get_metadatap(p), keyname, s->geotags[i].val, 0);
1014         if (ret<0) {
1015             av_log(avctx, AV_LOG_ERROR, "Writing metadata with key '%s' failed\n", keyname);
1016             return ret;
1017         }
1018     }
1019
1020     if (!s->strippos && !s->stripoff) {
1021         av_log(avctx, AV_LOG_ERROR, "Image data is missing\n");
1022         return AVERROR_INVALIDDATA;
1023     }
1024     /* now we have the data and may start decoding */
1025     if ((ret = init_image(s, &frame)) < 0)
1026         return ret;
1027
1028     if (s->strips == 1 && !s->stripsize) {
1029         av_log(avctx, AV_LOG_WARNING, "Image data size missing\n");
1030         s->stripsize = avpkt->size - s->stripoff;
1031     }
1032
1033     if (s->stripsizesoff) {
1034         if (s->stripsizesoff >= (unsigned)avpkt->size)
1035             return AVERROR_INVALIDDATA;
1036         bytestream2_init(&stripsizes, avpkt->data + s->stripsizesoff,
1037                          avpkt->size - s->stripsizesoff);
1038     }
1039     if (s->strippos) {
1040         if (s->strippos >= (unsigned)avpkt->size)
1041             return AVERROR_INVALIDDATA;
1042         bytestream2_init(&stripdata, avpkt->data + s->strippos,
1043                          avpkt->size - s->strippos);
1044     }
1045
1046     if (s->rps <= 0) {
1047         av_log(avctx, AV_LOG_ERROR, "rps %d invalid\n", s->rps);
1048         return AVERROR_INVALIDDATA;
1049     }
1050
1051     planes = s->planar ? s->bppcount : 1;
1052     for (plane = 0; plane < planes; plane++) {
1053         stride = p->linesize[plane];
1054         dst    = p->data[plane];
1055     for (i = 0; i < s->height; i += s->rps) {
1056         if (s->stripsizesoff)
1057             ssize = ff_tget(&stripsizes, s->sstype, le);
1058         else
1059             ssize = s->stripsize;
1060
1061         if (s->strippos)
1062             soff = ff_tget(&stripdata, s->sot, le);
1063         else
1064             soff = s->stripoff;
1065
1066         if (soff > avpkt->size || ssize > avpkt->size - soff) {
1067             av_log(avctx, AV_LOG_ERROR, "Invalid strip size/offset\n");
1068             return AVERROR_INVALIDDATA;
1069         }
1070         if ((ret = tiff_unpack_strip(s, dst, stride, avpkt->data + soff, ssize,
1071                                      FFMIN(s->rps, s->height - i))) < 0) {
1072             if (avctx->err_recognition & AV_EF_EXPLODE)
1073                 return ret;
1074             break;
1075         }
1076         dst += s->rps * stride;
1077     }
1078     if (s->predictor == 2) {
1079         dst   = p->data[plane];
1080         soff  = s->bpp >> 3;
1081         if (s->planar)
1082             soff  = FFMAX(soff / s->bppcount, 1);
1083         ssize = s->width * soff;
1084         if (s->avctx->pix_fmt == AV_PIX_FMT_RGB48LE ||
1085             s->avctx->pix_fmt == AV_PIX_FMT_RGBA64LE ||
1086             s->avctx->pix_fmt == AV_PIX_FMT_GBRP16LE ||
1087             s->avctx->pix_fmt == AV_PIX_FMT_GBRAP16LE) {
1088             for (i = 0; i < s->height; i++) {
1089                 for (j = soff; j < ssize; j += 2)
1090                     AV_WL16(dst + j, AV_RL16(dst + j) + AV_RL16(dst + j - soff));
1091                 dst += stride;
1092             }
1093         } else if (s->avctx->pix_fmt == AV_PIX_FMT_RGB48BE ||
1094                    s->avctx->pix_fmt == AV_PIX_FMT_RGBA64BE ||
1095                    s->avctx->pix_fmt == AV_PIX_FMT_GBRP16BE ||
1096                    s->avctx->pix_fmt == AV_PIX_FMT_GBRAP16BE) {
1097             for (i = 0; i < s->height; i++) {
1098                 for (j = soff; j < ssize; j += 2)
1099                     AV_WB16(dst + j, AV_RB16(dst + j) + AV_RB16(dst + j - soff));
1100                 dst += stride;
1101             }
1102         } else {
1103             for (i = 0; i < s->height; i++) {
1104                 for (j = soff; j < ssize; j++)
1105                     dst[j] += dst[j - soff];
1106                 dst += stride;
1107             }
1108         }
1109     }
1110
1111     if (s->photometric == TIFF_PHOTOMETRIC_WHITE_IS_ZERO) {
1112         dst = p->data[plane];
1113         for (i = 0; i < s->height; i++) {
1114             for (j = 0; j < p->linesize[plane]; j++)
1115                 dst[j] = (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 ? (1<<s->bpp) - 1 : 255) - dst[j];
1116             dst += stride;
1117         }
1118     }
1119     }
1120
1121     if (s->planar && s->bppcount > 2) {
1122         FFSWAP(uint8_t*, p->data[0],     p->data[2]);
1123         FFSWAP(int,      p->linesize[0], p->linesize[2]);
1124         FFSWAP(uint8_t*, p->data[0],     p->data[1]);
1125         FFSWAP(int,      p->linesize[0], p->linesize[1]);
1126     }
1127
1128     *got_frame = 1;
1129
1130     return avpkt->size;
1131 }
1132
1133 static av_cold int tiff_init(AVCodecContext *avctx)
1134 {
1135     TiffContext *s = avctx->priv_data;
1136
1137     s->width  = 0;
1138     s->height = 0;
1139     s->avctx  = avctx;
1140     ff_lzw_decode_open(&s->lzw);
1141     ff_ccitt_unpack_init();
1142
1143     return 0;
1144 }
1145
1146 static av_cold int tiff_end(AVCodecContext *avctx)
1147 {
1148     TiffContext *const s = avctx->priv_data;
1149
1150     free_geotags(s);
1151
1152     ff_lzw_decode_close(&s->lzw);
1153     av_freep(&s->deinvert_buf);
1154     return 0;
1155 }
1156
1157 AVCodec ff_tiff_decoder = {
1158     .name           = "tiff",
1159     .long_name      = NULL_IF_CONFIG_SMALL("TIFF image"),
1160     .type           = AVMEDIA_TYPE_VIDEO,
1161     .id             = AV_CODEC_ID_TIFF,
1162     .priv_data_size = sizeof(TiffContext),
1163     .init           = tiff_init,
1164     .close          = tiff_end,
1165     .decode         = decode_frame,
1166     .init_thread_copy = ONLY_IF_THREADS_ENABLED(tiff_init),
1167     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
1168 };