Mercurial > libavcodec.hg
annotate tiff.c @ 12266:48d6738904a9 libavcodec
Fix SPLATB_REG mess. Used to be a if/elseif/elseif/elseif spaghetti, so this
splits it into small optimization-specific macros which are selected for each
DSP function. The advantage of this approach is that the sse4 functions now
use the ssse3 codepath also without needing an explicit sse4 codepath.
author | rbultje |
---|---|
date | Sat, 24 Jul 2010 19:33:05 +0000 |
parents | 7dd2a45249a9 |
children | 914f484bb476 |
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 |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11560
diff
changeset
|
24 * @file |
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" |
10501
bdf4a9ca162a
Move ff_reverse in libavcodec to av_reverse in libavutil.
cehoyos
parents:
10337
diff
changeset
|
34 #include "libavutil/common.h" |
10635
2938c3bc34c7
lzw.h does not need get_bits.h, tiff.c needs intreadwrite.h for AV_R* though
bcoudurier
parents:
10501
diff
changeset
|
35 #include "libavutil/intreadwrite.h" |
4190 | 36 |
4013 | 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; | |
4186 | 45 int invert; |
8491 | 46 int fax_opts; |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
47 int predictor; |
10264
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
48 int fill_order; |
4013 | 49 |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
50 int strips, rps, sstype; |
4013 | 51 int sot; |
6256 | 52 const uint8_t* stripdata; |
53 const uint8_t* stripsizes; | |
4013 | 54 int stripsize, stripoff; |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
55 LZWState *lzw; |
4013 | 56 } TiffContext; |
57 | |
6256 | 58 static int tget_short(const uint8_t **p, int le){ |
4364 | 59 int v = le ? AV_RL16(*p) : AV_RB16(*p); |
4013 | 60 *p += 2; |
61 return v; | |
62 } | |
63 | |
6256 | 64 static int tget_long(const uint8_t **p, int le){ |
4364 | 65 int v = le ? AV_RL32(*p) : AV_RB32(*p); |
4013 | 66 *p += 4; |
67 return v; | |
68 } | |
69 | |
6256 | 70 static int tget(const uint8_t **p, int type, int le){ |
4013 | 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 | |
10299
a1654cd1b5b9
Do not compile ZLib data uncompressing function in TIFF decoder when ZLib is
kostya
parents:
10296
diff
changeset
|
79 #if CONFIG_ZLIB |
10296
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
80 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
|
81 { |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
82 z_stream zstream; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
83 int zret; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
84 |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
85 memset(&zstream, 0, sizeof(zstream)); |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
86 zstream.next_in = src; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
87 zstream.avail_in = size; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
88 zstream.next_out = dst; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
89 zstream.avail_out = *len; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
90 zret = inflateInit(&zstream); |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
91 if (zret != Z_OK) { |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
92 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
|
93 return zret; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
94 } |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
95 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
|
96 inflateEnd(&zstream); |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
97 *len = zstream.total_out; |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
98 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
|
99 } |
10299
a1654cd1b5b9
Do not compile ZLib data uncompressing function in TIFF decoder when ZLib is
kostya
parents:
10296
diff
changeset
|
100 #endif |
10296
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
101 |
6256 | 102 static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uint8_t *src, int size, int lines){ |
4013 | 103 int c, line, pixels, code; |
6256 | 104 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
|
105 int width = s->width * s->bpp >> 3; |
8590 | 106 #if CONFIG_ZLIB |
4013 | 107 uint8_t *zbuf; unsigned long outlen; |
108 | |
109 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
|
110 int ret; |
4013 | 111 outlen = width * lines; |
112 zbuf = av_malloc(outlen); | |
10296
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
113 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
|
114 if(ret != Z_OK){ |
a919d9583abd
Looks like ZLib uncompress() cannot deal with some kinds of TIFF deflated data,
kostya
parents:
10264
diff
changeset
|
115 av_log(s->avctx, AV_LOG_ERROR, "Uncompressing failed (%lu of %lu) with error %d\n", outlen, (unsigned long)width * lines, ret); |
4013 | 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 | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
129 if(s->compr == TIFF_LZW){ |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
130 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
|
131 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
|
132 return -1; |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
133 } |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
134 } |
8491 | 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 } | |
10337
d1014913ad1b
Do not attempt to decode TIFF files containing fax data with uncompressed
kostya
parents:
10324
diff
changeset
|
143 if(s->fax_opts & 2){ |
d1014913ad1b
Do not attempt to decode TIFF files containing fax data with uncompressed
kostya
parents:
10324
diff
changeset
|
144 av_log(s->avctx, AV_LOG_ERROR, "Uncompressed fax mode is not supported (yet)\n"); |
d1014913ad1b
Do not attempt to decode TIFF files containing fax data with uncompressed
kostya
parents:
10324
diff
changeset
|
145 av_free(src2); |
d1014913ad1b
Do not attempt to decode TIFF files containing fax data with uncompressed
kostya
parents:
10324
diff
changeset
|
146 return -1; |
d1014913ad1b
Do not attempt to decode TIFF files containing fax data with uncompressed
kostya
parents:
10324
diff
changeset
|
147 } |
10264
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
148 if(!s->fill_order){ |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
149 memcpy(src2, src, size); |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
150 }else{ |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
151 for(i = 0; i < size; i++) |
10501
bdf4a9ca162a
Move ff_reverse in libavcodec to av_reverse in libavutil.
cehoyos
parents:
10337
diff
changeset
|
152 src2[i] = av_reverse[src[i]]; |
10264
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
153 } |
8491 | 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: | |
10304
370d05e51d90
Finally distinguish TIFF_CCITT_RLE and TIFF_G3 1-D case, so both of them
kostya
parents:
10303
diff
changeset
|
159 ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride, s->compr, s->fax_opts); |
8491 | 160 break; |
161 } | |
162 av_free(src2); | |
163 return ret; | |
164 } | |
4013 | 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: | |
8426
898722eb4fd2
Calculate line size variable correctly for lower bitdepths and use it for raw data copying
kostya
parents:
8366
diff
changeset
|
172 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
|
173 src += width; |
4013 | 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; | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
199 case TIFF_LZW: |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
200 pixels = ff_lzw_decode(s->lzw, dst, width); |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
201 if(pixels < width){ |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
202 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
|
203 return -1; |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
204 } |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
205 break; |
4013 | 206 } |
207 dst += stride; | |
208 } | |
209 return 0; | |
210 } | |
211 | |
212 | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
213 static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf) |
4013 | 214 { |
215 int tag, type, count, off, value = 0; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
216 int i, j; |
5261 | 217 uint32_t *pal; |
6256 | 218 const uint8_t *rp, *gp, *bp; |
4013 | 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; | |
8366
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
237 case TIFF_STRING: |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
238 if(count <= 4){ |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
239 buf -= 4; |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
240 break; |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
241 } |
4013 | 242 default: |
243 value = -1; | |
244 buf = start + off; | |
245 } | |
4190 | 246 }else if(type_sizes[type] * count <= 4){ |
247 buf -= 4; | |
4013 | 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: | |
4183 | 269 s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) + ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF); |
4013 | 270 break; |
271 case TIFF_SHORT: | |
272 case TIFF_LONG: | |
4183 | 273 s->bpp = 0; |
274 for(i = 0; i < count; i++) s->bpp += tget(&buf, type, s->le); | |
4013 | 275 break; |
276 default: | |
277 s->bpp = -1; | |
278 } | |
279 } | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
280 if(count > 4){ |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
281 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
|
282 return -1; |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
283 } |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
284 switch(s->bpp*10 + count){ |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
285 case 11: |
8427 | 286 s->avctx->pix_fmt = PIX_FMT_MONOBLACK; |
287 break; | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
288 case 81: |
4186 | 289 s->avctx->pix_fmt = PIX_FMT_PAL8; |
290 break; | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
291 case 243: |
4186 | 292 s->avctx->pix_fmt = PIX_FMT_RGB24; |
293 break; | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
294 case 161: |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
295 s->avctx->pix_fmt = PIX_FMT_GRAY16BE; |
4193 | 296 break; |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
297 case 324: |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
298 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
|
299 break; |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
300 case 483: |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
301 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
|
302 break; |
4186 | 303 default: |
9611
8074df653392
Add 32-bit RGB support to TIFF decoder and extend a bit 'unsupported format' message
kostya
parents:
9553
diff
changeset
|
304 av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count); |
4013 | 305 return -1; |
306 } | |
4186 | 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 */ | |
5261 | 320 pal = (uint32_t *) s->picture.data[1]; |
4186 | 321 for(i = 0; i < 256; i++) |
322 pal[i] = i * 0x010101; | |
323 } | |
4013 | 324 break; |
325 case TIFF_COMPR: | |
326 s->compr = value; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
327 s->predictor = 0; |
4013 | 328 switch(s->compr){ |
329 case TIFF_RAW: | |
330 case TIFF_PACKBITS: | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
331 case TIFF_LZW: |
8491 | 332 case TIFF_CCITT_RLE: |
333 break; | |
334 case TIFF_G3: | |
335 case TIFF_G4: | |
336 s->fax_opts = 0; | |
4013 | 337 break; |
338 case TIFF_DEFLATE: | |
339 case TIFF_ADOBE_DEFLATE: | |
8590 | 340 #if CONFIG_ZLIB |
4013 | 341 break; |
342 #else | |
343 av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n"); | |
344 return -1; | |
345 #endif | |
4184 | 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; | |
4013 | 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: | |
8428 | 356 if(type == TIFF_LONG && value == -1) |
357 value = s->avctx->height; | |
4185 | 358 if(value < 1){ |
4013 | 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; | |
4405
48952197d91f
Some TIFFs do not set rows per strip for single strip.
kostya
parents:
4364
diff
changeset
|
371 if(s->strips == 1) s->rps = s->height; |
4013 | 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; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
387 s->sstype = type; |
4013 | 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: | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
394 s->predictor = value; |
4013 | 395 break; |
4186 | 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; | |
4187
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
404 case 2: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
405 case 3: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
406 break; |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
407 default: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
408 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
|
409 return -1; |
4186 | 410 } |
411 break; | |
10264
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
412 case TIFF_FILL_ORDER: |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
413 if(value < 1 || value > 2){ |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
414 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
|
415 value = 1; |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
416 } |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
417 s->fill_order = value - 1; |
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
418 break; |
4186 | 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 } | |
5261 | 424 pal = (uint32_t *) s->picture.data[1]; |
4190 | 425 off = type_sizes[type]; |
4186 | 426 rp = buf; |
427 gp = buf + count / 3 * off; | |
428 bp = buf + count / 3 * off * 2; | |
4190 | 429 off = (type_sizes[type] - 1) << 3; |
4186 | 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 } | |
4192 | 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; | |
8491 | 443 case TIFF_T4OPTIONS: |
10303
8a49525f2b1e
Make TIFF decoder load compression options only for corresponding codec
kostya
parents:
10299
diff
changeset
|
444 if(s->compr == TIFF_G3) |
8a49525f2b1e
Make TIFF decoder load compression options only for corresponding codec
kostya
parents:
10299
diff
changeset
|
445 s->fax_opts = value; |
8a49525f2b1e
Make TIFF decoder load compression options only for corresponding codec
kostya
parents:
10299
diff
changeset
|
446 break; |
8491 | 447 case TIFF_T6OPTIONS: |
10303
8a49525f2b1e
Make TIFF decoder load compression options only for corresponding codec
kostya
parents:
10299
diff
changeset
|
448 if(s->compr == TIFF_G4) |
8a49525f2b1e
Make TIFF decoder load compression options only for corresponding codec
kostya
parents:
10299
diff
changeset
|
449 s->fax_opts = value; |
8491 | 450 break; |
4013 | 451 } |
452 return 0; | |
453 } | |
454 | |
455 static int decode_frame(AVCodecContext *avctx, | |
456 void *data, int *data_size, | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
457 AVPacket *avpkt) |
4013 | 458 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
459 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
460 int buf_size = avpkt->size; |
4013 | 461 TiffContext * const s = avctx->priv_data; |
462 AVFrame *picture = data; | |
463 AVFrame * const p= (AVFrame*)&s->picture; | |
6256 | 464 const uint8_t *orig_buf = buf, *end_buf = buf + buf_size; |
4013 | 465 int id, le, off; |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
466 int i, j, entries; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
467 int stride, soff, ssize; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
468 uint8_t *dst; |
4013 | 469 |
470 //parse image header | |
4364 | 471 id = AV_RL16(buf); buf += 2; |
4013 | 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; | |
4186 | 479 s->invert = 0; |
5962 | 480 s->compr = TIFF_RAW; |
10264
f9efc2bd005d
Support both LSB and MSB orders for TIFF CCITT G.x compressed data.
kostya
parents:
9812
diff
changeset
|
481 s->fill_order = 0; |
4013 | 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++){ | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
497 if(tiff_decode_tag(s, orig_buf, buf, end_buf) < 0) |
4013 | 498 return -1; |
499 buf += 12; | |
500 } | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
501 if(!s->stripdata && !s->stripoff){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
502 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
|
503 return -1; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
504 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
505 /* 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
|
506 if(!p->data[0]){ |
10324
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
507 s->bpp = 1; |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
508 avctx->pix_fmt = PIX_FMT_MONOBLACK; |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
509 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
|
510 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
|
511 return -1; |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
512 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
|
513 } |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
514 if(s->picture.data[0]) |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
515 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
|
516 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
|
517 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
|
518 return -1; |
5bbe55451800
When BitsPerSample tag is not present in TIFF, that means file is
kostya
parents:
10304
diff
changeset
|
519 } |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
520 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
521 if(s->strips == 1 && !s->stripsize){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
522 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
|
523 s->stripsize = buf_size - s->stripoff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
524 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
525 stride = p->linesize[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
526 dst = p->data[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
527 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
|
528 if(s->stripsizes) |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
529 ssize = tget(&s->stripsizes, s->sstype, s->le); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
530 else |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
531 ssize = s->stripsize; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
532 |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
533 if(s->stripdata){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
534 soff = tget(&s->stripdata, s->sot, s->le); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
535 }else |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
536 soff = s->stripoff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
537 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
|
538 break; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
539 dst += s->rps * stride; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
540 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
541 if(s->predictor == 2){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
542 dst = p->data[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
543 soff = s->bpp >> 3; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
544 ssize = s->width * soff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
545 for(i = 0; i < s->height; i++) { |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
546 for(j = soff; j < ssize; j++) |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
547 dst[j] += dst[j - soff]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
548 dst += stride; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
549 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
550 } |
4013 | 551 |
4186 | 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 } | |
4013 | 563 *picture= *(AVFrame*)&s->picture; |
564 *data_size = sizeof(AVPicture); | |
565 | |
566 return buf_size; | |
567 } | |
568 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6256
diff
changeset
|
569 static av_cold int tiff_init(AVCodecContext *avctx){ |
4013 | 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; | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
577 ff_lzw_decode_open(&s->lzw); |
8491 | 578 ff_ccitt_unpack_init(); |
4013 | 579 |
580 return 0; | |
581 } | |
582 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6256
diff
changeset
|
583 static av_cold int tiff_end(AVCodecContext *avctx) |
4013 | 584 { |
585 TiffContext * const s = avctx->priv_data; | |
586 | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
587 ff_lzw_decode_close(&s->lzw); |
4013 | 588 if(s->picture.data[0]) |
589 avctx->release_buffer(avctx, &s->picture); | |
590 return 0; | |
591 } | |
592 | |
593 AVCodec tiff_decoder = { | |
594 "tiff", | |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
10635
diff
changeset
|
595 AVMEDIA_TYPE_VIDEO, |
4013 | 596 CODEC_ID_TIFF, |
597 sizeof(TiffContext), | |
598 tiff_init, | |
599 NULL, | |
600 tiff_end, | |
601 decode_frame, | |
9812
58d29c191e5a
tiff image decoder uses get_buffer, set CODEC_CAP_DR1
bcoudurier
parents:
9784
diff
changeset
|
602 CODEC_CAP_DR1, |
6722 | 603 NULL, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6722
diff
changeset
|
604 .long_name = NULL_IF_CONFIG_SMALL("TIFF image"), |
4013 | 605 }; |