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