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 324:
 266         s->avctx->pix_fmt = AV_PIX_FMT_RGBA;
 267         break;
 268     case 483:
 269         s->avctx->pix_fmt = s->le ? AV_PIX_FMT_RGB48LE : AV_PIX_FMT_RGB48BE;
 270         break;
 271     default:
 272         av_log(s->avctx, AV_LOG_ERROR,
 273                "This format is not supported (bpp=%d, bppcount=%d)\n",
 274                s->bpp, s->bppcount);
 275         return AVERROR_INVALIDDATA;
 276     }
 277     if (s->width != s->avctx->width || s->height != s->avctx->height) {
 278         ret = ff_set_dimensions(s->avctx, s->width, s->height);
 279         if (ret < 0)
 280             return ret;
 281     }
 282     if ((ret = ff_get_buffer(s->avctx, frame, 0)) < 0) {
 283         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 284         return ret;
 285     }
 286     if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8) {
 287         if (s->palette_is_set) {
 288             memcpy(frame->data[1], s->palette, sizeof(s->palette));
 289         } else {
 290             /* make default grayscale pal */
 291             pal = (uint32_t *) frame->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)
 300 {
 301     unsigned tag, type, count, off, value = 0;
 302     int i, start;
 303
 304     if (bytestream2_get_bytes_left(&s->gb) < 12)
 305         return AVERROR_INVALIDDATA;
 306     tag   = tget_short(&s->gb, s->le);
 307     type  = tget_short(&s->gb, s->le);
 308     count = tget_long(&s->gb, s->le);
 309     off   = tget_long(&s->gb, s->le);
 310     start = bytestream2_tell(&s->gb);
 311
 312     if (type == 0 || type >= FF_ARRAY_ELEMS(type_sizes)) {
 313         av_log(s->avctx, AV_LOG_DEBUG, "Unknown tiff type (%u) encountered\n",
 314                type);
 315         return 0;
 316     }
 317
 318     if (count == 1) {
 319         switch (type) {
 320         case TIFF_BYTE:
 321         case TIFF_SHORT:
 322             bytestream2_seek(&s->gb, -4, SEEK_CUR);
 323             value = tget(&s->gb, type, s->le);
 324             break;
 325         case TIFF_LONG:
 326             value = off;
 327             break;
 328         case TIFF_STRING:
 329             if (count <= 4) {
 330                 bytestream2_seek(&s->gb, -4, SEEK_CUR);
 331                 break;
 332             }
 333         default:
 334             value = UINT_MAX;
 335             bytestream2_seek(&s->gb, off, SEEK_SET);
 336         }
 337     } else {
 338         if (count <= 4 && type_sizes[type] * count <= 4)
 339             bytestream2_seek(&s->gb, -4, SEEK_CUR);
 340         else
 341             bytestream2_seek(&s->gb, off, SEEK_SET);
 342     }
 343
 344     switch (tag) {
 345     case TIFF_WIDTH:
 346         s->width = value;
 347         break;
 348     case TIFF_HEIGHT:
 349         s->height = value;
 350         break;
 351     case TIFF_BPP:
 352         s->bppcount = count;
 353         if (count > 4) {
 354             av_log(s->avctx, AV_LOG_ERROR,
 355                    "This format is not supported (bpp=%d, %d components)\n",
 356                    s->bpp, count);
 357             return AVERROR_INVALIDDATA;
 358         }
 359         if (count == 1)
 360             s->bpp = value;
 361         else {
 362             switch (type) {
 363             case TIFF_BYTE:
 364                 s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) +
 365                          ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF);
 366                 break;
 367             case TIFF_SHORT:
 368             case TIFF_LONG:
 369                 s->bpp = 0;
 370                 for (i = 0; i < count; i++)
 371                     s->bpp += tget(&s->gb, type, s->le);
 372                 break;
 373             default:
 374                 s->bpp = -1;
 375             }
 376         }
 377         break;
 378     case TIFF_SAMPLES_PER_PIXEL:
 379         if (count != 1) {
 380             av_log(s->avctx, AV_LOG_ERROR,
 381                    "Samples per pixel requires a single value, many provided\n");
 382             return AVERROR_INVALIDDATA;
 383         }
 384         if (s->bppcount == 1)
 385             s->bpp *= value;
 386         s->bppcount = value;
 387         break;
 388     case TIFF_COMPR:
 389         s->compr     = value;
 390         s->predictor = 0;
 391         switch (s->compr) {
 392         case TIFF_RAW:
 393         case TIFF_PACKBITS:
 394         case TIFF_LZW:
 395         case TIFF_CCITT_RLE:
 396             break;
 397         case TIFF_G3:
 398         case TIFF_G4:
 399             s->fax_opts = 0;
 400             break;
 401         case TIFF_DEFLATE:
 402         case TIFF_ADOBE_DEFLATE:
 403 #if CONFIG_ZLIB
 404             break;
 405 #else
 406             av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n");
 407             return AVERROR(ENOSYS);
 408 #endif
 409         case TIFF_JPEG:
 410         case TIFF_NEWJPEG:
 411             avpriv_report_missing_feature(s->avctx, "JPEG compression");
 412             return AVERROR_PATCHWELCOME;
 413         default:
 414             av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n",
 415                    s->compr);
 416             return AVERROR_INVALIDDATA;
 417         }
 418         break;
 419     case TIFF_ROWSPERSTRIP:
 420         if (!value || (type == TIFF_LONG && value == UINT_MAX))
 421             value = s->height;
 422         s->rps = FFMIN(value, s->height);
 423         break;
 424     case TIFF_STRIP_OFFS:
 425         if (count == 1) {
 426             s->strippos = 0;
 427             s->stripoff = value;
 428         } else
 429             s->strippos = off;
 430         s->strips = count;
 431         if (s->strips == 1)
 432             s->rps = s->height;
 433         s->sot = type;
 434         break;
 435     case TIFF_STRIP_SIZE:
 436         if (count == 1) {
 437             s->stripsizesoff = 0;
 438             s->stripsize     = value;
 439             s->strips        = 1;
 440         } else {
 441             s->stripsizesoff = off;
 442         }
 443         s->strips = count;
 444         s->sstype = type;
 445         break;
 446     case TIFF_PREDICTOR:
 447         s->predictor = value;
 448         break;
 449     case TIFF_PHOTOMETRIC:
 450         switch (value) {
 451         case TIFF_PHOTOMETRIC_WHITE_IS_ZERO:
 452         case TIFF_PHOTOMETRIC_BLACK_IS_ZERO:
 453         case TIFF_PHOTOMETRIC_RGB:
 454         case TIFF_PHOTOMETRIC_PALETTE:
 455             s->photometric = value;
 456             break;
 457         case TIFF_PHOTOMETRIC_ALPHA_MASK:
 458         case TIFF_PHOTOMETRIC_SEPARATED:
 459         case TIFF_PHOTOMETRIC_YCBCR:
 460         case TIFF_PHOTOMETRIC_CIE_LAB:
 461         case TIFF_PHOTOMETRIC_ICC_LAB:
 462         case TIFF_PHOTOMETRIC_ITU_LAB:
 463         case TIFF_PHOTOMETRIC_CFA:
 464         case TIFF_PHOTOMETRIC_LOG_L:
 465         case TIFF_PHOTOMETRIC_LOG_LUV:
 466         case TIFF_PHOTOMETRIC_LINEAR_RAW:
 467             avpriv_report_missing_feature(s->avctx,
 468                                           "PhotometricInterpretation 0x%04X",
 469                                           value);
 470             return AVERROR_PATCHWELCOME;
 471         default:
 472             av_log(s->avctx, AV_LOG_ERROR, "PhotometricInterpretation %u is "
 473                    "unknown\n", value);
 474             return AVERROR_INVALIDDATA;
 475         }
 476         break;
 477     case TIFF_FILL_ORDER:
 478         if (value < 1 || value > 2) {
 479             av_log(s->avctx, AV_LOG_ERROR,
 480                    "Unknown FillOrder value %d, trying default one\n", value);
 481             value = 1;
 482         }
 483         s->fill_order = value - 1;
 484         break;
 485     case TIFF_PAL: {
 486         GetByteContext pal_gb[3];
 487         off = type_sizes[type];
 488         if (count / 3 > 256 ||
 489             bytestream2_get_bytes_left(&s->gb) < count / 3 * off * 3)
 490             return AVERROR_INVALIDDATA;
 491         pal_gb[0] = pal_gb[1] = pal_gb[2] = s->gb;
 492         bytestream2_skip(&pal_gb[1], count / 3 * off);
 493         bytestream2_skip(&pal_gb[2], count / 3 * off * 2);
 494         off = (type_sizes[type] - 1) << 3;
 495         for (i = 0; i < count / 3; i++) {
 496             uint32_t p = 0xFF000000;
 497             p |= (tget(&pal_gb[0], type, s->le) >> off) << 16;
 498             p |= (tget(&pal_gb[1], type, s->le) >> off) << 8;
 499             p |=  tget(&pal_gb[2], type, s->le) >> off;
 500             s->palette[i] = p;
 501         }
 502         s->palette_is_set = 1;
 503         break;
 504     }
 505     case TIFF_PLANAR:
 506         if (value == 2) {
 507             avpriv_report_missing_feature(s->avctx, "Planar format");
 508             return AVERROR_PATCHWELCOME;
 509         }
 510         break;
 511     case TIFF_T4OPTIONS:
 512         if (s->compr == TIFF_G3)
 513             s->fax_opts = value;
 514         break;
 515     case TIFF_T6OPTIONS:
 516         if (s->compr == TIFF_G4)
 517             s->fax_opts = value;
 518         break;
 519     default:
 520         if (s->avctx->err_recognition & AV_EF_EXPLODE) {
 521             av_log(s->avctx, AV_LOG_ERROR,
 522                    "Unknown or unsupported tag %d/0X%0X\n",
 523                    tag, tag);
 524             return AVERROR_INVALIDDATA;
 525         }
 526     }
 527     bytestream2_seek(&s->gb, start, SEEK_SET);
 528     return 0;
 529 }
 530
 531 static int decode_frame(AVCodecContext *avctx,
 532                         void *data, int *got_frame, AVPacket *avpkt)
 533 {
 534     TiffContext *const s = avctx->priv_data;
 535     AVFrame *const p = data;
 536     unsigned off;
 537     int id, le, ret;
 538     int i, j, entries, stride;
 539     unsigned soff, ssize;
 540     uint8_t *dst;
 541     GetByteContext stripsizes;
 542     GetByteContext stripdata;
 543
 544     bytestream2_init(&s->gb, avpkt->data, avpkt->size);
 545
 546     // parse image header
 547     if (avpkt->size < 8)
 548         return AVERROR_INVALIDDATA;
 549     id = bytestream2_get_le16(&s->gb);
 550     if (id == 0x4949)
 551         le = 1;
 552     else if (id == 0x4D4D)
 553         le = 0;
 554     else {
 555         av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n");
 556         return AVERROR_INVALIDDATA;
 557     }
 558     s->le          = le;
 559     s->photometric = TIFF_PHOTOMETRIC_NONE;
 560     s->compr       = TIFF_RAW;
 561     s->fill_order  = 0;
 562     // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number
 563     // that further identifies the file as a TIFF file"
 564     if (tget_short(&s->gb, le) != 42) {
 565         av_log(avctx, AV_LOG_ERROR,
 566                "The answer to life, universe and everything is not correct!\n");
 567         return AVERROR_INVALIDDATA;
 568     }
 569     // Reset these offsets so we can tell if they were set this frame
 570     s->stripsizesoff = s->strippos = 0;
 571     /* parse image file directory */
 572     off = tget_long(&s->gb, le);
 573     if (off >= UINT_MAX - 14 || avpkt->size < off + 14) {
 574         av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n");
 575         return AVERROR_INVALIDDATA;
 576     }
 577     bytestream2_seek(&s->gb, off, SEEK_SET);
 578     entries = tget_short(&s->gb, le);
 579     for (i = 0; i < entries; i++) {
 580         if ((ret = tiff_decode_tag(s)) < 0)
 581             return ret;
 582     }
 583     if (!s->strippos && !s->stripoff) {
 584         av_log(avctx, AV_LOG_ERROR, "Image data is missing\n");
 585         return AVERROR_INVALIDDATA;
 586     }
 587     /* now we have the data and may start decoding */
 588     if ((ret = init_image(s, p)) < 0)
 589         return ret;
 590
 591     if (s->strips == 1 && !s->stripsize) {
 592         av_log(avctx, AV_LOG_WARNING, "Image data size missing\n");
 593         s->stripsize = avpkt->size - s->stripoff;
 594     }
 595     stride = p->linesize[0];
 596     dst    = p->data[0];
 597
 598     if (s->stripsizesoff) {
 599         if (s->stripsizesoff >= avpkt->size)
 600             return AVERROR_INVALIDDATA;
 601         bytestream2_init(&stripsizes, avpkt->data + s->stripsizesoff,
 602                          avpkt->size - s->stripsizesoff);
 603     }
 604     if (s->strippos) {
 605         if (s->strippos >= avpkt->size)
 606             return AVERROR_INVALIDDATA;
 607         bytestream2_init(&stripdata, avpkt->data + s->strippos,
 608                          avpkt->size - s->strippos);
 609     }
 610
 611     for (i = 0; i < s->height; i += s->rps) {
 612         if (s->stripsizesoff)
 613             ssize = tget(&stripsizes, s->sstype, le);
 614         else
 615             ssize = s->stripsize;
 616
 617         if (s->strippos)
 618             soff = tget(&stripdata, s->sot, le);
 619         else
 620             soff = s->stripoff;
 621
 622         if (soff > avpkt->size || ssize > avpkt->size - soff) {
 623             av_log(avctx, AV_LOG_ERROR, "Invalid strip size/offset\n");
 624             return AVERROR_INVALIDDATA;
 625         }
 626         if ((ret = tiff_unpack_strip(s, dst, stride, avpkt->data + soff, ssize,
 627                                      FFMIN(s->rps, s->height - i))) < 0) {
 628             if (avctx->err_recognition & AV_EF_EXPLODE)
 629                 return ret;
 630             break;
 631         }
 632         dst += s->rps * stride;
 633     }
 634     if (s->predictor == 2) {
 635         dst   = p->data[0];
 636         soff  = s->bpp >> 3;
 637         ssize = s->width * soff;
 638         if (s->avctx->pix_fmt == AV_PIX_FMT_RGB48LE) {
 639             for (i = 0; i < s->height; i++) {
 640                 for (j = soff; j < ssize; j += 2)
 641                     AV_WL16(dst + j, AV_RL16(dst + j) + AV_RL16(dst + j - soff));
 642                 dst += stride;
 643             }
 644         } else if (s->avctx->pix_fmt == AV_PIX_FMT_RGB48BE) {
 645             for (i = 0; i < s->height; i++) {
 646                 for (j = soff; j < ssize; j += 2)
 647                     AV_WB16(dst + j, AV_RB16(dst + j) + AV_RB16(dst + j - soff));
 648                 dst += stride;
 649             }
 650         } else {
 651             for (i = 0; i < s->height; i++) {
 652                 for (j = soff; j < ssize; j++)
 653                     dst[j] += dst[j - soff];
 654                 dst += stride;
 655             }
 656         }
 657     }
 658
 659     if (s->photometric == TIFF_PHOTOMETRIC_WHITE_IS_ZERO) {
 660         dst = p->data[0];
 661         for (i = 0; i < s->height; i++) {
 662             for (j = 0; j < p->linesize[0]; j++)
 663                 dst[j] = 255 - dst[j];
 664             dst += stride;
 665         }
 666     }
 667     *got_frame = 1;
 668
 669     return avpkt->size;
 670 }
 671
 672 static av_cold int tiff_init(AVCodecContext *avctx)
 673 {
 674     TiffContext *s = avctx->priv_data;
 675
 676     s->width  = 0;
 677     s->height = 0;
 678     s->avctx  = avctx;
 679     ff_lzw_decode_open(&s->lzw);
 680     ff_ccitt_unpack_init();
 681
 682     return 0;
 683 }
 684
 685 static av_cold int tiff_end(AVCodecContext *avctx)
 686 {
 687     TiffContext *const s = avctx->priv_data;
 688
 689     ff_lzw_decode_close(&s->lzw);
 690     return 0;
 691 }
 692
 693 AVCodec ff_tiff_decoder = {
 694     .name           = "tiff",
 695     .long_name      = NULL_IF_CONFIG_SMALL("TIFF image"),
 696     .type           = AVMEDIA_TYPE_VIDEO,
 697     .id             = AV_CODEC_ID_TIFF,
 698     .priv_data_size = sizeof(TiffContext),
 699     .init           = tiff_init,
 700     .close          = tiff_end,
 701     .decode         = decode_frame,
 702     .capabilities   = CODEC_CAP_DR1,
 703 };