Mercurial > libavcodec.hg
annotate tiff.c @ 10324:5bbe55451800 libavcodec
When BitsPerSample tag is not present in TIFF, that means file is
monochrome, so initialize picture before decoding.
This fixes decoding monochrome files produced by lavc TIFF encoder.
author | kostya |
---|---|
date | Wed, 30 Sep 2009 05:49:18 +0000 |
parents | 370d05e51d90 |
children | d1014913ad1b |
rev | line source |
---|---|
4013 | 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 */ | |
4782
bca8924ed36c
Add some Doxygen comments, by Kamil Nowosad, k.nowosad students.mimuw.edu pl.
diego
parents:
4774
diff
changeset
|
21 |
bca8924ed36c
Add some Doxygen comments, by Kamil Nowosad, k.nowosad students.mimuw.edu pl.
diego
parents:
4774
diff
changeset
|
22 /** |
bca8924ed36c
Add some Doxygen comments, by Kamil Nowosad, k.nowosad students.mimuw.edu pl.
diego
parents:
4774
diff
changeset
|
23 * TIFF image decoder |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8590
diff
changeset
|
24 * @file libavcodec/tiff.c |
4782
bca8924ed36c
Add some Doxygen comments, by Kamil Nowosad, k.nowosad students.mimuw.edu pl.
diego
parents:
4774
diff
changeset
|
25 * @author Konstantin Shishkov |
bca8924ed36c
Add some Doxygen comments, by Kamil Nowosad, k.nowosad students.mimuw.edu pl.
diego
parents:
4774
diff
changeset
|
26 */ |
4013 | 27 #include "avcodec.h" |
8590 | 28 #if CONFIG_ZLIB |
4013 | 29 #include <zlib.h> |
30 #endif | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
31 #include "lzw.h" |
4774
0860efc2f02b
tiff encoder by (Bartlomiej Wolowiec b.wolowiec students mimuw edu pl)
michael
parents:
4405
diff
changeset
|
32 #include "tiff.h" |
8491 | 33 #include "faxcompr.h" |
4013 | 34 |
4190 | 35 |
4013 | 36 typedef struct TiffContext { |
37 AVCodecContext *avctx; | |
38 AVFrame picture; | |
39 | |
40 int width, height; | |
41 unsigned int bpp; | |
42 int le; | |
43 int compr; | |
4186 | 44 int invert; |
8491 | 45 int fax_opts; |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
46 int predictor; |
10264
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
47 int fill_order; |
4013 | 48 |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
49 int strips, rps, sstype; |
4013 | 50 int sot; |
6256 | 51 const uint8_t* stripdata; |
52 const uint8_t* stripsizes; | |
4013 | 53 int stripsize, stripoff; |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
54 LZWState *lzw; |
4013 | 55 } TiffContext; |
56 | |
6256 | 57 static int tget_short(const uint8_t **p, int le){ |
4364 | 58 int v = le ? AV_RL16(*p) : AV_RB16(*p); |
4013 | 59 *p += 2; |
60 return v; | |
61 } | |
62 | |
6256 | 63 static int tget_long(const uint8_t **p, int le){ |
4364 | 64 int v = le ? AV_RL32(*p) : AV_RB32(*p); |
4013 | 65 *p += 4; |
66 return v; | |
67 } | |
68 | |
6256 | 69 static int tget(const uint8_t **p, int type, int le){ |
4013 | 70 switch(type){ |
71 case TIFF_BYTE : return *(*p)++; | |
72 case TIFF_SHORT: return tget_short(p, le); | |
73 case TIFF_LONG : return tget_long (p, le); | |
74 default : return -1; | |
75 } | |
76 } | |
77 | |
10299
a1654cd1b5b9
Do not compile ZLib data uncompressing function in TIFF decoder when ZLib is
kostya
parents:
10296
diff
changeset
|
78 #if CONFIG_ZLIB |
10296
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
79 static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src, int size) |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
80 { |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
81 z_stream zstream; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
82 int zret; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
83 |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
84 memset(&zstream, 0, sizeof(zstream)); |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
85 zstream.next_in = src; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
86 zstream.avail_in = size; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
87 zstream.next_out = dst; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
88 zstream.avail_out = *len; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
89 zret = inflateInit(&zstream); |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
90 if (zret != Z_OK) { |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
91 av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret); |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
92 return zret; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
93 } |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
94 zret = inflate(&zstream, Z_SYNC_FLUSH); |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
95 inflateEnd(&zstream); |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
96 *len = zstream.total_out; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
97 return zret == Z_STREAM_END ? Z_OK : zret; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
98 } |
10299
a1654cd1b5b9
Do not compile ZLib data uncompressing function in TIFF decoder when ZLib is
kostya
parents:
10296
diff
changeset
|
99 #endif |
10296
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
100 |
6256 | 101 static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uint8_t *src, int size, int lines){ |
4013 | 102 int c, line, pixels, code; |
6256 | 103 const uint8_t *ssrc = src; |
8426
898722eb4fd2
Calculate line size variable correctly for lower bitdepths and use it for raw data copying
kostya
parents:
8366
diff
changeset
|
104 int width = s->width * s->bpp >> 3; |
8590 | 105 #if CONFIG_ZLIB |
4013 | 106 uint8_t *zbuf; unsigned long outlen; |
107 | |
108 if(s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE){ | |
10296
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
109 int ret; |
4013 | 110 outlen = width * lines; |
111 zbuf = av_malloc(outlen); | |
10296
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
112 ret = tiff_uncompress(zbuf, &outlen, src, size); |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
113 if(ret != Z_OK){ |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
114 av_log(s->avctx, AV_LOG_ERROR, "Uncompressing failed (%lu of %lu) with error %d\n", outlen, (unsigned long)width * lines, ret); |
4013 | 115 av_free(zbuf); |
116 return -1; | |
117 } | |
118 src = zbuf; | |
119 for(line = 0; line < lines; line++){ | |
120 memcpy(dst, src, width); | |
121 dst += stride; | |
122 src += width; | |
123 } | |
124 av_free(zbuf); | |
125 return 0; | |
126 } | |
127 #endif | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
128 if(s->compr == TIFF_LZW){ |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
129 if(ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF) < 0){ |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
130 av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n"); |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
131 return -1; |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
132 } |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
133 } |
8491 | 134 if(s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3 || s->compr == TIFF_G4){ |
135 int i, ret = 0; | |
136 uint8_t *src2 = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); | |
137 | |
138 if(!src2 || (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE < (unsigned)size){ | |
139 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n"); | |
140 return -1; | |
141 } | |
10264
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
142 if(!s->fill_order){ |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
143 memcpy(src2, src, size); |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
144 }else{ |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
145 for(i = 0; i < size; i++) |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
146 src2[i] = ff_reverse[src[i]]; |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
147 } |
8491 | 148 memset(src2+size, 0, FF_INPUT_BUFFER_PADDING_SIZE); |
149 switch(s->compr){ | |
150 case TIFF_CCITT_RLE: | |
151 case TIFF_G3: | |
152 case TIFF_G4: | |
10304
370d05e51d90
Finally distinguish TIFF_CCITT_RLE and TIFF_G3 1-D case, so both of them
kostya
parents:
10303
diff
changeset
|
153 ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride, s->compr, s->fax_opts); |
8491 | 154 break; |
155 } | |
156 av_free(src2); | |
157 return ret; | |
158 } | |
4013 | 159 for(line = 0; line < lines; line++){ |
160 if(src - ssrc > size){ | |
161 av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n"); | |
162 return -1; | |
163 } | |
164 switch(s->compr){ | |
165 case TIFF_RAW: | |
8426
898722eb4fd2
Calculate line size variable correctly for lower bitdepths and use it for raw data copying
kostya
parents:
8366
diff
changeset
|
166 memcpy(dst, src, width); |
898722eb4fd2
Calculate line size variable correctly for lower bitdepths and use it for raw data copying
kostya
parents:
8366
diff
changeset
|
167 src += width; |
4013 | 168 break; |
169 case TIFF_PACKBITS: | |
170 for(pixels = 0; pixels < width;){ | |
171 code = (int8_t)*src++; | |
172 if(code >= 0){ | |
173 code++; | |
174 if(pixels + code > width){ | |
175 av_log(s->avctx, AV_LOG_ERROR, "Copy went out of bounds\n"); | |
176 return -1; | |
177 } | |
178 memcpy(dst + pixels, src, code); | |
179 src += code; | |
180 pixels += code; | |
181 }else if(code != -128){ // -127..-1 | |
182 code = (-code) + 1; | |
183 if(pixels + code > width){ | |
184 av_log(s->avctx, AV_LOG_ERROR, "Run went out of bounds\n"); | |
185 return -1; | |
186 } | |
187 c = *src++; | |
188 memset(dst + pixels, c, code); | |
189 pixels += code; | |
190 } | |
191 } | |
192 break; | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
193 case TIFF_LZW: |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
194 pixels = ff_lzw_decode(s->lzw, dst, width); |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
195 if(pixels < width){ |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
196 av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n", pixels, width); |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
197 return -1; |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
198 } |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
199 break; |
4013 | 200 } |
201 dst += stride; | |
202 } | |
203 return 0; | |
204 } | |
205 | |
206 | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
207 static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf) |
4013 | 208 { |
209 int tag, type, count, off, value = 0; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
210 int i, j; |
5261 | 211 uint32_t *pal; |
6256 | 212 const uint8_t *rp, *gp, *bp; |
4013 | 213 |
214 tag = tget_short(&buf, s->le); | |
215 type = tget_short(&buf, s->le); | |
216 count = tget_long(&buf, s->le); | |
217 off = tget_long(&buf, s->le); | |
218 | |
219 if(count == 1){ | |
220 switch(type){ | |
221 case TIFF_BYTE: | |
222 case TIFF_SHORT: | |
223 buf -= 4; | |
224 value = tget(&buf, type, s->le); | |
225 buf = NULL; | |
226 break; | |
227 case TIFF_LONG: | |
228 value = off; | |
229 buf = NULL; | |
230 break; | |
8366
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
231 case TIFF_STRING: |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
232 if(count <= 4){ |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
233 buf -= 4; |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
234 break; |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
235 } |
4013 | 236 default: |
237 value = -1; | |
238 buf = start + off; | |
239 } | |
4190 | 240 }else if(type_sizes[type] * count <= 4){ |
241 buf -= 4; | |
4013 | 242 }else{ |
243 buf = start + off; | |
244 } | |
245 | |
246 if(buf && (buf < start || buf > end_buf)){ | |
247 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); | |
248 return -1; | |
249 } | |
250 | |
251 switch(tag){ | |
252 case TIFF_WIDTH: | |
253 s->width = value; | |
254 break; | |
255 case TIFF_HEIGHT: | |
256 s->height = value; | |
257 break; | |
258 case TIFF_BPP: | |
259 if(count == 1) s->bpp = value; | |
260 else{ | |
261 switch(type){ | |
262 case TIFF_BYTE: | |
4183 | 263 s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) + ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF); |
4013 | 264 break; |
265 case TIFF_SHORT: | |
266 case TIFF_LONG: | |
4183 | 267 s->bpp = 0; |
268 for(i = 0; i < count; i++) s->bpp += tget(&buf, type, s->le); | |
4013 | 269 break; |
270 default: | |
271 s->bpp = -1; | |
272 } | |
273 } | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
274 if(count > 4){ |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
275 av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count); |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
276 return -1; |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
277 } |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
278 switch(s->bpp*10 + count){ |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
279 case 11: |
8427 | 280 s->avctx->pix_fmt = PIX_FMT_MONOBLACK; |
281 break; | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
282 case 81: |
4186 | 283 s->avctx->pix_fmt = PIX_FMT_PAL8; |
284 break; | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
285 case 243: |
4186 | 286 s->avctx->pix_fmt = PIX_FMT_RGB24; |
287 break; | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
288 case 161: |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
289 s->avctx->pix_fmt = PIX_FMT_GRAY16BE; |
4193 | 290 break; |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
291 case 324: |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
292 s->avctx->pix_fmt = PIX_FMT_RGBA; |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
293 break; |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
294 case 483: |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
295 s->avctx->pix_fmt = s->le ? PIX_FMT_RGB48LE : PIX_FMT_RGB48BE; |
9611
8074df653392
Add 32-bit RGB support to TIFF decoder and extend a bit 'unsupported format' message
kostya
parents:
9553
diff
changeset
|
296 break; |
4186 | 297 default: |
9611
8074df653392
Add 32-bit RGB support to TIFF decoder and extend a bit 'unsupported format' message
kostya
parents:
9553
diff
changeset
|
298 av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count); |
4013 | 299 return -1; |
300 } | |
4186 | 301 if(s->width != s->avctx->width || s->height != s->avctx->height){ |
302 if(avcodec_check_dimensions(s->avctx, s->width, s->height)) | |
303 return -1; | |
304 avcodec_set_dimensions(s->avctx, s->width, s->height); | |
305 } | |
306 if(s->picture.data[0]) | |
307 s->avctx->release_buffer(s->avctx, &s->picture); | |
308 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){ | |
309 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
310 return -1; | |
311 } | |
312 if(s->bpp == 8){ | |
313 /* make default grayscale pal */ | |
5261 | 314 pal = (uint32_t *) s->picture.data[1]; |
4186 | 315 for(i = 0; i < 256; i++) |
316 pal[i] = i * 0x010101; | |
317 } | |
4013 | 318 break; |
319 case TIFF_COMPR: | |
320 s->compr = value; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
321 s->predictor = 0; |
4013 | 322 switch(s->compr){ |
323 case TIFF_RAW: | |
324 case TIFF_PACKBITS: | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
325 case TIFF_LZW: |
8491 | 326 case TIFF_CCITT_RLE: |
327 break; | |
328 case TIFF_G3: | |
329 case TIFF_G4: | |
330 s->fax_opts = 0; | |
4013 | 331 break; |
332 case TIFF_DEFLATE: | |
333 case TIFF_ADOBE_DEFLATE: | |
8590 | 334 #if CONFIG_ZLIB |
4013 | 335 break; |
336 #else | |
337 av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n"); | |
338 return -1; | |
339 #endif | |
4184 | 340 case TIFF_JPEG: |
341 case TIFF_NEWJPEG: | |
342 av_log(s->avctx, AV_LOG_ERROR, "JPEG compression is not supported\n"); | |
343 return -1; | |
4013 | 344 default: |
345 av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n", s->compr); | |
346 return -1; | |
347 } | |
348 break; | |
349 case TIFF_ROWSPERSTRIP: | |
8428 | 350 if(type == TIFF_LONG && value == -1) |
351 value = s->avctx->height; | |
4185 | 352 if(value < 1){ |
4013 | 353 av_log(s->avctx, AV_LOG_ERROR, "Incorrect value of rows per strip\n"); |
354 return -1; | |
355 } | |
356 s->rps = value; | |
357 break; | |
358 case TIFF_STRIP_OFFS: | |
359 if(count == 1){ | |
360 s->stripdata = NULL; | |
361 s->stripoff = value; | |
362 }else | |
363 s->stripdata = start + off; | |
364 s->strips = count; | |
4405
48952197d91f
Some TIFFs do not set rows per strip for single strip.
kostya
parents:
4364
diff
changeset
|
365 if(s->strips == 1) s->rps = s->height; |
4013 | 366 s->sot = type; |
367 if(s->stripdata > end_buf){ | |
368 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); | |
369 return -1; | |
370 } | |
371 break; | |
372 case TIFF_STRIP_SIZE: | |
373 if(count == 1){ | |
374 s->stripsizes = NULL; | |
375 s->stripsize = value; | |
376 s->strips = 1; | |
377 }else{ | |
378 s->stripsizes = start + off; | |
379 } | |
380 s->strips = count; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
381 s->sstype = type; |
4013 | 382 if(s->stripsizes > end_buf){ |
383 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); | |
384 return -1; | |
385 } | |
386 break; | |
387 case TIFF_PREDICTOR: | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
388 s->predictor = value; |
4013 | 389 break; |
4186 | 390 case TIFF_INVERT: |
391 switch(value){ | |
392 case 0: | |
393 s->invert = 1; | |
394 break; | |
395 case 1: | |
396 s->invert = 0; | |
397 break; | |
4187
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
398 case 2: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
399 case 3: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
400 break; |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
401 default: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
402 av_log(s->avctx, AV_LOG_ERROR, "Color mode %d is not supported\n", value); |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
403 return -1; |
4186 | 404 } |
405 break; | |
10264
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
406 case TIFF_FILL_ORDER: |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
407 if(value < 1 || value > 2){ |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
408 av_log(s->avctx, AV_LOG_ERROR, "Unknown FillOrder value %d, trying default one\n", value); |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
409 value = 1; |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
410 } |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
411 s->fill_order = value - 1; |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
412 break; |
4186 | 413 case TIFF_PAL: |
414 if(s->avctx->pix_fmt != PIX_FMT_PAL8){ | |
415 av_log(s->avctx, AV_LOG_ERROR, "Palette met but this is not palettized format\n"); | |
416 return -1; | |
417 } | |
5261 | 418 pal = (uint32_t *) s->picture.data[1]; |
4190 | 419 off = type_sizes[type]; |
4186 | 420 rp = buf; |
421 gp = buf + count / 3 * off; | |
422 bp = buf + count / 3 * off * 2; | |
4190 | 423 off = (type_sizes[type] - 1) << 3; |
4186 | 424 for(i = 0; i < count / 3; i++){ |
425 j = (tget(&rp, type, s->le) >> off) << 16; | |
426 j |= (tget(&gp, type, s->le) >> off) << 8; | |
427 j |= tget(&bp, type, s->le) >> off; | |
428 pal[i] = j; | |
429 } | |
4192 | 430 break; |
431 case TIFF_PLANAR: | |
432 if(value == 2){ | |
433 av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n"); | |
434 return -1; | |
435 } | |
436 break; | |
8491 | 437 case TIFF_T4OPTIONS: |
10303
8a49525f2b1e
Make TIFF decoder load compression options only for corresponding codec
kostya
parents:
10299
diff
changeset
|
438 if(s->compr == TIFF_G3) |
8a49525f2b1e
Make TIFF decoder load compression options only for corresponding codec
kostya
parents:
10299
diff
changeset
|
439 s->fax_opts = value; |
8a49525f2b1e
Make TIFF decoder load compression options only for corresponding codec
kostya
parents:
10299
diff
changeset
|
440 break; |
8491 | 441 case TIFF_T6OPTIONS: |
10303
8a49525f2b1e
Make TIFF decoder load compression options only for corresponding codec
kostya
parents:
10299
diff
changeset
|
442 if(s->compr == TIFF_G4) |
8a49525f2b1e
Make TIFF decoder load compression options only for corresponding codec
kostya
parents:
10299
diff
changeset
|
443 s->fax_opts = value; |
8491 | 444 break; |
4013 | 445 } |
446 return 0; | |
447 } | |
448 | |
449 static int decode_frame(AVCodecContext *avctx, | |
450 void *data, int *data_size, | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
451 AVPacket *avpkt) |
4013 | 452 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
453 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
454 int buf_size = avpkt->size; |
4013 | 455 TiffContext * const s = avctx->priv_data; |
456 AVFrame *picture = data; | |
457 AVFrame * const p= (AVFrame*)&s->picture; | |
6256 | 458 const uint8_t *orig_buf = buf, *end_buf = buf + buf_size; |
4013 | 459 int id, le, off; |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
460 int i, j, entries; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
461 int stride, soff, ssize; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
462 uint8_t *dst; |
4013 | 463 |
464 //parse image header | |
4364 | 465 id = AV_RL16(buf); buf += 2; |
4013 | 466 if(id == 0x4949) le = 1; |
467 else if(id == 0x4D4D) le = 0; | |
468 else{ | |
469 av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n"); | |
470 return -1; | |
471 } | |
472 s->le = le; | |
4186 | 473 s->invert = 0; |
5962 | 474 s->compr = TIFF_RAW; |
10264
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
475 s->fill_order = 0; |
4013 | 476 // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number |
477 // that further identifies the file as a TIFF file" | |
478 if(tget_short(&buf, le) != 42){ | |
479 av_log(avctx, AV_LOG_ERROR, "The answer to life, universe and everything is not correct!\n"); | |
480 return -1; | |
481 } | |
482 /* parse image file directory */ | |
483 off = tget_long(&buf, le); | |
484 if(orig_buf + off + 14 >= end_buf){ | |
485 av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n"); | |
486 return -1; | |
487 } | |
488 buf = orig_buf + off; | |
489 entries = tget_short(&buf, le); | |
490 for(i = 0; i < entries; i++){ | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
491 if(tiff_decode_tag(s, orig_buf, buf, end_buf) < 0) |
4013 | 492 return -1; |
493 buf += 12; | |
494 } | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
495 if(!s->stripdata && !s->stripoff){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
496 av_log(avctx, AV_LOG_ERROR, "Image data is missing\n"); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
497 return -1; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
498 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
499 /* now we have the data and may start decoding */ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
500 if(!p->data[0]){ |
10324
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
501 s->bpp = 1; |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
502 avctx->pix_fmt = PIX_FMT_MONOBLACK; |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
503 if(s->width != s->avctx->width || s->height != s->avctx->height){ |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
504 if(avcodec_check_dimensions(s->avctx, s->width, s->height)) |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
505 return -1; |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
506 avcodec_set_dimensions(s->avctx, s->width, s->height); |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
507 } |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
508 if(s->picture.data[0]) |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
509 s->avctx->release_buffer(s->avctx, &s->picture); |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
510 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){ |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
511 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
512 return -1; |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
513 } |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
514 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
515 if(s->strips == 1 && !s->stripsize){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
516 av_log(avctx, AV_LOG_WARNING, "Image data size missing\n"); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
517 s->stripsize = buf_size - s->stripoff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
518 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
519 stride = p->linesize[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
520 dst = p->data[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
521 for(i = 0; i < s->height; i += s->rps){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
522 if(s->stripsizes) |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
523 ssize = tget(&s->stripsizes, s->sstype, s->le); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
524 else |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
525 ssize = s->stripsize; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
526 |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
527 if(s->stripdata){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
528 soff = tget(&s->stripdata, s->sot, s->le); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
529 }else |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
530 soff = s->stripoff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
531 if(tiff_unpack_strip(s, dst, stride, orig_buf + soff, ssize, FFMIN(s->rps, s->height - i)) < 0) |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
532 break; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
533 dst += s->rps * stride; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
534 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
535 if(s->predictor == 2){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
536 dst = p->data[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
537 soff = s->bpp >> 3; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
538 ssize = s->width * soff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
539 for(i = 0; i < s->height; i++) { |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
540 for(j = soff; j < ssize; j++) |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
541 dst[j] += dst[j - soff]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
542 dst += stride; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
543 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
544 } |
4013 | 545 |
4186 | 546 if(s->invert){ |
547 uint8_t *src; | |
548 int j; | |
549 | |
550 src = s->picture.data[0]; | |
551 for(j = 0; j < s->height; j++){ | |
552 for(i = 0; i < s->picture.linesize[0]; i++) | |
553 src[i] = 255 - src[i]; | |
554 src += s->picture.linesize[0]; | |
555 } | |
556 } | |
4013 | 557 *picture= *(AVFrame*)&s->picture; |
558 *data_size = sizeof(AVPicture); | |
559 | |
560 return buf_size; | |
561 } | |
562 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6256
diff
changeset
|
563 static av_cold int tiff_init(AVCodecContext *avctx){ |
4013 | 564 TiffContext *s = avctx->priv_data; |
565 | |
566 s->width = 0; | |
567 s->height = 0; | |
568 s->avctx = avctx; | |
569 avcodec_get_frame_defaults((AVFrame*)&s->picture); | |
570 avctx->coded_frame= (AVFrame*)&s->picture; | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
571 ff_lzw_decode_open(&s->lzw); |
8491 | 572 ff_ccitt_unpack_init(); |
4013 | 573 |
574 return 0; | |
575 } | |
576 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6256
diff
changeset
|
577 static av_cold int tiff_end(AVCodecContext *avctx) |
4013 | 578 { |
579 TiffContext * const s = avctx->priv_data; | |
580 | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
581 ff_lzw_decode_close(&s->lzw); |
4013 | 582 if(s->picture.data[0]) |
583 avctx->release_buffer(avctx, &s->picture); | |
584 return 0; | |
585 } | |
586 | |
587 AVCodec tiff_decoder = { | |
588 "tiff", | |
589 CODEC_TYPE_VIDEO, | |
590 CODEC_ID_TIFF, | |
591 sizeof(TiffContext), | |
592 tiff_init, | |
593 NULL, | |
594 tiff_end, | |
595 decode_frame, | |
9812
58d29c191e5a
tiff image decoder uses get_buffer, set CODEC_CAP_DR1
bcoudurier
parents:
9784
diff
changeset
|
596 CODEC_CAP_DR1, |
6722 | 597 NULL, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6722
diff
changeset
|
598 .long_name = NULL_IF_CONFIG_SMALL("TIFF image"), |
4013 | 599 }; |