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