1/* 2 * TIFF image decoder 3 * Copyright (c) 2006 Konstantin Shishkov 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg 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 * FFmpeg 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 FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22/** 23 * TIFF image decoder 24 * @file libavcodec/tiff.c 25 * @author Konstantin Shishkov 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 35 36typedef struct TiffContext { 37 AVCodecContext *avctx; 38 AVFrame picture; 39 40 int width, height; 41 unsigned int bpp; 42 int le; 43 int compr; 44 int invert; 45 int fax_opts; 46 int predictor; 47 48 int strips, rps, sstype; 49 int sot; 50 const uint8_t* stripdata; 51 const uint8_t* stripsizes; 52 int stripsize, stripoff; 53 LZWState *lzw; 54} TiffContext; 55 56static int tget_short(const uint8_t **p, int le){ 57 int v = le ? AV_RL16(*p) : AV_RB16(*p); 58 *p += 2; 59 return v; 60} 61 62static int tget_long(const uint8_t **p, int le){ 63 int v = le ? AV_RL32(*p) : AV_RB32(*p); 64 *p += 4; 65 return v; 66} 67 68static int tget(const uint8_t **p, int type, int le){ 69 switch(type){ 70 case TIFF_BYTE : return *(*p)++; 71 case TIFF_SHORT: return tget_short(p, le); 72 case TIFF_LONG : return tget_long (p, le); 73 default : return -1; 74 } 75} 76 77static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uint8_t *src, int size, int lines){ 78 int c, line, pixels, code; 79 const uint8_t *ssrc = src; 80 int width = s->width * s->bpp >> 3; 81#if CONFIG_ZLIB 82 uint8_t *zbuf; unsigned long outlen; 83 84 if(s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE){ 85 outlen = width * lines; 86 zbuf = av_malloc(outlen); 87 if(uncompress(zbuf, &outlen, src, size) != Z_OK){ 88 av_log(s->avctx, AV_LOG_ERROR, "Uncompressing failed (%lu of %lu)\n", outlen, (unsigned long)width * lines); 89 av_free(zbuf); 90 return -1; 91 } 92 src = zbuf; 93 for(line = 0; line < lines; line++){ 94 memcpy(dst, src, width); 95 dst += stride; 96 src += width; 97 } 98 av_free(zbuf); 99 return 0; 100 } 101#endif 102 if(s->compr == TIFF_LZW){ 103 if(ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF) < 0){ 104 av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n"); 105 return -1; 106 } 107 } 108 if(s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3 || s->compr == TIFF_G4){ 109 int i, ret = 0; 110 uint8_t *src2 = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); 111 112 if(!src2 || (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE < (unsigned)size){ 113 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n"); 114 return -1; 115 } 116 for(i = 0; i < size; i++) 117 src2[i] = ff_reverse[src[i]]; 118 memset(src2+size, 0, FF_INPUT_BUFFER_PADDING_SIZE); 119 if(s->compr == TIFF_G3 && !(s->fax_opts & 1)) 120 s->compr = TIFF_CCITT_RLE; 121 switch(s->compr){ 122 case TIFF_CCITT_RLE: 123 case TIFF_G3: 124 case TIFF_G4: 125 ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride, s->compr); 126 break; 127 } 128 av_free(src2); 129 return ret; 130 } 131 for(line = 0; line < lines; line++){ 132 if(src - ssrc > size){ 133 av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n"); 134 return -1; 135 } 136 switch(s->compr){ 137 case TIFF_RAW: 138 memcpy(dst, src, width); 139 src += width; 140 break; 141 case TIFF_PACKBITS: 142 for(pixels = 0; pixels < width;){ 143 code = (int8_t)*src++; 144 if(code >= 0){ 145 code++; 146 if(pixels + code > width){ 147 av_log(s->avctx, AV_LOG_ERROR, "Copy went out of bounds\n"); 148 return -1; 149 } 150 memcpy(dst + pixels, src, code); 151 src += code; 152 pixels += code; 153 }else if(code != -128){ // -127..-1 154 code = (-code) + 1; 155 if(pixels + code > width){ 156 av_log(s->avctx, AV_LOG_ERROR, "Run went out of bounds\n"); 157 return -1; 158 } 159 c = *src++; 160 memset(dst + pixels, c, code); 161 pixels += code; 162 } 163 } 164 break; 165 case TIFF_LZW: 166 pixels = ff_lzw_decode(s->lzw, dst, width); 167 if(pixels < width){ 168 av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n", pixels, width); 169 return -1; 170 } 171 break; 172 } 173 dst += stride; 174 } 175 return 0; 176} 177 178 179static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf) 180{ 181 int tag, type, count, off, value = 0; 182 int i, j; 183 uint32_t *pal; 184 const uint8_t *rp, *gp, *bp; 185 186 tag = tget_short(&buf, s->le); 187 type = tget_short(&buf, s->le); 188 count = tget_long(&buf, s->le); 189 off = tget_long(&buf, s->le); 190 191 if(count == 1){ 192 switch(type){ 193 case TIFF_BYTE: 194 case TIFF_SHORT: 195 buf -= 4; 196 value = tget(&buf, type, s->le); 197 buf = NULL; 198 break; 199 case TIFF_LONG: 200 value = off; 201 buf = NULL; 202 break; 203 case TIFF_STRING: 204 if(count <= 4){ 205 buf -= 4; 206 break; 207 } 208 default: 209 value = -1; 210 buf = start + off; 211 } 212 }else if(type_sizes[type] * count <= 4){ 213 buf -= 4; 214 }else{ 215 buf = start + off; 216 } 217 218 if(buf && (buf < start || buf > end_buf)){ 219 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); 220 return -1; 221 } 222 223 switch(tag){ 224 case TIFF_WIDTH: 225 s->width = value; 226 break; 227 case TIFF_HEIGHT: 228 s->height = value; 229 break; 230 case TIFF_BPP: 231 if(count == 1) s->bpp = value; 232 else{ 233 switch(type){ 234 case TIFF_BYTE: 235 s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) + ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF); 236 break; 237 case TIFF_SHORT: 238 case TIFF_LONG: 239 s->bpp = 0; 240 for(i = 0; i < count; i++) s->bpp += tget(&buf, type, s->le); 241 break; 242 default: 243 s->bpp = -1; 244 } 245 } 246 switch(s->bpp){ 247 case 1: 248 s->avctx->pix_fmt = PIX_FMT_MONOBLACK; 249 break; 250 case 8: 251 s->avctx->pix_fmt = PIX_FMT_PAL8; 252 break; 253 case 24: 254 s->avctx->pix_fmt = PIX_FMT_RGB24; 255 break; 256 case 16: 257 if(count == 1){ 258 s->avctx->pix_fmt = PIX_FMT_GRAY16BE; 259 }else{ 260 av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%i)\n", s->bpp); 261 return -1; 262 } 263 break; 264 default: 265 av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%i)\n", s->bpp); 266 return -1; 267 } 268 if(s->width != s->avctx->width || s->height != s->avctx->height){ 269 if(avcodec_check_dimensions(s->avctx, s->width, s->height)) 270 return -1; 271 avcodec_set_dimensions(s->avctx, s->width, s->height); 272 } 273 if(s->picture.data[0]) 274 s->avctx->release_buffer(s->avctx, &s->picture); 275 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){ 276 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); 277 return -1; 278 } 279 if(s->bpp == 8){ 280 /* make default grayscale pal */ 281 pal = (uint32_t *) s->picture.data[1]; 282 for(i = 0; i < 256; i++) 283 pal[i] = i * 0x010101; 284 } 285 break; 286 case TIFF_COMPR: 287 s->compr = value; 288 s->predictor = 0; 289 switch(s->compr){ 290 case TIFF_RAW: 291 case TIFF_PACKBITS: 292 case TIFF_LZW: 293 case TIFF_CCITT_RLE: 294 break; 295 case TIFF_G3: 296 case TIFF_G4: 297 s->fax_opts = 0; 298 break; 299 case TIFF_DEFLATE: 300 case TIFF_ADOBE_DEFLATE: 301#if CONFIG_ZLIB 302 break; 303#else 304 av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n"); 305 return -1; 306#endif 307 case TIFF_JPEG: 308 case TIFF_NEWJPEG: 309 av_log(s->avctx, AV_LOG_ERROR, "JPEG compression is not supported\n"); 310 return -1; 311 default: 312 av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n", s->compr); 313 return -1; 314 } 315 break; 316 case TIFF_ROWSPERSTRIP: 317 if(type == TIFF_LONG && value == -1) 318 value = s->avctx->height; 319 if(value < 1){ 320 av_log(s->avctx, AV_LOG_ERROR, "Incorrect value of rows per strip\n"); 321 return -1; 322 } 323 s->rps = value; 324 break; 325 case TIFF_STRIP_OFFS: 326 if(count == 1){ 327 s->stripdata = NULL; 328 s->stripoff = value; 329 }else 330 s->stripdata = start + off; 331 s->strips = count; 332 if(s->strips == 1) s->rps = s->height; 333 s->sot = type; 334 if(s->stripdata > end_buf){ 335 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); 336 return -1; 337 } 338 break; 339 case TIFF_STRIP_SIZE: 340 if(count == 1){ 341 s->stripsizes = NULL; 342 s->stripsize = value; 343 s->strips = 1; 344 }else{ 345 s->stripsizes = start + off; 346 } 347 s->strips = count; 348 s->sstype = type; 349 if(s->stripsizes > end_buf){ 350 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); 351 return -1; 352 } 353 break; 354 case TIFF_PREDICTOR: 355 s->predictor = value; 356 break; 357 case TIFF_INVERT: 358 switch(value){ 359 case 0: 360 s->invert = 1; 361 break; 362 case 1: 363 s->invert = 0; 364 break; 365 case 2: 366 case 3: 367 break; 368 default: 369 av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n", value); 370 return -1; 371 } 372 break; 373 case TIFF_PAL: 374 if(s->avctx->pix_fmt != PIX_FMT_PAL8){ 375 av_log(s->avctx, AV_LOG_ERROR, "Palette met but this is not palettized format\n"); 376 return -1; 377 } 378 pal = (uint32_t *) s->picture.data[1]; 379 off = type_sizes[type]; 380 rp = buf; 381 gp = buf + count / 3 * off; 382 bp = buf + count / 3 * off * 2; 383 off = (type_sizes[type] - 1) << 3; 384 for(i = 0; i < count / 3; i++){ 385 j = (tget(&rp, type, s->le) >> off) << 16; 386 j |= (tget(&gp, type, s->le) >> off) << 8; 387 j |= tget(&bp, type, s->le) >> off; 388 pal[i] = j; 389 } 390 break; 391 case TIFF_PLANAR: 392 if(value == 2){ 393 av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n"); 394 return -1; 395 } 396 break; 397 case TIFF_T4OPTIONS: 398 case TIFF_T6OPTIONS: 399 s->fax_opts = value; 400 break; 401 } 402 return 0; 403} 404 405static int decode_frame(AVCodecContext *avctx, 406 void *data, int *data_size, 407 const uint8_t *buf, int buf_size) 408{ 409 TiffContext * const s = avctx->priv_data; 410 AVFrame *picture = data; 411 AVFrame * const p= (AVFrame*)&s->picture; 412 const uint8_t *orig_buf = buf, *end_buf = buf + buf_size; 413 int id, le, off; 414 int i, j, entries; 415 int stride, soff, ssize; 416 uint8_t *dst; 417 418 //parse image header 419 id = AV_RL16(buf); buf += 2; 420 if(id == 0x4949) le = 1; 421 else if(id == 0x4D4D) le = 0; 422 else{ 423 av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n"); 424 return -1; 425 } 426 s->le = le; 427 s->invert = 0; 428 s->compr = TIFF_RAW; 429 // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number 430 // that further identifies the file as a TIFF file" 431 if(tget_short(&buf, le) != 42){ 432 av_log(avctx, AV_LOG_ERROR, "The answer to life, universe and everything is not correct!\n"); 433 return -1; 434 } 435 /* parse image file directory */ 436 off = tget_long(&buf, le); 437 if(orig_buf + off + 14 >= end_buf){ 438 av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n"); 439 return -1; 440 } 441 buf = orig_buf + off; 442 entries = tget_short(&buf, le); 443 for(i = 0; i < entries; i++){ 444 if(tiff_decode_tag(s, orig_buf, buf, end_buf) < 0) 445 return -1; 446 buf += 12; 447 } 448 if(!s->stripdata && !s->stripoff){ 449 av_log(avctx, AV_LOG_ERROR, "Image data is missing\n"); 450 return -1; 451 } 452 /* now we have the data and may start decoding */ 453 if(!p->data[0]){ 454 av_log(s->avctx, AV_LOG_ERROR, "Picture initialization missing\n"); 455 return -1; 456 } 457 if(s->strips == 1 && !s->stripsize){ 458 av_log(avctx, AV_LOG_WARNING, "Image data size missing\n"); 459 s->stripsize = buf_size - s->stripoff; 460 } 461 stride = p->linesize[0]; 462 dst = p->data[0]; 463 for(i = 0; i < s->height; i += s->rps){ 464 if(s->stripsizes) 465 ssize = tget(&s->stripsizes, s->sstype, s->le); 466 else 467 ssize = s->stripsize; 468 469 if(s->stripdata){ 470 soff = tget(&s->stripdata, s->sot, s->le); 471 }else 472 soff = s->stripoff; 473 if(tiff_unpack_strip(s, dst, stride, orig_buf + soff, ssize, FFMIN(s->rps, s->height - i)) < 0) 474 break; 475 dst += s->rps * stride; 476 } 477 if(s->predictor == 2){ 478 dst = p->data[0]; 479 soff = s->bpp >> 3; 480 ssize = s->width * soff; 481 for(i = 0; i < s->height; i++) { 482 for(j = soff; j < ssize; j++) 483 dst[j] += dst[j - soff]; 484 dst += stride; 485 } 486 } 487 488 if(s->invert){ 489 uint8_t *src; 490 int j; 491 492 src = s->picture.data[0]; 493 for(j = 0; j < s->height; j++){ 494 for(i = 0; i < s->picture.linesize[0]; i++) 495 src[i] = 255 - src[i]; 496 src += s->picture.linesize[0]; 497 } 498 } 499 *picture= *(AVFrame*)&s->picture; 500 *data_size = sizeof(AVPicture); 501 502 return buf_size; 503} 504 505static av_cold int tiff_init(AVCodecContext *avctx){ 506 TiffContext *s = avctx->priv_data; 507 508 s->width = 0; 509 s->height = 0; 510 s->avctx = avctx; 511 avcodec_get_frame_defaults((AVFrame*)&s->picture); 512 avctx->coded_frame= (AVFrame*)&s->picture; 513 s->picture.data[0] = NULL; 514 ff_lzw_decode_open(&s->lzw); 515 ff_ccitt_unpack_init(); 516 517 return 0; 518} 519 520static av_cold int tiff_end(AVCodecContext *avctx) 521{ 522 TiffContext * const s = avctx->priv_data; 523 524 ff_lzw_decode_close(&s->lzw); 525 if(s->picture.data[0]) 526 avctx->release_buffer(avctx, &s->picture); 527 return 0; 528} 529 530AVCodec tiff_decoder = { 531 "tiff", 532 CODEC_TYPE_VIDEO, 533 CODEC_ID_TIFF, 534 sizeof(TiffContext), 535 tiff_init, 536 NULL, 537 tiff_end, 538 decode_frame, 539 0, 540 NULL, 541 .long_name = NULL_IF_CONFIG_SMALL("TIFF image"), 542}; 543