tiff: K&R formatting cosmetics
[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 "config.h"
29 #if CONFIG_ZLIB
30 #include <zlib.h>
31 #endif
32
33 #include "libavutil/attributes.h"
34 #include "libavutil/intreadwrite.h"
35 #include "libavutil/imgutils.h"
36 #include "avcodec.h"
37 #include "faxcompr.h"
38 #include "internal.h"
39 #include "lzw.h"
40 #include "mathops.h"
41 #include "tiff.h"
42
43 typedef struct TiffContext {
44     AVCodecContext *avctx;
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:
83         return *(*p)++;
84     case TIFF_SHORT:
85         return tget_short(p, le);
86     case TIFF_LONG:
87         return tget_long(p, le);
88     default:
89         return UINT_MAX;
90     }
91 }
92
93 #if CONFIG_ZLIB
94 static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src,
95                            int size)
96 {
97     z_stream zstream = { 0 };
98     int zret;
99
100     zstream.next_in   = src;
101     zstream.avail_in  = size;
102     zstream.next_out  = dst;
103     zstream.avail_out = *len;
104     zret              = inflateInit(&zstream);
105     if (zret != Z_OK) {
106         av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
107         return zret;
108     }
109     zret = inflate(&zstream, Z_SYNC_FLUSH);
110     inflateEnd(&zstream);
111     *len = zstream.total_out;
112     return zret == Z_STREAM_END ? Z_OK : zret;
113 }
114 #endif
115
116 static int tiff_unpack_strip(TiffContext *s, uint8_t *dst, int stride,
117                              const uint8_t *src, int size, int lines)
118 {
119     int c, line, pixels, code, ret;
120     const uint8_t *ssrc = src;
121     int width           = ((s->width * s->bpp) + 7) >> 3;
122
123     if (size <= 0)
124         return AVERROR_INVALIDDATA;
125
126 #if CONFIG_ZLIB
127     if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE) {
128         uint8_t *zbuf;
129         unsigned long outlen;
130         int ret;
131         outlen = width * lines;
132         zbuf   = av_malloc(outlen);
133         if (!zbuf)
134             return AVERROR(ENOMEM);
135         ret = tiff_uncompress(zbuf, &outlen, src, size);
136         if (ret != Z_OK) {
137             av_log(s->avctx, AV_LOG_ERROR,
138                    "Uncompressing failed (%lu of %lu) with error %d\n", outlen,
139                    (unsigned long)width * lines, ret);
140             av_free(zbuf);
141             return AVERROR_UNKNOWN;
142         }
143         src = zbuf;
144         for (line = 0; line < lines; line++) {
145             memcpy(dst, src, width);
146             dst += stride;
147             src += width;
148         }
149         av_free(zbuf);
150         return 0;
151     }
152 #endif
153     if (s->compr == TIFF_LZW) {
154         if ((ret = ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF)) < 0) {
155             av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n");
156             return ret;
157         }
158     }
159     if (s->compr == TIFF_CCITT_RLE ||
160         s->compr == TIFF_G3        ||
161         s->compr == TIFF_G4) {
162         int i, ret = 0;
163         uint8_t *src2 = av_malloc((unsigned)size +
164                                   FF_INPUT_BUFFER_PADDING_SIZE);
165
166         if (!src2) {
167             av_log(s->avctx, AV_LOG_ERROR,
168                    "Error allocating temporary buffer\n");
169             return AVERROR(ENOMEM);
170         }
171         if (s->fax_opts & 2) {
172             av_log(s->avctx, AV_LOG_ERROR,
173                    "Uncompressed fax mode is not supported (yet)\n");
174             av_free(src2);
175             return AVERROR_INVALIDDATA;
176         }
177         if (!s->fill_order) {
178             memcpy(src2, src, size);
179         } else {
180             for (i = 0; i < size; i++)
181                 src2[i] = ff_reverse[src[i]];
182         }
183         memset(src2 + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
184         switch (s->compr) {
185         case TIFF_CCITT_RLE:
186         case TIFF_G3:
187         case TIFF_G4:
188             ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride,
189                                   s->compr, s->fax_opts);
190             break;
191         }
192         av_free(src2);
193         return ret;
194     }
195     for (line = 0; line < lines; line++) {
196         if (src - ssrc > size) {
197             av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n");
198             return AVERROR_INVALIDDATA;
199         }
200         switch (s->compr) {
201         case TIFF_RAW:
202             if (ssrc + size - src < width)
203                 return AVERROR_INVALIDDATA;
204             if (!s->fill_order) {
205                 memcpy(dst, src, width);
206             } else {
207                 int i;
208                 for (i = 0; i < width; i++)
209                     dst[i] = ff_reverse[src[i]];
210             }
211             src += width;
212             break;
213         case TIFF_PACKBITS:
214             for (pixels = 0; pixels < width;) {
215                 code = (int8_t) *src++;
216                 if (code >= 0) {
217                     code++;
218                     if (pixels + code > width) {
219                         av_log(s->avctx, AV_LOG_ERROR,
220                                "Copy went out of bounds\n");
221                         return AVERROR_INVALIDDATA;
222                     }
223                     memcpy(dst + pixels, src, code);
224                     src    += code;
225                     pixels += code;
226                 } else if (code != -128) { // -127..-1
227                     code = (-code) + 1;
228                     if (pixels + code > width) {
229                         av_log(s->avctx, AV_LOG_ERROR,
230                                "Run went out of bounds\n");
231                         return AVERROR_INVALIDDATA;
232                     }
233                     c = *src++;
234                     memset(dst + pixels, c, code);
235                     pixels += code;
236                 }
237             }
238             break;
239         case TIFF_LZW:
240             pixels = ff_lzw_decode(s->lzw, dst, width);
241             if (pixels < width) {
242                 av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n",
243                        pixels, width);
244                 return AVERROR_INVALIDDATA;
245             }
246             break;
247         }
248         dst += stride;
249     }
250     return 0;
251 }
252
253 static int init_image(TiffContext *s, AVFrame *frame)
254 {
255     int i, ret;
256     uint32_t *pal;
257
258     switch (s->bpp * 10 + s->bppcount) {
259     case 11:
260         s->avctx->pix_fmt = AV_PIX_FMT_MONOBLACK;
261         break;
262     case 81:
263         s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
264         break;
265     case 243:
266         s->avctx->pix_fmt = AV_PIX_FMT_RGB24;
267         break;
268     case 161:
269         s->avctx->pix_fmt = s->le ? AV_PIX_FMT_GRAY16LE : AV_PIX_FMT_GRAY16BE;
270         break;
271     case 324:
272         s->avctx->pix_fmt = AV_PIX_FMT_RGBA;
273         break;
274     case 483:
275         s->avctx->pix_fmt = s->le ? AV_PIX_FMT_RGB48LE : AV_PIX_FMT_RGB48BE;
276         break;
277     default:
278         av_log(s->avctx, AV_LOG_ERROR,
279                "This format is not supported (bpp=%d, bppcount=%d)\n",
280                s->bpp, s->bppcount);
281         return AVERROR_INVALIDDATA;
282     }
283     if (s->width != s->avctx->width || s->height != s->avctx->height) {
284         if ((ret = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
285             return ret;
286         avcodec_set_dimensions(s->avctx, s->width, s->height);
287     }
288     if ((ret = ff_get_buffer(s->avctx, frame, 0)) < 0) {
289         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
290         return ret;
291     }
292     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8) {
293         if (s->palette_is_set) {
294             memcpy(frame->data[1], s->palette, sizeof(s->palette));
295         } else {
296             /* make default grayscale pal */
297             pal = (uint32_t *) frame->data[1];
298             for (i = 0; i < 256; i++)
299                 pal[i] = i * 0x010101;
300         }
301     }
302     return 0;
303 }
304
305 static int tiff_decode_tag(TiffContext *s, const uint8_t *start,
306                            const uint8_t *buf, const uint8_t *end_buf)
307 {
308     unsigned tag, type, count, off, value = 0;
309     int i, j;
310     uint32_t *pal;
311     const uint8_t *rp, *gp, *bp;
312
313     if (end_buf - buf < 12)
314         return AVERROR_INVALIDDATA;
315     tag   = tget_short(&buf, s->le);
316     type  = tget_short(&buf, s->le);
317     count = tget_long(&buf, s->le);
318     off   = tget_long(&buf, s->le);
319
320     if (type == 0 || type >= FF_ARRAY_ELEMS(type_sizes)) {
321         av_log(s->avctx, AV_LOG_DEBUG, "Unknown tiff type (%u) encountered\n",
322                type);
323         return 0;
324     }
325
326     if (count == 1) {
327         switch (type) {
328         case TIFF_BYTE:
329         case TIFF_SHORT:
330             buf  -= 4;
331             value = tget(&buf, type, s->le);
332             buf   = NULL;
333             break;
334         case TIFF_LONG:
335             value = off;
336             buf   = NULL;
337             break;
338         case TIFF_STRING:
339             if (count <= 4) {
340                 buf -= 4;
341                 break;
342             }
343         default:
344             value = UINT_MAX;
345             buf   = start + off;
346         }
347     } else {
348         if (count <= 4 && type_sizes[type] * count <= 4)
349             buf -= 4;
350         else
351             buf = start + off;
352     }
353
354     if (buf && (buf < start || buf > end_buf)) {
355         av_log(s->avctx, AV_LOG_ERROR,
356                "Tag referencing position outside the image\n");
357         return AVERROR_INVALIDDATA;
358     }
359
360     switch (tag) {
361     case TIFF_WIDTH:
362         s->width = value;
363         break;
364     case TIFF_HEIGHT:
365         s->height = value;
366         break;
367     case TIFF_BPP:
368         s->bppcount = count;
369         if (count > 4) {
370             av_log(s->avctx, AV_LOG_ERROR,
371                    "This format is not supported (bpp=%d, %d components)\n",
372                    s->bpp, count);
373             return AVERROR_INVALIDDATA;
374         }
375         if (count == 1)
376             s->bpp = value;
377         else {
378             switch (type) {
379             case TIFF_BYTE:
380                 s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) +
381                          ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF);
382                 break;
383             case TIFF_SHORT:
384             case TIFF_LONG:
385                 s->bpp = 0;
386                 for (i = 0; i < count && buf < end_buf; i++)
387                     s->bpp += tget(&buf, type, s->le);
388                 break;
389             default:
390                 s->bpp = -1;
391             }
392         }
393         break;
394     case TIFF_SAMPLES_PER_PIXEL:
395         if (count != 1) {
396             av_log(s->avctx, AV_LOG_ERROR,
397                    "Samples per pixel requires a single value, many provided\n");
398             return AVERROR_INVALIDDATA;
399         }
400         if (s->bppcount == 1)
401             s->bpp *= value;
402         s->bppcount = value;
403         break;
404     case TIFF_COMPR:
405         s->compr     = value;
406         s->predictor = 0;
407         switch (s->compr) {
408         case TIFF_RAW:
409         case TIFF_PACKBITS:
410         case TIFF_LZW:
411         case TIFF_CCITT_RLE:
412             break;
413         case TIFF_G3:
414         case TIFF_G4:
415             s->fax_opts = 0;
416             break;
417         case TIFF_DEFLATE:
418         case TIFF_ADOBE_DEFLATE:
419 #if CONFIG_ZLIB
420             break;
421 #else
422             av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n");
423             return AVERROR(ENOSYS);
424 #endif
425         case TIFF_JPEG:
426         case TIFF_NEWJPEG:
427             av_log(s->avctx, AV_LOG_ERROR,
428                    "JPEG compression is not supported\n");
429             return AVERROR_PATCHWELCOME;
430         default:
431             av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n",
432                    s->compr);
433             return AVERROR_INVALIDDATA;
434         }
435         break;
436     case TIFF_ROWSPERSTRIP:
437         if (type == TIFF_LONG && value == UINT_MAX)
438             value = s->avctx->height;
439         if (value < 1) {
440             av_log(s->avctx, AV_LOG_ERROR,
441                    "Incorrect value of rows per strip\n");
442             return AVERROR_INVALIDDATA;
443         }
444         s->rps = value;
445         break;
446     case TIFF_STRIP_OFFS:
447         if (count == 1) {
448             s->stripdata = NULL;
449             s->stripoff  = value;
450         } else
451             s->stripdata = start + off;
452         s->strips = count;
453         if (s->strips == 1)
454             s->rps = s->height;
455         s->sot = type;
456         if (s->stripdata > end_buf) {
457             av_log(s->avctx, AV_LOG_ERROR,
458                    "Tag referencing position outside the image\n");
459             return AVERROR_INVALIDDATA;
460         }
461         break;
462     case TIFF_STRIP_SIZE:
463         if (count == 1) {
464             s->stripsizes = NULL;
465             s->stripsize  = value;
466             s->strips     = 1;
467         } else {
468             s->stripsizes = start + off;
469         }
470         s->strips = count;
471         s->sstype = type;
472         if (s->stripsizes > end_buf) {
473             av_log(s->avctx, AV_LOG_ERROR,
474                    "Tag referencing position outside the image\n");
475             return AVERROR_INVALIDDATA;
476         }
477         break;
478     case TIFF_PREDICTOR:
479         s->predictor = value;
480         break;
481     case TIFF_INVERT:
482         switch (value) {
483         case 0:
484             s->invert = 1;
485             break;
486         case 1:
487             s->invert = 0;
488             break;
489         case 2:
490         case 3:
491             break;
492         default:
493             av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n",
494                    value);
495             return AVERROR_INVALIDDATA;
496         }
497         break;
498     case TIFF_FILL_ORDER:
499         if (value < 1 || value > 2) {
500             av_log(s->avctx, AV_LOG_ERROR,
501                    "Unknown FillOrder value %d, trying default one\n", value);
502             value = 1;
503         }
504         s->fill_order = value - 1;
505         break;
506     case TIFF_PAL:
507         pal = (uint32_t *) s->palette;
508         off = type_sizes[type];
509         if (count / 3 > 256 || end_buf - buf < count / 3 * off * 3)
510             return AVERROR_INVALIDDATA;
511         rp  = buf;
512         gp  = buf + count / 3 * off;
513         bp  = buf + count / 3 * off * 2;
514         off = (type_sizes[type] - 1) << 3;
515         for (i = 0; i < count / 3; i++) {
516             j      = (tget(&rp, type, s->le) >> off) << 16;
517             j     |= (tget(&gp, type, s->le) >> off) << 8;
518             j     |= tget(&bp, type, s->le) >> off;
519             pal[i] = j;
520         }
521         s->palette_is_set = 1;
522         break;
523     case TIFF_PLANAR:
524         if (value == 2) {
525             av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n");
526             return AVERROR_PATCHWELCOME;
527         }
528         break;
529     case TIFF_T4OPTIONS:
530         if (s->compr == TIFF_G3)
531             s->fax_opts = value;
532         break;
533     case TIFF_T6OPTIONS:
534         if (s->compr == TIFF_G4)
535             s->fax_opts = value;
536         break;
537     default:
538         av_log(s->avctx, AV_LOG_DEBUG, "Unknown or unsupported tag %d/0X%0X\n",
539                tag, tag);
540     }
541     return 0;
542 }
543
544 static int decode_frame(AVCodecContext *avctx,
545                         void *data, int *got_frame, AVPacket *avpkt)
546 {
547     const uint8_t *buf = avpkt->data;
548     int buf_size       = avpkt->size;
549     TiffContext *const s = avctx->priv_data;
550     AVFrame *const p = data;
551     const uint8_t *orig_buf = buf, *end_buf = buf + buf_size;
552     unsigned off;
553     int id, le, ret;
554     int i, j, entries, 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, p)) < 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 = p->data[0];
651         for (j = 0; j < s->height; j++) {
652             for (i = 0; i < p->linesize[0]; i++)
653                 src[i] = 255 - src[i];
654             src += p->linesize[0];
655         }
656     }
657     *got_frame = 1;
658
659     return buf_size;
660 }
661
662 static av_cold int tiff_init(AVCodecContext *avctx)
663 {
664     TiffContext *s = avctx->priv_data;
665
666     s->width  = 0;
667     s->height = 0;
668     s->avctx  = avctx;
669     ff_lzw_decode_open(&s->lzw);
670     ff_ccitt_unpack_init();
671
672     return 0;
673 }
674
675 static av_cold int tiff_end(AVCodecContext *avctx)
676 {
677     TiffContext *const s = avctx->priv_data;
678
679     ff_lzw_decode_close(&s->lzw);
680     return 0;
681 }
682
683 AVCodec ff_tiff_decoder = {
684     .name           = "tiff",
685     .long_name      = NULL_IF_CONFIG_SMALL("TIFF image"),
686     .type           = AVMEDIA_TYPE_VIDEO,
687     .id             = AV_CODEC_ID_TIFF,
688     .priv_data_size = sizeof(TiffContext),
689     .init           = tiff_init,
690     .close          = tiff_end,
691     .decode         = decode_frame,
692     .capabilities   = CODEC_CAP_DR1,
693 };