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