git.sesse.net Git - ffmpeg/blob - 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 };