Mercurial > libavcodec.hg
annotate tiff.c @ 9830:bd0879f752e6 libavcodec
Express the H.264 parser dependency on the golomb code in configure instead of
in the Makefile as it is done for all other parts that depend on golomb.
author | diego |
---|---|
date | Tue, 09 Jun 2009 20:29:52 +0000 |
parents | 58d29c191e5a |
children | f9efc2bd005d |
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; |
4013 | 47 |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
48 int strips, rps, sstype; |
4013 | 49 int sot; |
6256 | 50 const uint8_t* stripdata; |
51 const uint8_t* stripsizes; | |
4013 | 52 int stripsize, stripoff; |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
53 LZWState *lzw; |
4013 | 54 } TiffContext; |
55 | |
6256 | 56 static int tget_short(const uint8_t **p, int le){ |
4364 | 57 int v = le ? AV_RL16(*p) : AV_RB16(*p); |
4013 | 58 *p += 2; |
59 return v; | |
60 } | |
61 | |
6256 | 62 static int tget_long(const uint8_t **p, int le){ |
4364 | 63 int v = le ? AV_RL32(*p) : AV_RB32(*p); |
4013 | 64 *p += 4; |
65 return v; | |
66 } | |
67 | |
6256 | 68 static int tget(const uint8_t **p, int type, int le){ |
4013 | 69 switch(type){ |
70 case TIFF_BYTE : return *(*p)++; | |
71 case TIFF_SHORT: return tget_short(p, le); | |
72 case TIFF_LONG : return tget_long (p, le); | |
73 default : return -1; | |
74 } | |
75 } | |
76 | |
6256 | 77 static int tiff_unpack_strip(TiffContext *s, uint8_t* dst, int stride, const uint8_t *src, int size, int lines){ |
4013 | 78 int c, line, pixels, code; |
6256 | 79 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
|
80 int width = s->width * s->bpp >> 3; |
8590 | 81 #if CONFIG_ZLIB |
4013 | 82 uint8_t *zbuf; unsigned long outlen; |
83 | |
84 if(s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE){ | |
85 outlen = width * lines; | |
86 zbuf = av_malloc(outlen); | |
87 if(uncompress(zbuf, &outlen, src, size) != Z_OK){ | |
88 av_log(s->avctx, AV_LOG_ERROR, "Uncompressing failed (%lu of %lu)\n", outlen, (unsigned long)width * lines); | |
89 av_free(zbuf); | |
90 return -1; | |
91 } | |
92 src = zbuf; | |
93 for(line = 0; line < lines; line++){ | |
94 memcpy(dst, src, width); | |
95 dst += stride; | |
96 src += width; | |
97 } | |
98 av_free(zbuf); | |
99 return 0; | |
100 } | |
101 #endif | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
102 if(s->compr == TIFF_LZW){ |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
103 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
|
104 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
|
105 return -1; |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
106 } |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
107 } |
8491 | 108 if(s->compr == TIFF_CCITT_RLE || s->compr == TIFF_G3 || s->compr == TIFF_G4){ |
109 int i, ret = 0; | |
110 uint8_t *src2 = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); | |
111 | |
112 if(!src2 || (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE < (unsigned)size){ | |
113 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n"); | |
114 return -1; | |
115 } | |
116 for(i = 0; i < size; i++) | |
117 src2[i] = ff_reverse[src[i]]; | |
118 memset(src2+size, 0, FF_INPUT_BUFFER_PADDING_SIZE); | |
119 if(s->compr == TIFF_G3 && !(s->fax_opts & 1)) | |
120 s->compr = TIFF_CCITT_RLE; | |
121 switch(s->compr){ | |
122 case TIFF_CCITT_RLE: | |
123 case TIFF_G3: | |
124 case TIFF_G4: | |
125 ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride, s->compr); | |
126 break; | |
127 } | |
128 av_free(src2); | |
129 return ret; | |
130 } | |
4013 | 131 for(line = 0; line < lines; line++){ |
132 if(src - ssrc > size){ | |
133 av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n"); | |
134 return -1; | |
135 } | |
136 switch(s->compr){ | |
137 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
|
138 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
|
139 src += width; |
4013 | 140 break; |
141 case TIFF_PACKBITS: | |
142 for(pixels = 0; pixels < width;){ | |
143 code = (int8_t)*src++; | |
144 if(code >= 0){ | |
145 code++; | |
146 if(pixels + code > width){ | |
147 av_log(s->avctx, AV_LOG_ERROR, "Copy went out of bounds\n"); | |
148 return -1; | |
149 } | |
150 memcpy(dst + pixels, src, code); | |
151 src += code; | |
152 pixels += code; | |
153 }else if(code != -128){ // -127..-1 | |
154 code = (-code) + 1; | |
155 if(pixels + code > width){ | |
156 av_log(s->avctx, AV_LOG_ERROR, "Run went out of bounds\n"); | |
157 return -1; | |
158 } | |
159 c = *src++; | |
160 memset(dst + pixels, c, code); | |
161 pixels += code; | |
162 } | |
163 } | |
164 break; | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
165 case TIFF_LZW: |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
166 pixels = ff_lzw_decode(s->lzw, dst, width); |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
167 if(pixels < width){ |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
168 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
|
169 return -1; |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
170 } |
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
171 break; |
4013 | 172 } |
173 dst += stride; | |
174 } | |
175 return 0; | |
176 } | |
177 | |
178 | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
179 static int tiff_decode_tag(TiffContext *s, const uint8_t *start, const uint8_t *buf, const uint8_t *end_buf) |
4013 | 180 { |
181 int tag, type, count, off, value = 0; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
182 int i, j; |
5261 | 183 uint32_t *pal; |
6256 | 184 const uint8_t *rp, *gp, *bp; |
4013 | 185 |
186 tag = tget_short(&buf, s->le); | |
187 type = tget_short(&buf, s->le); | |
188 count = tget_long(&buf, s->le); | |
189 off = tget_long(&buf, s->le); | |
190 | |
191 if(count == 1){ | |
192 switch(type){ | |
193 case TIFF_BYTE: | |
194 case TIFF_SHORT: | |
195 buf -= 4; | |
196 value = tget(&buf, type, s->le); | |
197 buf = NULL; | |
198 break; | |
199 case TIFF_LONG: | |
200 value = off; | |
201 buf = NULL; | |
202 break; | |
8366
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
203 case TIFF_STRING: |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
204 if(count <= 4){ |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
205 buf -= 4; |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
206 break; |
3bbfd02865d7
4l: TIFF stores short strings inside tag, do not interpret it is as an offset
kostya
parents:
7040
diff
changeset
|
207 } |
4013 | 208 default: |
209 value = -1; | |
210 buf = start + off; | |
211 } | |
4190 | 212 }else if(type_sizes[type] * count <= 4){ |
213 buf -= 4; | |
4013 | 214 }else{ |
215 buf = start + off; | |
216 } | |
217 | |
218 if(buf && (buf < start || buf > end_buf)){ | |
219 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); | |
220 return -1; | |
221 } | |
222 | |
223 switch(tag){ | |
224 case TIFF_WIDTH: | |
225 s->width = value; | |
226 break; | |
227 case TIFF_HEIGHT: | |
228 s->height = value; | |
229 break; | |
230 case TIFF_BPP: | |
231 if(count == 1) s->bpp = value; | |
232 else{ | |
233 switch(type){ | |
234 case TIFF_BYTE: | |
4183 | 235 s->bpp = (off & 0xFF) + ((off >> 8) & 0xFF) + ((off >> 16) & 0xFF) + ((off >> 24) & 0xFF); |
4013 | 236 break; |
237 case TIFF_SHORT: | |
238 case TIFF_LONG: | |
4183 | 239 s->bpp = 0; |
240 for(i = 0; i < count; i++) s->bpp += tget(&buf, type, s->le); | |
4013 | 241 break; |
242 default: | |
243 s->bpp = -1; | |
244 } | |
245 } | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
246 if(count > 4){ |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
247 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
|
248 return -1; |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
249 } |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
250 switch(s->bpp*10 + count){ |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
251 case 11: |
8427 | 252 s->avctx->pix_fmt = PIX_FMT_MONOBLACK; |
253 break; | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
254 case 81: |
4186 | 255 s->avctx->pix_fmt = PIX_FMT_PAL8; |
256 break; | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
257 case 243: |
4186 | 258 s->avctx->pix_fmt = PIX_FMT_RGB24; |
259 break; | |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
260 case 161: |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
261 s->avctx->pix_fmt = PIX_FMT_GRAY16BE; |
4193 | 262 break; |
9784
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
263 case 324: |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
264 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
|
265 break; |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
266 case 483: |
2142607ddc2e
Check combined depth and number of components in TIFF decoder, thus eliminating
kostya
parents:
9611
diff
changeset
|
267 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
|
268 break; |
4186 | 269 default: |
9611
8074df653392
Add 32-bit RGB support to TIFF decoder and extend a bit 'unsupported format' message
kostya
parents:
9553
diff
changeset
|
270 av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%d, %d components)\n", s->bpp, count); |
4013 | 271 return -1; |
272 } | |
4186 | 273 if(s->width != s->avctx->width || s->height != s->avctx->height){ |
274 if(avcodec_check_dimensions(s->avctx, s->width, s->height)) | |
275 return -1; | |
276 avcodec_set_dimensions(s->avctx, s->width, s->height); | |
277 } | |
278 if(s->picture.data[0]) | |
279 s->avctx->release_buffer(s->avctx, &s->picture); | |
280 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){ | |
281 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
282 return -1; | |
283 } | |
284 if(s->bpp == 8){ | |
285 /* make default grayscale pal */ | |
5261 | 286 pal = (uint32_t *) s->picture.data[1]; |
4186 | 287 for(i = 0; i < 256; i++) |
288 pal[i] = i * 0x010101; | |
289 } | |
4013 | 290 break; |
291 case TIFF_COMPR: | |
292 s->compr = value; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
293 s->predictor = 0; |
4013 | 294 switch(s->compr){ |
295 case TIFF_RAW: | |
296 case TIFF_PACKBITS: | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
297 case TIFF_LZW: |
8491 | 298 case TIFF_CCITT_RLE: |
299 break; | |
300 case TIFF_G3: | |
301 case TIFF_G4: | |
302 s->fax_opts = 0; | |
4013 | 303 break; |
304 case TIFF_DEFLATE: | |
305 case TIFF_ADOBE_DEFLATE: | |
8590 | 306 #if CONFIG_ZLIB |
4013 | 307 break; |
308 #else | |
309 av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n"); | |
310 return -1; | |
311 #endif | |
4184 | 312 case TIFF_JPEG: |
313 case TIFF_NEWJPEG: | |
314 av_log(s->avctx, AV_LOG_ERROR, "JPEG compression is not supported\n"); | |
315 return -1; | |
4013 | 316 default: |
317 av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n", s->compr); | |
318 return -1; | |
319 } | |
320 break; | |
321 case TIFF_ROWSPERSTRIP: | |
8428 | 322 if(type == TIFF_LONG && value == -1) |
323 value = s->avctx->height; | |
4185 | 324 if(value < 1){ |
4013 | 325 av_log(s->avctx, AV_LOG_ERROR, "Incorrect value of rows per strip\n"); |
326 return -1; | |
327 } | |
328 s->rps = value; | |
329 break; | |
330 case TIFF_STRIP_OFFS: | |
331 if(count == 1){ | |
332 s->stripdata = NULL; | |
333 s->stripoff = value; | |
334 }else | |
335 s->stripdata = start + off; | |
336 s->strips = count; | |
4405
48952197d91f
Some TIFFs do not set rows per strip for single strip.
kostya
parents:
4364
diff
changeset
|
337 if(s->strips == 1) s->rps = s->height; |
4013 | 338 s->sot = type; |
339 if(s->stripdata > end_buf){ | |
340 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); | |
341 return -1; | |
342 } | |
343 break; | |
344 case TIFF_STRIP_SIZE: | |
345 if(count == 1){ | |
346 s->stripsizes = NULL; | |
347 s->stripsize = value; | |
348 s->strips = 1; | |
349 }else{ | |
350 s->stripsizes = start + off; | |
351 } | |
352 s->strips = count; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
353 s->sstype = type; |
4013 | 354 if(s->stripsizes > end_buf){ |
355 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); | |
356 return -1; | |
357 } | |
358 break; | |
359 case TIFF_PREDICTOR: | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
360 s->predictor = value; |
4013 | 361 break; |
4186 | 362 case TIFF_INVERT: |
363 switch(value){ | |
364 case 0: | |
365 s->invert = 1; | |
366 break; | |
367 case 1: | |
368 s->invert = 0; | |
369 break; | |
4187
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
370 case 2: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
371 case 3: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
372 break; |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
373 default: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
374 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
|
375 return -1; |
4186 | 376 } |
377 break; | |
378 case TIFF_PAL: | |
379 if(s->avctx->pix_fmt != PIX_FMT_PAL8){ | |
380 av_log(s->avctx, AV_LOG_ERROR, "Palette met but this is not palettized format\n"); | |
381 return -1; | |
382 } | |
5261 | 383 pal = (uint32_t *) s->picture.data[1]; |
4190 | 384 off = type_sizes[type]; |
4186 | 385 rp = buf; |
386 gp = buf + count / 3 * off; | |
387 bp = buf + count / 3 * off * 2; | |
4190 | 388 off = (type_sizes[type] - 1) << 3; |
4186 | 389 for(i = 0; i < count / 3; i++){ |
390 j = (tget(&rp, type, s->le) >> off) << 16; | |
391 j |= (tget(&gp, type, s->le) >> off) << 8; | |
392 j |= tget(&bp, type, s->le) >> off; | |
393 pal[i] = j; | |
394 } | |
4192 | 395 break; |
396 case TIFF_PLANAR: | |
397 if(value == 2){ | |
398 av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n"); | |
399 return -1; | |
400 } | |
401 break; | |
8491 | 402 case TIFF_T4OPTIONS: |
403 case TIFF_T6OPTIONS: | |
404 s->fax_opts = value; | |
405 break; | |
4013 | 406 } |
407 return 0; | |
408 } | |
409 | |
410 static int decode_frame(AVCodecContext *avctx, | |
411 void *data, int *data_size, | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
412 AVPacket *avpkt) |
4013 | 413 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
414 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
8718
diff
changeset
|
415 int buf_size = avpkt->size; |
4013 | 416 TiffContext * const s = avctx->priv_data; |
417 AVFrame *picture = data; | |
418 AVFrame * const p= (AVFrame*)&s->picture; | |
6256 | 419 const uint8_t *orig_buf = buf, *end_buf = buf + buf_size; |
4013 | 420 int id, le, off; |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
421 int i, j, entries; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
422 int stride, soff, ssize; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
423 uint8_t *dst; |
4013 | 424 |
425 //parse image header | |
4364 | 426 id = AV_RL16(buf); buf += 2; |
4013 | 427 if(id == 0x4949) le = 1; |
428 else if(id == 0x4D4D) le = 0; | |
429 else{ | |
430 av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n"); | |
431 return -1; | |
432 } | |
433 s->le = le; | |
4186 | 434 s->invert = 0; |
5962 | 435 s->compr = TIFF_RAW; |
4013 | 436 // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number |
437 // that further identifies the file as a TIFF file" | |
438 if(tget_short(&buf, le) != 42){ | |
439 av_log(avctx, AV_LOG_ERROR, "The answer to life, universe and everything is not correct!\n"); | |
440 return -1; | |
441 } | |
442 /* parse image file directory */ | |
443 off = tget_long(&buf, le); | |
444 if(orig_buf + off + 14 >= end_buf){ | |
445 av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n"); | |
446 return -1; | |
447 } | |
448 buf = orig_buf + off; | |
449 entries = tget_short(&buf, le); | |
450 for(i = 0; i < entries; i++){ | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
451 if(tiff_decode_tag(s, orig_buf, buf, end_buf) < 0) |
4013 | 452 return -1; |
453 buf += 12; | |
454 } | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
455 if(!s->stripdata && !s->stripoff){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
456 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
|
457 return -1; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
458 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
459 /* 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
|
460 if(!p->data[0]){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
461 av_log(s->avctx, AV_LOG_ERROR, "Picture initialization missing\n"); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
462 return -1; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
463 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
464 if(s->strips == 1 && !s->stripsize){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
465 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
|
466 s->stripsize = buf_size - s->stripoff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
467 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
468 stride = p->linesize[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
469 dst = p->data[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
470 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
|
471 if(s->stripsizes) |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
472 ssize = tget(&s->stripsizes, s->sstype, s->le); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
473 else |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
474 ssize = s->stripsize; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
475 |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
476 if(s->stripdata){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
477 soff = tget(&s->stripdata, s->sot, s->le); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
478 }else |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
479 soff = s->stripoff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
480 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
|
481 break; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
482 dst += s->rps * stride; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
483 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
484 if(s->predictor == 2){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
485 dst = p->data[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
486 soff = s->bpp >> 3; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
487 ssize = s->width * soff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
488 for(i = 0; i < s->height; i++) { |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
489 for(j = soff; j < ssize; j++) |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
490 dst[j] += dst[j - soff]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
491 dst += stride; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
492 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
493 } |
4013 | 494 |
4186 | 495 if(s->invert){ |
496 uint8_t *src; | |
497 int j; | |
498 | |
499 src = s->picture.data[0]; | |
500 for(j = 0; j < s->height; j++){ | |
501 for(i = 0; i < s->picture.linesize[0]; i++) | |
502 src[i] = 255 - src[i]; | |
503 src += s->picture.linesize[0]; | |
504 } | |
505 } | |
4013 | 506 *picture= *(AVFrame*)&s->picture; |
507 *data_size = sizeof(AVPicture); | |
508 | |
509 return buf_size; | |
510 } | |
511 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6256
diff
changeset
|
512 static av_cold int tiff_init(AVCodecContext *avctx){ |
4013 | 513 TiffContext *s = avctx->priv_data; |
514 | |
515 s->width = 0; | |
516 s->height = 0; | |
517 s->avctx = avctx; | |
518 avcodec_get_frame_defaults((AVFrame*)&s->picture); | |
519 avctx->coded_frame= (AVFrame*)&s->picture; | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
520 ff_lzw_decode_open(&s->lzw); |
8491 | 521 ff_ccitt_unpack_init(); |
4013 | 522 |
523 return 0; | |
524 } | |
525 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6256
diff
changeset
|
526 static av_cold int tiff_end(AVCodecContext *avctx) |
4013 | 527 { |
528 TiffContext * const s = avctx->priv_data; | |
529 | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
530 ff_lzw_decode_close(&s->lzw); |
4013 | 531 if(s->picture.data[0]) |
532 avctx->release_buffer(avctx, &s->picture); | |
533 return 0; | |
534 } | |
535 | |
536 AVCodec tiff_decoder = { | |
537 "tiff", | |
538 CODEC_TYPE_VIDEO, | |
539 CODEC_ID_TIFF, | |
540 sizeof(TiffContext), | |
541 tiff_init, | |
542 NULL, | |
543 tiff_end, | |
544 decode_frame, | |
9812
58d29c191e5a
tiff image decoder uses get_buffer, set CODEC_CAP_DR1
bcoudurier
parents:
9784
diff
changeset
|
545 CODEC_CAP_DR1, |
6722 | 546 NULL, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6722
diff
changeset
|
547 .long_name = NULL_IF_CONFIG_SMALL("TIFF image"), |
4013 | 548 }; |