tiff.c
Go to the documentation of this file.
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 
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #if CONFIG_ZLIB
31 #include <zlib.h>
32 #endif
33 #include "lzw.h"
34 #include "tiff.h"
35 #include "faxcompr.h"
36 #include "libavutil/common.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/imgutils.h"
39 
40 typedef struct TiffContext {
44 
45  int width, height;
46  unsigned int bpp, bppcount;
47  uint32_t palette[256];
49  int le;
51  int invert;
52  int fax_opts;
53  int predictor;
55 
56  int strips, rps, sstype;
57  int sot;
60 } TiffContext;
61 
62 static unsigned tget_short(GetByteContext *gb, int le)
63 {
64  return le ? bytestream2_get_le16(gb) : bytestream2_get_be16(gb);
65 }
66 
67 static unsigned tget_long(GetByteContext *gb, int le)
68 {
69  return le ? bytestream2_get_le32(gb) : bytestream2_get_be32(gb);
70 }
71 
72 static unsigned tget(GetByteContext *gb, int type, int le)
73 {
74  switch(type){
75  case TIFF_BYTE: return bytestream2_get_byte(gb);
76  case TIFF_SHORT: return tget_short(gb, le);
77  case TIFF_LONG: return tget_long(gb, le);
78  default: return UINT_MAX;
79  }
80 }
81 
82 #if CONFIG_ZLIB
83 static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src, int size)
84 {
85  z_stream zstream;
86  int zret;
87 
88  memset(&zstream, 0, sizeof(zstream));
89  zstream.next_in = src;
90  zstream.avail_in = size;
91  zstream.next_out = dst;
92  zstream.avail_out = *len;
93  zret = inflateInit(&zstream);
94  if (zret != Z_OK) {
95  av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
96  return zret;
97  }
98  zret = inflate(&zstream, Z_SYNC_FLUSH);
99  inflateEnd(&zstream);
100  *len = zstream.total_out;
101  return zret == Z_STREAM_END ? Z_OK : zret;
102 }
103 #endif
104 
105 static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uint8_t *src, int size, int lines){
106  PutByteContext pb;
107  int c, line, pixels, code;
108  int width = ((s->width * s->bpp) + 7) >> 3;
109 #if CONFIG_ZLIB
110  uint8_t *zbuf; unsigned long outlen;
111 
112  if(s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE){
113  int ret;
114  outlen = width * lines;
115  zbuf = av_malloc(outlen);
116  ret = tiff_uncompress(zbuf, &outlen, src, size);
117  if(ret != Z_OK){
118  av_log(s->avctx, AV_LOG_ERROR, "Uncompressing failed (%lu of %lu) with error %d\n", outlen, (unsigned long)width * lines, ret);
119  av_free(zbuf);
120  return -1;
121  }
122  src = zbuf;
123  for(line = 0; line < lines; line++){
124  memcpy(dst, src, width);
125  dst += stride;
126  src += width;
127  }
128  av_free(zbuf);
129  return 0;
130  }
131 #endif
132  if(s->compr == TIFF_LZW){
133  if(ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF) < 0){
134  av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n");
135  return -1;
136  }
137  for (line = 0; line < lines; line++) {
138  pixels = ff_lzw_decode(s->lzw, dst, width);
139  if (pixels < width) {
140  av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n",
141  pixels, width);
142  return AVERROR_INVALIDDATA;
143  }
144  dst += stride;
145  }
146  return 0;
147  }
148  if(s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3 || s->compr == TIFF_G4){
149  int i, ret = 0;
150  uint8_t *src2 = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
151 
152  if(!src2 || (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE < (unsigned)size){
153  av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");
154  return -1;
155  }
156  if(s->fax_opts & 2){
157  av_log(s->avctx, AV_LOG_ERROR, "Uncompressed fax mode is not supported (yet)\n");
158  av_free(src2);
159  return -1;
160  }
161  if(!s->fill_order){
162  memcpy(src2, src, size);
163  }else{
164  for(i = 0; i < size; i++)
165  src2[i] = av_reverse[src[i]];
166  }
167  memset(src2+size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
168  switch(s->compr){
169  case TIFF_CCITT_RLE:
170  case TIFF_G3:
171  case TIFF_G4:
172  ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride, s->compr, s->fax_opts);
173  break;
174  }
175  av_free(src2);
176  return ret;
177  }
178 
179  bytestream2_init(&s->gb, src, size);
180  bytestream2_init_writer(&pb, dst, stride * lines);
181 
182  for(line = 0; line < lines; line++){
183  if (bytestream2_get_bytes_left(&s->gb) == 0 || bytestream2_get_eof(&pb))
184  break;
185  bytestream2_seek_p(&pb, stride * line, SEEK_SET);
186  switch(s->compr){
187  case TIFF_RAW:
188  if (!s->fill_order) {
189  bytestream2_copy_buffer(&pb, &s->gb, width);
190  } else {
191  int i;
192  for (i = 0; i < width; i++)
193  bytestream2_put_byte(&pb, av_reverse[bytestream2_get_byte(&s->gb)]);
194  }
195  break;
196  case TIFF_PACKBITS:
197  for(pixels = 0; pixels < width;){
198  code = (int8_t)bytestream2_get_byte(&s->gb);
199  if(code >= 0){
200  code++;
201  bytestream2_copy_buffer(&pb, &s->gb, code);
202  pixels += code;
203  }else if(code != -128){ // -127..-1
204  code = (-code) + 1;
205  c = bytestream2_get_byte(&s->gb);
206  bytestream2_set_buffer(&pb, c, code);
207  pixels += code;
208  }
209  }
210  break;
211  }
212  }
213  return 0;
214 }
215 
216 static int init_image(TiffContext *s)
217 {
218  int i, ret;
219  uint32_t *pal;
220 
221  switch (s->bpp * 10 + s->bppcount) {
222  case 11:
224  break;
225  case 81:
226  s->avctx->pix_fmt = PIX_FMT_PAL8;
227  break;
228  case 243:
230  break;
231  case 161:
233  break;
234  case 324:
235  s->avctx->pix_fmt = PIX_FMT_RGBA;
236  break;
237  case 483:
239  break;
240  default:
242  "This format is not supported (bpp=%d, bppcount=%d)\n",
243  s->bpp, s->bppcount);
244  return AVERROR_INVALIDDATA;
245  }
246  if (s->width != s->avctx->width || s->height != s->avctx->height) {
247  if ((ret = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
248  return ret;
250  }
251  if (s->picture.data[0])
252  s->avctx->release_buffer(s->avctx, &s->picture);
253  if ((ret = s->avctx->get_buffer(s->avctx, &s->picture)) < 0) {
254  av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
255  return ret;
256  }
257  if (s->avctx->pix_fmt == PIX_FMT_PAL8) {
258  if (s->palette_is_set) {
259  memcpy(s->picture.data[1], s->palette, sizeof(s->palette));
260  } else {
261  /* make default grayscale pal */
262  pal = (uint32_t *) s->picture.data[1];
263  for (i = 0; i < 256; i++)
264  pal[i] = i * 0x010101;
265  }
266  }
267  return 0;
268 }
269 
271 {
272  unsigned tag, type, count, off, value = 0;
273  int i, start;
274  uint32_t *pal;
275 
276  if (bytestream2_get_bytes_left(&s->gb) < 12)
277  return -1;
278  tag = tget_short(&s->gb, s->le);
279  type = tget_short(&s->gb, s->le);
280  count = tget_long(&s->gb, s->le);
281  off = tget_long(&s->gb, s->le);
282  start = bytestream2_tell(&s->gb);
283 
284  if (type == 0 || type >= FF_ARRAY_ELEMS(type_sizes)) {
285  av_log(s->avctx, AV_LOG_DEBUG, "Unknown tiff type (%u) encountered\n", type);
286  return 0;
287  }
288 
289  if(count == 1){
290  switch(type){
291  case TIFF_BYTE:
292  case TIFF_SHORT:
293  bytestream2_seek(&s->gb, -4, SEEK_CUR);
294  value = tget(&s->gb, type, s->le);
295  break;
296  case TIFF_LONG:
297  value = off;
298  break;
299  case TIFF_STRING:
300  if(count <= 4){
301  bytestream2_seek(&s->gb, -4, SEEK_CUR);
302  break;
303  }
304  default:
305  value = UINT_MAX;
306  bytestream2_seek(&s->gb, off, SEEK_SET);
307  }
308  } else {
309  if (count <= 4 && type_sizes[type] * count <= 4)
310  bytestream2_seek(&s->gb, -4, SEEK_CUR);
311  else
312  bytestream2_seek(&s->gb, off, SEEK_SET);
313  }
314 
315  switch(tag){
316  case TIFF_WIDTH:
317  s->width = value;
318  break;
319  case TIFF_HEIGHT:
320  s->height = value;
321  break;
322  case TIFF_BPP:
323  s->bppcount = count;
324  if(count > 4){
325  av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count);
326  return -1;
327  }
328  if(count == 1) s->bpp = value;
329  else{
330  switch(type){
331  case TIFF_BYTE:
332  s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) + ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF);
333  break;
334  case TIFF_SHORT:
335  case TIFF_LONG:
336  s->bpp = 0;
337  for (i = 0; i < count; i++)
338  s->bpp += tget(&s->gb, type, s->le);
339  break;
340  default:
341  s->bpp = -1;
342  }
343  }
344  break;
346  if (count != 1) {
348  "Samples per pixel requires a single value, many provided\n");
349  return AVERROR_INVALIDDATA;
350  }
351  if (s->bppcount == 1)
352  s->bpp *= value;
353  s->bppcount = value;
354  break;
355  case TIFF_COMPR:
356  s->compr = value;
357  s->predictor = 0;
358  switch(s->compr){
359  case TIFF_RAW:
360  case TIFF_PACKBITS:
361  case TIFF_LZW:
362  case TIFF_CCITT_RLE:
363  break;
364  case TIFF_G3:
365  case TIFF_G4:
366  s->fax_opts = 0;
367  break;
368  case TIFF_DEFLATE:
369  case TIFF_ADOBE_DEFLATE:
370 #if CONFIG_ZLIB
371  break;
372 #else
373  av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n");
374  return -1;
375 #endif
376  case TIFF_JPEG:
377  case TIFF_NEWJPEG:
378  av_log(s->avctx, AV_LOG_ERROR, "JPEG compression is not supported\n");
379  return -1;
380  default:
381  av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n", s->compr);
382  return -1;
383  }
384  break;
385  case TIFF_ROWSPERSTRIP:
386  if (type == TIFF_LONG && value == UINT_MAX)
387  value = s->avctx->height;
388  if(value < 1){
389  av_log(s->avctx, AV_LOG_ERROR, "Incorrect value of rows per strip\n");
390  return -1;
391  }
392  s->rps = value;
393  break;
394  case TIFF_STRIP_OFFS:
395  if(count == 1){
396  s->strippos = 0;
397  s->stripoff = value;
398  }else
399  s->strippos = off;
400  s->strips = count;
401  if(s->strips == 1) s->rps = s->height;
402  s->sot = type;
403  break;
404  case TIFF_STRIP_SIZE:
405  if(count == 1){
406  s->stripsizesoff = 0;
407  s->stripsize = value;
408  s->strips = 1;
409  }else{
410  s->stripsizesoff = off;
411  }
412  s->strips = count;
413  s->sstype = type;
414  break;
415  case TIFF_PREDICTOR:
416  s->predictor = value;
417  break;
418  case TIFF_INVERT:
419  switch(value){
420  case 0:
421  s->invert = 1;
422  break;
423  case 1:
424  s->invert = 0;
425  break;
426  case 2:
427  case 3:
428  break;
429  default:
430  av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n", value);
431  return -1;
432  }
433  break;
434  case TIFF_FILL_ORDER:
435  if(value < 1 || value > 2){
436  av_log(s->avctx, AV_LOG_ERROR, "Unknown FillOrder value %d, trying default one\n", value);
437  value = 1;
438  }
439  s->fill_order = value - 1;
440  break;
441  case TIFF_PAL: {
442  GetByteContext pal_gb[3];
443  pal = (uint32_t *) s->palette;
444  off = type_sizes[type];
445  if (count / 3 > 256 ||
446  bytestream2_get_bytes_left(&s->gb) < count / 3 * off * 3)
447  return -1;
448  pal_gb[0] = pal_gb[1] = pal_gb[2] = s->gb;
449  bytestream2_skip(&pal_gb[1], count / 3 * off);
450  bytestream2_skip(&pal_gb[2], count / 3 * off * 2);
451  off = (type_sizes[type] - 1) << 3;
452  for(i = 0; i < count / 3; i++){
453  uint32_t p = 0xFF000000;
454  p |= (tget(&pal_gb[0], type, s->le) >> off) << 16;
455  p |= (tget(&pal_gb[1], type, s->le) >> off) << 8;
456  p |= tget(&pal_gb[2], type, s->le) >> off;
457  pal[i] = p;
458  }
459  s->palette_is_set = 1;
460  break;
461  }
462  case TIFF_PLANAR:
463  if(value == 2){
464  av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n");
465  return -1;
466  }
467  break;
468  case TIFF_T4OPTIONS:
469  if(s->compr == TIFF_G3)
470  s->fax_opts = value;
471  break;
472  case TIFF_T6OPTIONS:
473  if(s->compr == TIFF_G4)
474  s->fax_opts = value;
475  break;
476  default:
477  av_log(s->avctx, AV_LOG_DEBUG, "Unknown or unsupported tag %d/0X%0X\n", tag, tag);
478  }
479  bytestream2_seek(&s->gb, start, SEEK_SET);
480  return 0;
481 }
482 
483 static int decode_frame(AVCodecContext *avctx,
484  void *data, int *data_size,
485  AVPacket *avpkt)
486 {
487  TiffContext * const s = avctx->priv_data;
488  AVFrame *picture = data;
489  AVFrame * const p= (AVFrame*)&s->picture;
490  unsigned off;
491  int id, le, ret;
492  int i, j, entries;
493  int stride;
494  unsigned soff, ssize;
495  uint8_t *dst;
496  GetByteContext stripsizes;
497  GetByteContext stripdata;
498 
499  bytestream2_init(&s->gb, avpkt->data, avpkt->size);
500 
501  //parse image header
502  if (avpkt->size < 8)
503  return AVERROR_INVALIDDATA;
504  id = bytestream2_get_le16(&s->gb);
505  if(id == 0x4949) le = 1;
506  else if(id == 0x4D4D) le = 0;
507  else{
508  av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n");
509  return -1;
510  }
511  s->le = le;
512  s->invert = 0;
513  s->compr = TIFF_RAW;
514  s->fill_order = 0;
515  // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number
516  // that further identifies the file as a TIFF file"
517  if (tget_short(&s->gb, le) != 42) {
518  av_log(avctx, AV_LOG_ERROR, "The answer to life, universe and everything is not correct!\n");
519  return -1;
520  }
521  // Reset these offsets so we can tell if they were set this frame
522  s->stripsizesoff = s->strippos = 0;
523  /* parse image file directory */
524  off = tget_long(&s->gb, le);
525  if (off >= UINT_MAX - 14 || avpkt->size < off + 14) {
526  av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n");
527  return AVERROR_INVALIDDATA;
528  }
529  bytestream2_seek(&s->gb, off, SEEK_SET);
530  entries = tget_short(&s->gb, le);
531  for(i = 0; i < entries; i++){
532  if (tiff_decode_tag(s) < 0)
533  return -1;
534  }
535  if (!s->strippos && !s->stripoff) {
536  av_log(avctx, AV_LOG_ERROR, "Image data is missing\n");
537  return -1;
538  }
539  /* now we have the data and may start decoding */
540  if ((ret = init_image(s)) < 0)
541  return ret;
542 
543  if(s->strips == 1 && !s->stripsize){
544  av_log(avctx, AV_LOG_WARNING, "Image data size missing\n");
545  s->stripsize = avpkt->size - s->stripoff;
546  }
547  stride = p->linesize[0];
548  dst = p->data[0];
549 
550  if (s->stripsizesoff) {
551  if (s->stripsizesoff >= avpkt->size)
552  return AVERROR_INVALIDDATA;
553  bytestream2_init(&stripsizes, avpkt->data + s->stripsizesoff,
554  avpkt->size - s->stripsizesoff);
555  }
556  if (s->strippos) {
557  if (s->strippos >= avpkt->size)
558  return AVERROR_INVALIDDATA;
559  bytestream2_init(&stripdata, avpkt->data + s->strippos,
560  avpkt->size - s->strippos);
561  }
562 
563  for(i = 0; i < s->height; i += s->rps){
564  if (s->stripsizesoff)
565  ssize = tget(&stripsizes, s->sstype, le);
566  else
567  ssize = s->stripsize;
568 
569  if (s->strippos)
570  soff = tget(&stripdata, s->sot, le);
571  else
572  soff = s->stripoff;
573 
574  if (soff > avpkt->size || ssize > avpkt->size - soff) {
575  av_log(avctx, AV_LOG_ERROR, "Invalid strip size/offset\n");
576  return -1;
577  }
578  if (tiff_unpack_strip(s, dst, stride, avpkt->data + soff, ssize,
579  FFMIN(s->rps, s->height - i)) < 0)
580  break;
581  dst += s->rps * stride;
582  }
583  if(s->predictor == 2){
584  dst = p->data[0];
585  soff = s->bpp >> 3;
586  ssize = s->width * soff;
587  for(i = 0; i < s->height; i++) {
588  for(j = soff; j < ssize; j++)
589  dst[j] += dst[j - soff];
590  dst += stride;
591  }
592  }
593 
594  if(s->invert){
595  uint8_t *src;
596  int j;
597 
598  src = s->picture.data[0];
599  for(j = 0; j < s->height; j++){
600  for(i = 0; i < s->picture.linesize[0]; i++)
601  src[i] = 255 - src[i];
602  src += s->picture.linesize[0];
603  }
604  }
605  *picture= *(AVFrame*)&s->picture;
606  *data_size = sizeof(AVPicture);
607 
608  return avpkt->size;
609 }
610 
611 static av_cold int tiff_init(AVCodecContext *avctx){
612  TiffContext *s = avctx->priv_data;
613 
614  s->width = 0;
615  s->height = 0;
616  s->avctx = avctx;
618  avctx->coded_frame= (AVFrame*)&s->picture;
619  ff_lzw_decode_open(&s->lzw);
621 
622  return 0;
623 }
624 
625 static av_cold int tiff_end(AVCodecContext *avctx)
626 {
627  TiffContext * const s = avctx->priv_data;
628 
630  if(s->picture.data[0])
631  avctx->release_buffer(avctx, &s->picture);
632  return 0;
633 }
634 
636  .name = "tiff",
637  .type = AVMEDIA_TYPE_VIDEO,
638  .id = CODEC_ID_TIFF,
639  .priv_data_size = sizeof(TiffContext),
640  .init = tiff_init,
641  .close = tiff_end,
642  .decode = decode_frame,
643  .capabilities = CODEC_CAP_DR1,
644  .long_name = NULL_IF_CONFIG_SMALL("TIFF image"),
645 };