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