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