3 * Copyright (c) 2006 Konstantin Shishkov
5 * This file is part of FFmpeg.
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.
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.
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
24 * @file libavcodec/tiff.c
25 * @author Konstantin Shishkov
34 #include "libavutil/common.h"
37 typedef struct TiffContext
{
38 AVCodecContext
*avctx
;
50 int strips
, rps
, sstype
;
52 const uint8_t* stripdata
;
53 const uint8_t* stripsizes
;
54 int stripsize
, stripoff
;
58 static int tget_short(const uint8_t **p
, int le
){
59 int v
= le
? AV_RL16(*p
) : AV_RB16(*p
);
64 static int tget_long(const uint8_t **p
, int le
){
65 int v
= le
? AV_RL32(*p
) : AV_RB32(*p
);
70 static int tget(const uint8_t **p
, int type
, int le
){
72 case TIFF_BYTE
: return *(*p
)++;
73 case TIFF_SHORT
: return tget_short(p
, le
);
74 case TIFF_LONG
: return tget_long (p
, le
);
80 static int tiff_uncompress(uint8_t *dst
, unsigned long *len
, const uint8_t *src
, int size
)
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
);
92 av_log(NULL
, AV_LOG_ERROR
, "Inflate init error: %d\n", zret
);
95 zret
= inflate(&zstream
, Z_SYNC_FLUSH
);
97 *len
= zstream
.total_out
;
98 return zret
== Z_STREAM_END
? Z_OK
: zret
;
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;
107 uint8_t *zbuf
; unsigned long outlen
;
109 if(s
->compr
== TIFF_DEFLATE
|| s
->compr
== TIFF_ADOBE_DEFLATE
){
111 outlen
= width
* lines
;
112 zbuf
= av_malloc(outlen
);
113 ret
= tiff_uncompress(zbuf
, &outlen
, src
, size
);
115 av_log(s
->avctx
, AV_LOG_ERROR
, "Uncompressing failed (%lu of %lu) with error %d\n", outlen
, (unsigned long)width
* lines
, ret
);
120 for(line
= 0; line
< lines
; line
++){
121 memcpy(dst
, src
, width
);
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");
135 if(s
->compr
== TIFF_CCITT_RLE
|| s
->compr
== TIFF_G3
|| s
->compr
== TIFF_G4
){
137 uint8_t *src2
= av_malloc(size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
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");
144 av_log(s
->avctx
, AV_LOG_ERROR
, "Uncompressed fax mode is not supported (yet)\n");
149 memcpy(src2
, src
, size
);
151 for(i
= 0; i
< size
; i
++)
152 src2
[i
] = av_reverse
[src
[i
]];
154 memset(src2
+size
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
159 ret
= ff_ccitt_unpack(s
->avctx
, src2
, size
, dst
, lines
, stride
, s
->compr
, s
->fax_opts
);
165 for(line
= 0; line
< lines
; line
++){
166 if(src
- ssrc
> size
){
167 av_log(s
->avctx
, AV_LOG_ERROR
, "Source data overread\n");
172 memcpy(dst
, src
, width
);
176 for(pixels
= 0; pixels
< width
;){
177 code
= (int8_t)*src
++;
180 if(pixels
+ code
> width
){
181 av_log(s
->avctx
, AV_LOG_ERROR
, "Copy went out of bounds\n");
184 memcpy(dst
+ pixels
, src
, code
);
187 }else if(code
!= -128){ // -127..-1
189 if(pixels
+ code
> width
){
190 av_log(s
->avctx
, AV_LOG_ERROR
, "Run went out of bounds\n");
194 memset(dst
+ pixels
, c
, code
);
200 pixels
= ff_lzw_decode(s
->lzw
, dst
, width
);
202 av_log(s
->avctx
, AV_LOG_ERROR
, "Decoded only %i bytes of %i\n", pixels
, width
);
213 static int tiff_decode_tag(TiffContext
*s
, const uint8_t *start
, const uint8_t *buf
, const uint8_t *end_buf
)
215 int tag
, type
, count
, off
, value
= 0;
218 const uint8_t *rp
, *gp
, *bp
;
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
);
230 value
= tget(&buf
, type
, s
->le
);
246 }else if(type_sizes
[type
] * count
<= 4){
252 if(buf
&& (buf
< start
|| buf
> end_buf
)){
253 av_log(s
->avctx
, AV_LOG_ERROR
, "Tag referencing position outside the image\n");
265 if(count
== 1) s
->bpp
= value
;
269 s
->bpp
= (off
& 0xFF) + ((off
>> 8) & 0xFF) + ((off
>> 16) & 0xFF) + ((off
>> 24) & 0xFF);
274 for(i
= 0; i
< count
; i
++) s
->bpp
+= tget(&buf
, type
, s
->le
);
281 av_log(s
->avctx
, AV_LOG_ERROR
, "This format is not supported (bpp=%d, %d components)\n", s
->bpp
, count
);
284 switch(s
->bpp
*10 + count
){
286 s
->avctx
->pix_fmt
= PIX_FMT_MONOBLACK
;
289 s
->avctx
->pix_fmt
= PIX_FMT_PAL8
;
292 s
->avctx
->pix_fmt
= PIX_FMT_RGB24
;
295 s
->avctx
->pix_fmt
= PIX_FMT_GRAY16BE
;
298 s
->avctx
->pix_fmt
= PIX_FMT_RGBA
;
301 s
->avctx
->pix_fmt
= s
->le
? PIX_FMT_RGB48LE
: PIX_FMT_RGB48BE
;
304 av_log(s
->avctx
, AV_LOG_ERROR
, "This format is not supported (bpp=%d, %d components)\n", s
->bpp
, count
);
307 if(s
->width
!= s
->avctx
->width
|| s
->height
!= s
->avctx
->height
){
308 if(avcodec_check_dimensions(s
->avctx
, s
->width
, s
->height
))
310 avcodec_set_dimensions(s
->avctx
, s
->width
, s
->height
);
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");
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;
339 case TIFF_ADOBE_DEFLATE
:
343 av_log(s
->avctx
, AV_LOG_ERROR
, "Deflate: ZLib not compiled in\n");
348 av_log(s
->avctx
, AV_LOG_ERROR
, "JPEG compression is not supported\n");
351 av_log(s
->avctx
, AV_LOG_ERROR
, "Unknown compression method %i\n", s
->compr
);
355 case TIFF_ROWSPERSTRIP
:
356 if(type
== TIFF_LONG
&& value
== -1)
357 value
= s
->avctx
->height
;
359 av_log(s
->avctx
, AV_LOG_ERROR
, "Incorrect value of rows per strip\n");
364 case TIFF_STRIP_OFFS
:
369 s
->stripdata
= start
+ off
;
371 if(s
->strips
== 1) s
->rps
= s
->height
;
373 if(s
->stripdata
> end_buf
){
374 av_log(s
->avctx
, AV_LOG_ERROR
, "Tag referencing position outside the image\n");
378 case TIFF_STRIP_SIZE
:
380 s
->stripsizes
= NULL
;
381 s
->stripsize
= value
;
384 s
->stripsizes
= start
+ off
;
388 if(s
->stripsizes
> end_buf
){
389 av_log(s
->avctx
, AV_LOG_ERROR
, "Tag referencing position outside the image\n");
394 s
->predictor
= value
;
408 av_log(s
->avctx
, AV_LOG_ERROR
, "Color mode %d is not supported\n", value
);
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
);
417 s
->fill_order
= value
- 1;
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");
424 pal
= (uint32_t *) s
->picture
.data
[1];
425 off
= type_sizes
[type
];
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
;
439 av_log(s
->avctx
, AV_LOG_ERROR
, "Planar format is not supported\n");
444 if(s
->compr
== TIFF_G3
)
448 if(s
->compr
== TIFF_G4
)
455 static int decode_frame(AVCodecContext
*avctx
,
456 void *data
, int *data_size
,
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
;
467 int stride
, soff
, ssize
;
471 id
= AV_RL16(buf
); buf
+= 2;
472 if(id
== 0x4949) le
= 1;
473 else if(id
== 0x4D4D) le
= 0;
475 av_log(avctx
, AV_LOG_ERROR
, "TIFF header not found\n");
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");
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");
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)
501 if(!s
->stripdata
&& !s
->stripoff
){
502 av_log(avctx
, AV_LOG_ERROR
, "Image data is missing\n");
505 /* now we have the data and may start decoding */
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
))
512 avcodec_set_dimensions(s
->avctx
, s
->width
, s
->height
);
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");
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
;
525 stride
= p
->linesize
[0];
527 for(i
= 0; i
< s
->height
; i
+= s
->rps
){
529 ssize
= tget(&s
->stripsizes
, s
->sstype
, s
->le
);
531 ssize
= s
->stripsize
;
534 soff
= tget(&s
->stripdata
, s
->sot
, s
->le
);
537 if(tiff_unpack_strip(s
, dst
, stride
, orig_buf
+ soff
, ssize
, FFMIN(s
->rps
, s
->height
- i
)) < 0)
539 dst
+= s
->rps
* stride
;
541 if(s
->predictor
== 2){
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
];
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];
563 *picture
= *(AVFrame
*)&s
->picture
;
564 *data_size
= sizeof(AVPicture
);
569 static av_cold
int tiff_init(AVCodecContext
*avctx
){
570 TiffContext
*s
= avctx
->priv_data
;
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();
583 static av_cold
int tiff_end(AVCodecContext
*avctx
)
585 TiffContext
* const s
= avctx
->priv_data
;
587 ff_lzw_decode_close(&s
->lzw
);
588 if(s
->picture
.data
[0])
589 avctx
->release_buffer(avctx
, &s
->picture
);
593 AVCodec tiff_decoder
= {
604 .long_name
= NULL_IF_CONFIG_SMALL("TIFF image"),