Mercurial > libavcodec.hg
annotate tiff.c @ 8991:ca768cb2bfb6 libavcodec
Use last decoded SPS as current SPS in order to parse picture timing SEI
correctly. This works around an apparent H.264 standard deficiency.
Patch by Ivan Schreter, schreter gmx net
author | cehoyos |
---|---|
date | Fri, 20 Feb 2009 16:20:01 +0000 |
parents | e9d9d946f213 |
children | 54bc8a2727b0 |
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 } | |
4186 | 246 switch(s->bpp){ |
8427 | 247 case 1: |
248 s->avctx->pix_fmt = PIX_FMT_MONOBLACK; | |
249 break; | |
4186 | 250 case 8: |
251 s->avctx->pix_fmt = PIX_FMT_PAL8; | |
252 break; | |
253 case 24: | |
254 s->avctx->pix_fmt = PIX_FMT_RGB24; | |
255 break; | |
4193 | 256 case 16: |
257 if(count == 1){ | |
258 s->avctx->pix_fmt = PIX_FMT_GRAY16BE; | |
259 }else{ | |
260 av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%i)\n", s->bpp); | |
261 return -1; | |
262 } | |
263 break; | |
4186 | 264 default: |
4191 | 265 av_log(s->avctx, AV_LOG_ERROR, "This format is not supported (bpp=%i)\n", s->bpp); |
4013 | 266 return -1; |
267 } | |
4186 | 268 if(s->width != s->avctx->width || s->height != s->avctx->height){ |
269 if(avcodec_check_dimensions(s->avctx, s->width, s->height)) | |
270 return -1; | |
271 avcodec_set_dimensions(s->avctx, s->width, s->height); | |
272 } | |
273 if(s->picture.data[0]) | |
274 s->avctx->release_buffer(s->avctx, &s->picture); | |
275 if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){ | |
276 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
277 return -1; | |
278 } | |
279 if(s->bpp == 8){ | |
280 /* make default grayscale pal */ | |
5261 | 281 pal = (uint32_t *) s->picture.data[1]; |
4186 | 282 for(i = 0; i < 256; i++) |
283 pal[i] = i * 0x010101; | |
284 } | |
4013 | 285 break; |
286 case TIFF_COMPR: | |
287 s->compr = value; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
288 s->predictor = 0; |
4013 | 289 switch(s->compr){ |
290 case TIFF_RAW: | |
291 case TIFF_PACKBITS: | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
292 case TIFF_LZW: |
8491 | 293 case TIFF_CCITT_RLE: |
294 break; | |
295 case TIFF_G3: | |
296 case TIFF_G4: | |
297 s->fax_opts = 0; | |
4013 | 298 break; |
299 case TIFF_DEFLATE: | |
300 case TIFF_ADOBE_DEFLATE: | |
8590 | 301 #if CONFIG_ZLIB |
4013 | 302 break; |
303 #else | |
304 av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n"); | |
305 return -1; | |
306 #endif | |
4184 | 307 case TIFF_JPEG: |
308 case TIFF_NEWJPEG: | |
309 av_log(s->avctx, AV_LOG_ERROR, "JPEG compression is not supported\n"); | |
310 return -1; | |
4013 | 311 default: |
312 av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n", s->compr); | |
313 return -1; | |
314 } | |
315 break; | |
316 case TIFF_ROWSPERSTRIP: | |
8428 | 317 if(type == TIFF_LONG && value == -1) |
318 value = s->avctx->height; | |
4185 | 319 if(value < 1){ |
4013 | 320 av_log(s->avctx, AV_LOG_ERROR, "Incorrect value of rows per strip\n"); |
321 return -1; | |
322 } | |
323 s->rps = value; | |
324 break; | |
325 case TIFF_STRIP_OFFS: | |
326 if(count == 1){ | |
327 s->stripdata = NULL; | |
328 s->stripoff = value; | |
329 }else | |
330 s->stripdata = start + off; | |
331 s->strips = count; | |
4405
48952197d91f
Some TIFFs do not set rows per strip for single strip.
kostya
parents:
4364
diff
changeset
|
332 if(s->strips == 1) s->rps = s->height; |
4013 | 333 s->sot = type; |
334 if(s->stripdata > end_buf){ | |
335 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); | |
336 return -1; | |
337 } | |
338 break; | |
339 case TIFF_STRIP_SIZE: | |
340 if(count == 1){ | |
341 s->stripsizes = NULL; | |
342 s->stripsize = value; | |
343 s->strips = 1; | |
344 }else{ | |
345 s->stripsizes = start + off; | |
346 } | |
347 s->strips = count; | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
348 s->sstype = type; |
4013 | 349 if(s->stripsizes > end_buf){ |
350 av_log(s->avctx, AV_LOG_ERROR, "Tag referencing position outside the image\n"); | |
351 return -1; | |
352 } | |
353 break; | |
354 case TIFF_PREDICTOR: | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
355 s->predictor = value; |
4013 | 356 break; |
4186 | 357 case TIFF_INVERT: |
358 switch(value){ | |
359 case 0: | |
360 s->invert = 1; | |
361 break; | |
362 case 1: | |
363 s->invert = 0; | |
364 break; | |
4187
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
365 case 2: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
366 case 3: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
367 break; |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
368 default: |
46f12596304f
Print error message for unsupported mode (RGB planar,CMYK,YCrCb)
kostya
parents:
4186
diff
changeset
|
369 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
|
370 return -1; |
4186 | 371 } |
372 break; | |
373 case TIFF_PAL: | |
374 if(s->avctx->pix_fmt != PIX_FMT_PAL8){ | |
375 av_log(s->avctx, AV_LOG_ERROR, "Palette met but this is not palettized format\n"); | |
376 return -1; | |
377 } | |
5261 | 378 pal = (uint32_t *) s->picture.data[1]; |
4190 | 379 off = type_sizes[type]; |
4186 | 380 rp = buf; |
381 gp = buf + count / 3 * off; | |
382 bp = buf + count / 3 * off * 2; | |
4190 | 383 off = (type_sizes[type] - 1) << 3; |
4186 | 384 for(i = 0; i < count / 3; i++){ |
385 j = (tget(&rp, type, s->le) >> off) << 16; | |
386 j |= (tget(&gp, type, s->le) >> off) << 8; | |
387 j |= tget(&bp, type, s->le) >> off; | |
388 pal[i] = j; | |
389 } | |
4192 | 390 break; |
391 case TIFF_PLANAR: | |
392 if(value == 2){ | |
393 av_log(s->avctx, AV_LOG_ERROR, "Planar format is not supported\n"); | |
394 return -1; | |
395 } | |
396 break; | |
8491 | 397 case TIFF_T4OPTIONS: |
398 case TIFF_T6OPTIONS: | |
399 s->fax_opts = value; | |
400 break; | |
4013 | 401 } |
402 return 0; | |
403 } | |
404 | |
405 static int decode_frame(AVCodecContext *avctx, | |
406 void *data, int *data_size, | |
6256 | 407 const uint8_t *buf, int buf_size) |
4013 | 408 { |
409 TiffContext * const s = avctx->priv_data; | |
410 AVFrame *picture = data; | |
411 AVFrame * const p= (AVFrame*)&s->picture; | |
6256 | 412 const uint8_t *orig_buf = buf, *end_buf = buf + buf_size; |
4013 | 413 int id, le, off; |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
414 int i, j, entries; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
415 int stride, soff, ssize; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
416 uint8_t *dst; |
4013 | 417 |
418 //parse image header | |
4364 | 419 id = AV_RL16(buf); buf += 2; |
4013 | 420 if(id == 0x4949) le = 1; |
421 else if(id == 0x4D4D) le = 0; | |
422 else{ | |
423 av_log(avctx, AV_LOG_ERROR, "TIFF header not found\n"); | |
424 return -1; | |
425 } | |
426 s->le = le; | |
4186 | 427 s->invert = 0; |
5962 | 428 s->compr = TIFF_RAW; |
4013 | 429 // As TIFF 6.0 specification puts it "An arbitrary but carefully chosen number |
430 // that further identifies the file as a TIFF file" | |
431 if(tget_short(&buf, le) != 42){ | |
432 av_log(avctx, AV_LOG_ERROR, "The answer to life, universe and everything is not correct!\n"); | |
433 return -1; | |
434 } | |
435 /* parse image file directory */ | |
436 off = tget_long(&buf, le); | |
437 if(orig_buf + off + 14 >= end_buf){ | |
438 av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n"); | |
439 return -1; | |
440 } | |
441 buf = orig_buf + off; | |
442 entries = tget_short(&buf, le); | |
443 for(i = 0; i < entries; i++){ | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
444 if(tiff_decode_tag(s, orig_buf, buf, end_buf) < 0) |
4013 | 445 return -1; |
446 buf += 12; | |
447 } | |
8429
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
448 if(!s->stripdata && !s->stripoff){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
449 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
|
450 return -1; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
451 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
452 /* 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
|
453 if(!p->data[0]){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
454 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
|
455 return -1; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
456 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
457 if(s->strips == 1 && !s->stripsize){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
458 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
|
459 s->stripsize = buf_size - s->stripoff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
460 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
461 stride = p->linesize[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
462 dst = p->data[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
463 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
|
464 if(s->stripsizes) |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
465 ssize = tget(&s->stripsizes, s->sstype, s->le); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
466 else |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
467 ssize = s->stripsize; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
468 |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
469 if(s->stripdata){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
470 soff = tget(&s->stripdata, s->sot, s->le); |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
471 }else |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
472 soff = s->stripoff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
473 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
|
474 break; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
475 dst += s->rps * stride; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
476 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
477 if(s->predictor == 2){ |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
478 dst = p->data[0]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
479 soff = s->bpp >> 3; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
480 ssize = s->width * soff; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
481 for(i = 0; i < s->height; i++) { |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
482 for(j = soff; j < ssize; j++) |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
483 dst[j] += dst[j - soff]; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
484 dst += stride; |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
485 } |
b3ecaba81501
Decode TIFF image only after all tags have been decoded
kostya
parents:
8428
diff
changeset
|
486 } |
4013 | 487 |
4186 | 488 if(s->invert){ |
489 uint8_t *src; | |
490 int j; | |
491 | |
492 src = s->picture.data[0]; | |
493 for(j = 0; j < s->height; j++){ | |
494 for(i = 0; i < s->picture.linesize[0]; i++) | |
495 src[i] = 255 - src[i]; | |
496 src += s->picture.linesize[0]; | |
497 } | |
498 } | |
4013 | 499 *picture= *(AVFrame*)&s->picture; |
500 *data_size = sizeof(AVPicture); | |
501 | |
502 return buf_size; | |
503 } | |
504 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6256
diff
changeset
|
505 static av_cold int tiff_init(AVCodecContext *avctx){ |
4013 | 506 TiffContext *s = avctx->priv_data; |
507 | |
508 s->width = 0; | |
509 s->height = 0; | |
510 s->avctx = avctx; | |
511 avcodec_get_frame_defaults((AVFrame*)&s->picture); | |
512 avctx->coded_frame= (AVFrame*)&s->picture; | |
513 s->picture.data[0] = NULL; | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
514 ff_lzw_decode_open(&s->lzw); |
8491 | 515 ff_ccitt_unpack_init(); |
4013 | 516 |
517 return 0; | |
518 } | |
519 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6256
diff
changeset
|
520 static av_cold int tiff_end(AVCodecContext *avctx) |
4013 | 521 { |
522 TiffContext * const s = avctx->priv_data; | |
523 | |
4080
f426c81afc9e
LZW decoder as separate module plus TIFF LZW support
kostya
parents:
4079
diff
changeset
|
524 ff_lzw_decode_close(&s->lzw); |
4013 | 525 if(s->picture.data[0]) |
526 avctx->release_buffer(avctx, &s->picture); | |
527 return 0; | |
528 } | |
529 | |
530 AVCodec tiff_decoder = { | |
531 "tiff", | |
532 CODEC_TYPE_VIDEO, | |
533 CODEC_ID_TIFF, | |
534 sizeof(TiffContext), | |
535 tiff_init, | |
536 NULL, | |
537 tiff_end, | |
538 decode_frame, | |
539 0, | |
6722 | 540 NULL, |
7040
e943e1409077
Make AVCodec long_names definition conditional depending on CONFIG_SMALL.
stefano
parents:
6722
diff
changeset
|
541 .long_name = NULL_IF_CONFIG_SMALL("TIFF image"), |
4013 | 542 }; |