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