dd25190ecf5997030c5a407069c0d7a35edd3e0b
[ffmpeg.git] / libavcodec / tiff.c
1 /*
2  * TIFF image decoder
3  * Copyright (c) 2006 Konstantin Shishkov
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * TIFF image decoder
25  * @author Konstantin Shishkov
26  */
27
28 #include "avcodec.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 "faxcompr.h"
36 #include "internal.h"
37 #include "mathops.h"
38 #include "libavutil/attributes.h"
39 #include "libavutil/intreadwrite.h"
40 #include "libavutil/imgutils.h"
41
42 typedef struct TiffContext {
43     AVCodecContext *avctx;
44     AVFrame picture;
45
46     int width, height;
47     unsigned int bpp, bppcount;
48     uint32_t palette[256];
49     int palette_is_set;
50     int le;
51     enum TiffCompr compr;
52     int invert;
53     int fax_opts;
54     int predictor;
55     int fill_order;
56
57     int strips, rps, sstype;
58     int sot;
59     const uint8_t *stripdata;
60     const uint8_t *stripsizes;
61     int stripsize, stripoff;
62     LZWState *lzw;
63 } TiffContext;
64
65 static unsigned tget_short(const uint8_t **p, int le)
66 {
67     unsigned v = le ? AV_RL16(*p) : AV_RB16(*p);
68     *p += 2;
69     return v;
70 }
71
72 static unsigned tget_long(const uint8_t **p, int le)
73 {
74     unsigned v = le ? AV_RL32(*p) : AV_RB32(*p);
75     *p += 4;
76     return v;
77 }
78
79 static unsigned tget(const uint8_t **p, int type, int le)
80 {
81     switch (type) {
82     case TIFF_BYTE : return *(*p)++;
83     case TIFF_SHORT: return tget_short(p, le);
84     case TIFF_LONG : return tget_long(p, le);
85     default        : return UINT_MAX;
86     }
87 }
88
89 #if CONFIG_ZLIB
90 static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src,
91                            int size)
92 {
93     z_stream zstream = { 0 };
94     int zret;
95
96     zstream.next_in = src;
97     zstream.avail_in = size;
98     zstream.next_out = dst;
99     zstream.avail_out = *len;
100     zret = inflateInit(&zstream);
101     if (zret != Z_OK) {
102         av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
103         return zret;
104     }
105     zret = inflate(&zstream, Z_SYNC_FLUSH);
106     inflateEnd(&zstream);
107     *len = zstream.total_out;
108     return zret == Z_STREAM_END ? Z_OK : zret;
109 }
110 #endif
111
112 static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
113                              const uint8_t *src, int size, int lines)
114 {
115     int c, line, pixels, code, ret;
116     const uint8_t *ssrc = src;
117     int width = ((s->width * s->bpp) + 7) >> 3;
118
119     if (size <= 0)
120         return AVERROR_INVALIDDATA;
121
122 #if CONFIG_ZLIB
123     if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE) {
124         uint8_t *zbuf;
125         unsigned long outlen;
126         int ret;
127         outlen = width * lines;
128         zbuf = av_malloc(outlen);
129         if (!zbuf)
130             return AVERROR(ENOMEM);
131         ret = tiff_uncompress(zbuf, &outlen, src, size);
132         if (ret != Z_OK) {
133             av_log(s->avctx, AV_LOG_ERROR,
134                    "Uncompressing failed (%lu of %lu) with error %d\n", outlen,
135                    (unsigned long)width * lines, ret);
136             av_free(zbuf);
137             return AVERROR_UNKNOWN;
138         }
139         src = zbuf;
140         for (line = 0; line < lines; line++) {
141             memcpy(dst, src, width);
142             dst += stride;
143             src += width;
144         }
145         av_free(zbuf);
146         return 0;
147     }
148 #endif
149     if (s->compr == TIFF_LZW) {
150         if ((ret = ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF)) < 0) {
151             av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n");
152             return ret;
153         }
154     }
155     if (s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3
156         || s->compr == TIFF_G4) {
157         int i, ret = 0;
158         uint8_t *src2 = av_malloc((unsigned)size +
159                                   FF_INPUT_BUFFER_PADDING_SIZE);
160
161         if (!src2) {
162             av_log(s->avctx, AV_LOG_ERROR,
163                    "Error allocating temporary buffer\n");
164             return AVERROR(ENOMEM);
165         }
166         if (s->fax_opts & 2) {
167             av_log(s->avctx, AV_LOG_ERROR,
168                    "Uncompressed fax mode is not supported (yet)\n");
169             av_free(src2);
170             return AVERROR_INVALIDDATA;
171         }
172         if (!s->fill_order) {
173             memcpy(src2, src, size);
174         } else {
175             for (i = 0; i < size; i++)
176                 src2[i] = ff_reverse[src[i]];
177         }
178         memset(src2 + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
179         switch (s->compr) {
180         case TIFF_CCITT_RLE:
181         case TIFF_G3:
182         case TIFF_G4:
183             ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride,
184                                   s->compr, s->fax_opts);
185             break;
186         }
187         av_free(src2);
188         return ret;
189     }
190     for (line = 0; line < lines; line++) {
191         if (src - ssrc > size) {
192             av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n");
193             return AVERROR_INVALIDDATA;
194         }
195         switch (s->compr) {
196         case TIFF_RAW:
197             if (ssrc + size - src < width)
198                 return AVERROR_INVALIDDATA;
199             if (!s->fill_order) {
200                 memcpy(dst, src, width);
201             } else {
202                 int i;
203                 for (i = 0; i < width; i++)
204                     dst[i] = ff_reverse[src[i]];
205             }
206             src += width;
207             break;
208         case TIFF_PACKBITS:
209             for (pixels = 0; pixels < width;) {
210                 code = (int8_t) * src++;
211                 if (code >= 0) {
212                     code++;
213                     if (pixels + code > width) {
214                         av_log(s->avctx, AV_LOG_ERROR,
215                                "Copy went out of bounds\n");
216                         return AVERROR_INVALIDDATA;
217                     }
218                     memcpy(dst + pixels, src, code);
219                     src += code;
220                     pixels += code;
221                 } else if (code != -128) { // -127..-1
222                     code = (-code) + 1;
223                     if (pixels + code > width) {
224                         av_log(s->avctx, AV_LOG_ERROR,
225                                "Run went out of bounds\n");
226                         return AVERROR_INVALIDDATA;
227                     }
228                     c = *src++;
229                     memset(dst + pixels, c, code);
230                     pixels += code;
231                 }
232             }
233             break;
234         case TIFF_LZW:
235             pixels = ff_lzw_decode(s->lzw, dst, width);
236             if (pixels < width) {
237                 av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n",
238                        pixels, width);
239                 return AVERROR_INVALIDDATA;
240             }
241             break;
242         }
243         dst += stride;
244     }
245     return 0;
246 }
247
248 static int init_image(TiffContext *s)
249 {
250     int i, ret;
251     uint32_t *pal;
252
253     switch (s->bpp * 10 + s->bppcount) {
254     case 11:
255         s->avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
256         break;
257     case 81:
258         s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
259         break;
260     case 243:
261         s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
262         break;
263     case 161:
264         s->avctx->pix_fmt = s->le ? AV_PIX_FMT_GRAY16LE : AV_PIX_FMT_GRAY16BE;
265         break;
266     case 324:
267         s->avctx->pix_fmt = AV_PIX_FMT_RGBA;
268         break;
269     case 483:
270         s->avctx->pix_fmt = s->le ? AV_PIX_FMT_RGB48LE : AV_PIX_FMT_RGB48BE;
271         break;
272     default:
273         av_log(s->avctx, AV_LOG_ERROR,
274                "This format is not supported (bpp=%d, bppcount=%d)\n",
275                s->bpp, s->bppcount);
276         return AVERROR_INVALIDDATA;
277     }
278     if (s->width != s->avctx->width || s->height != s->avctx->height) {
279         if ((ret = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
280             return ret;
281         avcodec_set_dimensions(s->avctx, s->width, s->height);
282     }
283     if (s->picture.data[0])
284         s->avctx->release_buffer(s->avctx, &s->picture);
285     if ((ret = ff_get_buffer(s->avctx, &s->picture)) < 0) {
286         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
287         return ret;
288     }
289     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8) {
290         if (s->palette_is_set) {
291             memcpy(s->picture.data[1], s->palette, sizeof(s->palette));
292         } else {
293             /* make default grayscale pal */
294             pal = (uint32_t *) s->picture.data[1];
295             for (i = 0; i < 256; i++)
296                 pal[i] = i * 0x010101;
297         }
298     }
299     return 0;
300 }
301
302 static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
303                            const uint8_t *buf, const uint8_t *end_buf)
304 {
305     unsigned tag, type, count, off, value = 0;
306     int i, j;
307     uint32_t *pal;
308     const uint8_t *rp, *gp, *bp;
309
310     if (end_buf - buf < 12)
311         return AVERROR_INVALIDDATA;
312     tag = tget_short(&buf, s->le);
313     type = tget_short(&buf, s->le);
314     count = tget_long(&buf, s->le);
315     off = tget_long(&buf, s->le);
316
317     if (type == 0 || type >= FF_ARRAY_ELEMS(type_sizes)) {
318         av_log(s->avctx, AV_LOG_DEBUG, "Unknown tiff type (%u) encountered\n",
319                type);
320         return 0;
321     }
322
323     if (count == 1) {
324         switch (type) {
325         case TIFF_BYTE:
326         case TIFF_SHORT:
327             buf -= 4;
328             value = tget(&buf, type, s->le);
329             buf = NULL;
330             break;
331         case TIFF_LONG:
332             value = off;
333             buf = NULL;
334             break;
335         case TIFF_STRING:
336             if (count <= 4) {
337                 buf -= 4;
338                 break;
339             }
340         default:
341             value = UINT_MAX;
342             buf = start + off;
343         }
344     } else {
345         if (count <= 4 && type_sizes[type] * count <= 4) {
346             buf -= 4;
347         } else {
348             buf = start + off;
349         }
350     }
351
352     if (buf && (buf < start || buf > end_buf)) {
353         av_log(s->avctx, AV_LOG_ERROR,
354                "Tag referencing position outside the image\n");
355         return AVERROR_INVALIDDATA;
356     }
357
358     switch (tag) {
359     case TIFF_WIDTH:
360         s->width = value;
361         break;
362     case TIFF_HEIGHT:
363         s->height = value;
364         break;
365     case TIFF_BPP:
366         s->bppcount = count;
367         if (count > 4) {
368             av_log(s->avctx, AV_LOG_ERROR,
369                    "This format is not supported (bpp=%d, %d components)\n",
370                    s->bpp, count);
371             return AVERROR_INVALIDDATA;
372         }
373         if (count == 1)
374             s->bpp = value;
375         else {
376             switch (type) {
377             case TIFF_BYTE:
378                 s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) +
379                          ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF);
380                 break;
381             case TIFF_SHORT:
382             case TIFF_LONG:
383                 s->bpp = 0;
384                 for (i = 0; i < count && buf < end_buf; i++)
385                     s->bpp += tget(&buf, type, s->le);
386                 break;
387             default:
388                 s->bpp = -1;
389             }
390         }
391         break;
392     case TIFF_SAMPLES_PER_PIXEL:
393         if (count != 1) {
394             av_log(s->avctx, AV_LOG_ERROR,
395                    "Samples per pixel requires a single value, many provided\n");
396             return AVERROR_INVALIDDATA;
397         }
398         if (s->bppcount == 1)
399             s->bpp *= value;
400         s->bppcount = value;
401         break;
402     case TIFF_COMPR:
403         s->compr = value;
404         s->predictor = 0;
405         switch (s->compr) {
406         case TIFF_RAW:
407         case TIFF_PACKBITS:
408         case TIFF_LZW:
409         case TIFF_CCITT_RLE:
410             break;
411         case TIFF_G3:
412         case TIFF_G4:
413             s->fax_opts = 0;
414             break;
415         case TIFF_DEFLATE:
416         case TIFF_ADOBE_DEFLATE:
417 #if CONFIG_ZLIB
418             break;
419 #else
420             av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n");
421             return AVERROR(ENOSYS);
422 #endif
423         case TIFF_JPEG:
424         case TIFF_NEWJPEG:
425             av_log(s->avctx, AV_LOG_ERROR,
426                    "JPEG compression is not supported\n");
427             return AVERROR_PATCHWELCOME;
428         default:
429             av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n",
430                    s->compr);
431             return AVERROR_INVALIDDATA;
432         }
433         break;
434     case TIFF_ROWSPERSTRIP:
435         if (type == TIFF_LONG && value == UINT_MAX)
436             value = s->avctx->height;
437         if (value < 1) {
438             av_log(s->avctx, AV_LOG_ERROR,
439                    "Incorrect value of rows per strip\n");
440             return AVERROR_INVALIDDATA;
441         }
442         s->rps = value;
443         break;
444     case TIFF_STRIP_OFFS:
445         if (count == 1) {
446             s->stripdata = NULL;
447             s->stripoff = value;
448         } else
449             s->stripdata = start + off;
450         s->strips = count;
451         if (s->strips == 1)
452             s->rps = s->height;
453         s->sot = type;
454         if (s->stripdata > end_buf) {
455             av_log(s->avctx, AV_LOG_ERROR,
456                    "Tag referencing position outside the image\n");
457             return AVERROR_INVALIDDATA;
458         }
459         break;
460     case TIFF_STRIP_SIZE:
461         if (count == 1) {
462             s->stripsizes = NULL;
463             s->stripsize = value;
464             s->strips = 1;
465         } else {
466             s->stripsizes = start + off;
467         }
468         s->strips = count;
469         s->sstype = type;
470         if (s->stripsizes > end_buf) {
471             av_log(s->avctx, AV_LOG_ERROR,
472                    "Tag referencing position outside the image\n");
473             return AVERROR_INVALIDDATA;
474         }
475         break;
476     case TIFF_PREDICTOR:
477         s->predictor = value;
478         break;
479     case TIFF_INVERT:
480         switch (value) {
481         case 0:
482             s->invert = 1;
483             break;
484         case 1:
485             s->invert = 0;
486             break;
487         case 2:
488         case 3:
489             break;
490         default:
491             av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n",
492                    value);
493             return AVERROR_INVALIDDATA;
494         }
495         break;
496     case TIFF_FILL_ORDER:
497         if (value < 1 || value > 2) {
498             av_log(s->avctx, AV_LOG_ERROR,
499                    "Unknown FillOrder value %d, trying default one\n", value);
500             value = 1;
501         }
502         s->fill_order = value - 1;
503         break;
504     case TIFF_PAL:
505         pal = (uint32_t *) s->palette;
506         off = type_sizes[type];
507         if (count / 3 > 256 || end_buf - buf < count / 3 * off * 3)
508             return AVERROR_INVALIDDATA;
509         rp = buf;
510         gp = buf + count / 3 * off;
511         bp = buf + count / 3 * off * 2;
512         off = (type_sizes[type] - 1) << 3;
513         for (i = 0; i < count / 3; i++) {
514             j  = (tget(&rp, type, s->le) >> off) << 16;
515             j |= (tget(&gp, type, s->le) >> off) << 8;
516             j |=  tget(&bp, type, s->le) >> off;
517             pal[i] = j;
518         }
519         s->palette_is_set = 1;
520         break;
521     case TIFF_PLANAR:
522         if (value == 2) {
523             av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n");
524             return AVERROR_PATCHWELCOME;
525         }
526         break;
527     case TIFF_T4OPTIONS:
528         if (s->compr == TIFF_G3)
529             s->fax_opts = value;
530         break;
531     case TIFF_T6OPTIONS:
532         if (s->compr == TIFF_G4)
533             s->fax_opts = value;
534         break;
535     default:
536         av_log(s->avctx, AV_LOG_DEBUG, "Unknown or unsupported tag %d/0X%0X\n",
537                tag, tag);
538     }
539     return 0;
540 }
541
542 static int decode_frame(AVCodecContext *avctx,
543                         void *data, int *got_frame, AVPacket *avpkt)
544 {
545     const uint8_t *buf = avpkt->data;
546     int buf_size = avpkt->size;
547     TiffContext *const s = avctx->priv_data;
548     AVFrame *picture = data;
549     AVFrame *const p = &s->picture;
550     const uint8_t *orig_buf = buf, *end_buf = buf + buf_size;
551     unsigned off;
552     int id, le, ret;
553     int i, j, entries;
554     int stride;
555     unsigned soff, ssize;
556     uint8_t *dst;
557
558     //parse image header
559     if (end_buf - buf < 8)
560         return AVERROR_INVALIDDATA;
561     id = AV_RL16(buf);
562     buf += 2;
563     if (id == 0x4949)
564         le = 1;
565     else if (id == 0x4D4D)
566         le = 0;
567     else {
568         av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n");
569         return AVERROR_INVALIDDATA;
570     }
571     s->le = le;
572     s->invert = 0;
573     s->compr = TIFF_RAW;
574     s->fill_order = 0;
575     // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number
576     // that further identifies the file as a TIFF file"
577     if (tget_short(&buf, le) != 42) {
578         av_log(avctx, AV_LOG_ERROR,
579                "The answer to life, universe and everything is not correct!\n");
580         return AVERROR_INVALIDDATA;
581     }
582     // Reset these pointers so we can tell if they were set this frame
583     s->stripsizes = s->stripdata = NULL;
584     /* parse image file directory */
585     off = tget_long(&buf, le);
586     if (off >= UINT_MAX - 14 || end_buf - orig_buf < off + 14) {
587         av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n");
588         return AVERROR_INVALIDDATA;
589     }
590     buf = orig_buf + off;
591     entries = tget_short(&buf, le);
592     for (i = 0; i < entries; i++) {
593         if ((ret = tiff_decode_tag(s, orig_buf, buf, end_buf)) < 0)
594             return ret;
595         buf += 12;
596     }
597     if (!s->stripdata && !s->stripoff) {
598         av_log(avctx, AV_LOG_ERROR, "Image data is missing\n");
599         return AVERROR_INVALIDDATA;
600     }
601     /* now we have the data and may start decoding */
602     if ((ret = init_image(s)) < 0)
603         return ret;
604
605     if (s->strips == 1 && !s->stripsize) {
606         av_log(avctx, AV_LOG_WARNING, "Image data size missing\n");
607         s->stripsize = buf_size - s->stripoff;
608     }
609     stride = p->linesize[0];
610     dst = p->data[0];
611     for (i = 0; i < s->height; i += s->rps) {
612         if (s->stripsizes) {
613             if (s->stripsizes >= end_buf)
614                 return AVERROR_INVALIDDATA;
615             ssize = tget(&s->stripsizes, s->sstype, s->le);
616         } else
617             ssize = s->stripsize;
618
619         if (s->stripdata) {
620             if (s->stripdata >= end_buf)
621                 return AVERROR_INVALIDDATA;
622             soff = tget(&s->stripdata, s->sot, s->le);
623         } else
624             soff = s->stripoff;
625
626         if (soff > buf_size || ssize > buf_size - soff) {
627             av_log(avctx, AV_LOG_ERROR, "Invalid strip size/offset\n");
628             return AVERROR_INVALIDDATA;
629         }
630         if (tiff_unpack_strip(s, dst, stride, orig_buf + soff, ssize,
631                               FFMIN(s->rps, s->height - i)) < 0)
632             break;
633         dst += s->rps * stride;
634     }
635     if (s->predictor == 2) {
636         dst = p->data[0];
637         soff = s->bpp >> 3;
638         ssize = s->width * soff;
639         for (i = 0; i < s->height; i++) {
640             for (j = soff; j < ssize; j++)
641                 dst[j] += dst[j - soff];
642             dst += stride;
643         }
644     }
645
646     if (s->invert) {
647         uint8_t *src;
648         int j;
649
650         src = s->picture.data[0];
651         for (j = 0; j < s->height; j++) {
652             for (i = 0; i < s->picture.linesize[0]; i++)
653                 src[i] = 255 - src[i];
654             src += s->picture.linesize[0];
655         }
656     }
657     *picture   = s->picture;
658     *got_frame = 1;
659
660     return buf_size;
661 }
662
663 static av_cold int tiff_init(AVCodecContext *avctx)
664 {
665     TiffContext *s = avctx->priv_data;
666
667     s->width = 0;
668     s->height = 0;
669     s->avctx = avctx;
670     avcodec_get_frame_defaults(&s->picture);
671     avctx->coded_frame = &s->picture;
672     ff_lzw_decode_open(&s->lzw);
673     ff_ccitt_unpack_init();
674
675     return 0;
676 }
677
678 static av_cold int tiff_end(AVCodecContext *avctx)
679 {
680     TiffContext *const s = avctx->priv_data;
681
682     ff_lzw_decode_close(&s->lzw);
683     if (s->picture.data[0])
684         avctx->release_buffer(avctx, &s->picture);
685     return 0;
686 }
687
688 AVCodec ff_tiff_decoder = {
689     .name           = "tiff",
690     .type           = AVMEDIA_TYPE_VIDEO,
691     .id             = AV_CODEC_ID_TIFF,
692     .priv_data_size = sizeof(TiffContext),
693     .init           = tiff_init,
694     .close          = tiff_end,
695     .decode         = decode_frame,
696     .capabilities   = CODEC_CAP_DR1,
697     .long_name      = NULL_IF_CONFIG_SMALL("TIFF image"),
698 };