blob: 3aaf63338d60040e833204d73407fd60f20ae345
1 | /* |
2 | * Copyright (c) 2006 Konstantin Shishkov |
3 | * |
4 | * This file is part of FFmpeg. |
5 | * |
6 | * FFmpeg is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU Lesser General Public |
8 | * License as published by the Free Software Foundation; either |
9 | * version 2.1 of the License, or (at your option) any later version. |
10 | * |
11 | * FFmpeg is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | * Lesser General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU Lesser General Public |
17 | * License along with FFmpeg; if not, write to the Free Software |
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
19 | */ |
20 | |
21 | /** |
22 | * @file |
23 | * TIFF image decoder |
24 | * @author Konstantin Shishkov |
25 | */ |
26 | |
27 | #include "config.h" |
28 | #if CONFIG_ZLIB |
29 | #include <zlib.h> |
30 | #endif |
31 | #if CONFIG_LZMA |
32 | #define LZMA_API_STATIC |
33 | #include <lzma.h> |
34 | #endif |
35 | |
36 | #include "libavutil/attributes.h" |
37 | #include "libavutil/avstring.h" |
38 | #include "libavutil/intreadwrite.h" |
39 | #include "libavutil/imgutils.h" |
40 | #include "avcodec.h" |
41 | #include "bytestream.h" |
42 | #include "faxcompr.h" |
43 | #include "internal.h" |
44 | #include "lzw.h" |
45 | #include "mathops.h" |
46 | #include "tiff.h" |
47 | #include "tiff_data.h" |
48 | #include "thread.h" |
49 | |
50 | typedef struct TiffContext { |
51 | AVCodecContext *avctx; |
52 | GetByteContext gb; |
53 | |
54 | int width, height; |
55 | unsigned int bpp, bppcount; |
56 | uint32_t palette[256]; |
57 | int palette_is_set; |
58 | int le; |
59 | enum TiffCompr compr; |
60 | enum TiffPhotometric photometric; |
61 | int planar; |
62 | int subsampling[2]; |
63 | int fax_opts; |
64 | int predictor; |
65 | int fill_order; |
66 | uint32_t res[4]; |
67 | |
68 | int strips, rps, sstype; |
69 | int sot; |
70 | int stripsizesoff, stripsize, stripoff, strippos; |
71 | LZWState *lzw; |
72 | |
73 | uint8_t *deinvert_buf; |
74 | int deinvert_buf_size; |
75 | uint8_t *yuv_line; |
76 | unsigned int yuv_line_size; |
77 | |
78 | int geotag_count; |
79 | TiffGeoTag *geotags; |
80 | } TiffContext; |
81 | |
82 | static void free_geotags(TiffContext *const s) |
83 | { |
84 | int i; |
85 | for (i = 0; i < s->geotag_count; i++) { |
86 | if (s->geotags[i].val) |
87 | av_freep(&s->geotags[i].val); |
88 | } |
89 | av_freep(&s->geotags); |
90 | s->geotag_count = 0; |
91 | } |
92 | |
93 | #define RET_GEOKEY(TYPE, array, element)\ |
94 | if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\ |
95 | key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_name_type_map))\ |
96 | return ff_tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].element; |
97 | |
98 | static const char *get_geokey_name(int key) |
99 | { |
100 | RET_GEOKEY(VERT, vert, name); |
101 | RET_GEOKEY(PROJ, proj, name); |
102 | RET_GEOKEY(GEOG, geog, name); |
103 | RET_GEOKEY(CONF, conf, name); |
104 | |
105 | return NULL; |
106 | } |
107 | |
108 | static int get_geokey_type(int key) |
109 | { |
110 | RET_GEOKEY(VERT, vert, type); |
111 | RET_GEOKEY(PROJ, proj, type); |
112 | RET_GEOKEY(GEOG, geog, type); |
113 | RET_GEOKEY(CONF, conf, type); |
114 | |
115 | return AVERROR_INVALIDDATA; |
116 | } |
117 | |
118 | static int cmp_id_key(const void *id, const void *k) |
119 | { |
120 | return *(const int*)id - ((const TiffGeoTagKeyName*)k)->key; |
121 | } |
122 | |
123 | static const char *search_keyval(const TiffGeoTagKeyName *keys, int n, int id) |
124 | { |
125 | TiffGeoTagKeyName *r = bsearch(&id, keys, n, sizeof(keys[0]), cmp_id_key); |
126 | if(r) |
127 | return r->name; |
128 | |
129 | return NULL; |
130 | } |
131 | |
132 | static char *get_geokey_val(int key, int val) |
133 | { |
134 | char *ap; |
135 | |
136 | if (val == TIFF_GEO_KEY_UNDEFINED) |
137 | return av_strdup("undefined"); |
138 | if (val == TIFF_GEO_KEY_USER_DEFINED) |
139 | return av_strdup("User-Defined"); |
140 | |
141 | #define RET_GEOKEY_VAL(TYPE, array)\ |
142 | if (val >= TIFF_##TYPE##_OFFSET &&\ |
143 | val - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_codes))\ |
144 | return av_strdup(ff_tiff_##array##_codes[val - TIFF_##TYPE##_OFFSET]); |
145 | |
146 | switch (key) { |
147 | case TIFF_GT_MODEL_TYPE_GEOKEY: |
148 | RET_GEOKEY_VAL(GT_MODEL_TYPE, gt_model_type); |
149 | break; |
150 | case TIFF_GT_RASTER_TYPE_GEOKEY: |
151 | RET_GEOKEY_VAL(GT_RASTER_TYPE, gt_raster_type); |
152 | break; |
153 | case TIFF_GEOG_LINEAR_UNITS_GEOKEY: |
154 | case TIFF_PROJ_LINEAR_UNITS_GEOKEY: |
155 | case TIFF_VERTICAL_UNITS_GEOKEY: |
156 | RET_GEOKEY_VAL(LINEAR_UNIT, linear_unit); |
157 | break; |
158 | case TIFF_GEOG_ANGULAR_UNITS_GEOKEY: |
159 | case TIFF_GEOG_AZIMUTH_UNITS_GEOKEY: |
160 | RET_GEOKEY_VAL(ANGULAR_UNIT, angular_unit); |
161 | break; |
162 | case TIFF_GEOGRAPHIC_TYPE_GEOKEY: |
163 | RET_GEOKEY_VAL(GCS_TYPE, gcs_type); |
164 | RET_GEOKEY_VAL(GCSE_TYPE, gcse_type); |
165 | break; |
166 | case TIFF_GEOG_GEODETIC_DATUM_GEOKEY: |
167 | RET_GEOKEY_VAL(GEODETIC_DATUM, geodetic_datum); |
168 | RET_GEOKEY_VAL(GEODETIC_DATUM_E, geodetic_datum_e); |
169 | break; |
170 | case TIFF_GEOG_ELLIPSOID_GEOKEY: |
171 | RET_GEOKEY_VAL(ELLIPSOID, ellipsoid); |
172 | break; |
173 | case TIFF_GEOG_PRIME_MERIDIAN_GEOKEY: |
174 | RET_GEOKEY_VAL(PRIME_MERIDIAN, prime_meridian); |
175 | break; |
176 | case TIFF_PROJECTED_CS_TYPE_GEOKEY: |
177 | ap = av_strdup(search_keyval(ff_tiff_proj_cs_type_codes, FF_ARRAY_ELEMS(ff_tiff_proj_cs_type_codes), val)); |
178 | if(ap) return ap; |
179 | break; |
180 | case TIFF_PROJECTION_GEOKEY: |
181 | ap = av_strdup(search_keyval(ff_tiff_projection_codes, FF_ARRAY_ELEMS(ff_tiff_projection_codes), val)); |
182 | if(ap) return ap; |
183 | break; |
184 | case TIFF_PROJ_COORD_TRANS_GEOKEY: |
185 | RET_GEOKEY_VAL(COORD_TRANS, coord_trans); |
186 | break; |
187 | case TIFF_VERTICAL_CS_TYPE_GEOKEY: |
188 | RET_GEOKEY_VAL(VERT_CS, vert_cs); |
189 | RET_GEOKEY_VAL(ORTHO_VERT_CS, ortho_vert_cs); |
190 | break; |
191 | |
192 | } |
193 | |
194 | ap = av_malloc(14); |
195 | if (ap) |
196 | snprintf(ap, 14, "Unknown-%d", val); |
197 | return ap; |
198 | } |
199 | |
200 | static char *doubles2str(double *dp, int count, const char *sep) |
201 | { |
202 | int i; |
203 | char *ap, *ap0; |
204 | uint64_t component_len; |
205 | if (!sep) sep = ", "; |
206 | component_len = 24LL + strlen(sep); |
207 | if (count >= (INT_MAX - 1)/component_len) |
208 | return NULL; |
209 | ap = av_malloc(component_len * count + 1); |
210 | if (!ap) |
211 | return NULL; |
212 | ap0 = ap; |
213 | ap[0] = '\0'; |
214 | for (i = 0; i < count; i++) { |
215 | unsigned l = snprintf(ap, component_len, "%.15g%s", dp[i], sep); |
216 | if(l >= component_len) { |
217 | av_free(ap0); |
218 | return NULL; |
219 | } |
220 | ap += l; |
221 | } |
222 | ap0[strlen(ap0) - strlen(sep)] = '\0'; |
223 | return ap0; |
224 | } |
225 | |
226 | static int add_metadata(int count, int type, |
227 | const char *name, const char *sep, TiffContext *s, AVFrame *frame) |
228 | { |
229 | switch(type) { |
230 | case TIFF_DOUBLE: return ff_tadd_doubles_metadata(count, name, sep, &s->gb, s->le, avpriv_frame_get_metadatap(frame)); |
231 | case TIFF_SHORT : return ff_tadd_shorts_metadata(count, name, sep, &s->gb, s->le, 0, avpriv_frame_get_metadatap(frame)); |
232 | case TIFF_STRING: return ff_tadd_string_metadata(count, name, &s->gb, s->le, avpriv_frame_get_metadatap(frame)); |
233 | default : return AVERROR_INVALIDDATA; |
234 | }; |
235 | } |
236 | |
237 | static void av_always_inline horizontal_fill(unsigned int bpp, uint8_t* dst, |
238 | int usePtr, const uint8_t *src, |
239 | uint8_t c, int width, int offset) |
240 | { |
241 | switch (bpp) { |
242 | case 1: |
243 | while (--width >= 0) { |
244 | dst[(width+offset)*8+7] = (usePtr ? src[width] : c) & 0x1; |
245 | dst[(width+offset)*8+6] = (usePtr ? src[width] : c) >> 1 & 0x1; |
246 | dst[(width+offset)*8+5] = (usePtr ? src[width] : c) >> 2 & 0x1; |
247 | dst[(width+offset)*8+4] = (usePtr ? src[width] : c) >> 3 & 0x1; |
248 | dst[(width+offset)*8+3] = (usePtr ? src[width] : c) >> 4 & 0x1; |
249 | dst[(width+offset)*8+2] = (usePtr ? src[width] : c) >> 5 & 0x1; |
250 | dst[(width+offset)*8+1] = (usePtr ? src[width] : c) >> 6 & 0x1; |
251 | dst[(width+offset)*8+0] = (usePtr ? src[width] : c) >> 7; |
252 | } |
253 | break; |
254 | case 2: |
255 | while (--width >= 0) { |
256 | dst[(width+offset)*4+3] = (usePtr ? src[width] : c) & 0x3; |
257 | dst[(width+offset)*4+2] = (usePtr ? src[width] : c) >> 2 & 0x3; |
258 | dst[(width+offset)*4+1] = (usePtr ? src[width] : c) >> 4 & 0x3; |
259 | dst[(width+offset)*4+0] = (usePtr ? src[width] : c) >> 6; |
260 | } |
261 | break; |
262 | case 4: |
263 | while (--width >= 0) { |
264 | dst[(width+offset)*2+1] = (usePtr ? src[width] : c) & 0xF; |
265 | dst[(width+offset)*2+0] = (usePtr ? src[width] : c) >> 4; |
266 | } |
267 | break; |
268 | default: |
269 | if (usePtr) { |
270 | memcpy(dst + offset, src, width); |
271 | } else { |
272 | memset(dst + offset, c, width); |
273 | } |
274 | } |
275 | } |
276 | |
277 | static int deinvert_buffer(TiffContext *s, const uint8_t *src, int size) |
278 | { |
279 | int i; |
280 | |
281 | av_fast_padded_malloc(&s->deinvert_buf, &s->deinvert_buf_size, size); |
282 | if (!s->deinvert_buf) |
283 | return AVERROR(ENOMEM); |
284 | for (i = 0; i < size; i++) |
285 | s->deinvert_buf[i] = ff_reverse[src[i]]; |
286 | |
287 | return 0; |
288 | } |
289 | |
290 | static void unpack_yuv(TiffContext *s, AVFrame *p, |
291 | const uint8_t *src, int lnum) |
292 | { |
293 | int i, j, k; |
294 | int w = (s->width - 1) / s->subsampling[0] + 1; |
295 | uint8_t *pu = &p->data[1][lnum / s->subsampling[1] * p->linesize[1]]; |
296 | uint8_t *pv = &p->data[2][lnum / s->subsampling[1] * p->linesize[2]]; |
297 | if (s->width % s->subsampling[0] || s->height % s->subsampling[1]) { |
298 | for (i = 0; i < w; i++) { |
299 | for (j = 0; j < s->subsampling[1]; j++) |
300 | for (k = 0; k < s->subsampling[0]; k++) |
301 | p->data[0][FFMIN(lnum + j, s->height-1) * p->linesize[0] + |
302 | FFMIN(i * s->subsampling[0] + k, s->width-1)] = *src++; |
303 | *pu++ = *src++; |
304 | *pv++ = *src++; |
305 | } |
306 | }else{ |
307 | for (i = 0; i < w; i++) { |
308 | for (j = 0; j < s->subsampling[1]; j++) |
309 | for (k = 0; k < s->subsampling[0]; k++) |
310 | p->data[0][(lnum + j) * p->linesize[0] + |
311 | i * s->subsampling[0] + k] = *src++; |
312 | *pu++ = *src++; |
313 | *pv++ = *src++; |
314 | } |
315 | } |
316 | } |
317 | |
318 | #if CONFIG_ZLIB |
319 | static int tiff_uncompress(uint8_t *dst, unsigned long *len, const uint8_t *src, |
320 | int size) |
321 | { |
322 | z_stream zstream = { 0 }; |
323 | int zret; |
324 | |
325 | zstream.next_in = (uint8_t *)src; |
326 | zstream.avail_in = size; |
327 | zstream.next_out = dst; |
328 | zstream.avail_out = *len; |
329 | zret = inflateInit(&zstream); |
330 | if (zret != Z_OK) { |
331 | av_log(NULL, AV_LOG_ERROR, "Inflate init error: %d\n", zret); |
332 | return zret; |
333 | } |
334 | zret = inflate(&zstream, Z_SYNC_FLUSH); |
335 | inflateEnd(&zstream); |
336 | *len = zstream.total_out; |
337 | return zret == Z_STREAM_END ? Z_OK : zret; |
338 | } |
339 | |
340 | static int tiff_unpack_zlib(TiffContext *s, AVFrame *p, uint8_t *dst, int stride, |
341 | const uint8_t *src, int size, int width, int lines, |
342 | int strip_start, int is_yuv) |
343 | { |
344 | uint8_t *zbuf; |
345 | unsigned long outlen; |
346 | int ret, line; |
347 | outlen = width * lines; |
348 | zbuf = av_malloc(outlen); |
349 | if (!zbuf) |
350 | return AVERROR(ENOMEM); |
351 | if (s->fill_order) { |
352 | if ((ret = deinvert_buffer(s, src, size)) < 0) { |
353 | av_free(zbuf); |
354 | return ret; |
355 | } |
356 | src = s->deinvert_buf; |
357 | } |
358 | ret = tiff_uncompress(zbuf, &outlen, src, size); |
359 | if (ret != Z_OK) { |
360 | av_log(s->avctx, AV_LOG_ERROR, |
361 | "Uncompressing failed (%lu of %lu) with error %d\n", outlen, |
362 | (unsigned long)width * lines, ret); |
363 | av_free(zbuf); |
364 | return AVERROR_UNKNOWN; |
365 | } |
366 | src = zbuf; |
367 | for (line = 0; line < lines; line++) { |
368 | if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8) { |
369 | horizontal_fill(s->bpp, dst, 1, src, 0, width, 0); |
370 | } else { |
371 | memcpy(dst, src, width); |
372 | } |
373 | if (is_yuv) { |
374 | unpack_yuv(s, p, dst, strip_start + line); |
375 | line += s->subsampling[1] - 1; |
376 | } |
377 | dst += stride; |
378 | src += width; |
379 | } |
380 | av_free(zbuf); |
381 | return 0; |
382 | } |
383 | #endif |
384 | |
385 | #if CONFIG_LZMA |
386 | static int tiff_uncompress_lzma(uint8_t *dst, uint64_t *len, const uint8_t *src, |
387 | int size) |
388 | { |
389 | lzma_stream stream = LZMA_STREAM_INIT; |
390 | lzma_ret ret; |
391 | |
392 | stream.next_in = (uint8_t *)src; |
393 | stream.avail_in = size; |
394 | stream.next_out = dst; |
395 | stream.avail_out = *len; |
396 | ret = lzma_stream_decoder(&stream, UINT64_MAX, 0); |
397 | if (ret != LZMA_OK) { |
398 | av_log(NULL, AV_LOG_ERROR, "LZMA init error: %d\n", ret); |
399 | return ret; |
400 | } |
401 | ret = lzma_code(&stream, LZMA_RUN); |
402 | lzma_end(&stream); |
403 | *len = stream.total_out; |
404 | return ret == LZMA_STREAM_END ? LZMA_OK : ret; |
405 | } |
406 | |
407 | static int tiff_unpack_lzma(TiffContext *s, AVFrame *p, uint8_t *dst, int stride, |
408 | const uint8_t *src, int size, int width, int lines, |
409 | int strip_start, int is_yuv) |
410 | { |
411 | uint64_t outlen = width * (uint64_t)lines; |
412 | int ret, line; |
413 | uint8_t *buf = av_malloc(outlen); |
414 | if (!buf) |
415 | return AVERROR(ENOMEM); |
416 | if (s->fill_order) { |
417 | if ((ret = deinvert_buffer(s, src, size)) < 0) { |
418 | av_free(buf); |
419 | return ret; |
420 | } |
421 | src = s->deinvert_buf; |
422 | } |
423 | ret = tiff_uncompress_lzma(buf, &outlen, src, size); |
424 | if (ret != LZMA_OK) { |
425 | av_log(s->avctx, AV_LOG_ERROR, |
426 | "Uncompressing failed (%"PRIu64" of %"PRIu64") with error %d\n", outlen, |
427 | (uint64_t)width * lines, ret); |
428 | av_free(buf); |
429 | return AVERROR_UNKNOWN; |
430 | } |
431 | src = buf; |
432 | for (line = 0; line < lines; line++) { |
433 | if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8) { |
434 | horizontal_fill(s->bpp, dst, 1, src, 0, width, 0); |
435 | } else { |
436 | memcpy(dst, src, width); |
437 | } |
438 | if (is_yuv) { |
439 | unpack_yuv(s, p, dst, strip_start + line); |
440 | line += s->subsampling[1] - 1; |
441 | } |
442 | dst += stride; |
443 | src += width; |
444 | } |
445 | av_free(buf); |
446 | return 0; |
447 | } |
448 | #endif |
449 | |
450 | static int tiff_unpack_fax(TiffContext *s, uint8_t *dst, int stride, |
451 | const uint8_t *src, int size, int width, int lines) |
452 | { |
453 | int i, ret = 0; |
454 | int line; |
455 | uint8_t *src2 = av_malloc((unsigned)size + |
456 | AV_INPUT_BUFFER_PADDING_SIZE); |
457 | |
458 | if (!src2) { |
459 | av_log(s->avctx, AV_LOG_ERROR, |
460 | "Error allocating temporary buffer\n"); |
461 | return AVERROR(ENOMEM); |
462 | } |
463 | |
464 | if (!s->fill_order) { |
465 | memcpy(src2, src, size); |
466 | } else { |
467 | for (i = 0; i < size; i++) |
468 | src2[i] = ff_reverse[src[i]]; |
469 | } |
470 | memset(src2 + size, 0, AV_INPUT_BUFFER_PADDING_SIZE); |
471 | ret = ff_ccitt_unpack(s->avctx, src2, size, dst, lines, stride, |
472 | s->compr, s->fax_opts); |
473 | if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8) |
474 | for (line = 0; line < lines; line++) { |
475 | horizontal_fill(s->bpp, dst, 1, dst, 0, width, 0); |
476 | dst += stride; |
477 | } |
478 | av_free(src2); |
479 | return ret; |
480 | } |
481 | |
482 | static int tiff_unpack_strip(TiffContext *s, AVFrame *p, uint8_t *dst, int stride, |
483 | const uint8_t *src, int size, int strip_start, int lines) |
484 | { |
485 | PutByteContext pb; |
486 | int c, line, pixels, code, ret; |
487 | const uint8_t *ssrc = src; |
488 | int width = ((s->width * s->bpp) + 7) >> 3; |
489 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(p->format); |
490 | int is_yuv = !(desc->flags & AV_PIX_FMT_FLAG_RGB) && |
491 | (desc->flags & AV_PIX_FMT_FLAG_PLANAR) && |
492 | desc->nb_components >= 3; |
493 | |
494 | if (s->planar) |
495 | width /= s->bppcount; |
496 | |
497 | if (size <= 0) |
498 | return AVERROR_INVALIDDATA; |
499 | |
500 | if (is_yuv) { |
501 | int bytes_per_row = (((s->width - 1) / s->subsampling[0] + 1) * s->bpp * |
502 | s->subsampling[0] * s->subsampling[1] + 7) >> 3; |
503 | av_fast_padded_malloc(&s->yuv_line, &s->yuv_line_size, bytes_per_row); |
504 | if (s->yuv_line == NULL) { |
505 | av_log(s->avctx, AV_LOG_ERROR, "Not enough memory\n"); |
506 | return AVERROR(ENOMEM); |
507 | } |
508 | dst = s->yuv_line; |
509 | stride = 0; |
510 | |
511 | width = (s->width - 1) / s->subsampling[0] + 1; |
512 | width = width * s->subsampling[0] * s->subsampling[1] + 2*width; |
513 | av_assert0(width <= bytes_per_row); |
514 | av_assert0(s->bpp == 24); |
515 | } |
516 | |
517 | if (s->compr == TIFF_DEFLATE || s->compr == TIFF_ADOBE_DEFLATE) { |
518 | #if CONFIG_ZLIB |
519 | return tiff_unpack_zlib(s, p, dst, stride, src, size, width, lines, |
520 | strip_start, is_yuv); |
521 | #else |
522 | av_log(s->avctx, AV_LOG_ERROR, |
523 | "zlib support not enabled, " |
524 | "deflate compression not supported\n"); |
525 | return AVERROR(ENOSYS); |
526 | #endif |
527 | } |
528 | if (s->compr == TIFF_LZMA) { |
529 | #if CONFIG_LZMA |
530 | return tiff_unpack_lzma(s, p, dst, stride, src, size, width, lines, |
531 | strip_start, is_yuv); |
532 | #else |
533 | av_log(s->avctx, AV_LOG_ERROR, |
534 | "LZMA support not enabled\n"); |
535 | return AVERROR(ENOSYS); |
536 | #endif |
537 | } |
538 | if (s->compr == TIFF_LZW) { |
539 | if (s->fill_order) { |
540 | if ((ret = deinvert_buffer(s, src, size)) < 0) |
541 | return ret; |
542 | ssrc = src = s->deinvert_buf; |
543 | } |
544 | if (size > 1 && !src[0] && (src[1]&1)) { |
545 | av_log(s->avctx, AV_LOG_ERROR, "Old style LZW is unsupported\n"); |
546 | } |
547 | if ((ret = ff_lzw_decode_init(s->lzw, 8, src, size, FF_LZW_TIFF)) < 0) { |
548 | av_log(s->avctx, AV_LOG_ERROR, "Error initializing LZW decoder\n"); |
549 | return ret; |
550 | } |
551 | for (line = 0; line < lines; line++) { |
552 | pixels = ff_lzw_decode(s->lzw, dst, width); |
553 | if (pixels < width) { |
554 | av_log(s->avctx, AV_LOG_ERROR, "Decoded only %i bytes of %i\n", |
555 | pixels, width); |
556 | return AVERROR_INVALIDDATA; |
557 | } |
558 | if (s->bpp < 8 && s->avctx->pix_fmt == AV_PIX_FMT_PAL8) |
559 | horizontal_fill(s->bpp, dst, 1, dst, 0, width, 0); |
560 | if (is_yuv) { |
561 | unpack_yuv(s, p, dst, strip_start + line); |
562 | line += s->subsampling[1] - 1; |
563 | } |
564 | dst += stride; |
565 | } |
566 | return 0; |
567 | } |
568 | if (s->compr == TIFF_CCITT_RLE || |
569 | s->compr == TIFF_G3 || |
570 | s->compr == TIFF_G4) { |
571 | if (is_yuv) |
572 | return AVERROR_INVALIDDATA; |
573 | |
574 | return tiff_unpack_fax(s, dst, stride, src, size, width, lines); |
575 | } |
576 | |
577 | bytestream2_init(&s->gb, src, size); |
578 | bytestream2_init_writer(&pb, dst, is_yuv ? s->yuv_line_size : (stride * lines)); |
579 | |
580 | for (line = 0; line < lines; line++) { |
581 | if (src - ssrc > size) { |
582 | av_log(s->avctx, AV_LOG_ERROR, "Source data overread\n"); |
583 | return AVERROR_INVALIDDATA; |
584 | } |
585 | |
586 | if (bytestream2_get_bytes_left(&s->gb) == 0 || bytestream2_get_eof(&pb)) |
587 | break; |
588 | bytestream2_seek_p(&pb, stride * line, SEEK_SET); |
589 | switch (s->compr) { |
590 | case TIFF_RAW: |
591 | if (ssrc + size - src < width) |
592 | return AVERROR_INVALIDDATA; |
593 | |
594 | if (!s->fill_order) { |
595 | horizontal_fill(s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8), |
596 | dst, 1, src, 0, width, 0); |
597 | } else { |
598 | int i; |
599 | for (i = 0; i < width; i++) |
600 | dst[i] = ff_reverse[src[i]]; |
601 | } |
602 | src += width; |
603 | break; |
604 | case TIFF_PACKBITS: |
605 | for (pixels = 0; pixels < width;) { |
606 | if (ssrc + size - src < 2) { |
607 | av_log(s->avctx, AV_LOG_ERROR, "Read went out of bounds\n"); |
608 | return AVERROR_INVALIDDATA; |
609 | } |
610 | code = s->fill_order ? (int8_t) ff_reverse[*src++]: (int8_t) *src++; |
611 | if (code >= 0) { |
612 | code++; |
613 | if (pixels + code > width || |
614 | ssrc + size - src < code) { |
615 | av_log(s->avctx, AV_LOG_ERROR, |
616 | "Copy went out of bounds\n"); |
617 | return AVERROR_INVALIDDATA; |
618 | } |
619 | horizontal_fill(s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8), |
620 | dst, 1, src, 0, code, pixels); |
621 | src += code; |
622 | pixels += code; |
623 | } else if (code != -128) { // -127..-1 |
624 | code = (-code) + 1; |
625 | if (pixels + code > width) { |
626 | av_log(s->avctx, AV_LOG_ERROR, |
627 | "Run went out of bounds\n"); |
628 | return AVERROR_INVALIDDATA; |
629 | } |
630 | c = *src++; |
631 | horizontal_fill(s->bpp * (s->avctx->pix_fmt == AV_PIX_FMT_PAL8), |
632 | dst, 0, NULL, c, code, pixels); |
633 | pixels += code; |
634 | } |
635 | } |
636 | if (s->fill_order) { |
637 | int i; |
638 | for (i = 0; i < width; i++) |
639 | dst[i] = ff_reverse[dst[i]]; |
640 | } |
641 | break; |
642 | } |
643 | if (is_yuv) { |
644 | unpack_yuv(s, p, dst, strip_start + line); |
645 | line += s->subsampling[1] - 1; |
646 | } |
647 | dst += stride; |
648 | } |
649 | return 0; |
650 | } |
651 | |
652 | static int init_image(TiffContext *s, ThreadFrame *frame) |
653 | { |
654 | int ret; |
655 | int create_gray_palette = 0; |
656 | |
657 | // make sure there is no aliasing in the following switch |
658 | if (s->bpp >= 100 || s->bppcount >= 10) { |
659 | av_log(s->avctx, AV_LOG_ERROR, |
660 | "Unsupported image parameters: bpp=%d, bppcount=%d\n", |
661 | s->bpp, s->bppcount); |
662 | return AVERROR_INVALIDDATA; |
663 | } |
664 | |
665 | switch (s->planar * 1000 + s->bpp * 10 + s->bppcount) { |
666 | case 11: |
667 | if (!s->palette_is_set) { |
668 | s->avctx->pix_fmt = AV_PIX_FMT_MONOBLACK; |
669 | break; |
670 | } |
671 | case 21: |
672 | case 41: |
673 | s->avctx->pix_fmt = AV_PIX_FMT_PAL8; |
674 | if (!s->palette_is_set) { |
675 | create_gray_palette = 1; |
676 | } |
677 | break; |
678 | case 81: |
679 | s->avctx->pix_fmt = s->palette_is_set ? AV_PIX_FMT_PAL8 : AV_PIX_FMT_GRAY8; |
680 | break; |
681 | case 243: |
682 | if (s->photometric == TIFF_PHOTOMETRIC_YCBCR) { |
683 | if (s->subsampling[0] == 1 && s->subsampling[1] == 1) { |
684 | s->avctx->pix_fmt = AV_PIX_FMT_YUV444P; |
685 | } else if (s->subsampling[0] == 2 && s->subsampling[1] == 1) { |
686 | s->avctx->pix_fmt = AV_PIX_FMT_YUV422P; |
687 | } else if (s->subsampling[0] == 4 && s->subsampling[1] == 1) { |
688 | s->avctx->pix_fmt = AV_PIX_FMT_YUV411P; |
689 | } else if (s->subsampling[0] == 1 && s->subsampling[1] == 2) { |
690 | s->avctx->pix_fmt = AV_PIX_FMT_YUV440P; |
691 | } else if (s->subsampling[0] == 2 && s->subsampling[1] == 2) { |
692 | s->avctx->pix_fmt = AV_PIX_FMT_YUV420P; |
693 | } else if (s->subsampling[0] == 4 && s->subsampling[1] == 4) { |
694 | s->avctx->pix_fmt = AV_PIX_FMT_YUV410P; |
695 | } else { |
696 | av_log(s->avctx, AV_LOG_ERROR, "Unsupported YCbCr subsampling\n"); |
697 | return AVERROR_PATCHWELCOME; |
698 | } |
699 | } else |
700 | s->avctx->pix_fmt = AV_PIX_FMT_RGB24; |
701 | break; |
702 | case 161: |
703 | s->avctx->pix_fmt = s->le ? AV_PIX_FMT_GRAY16LE : AV_PIX_FMT_GRAY16BE; |
704 | break; |
705 | case 162: |
706 | s->avctx->pix_fmt = AV_PIX_FMT_YA8; |
707 | break; |
708 | case 322: |
709 | s->avctx->pix_fmt = s->le ? AV_PIX_FMT_YA16LE : AV_PIX_FMT_YA16BE; |
710 | break; |
711 | case 324: |
712 | s->avctx->pix_fmt = AV_PIX_FMT_RGBA; |
713 | break; |
714 | case 483: |
715 | s->avctx->pix_fmt = s->le ? AV_PIX_FMT_RGB48LE : AV_PIX_FMT_RGB48BE; |
716 | break; |
717 | case 644: |
718 | s->avctx->pix_fmt = s->le ? AV_PIX_FMT_RGBA64LE : AV_PIX_FMT_RGBA64BE; |
719 | break; |
720 | case 1243: |
721 | s->avctx->pix_fmt = AV_PIX_FMT_GBRP; |
722 | break; |
723 | case 1324: |
724 | s->avctx->pix_fmt = AV_PIX_FMT_GBRAP; |
725 | break; |
726 | case 1483: |
727 | s->avctx->pix_fmt = s->le ? AV_PIX_FMT_GBRP16LE : AV_PIX_FMT_GBRP16BE; |
728 | break; |
729 | case 1644: |
730 | s->avctx->pix_fmt = s->le ? AV_PIX_FMT_GBRAP16LE : AV_PIX_FMT_GBRAP16BE; |
731 | break; |
732 | default: |
733 | av_log(s->avctx, AV_LOG_ERROR, |
734 | "This format is not supported (bpp=%d, bppcount=%d)\n", |
735 | s->bpp, s->bppcount); |
736 | return AVERROR_INVALIDDATA; |
737 | } |
738 | |
739 | if (s->photometric == TIFF_PHOTOMETRIC_YCBCR) { |
740 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt); |
741 | if((desc->flags & AV_PIX_FMT_FLAG_RGB) || |
742 | !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) || |
743 | desc->nb_components < 3) { |
744 | av_log(s->avctx, AV_LOG_ERROR, "Unsupported YCbCr variant\n"); |
745 | return AVERROR_INVALIDDATA; |
746 | } |
747 | } |
748 | |
749 | if (s->width != s->avctx->width || s->height != s->avctx->height) { |
750 | ret = ff_set_dimensions(s->avctx, s->width, s->height); |
751 | if (ret < 0) |
752 | return ret; |
753 | } |
754 | if ((ret = ff_thread_get_buffer(s->avctx, frame, 0)) < 0) |
755 | return ret; |
756 | if (s->avctx->pix_fmt == AV_PIX_FMT_PAL8) { |
757 | if (!create_gray_palette) |
758 | memcpy(frame->f->data[1], s->palette, sizeof(s->palette)); |
759 | else { |
760 | /* make default grayscale pal */ |
761 | int i; |
762 | uint32_t *pal = (uint32_t *)frame->f->data[1]; |
763 | for (i = 0; i < 1<<s->bpp; i++) |
764 | pal[i] = 0xFFU << 24 | i * 255 / ((1<<s->bpp) - 1) * 0x010101; |
765 | } |
766 | } |
767 | return 0; |
768 | } |
769 | |
770 | static void set_sar(TiffContext *s, unsigned tag, unsigned num, unsigned den) |
771 | { |
772 | int offset = tag == TIFF_YRES ? 2 : 0; |
773 | s->res[offset++] = num; |
774 | s->res[offset] = den; |
775 | if (s->res[0] && s->res[1] && s->res[2] && s->res[3]) { |
776 | uint64_t num = s->res[2] * (uint64_t)s->res[1]; |
777 | uint64_t den = s->res[0] * (uint64_t)s->res[3]; |
778 | if (num > INT64_MAX || den > INT64_MAX) { |
779 | num = num >> 1; |
780 | den = den >> 1; |
781 | } |
782 | av_reduce(&s->avctx->sample_aspect_ratio.num, &s->avctx->sample_aspect_ratio.den, |
783 | num, den, INT32_MAX); |
784 | if (!s->avctx->sample_aspect_ratio.den) |
785 | s->avctx->sample_aspect_ratio = (AVRational) {0, 1}; |
786 | } |
787 | } |
788 | |
789 | static int tiff_decode_tag(TiffContext *s, AVFrame *frame) |
790 | { |
791 | unsigned tag, type, count, off, value = 0, value2 = 0; |
792 | int i, start; |
793 | int pos; |
794 | int ret; |
795 | double *dp; |
796 | |
797 | ret = ff_tread_tag(&s->gb, s->le, &tag, &type, &count, &start); |
798 | if (ret < 0) { |
799 | goto end; |
800 | } |
801 | |
802 | off = bytestream2_tell(&s->gb); |
803 | if (count == 1) { |
804 | switch (type) { |
805 | case TIFF_BYTE: |
806 | case TIFF_SHORT: |
807 | case TIFF_LONG: |
808 | value = ff_tget(&s->gb, type, s->le); |
809 | break; |
810 | case TIFF_RATIONAL: |
811 | value = ff_tget(&s->gb, TIFF_LONG, s->le); |
812 | value2 = ff_tget(&s->gb, TIFF_LONG, s->le); |
813 | break; |
814 | case TIFF_STRING: |
815 | if (count <= 4) { |
816 | break; |
817 | } |
818 | default: |
819 | value = UINT_MAX; |
820 | } |
821 | } |
822 | |
823 | switch (tag) { |
824 | case TIFF_WIDTH: |
825 | s->width = value; |
826 | break; |
827 | case TIFF_HEIGHT: |
828 | s->height = value; |
829 | break; |
830 | case TIFF_BPP: |
831 | if (count > 4U) { |
832 | av_log(s->avctx, AV_LOG_ERROR, |
833 | "This format is not supported (bpp=%d, %d components)\n", |
834 | value, count); |
835 | return AVERROR_INVALIDDATA; |
836 | } |
837 | s->bppcount = count; |
838 | if (count == 1) |
839 | s->bpp = value; |
840 | else { |
841 | switch (type) { |
842 | case TIFF_BYTE: |
843 | case TIFF_SHORT: |
844 | case TIFF_LONG: |
845 | s->bpp = 0; |
846 | if (bytestream2_get_bytes_left(&s->gb) < type_sizes[type] * count) |
847 | return AVERROR_INVALIDDATA; |
848 | for (i = 0; i < count; i++) |
849 | s->bpp += ff_tget(&s->gb, type, s->le); |
850 | break; |
851 | default: |
852 | s->bpp = -1; |
853 | } |
854 | } |
855 | break; |
856 | case TIFF_SAMPLES_PER_PIXEL: |
857 | if (count != 1) { |
858 | av_log(s->avctx, AV_LOG_ERROR, |
859 | "Samples per pixel requires a single value, many provided\n"); |
860 | return AVERROR_INVALIDDATA; |
861 | } |
862 | if (value > 4U) { |
863 | av_log(s->avctx, AV_LOG_ERROR, |
864 | "Samples per pixel %d is too large\n", value); |
865 | return AVERROR_INVALIDDATA; |
866 | } |
867 | if (s->bppcount == 1) |
868 | s->bpp *= value; |
869 | s->bppcount = value; |
870 | break; |
871 | case TIFF_COMPR: |
872 | s->compr = value; |
873 | av_log(s->avctx, AV_LOG_DEBUG, "compression: %d\n", s->compr); |
874 | s->predictor = 0; |
875 | switch (s->compr) { |
876 | case TIFF_RAW: |
877 | case TIFF_PACKBITS: |
878 | case TIFF_LZW: |
879 | case TIFF_CCITT_RLE: |
880 | break; |
881 | case TIFF_G3: |
882 | case TIFF_G4: |
883 | s->fax_opts = 0; |
884 | break; |
885 | case TIFF_DEFLATE: |
886 | case TIFF_ADOBE_DEFLATE: |
887 | #if CONFIG_ZLIB |
888 | break; |
889 | #else |
890 | av_log(s->avctx, AV_LOG_ERROR, "Deflate: ZLib not compiled in\n"); |
891 | return AVERROR(ENOSYS); |
892 | #endif |
893 | case TIFF_JPEG: |
894 | case TIFF_NEWJPEG: |
895 | avpriv_report_missing_feature(s->avctx, "JPEG compression"); |
896 | return AVERROR_PATCHWELCOME; |
897 | case TIFF_LZMA: |
898 | #if CONFIG_LZMA |
899 | break; |
900 | #else |
901 | av_log(s->avctx, AV_LOG_ERROR, "LZMA not compiled in\n"); |
902 | return AVERROR(ENOSYS); |
903 | #endif |
904 | default: |
905 | av_log(s->avctx, AV_LOG_ERROR, "Unknown compression method %i\n", |
906 | s->compr); |
907 | return AVERROR_INVALIDDATA; |
908 | } |
909 | break; |
910 | case TIFF_ROWSPERSTRIP: |
911 | if (!value || (type == TIFF_LONG && value == UINT_MAX)) |
912 | value = s->height; |
913 | s->rps = FFMIN(value, s->height); |
914 | break; |
915 | case TIFF_STRIP_OFFS: |
916 | if (count == 1) { |
917 | if (value > INT_MAX) { |
918 | av_log(s->avctx, AV_LOG_ERROR, |
919 | "strippos %u too large\n", value); |
920 | return AVERROR_INVALIDDATA; |
921 | } |
922 | s->strippos = 0; |
923 | s->stripoff = value; |
924 | } else |
925 | s->strippos = off; |
926 | s->strips = count; |
927 | if (s->strips == 1) |
928 | s->rps = s->height; |
929 | s->sot = type; |
930 | break; |
931 | case TIFF_STRIP_SIZE: |
932 | if (count == 1) { |
933 | if (value > INT_MAX) { |
934 | av_log(s->avctx, AV_LOG_ERROR, |
935 | "stripsize %u too large\n", value); |
936 | return AVERROR_INVALIDDATA; |
937 | } |
938 | s->stripsizesoff = 0; |
939 | s->stripsize = value; |
940 | s->strips = 1; |
941 | } else { |
942 | s->stripsizesoff = off; |
943 | } |
944 | s->strips = count; |
945 | s->sstype = type; |
946 | break; |
947 | case TIFF_XRES: |
948 | case TIFF_YRES: |
949 | set_sar(s, tag, value, value2); |
950 | break; |
951 | case TIFF_TILE_BYTE_COUNTS: |
952 | case TIFF_TILE_LENGTH: |
953 | case TIFF_TILE_OFFSETS: |
954 | case TIFF_TILE_WIDTH: |
955 | av_log(s->avctx, AV_LOG_ERROR, "Tiled images are not supported\n"); |
956 | return AVERROR_PATCHWELCOME; |
957 | break; |
958 | case TIFF_PREDICTOR: |
959 | s->predictor = value; |
960 | break; |
961 | case TIFF_PHOTOMETRIC: |
962 | switch (value) { |
963 | case TIFF_PHOTOMETRIC_WHITE_IS_ZERO: |
964 | case TIFF_PHOTOMETRIC_BLACK_IS_ZERO: |
965 | case TIFF_PHOTOMETRIC_RGB: |
966 | case TIFF_PHOTOMETRIC_PALETTE: |
967 | case TIFF_PHOTOMETRIC_YCBCR: |
968 | s->photometric = value; |
969 | break; |
970 | case TIFF_PHOTOMETRIC_ALPHA_MASK: |
971 | case TIFF_PHOTOMETRIC_SEPARATED: |
972 | case TIFF_PHOTOMETRIC_CIE_LAB: |
973 | case TIFF_PHOTOMETRIC_ICC_LAB: |
974 | case TIFF_PHOTOMETRIC_ITU_LAB: |
975 | case TIFF_PHOTOMETRIC_CFA: |
976 | case TIFF_PHOTOMETRIC_LOG_L: |
977 | case TIFF_PHOTOMETRIC_LOG_LUV: |
978 | case TIFF_PHOTOMETRIC_LINEAR_RAW: |
979 | avpriv_report_missing_feature(s->avctx, |
980 | "PhotometricInterpretation 0x%04X", |
981 | value); |
982 | return AVERROR_PATCHWELCOME; |
983 | default: |
984 | av_log(s->avctx, AV_LOG_ERROR, "PhotometricInterpretation %u is " |
985 | "unknown\n", value); |
986 | return AVERROR_INVALIDDATA; |
987 | } |
988 | break; |
989 | case TIFF_FILL_ORDER: |
990 | if (value < 1 || value > 2) { |
991 | av_log(s->avctx, AV_LOG_ERROR, |
992 | "Unknown FillOrder value %d, trying default one\n", value); |
993 | value = 1; |
994 | } |
995 | s->fill_order = value - 1; |
996 | break; |
997 | case TIFF_PAL: { |
998 | GetByteContext pal_gb[3]; |
999 | off = type_sizes[type]; |
1000 | if (count / 3 > 256 || |
1001 | bytestream2_get_bytes_left(&s->gb) < count / 3 * off * 3) |
1002 | return AVERROR_INVALIDDATA; |
1003 | |
1004 | pal_gb[0] = pal_gb[1] = pal_gb[2] = s->gb; |
1005 | bytestream2_skip(&pal_gb[1], count / 3 * off); |
1006 | bytestream2_skip(&pal_gb[2], count / 3 * off * 2); |
1007 | |
1008 | off = (type_sizes[type] - 1) << 3; |
1009 | if (off > 31U) { |
1010 | av_log(s->avctx, AV_LOG_ERROR, "palette shift %d is out of range\n", off); |
1011 | return AVERROR_INVALIDDATA; |
1012 | } |
1013 | |
1014 | for (i = 0; i < count / 3; i++) { |
1015 | uint32_t p = 0xFF000000; |
1016 | p |= (ff_tget(&pal_gb[0], type, s->le) >> off) << 16; |
1017 | p |= (ff_tget(&pal_gb[1], type, s->le) >> off) << 8; |
1018 | p |= ff_tget(&pal_gb[2], type, s->le) >> off; |
1019 | s->palette[i] = p; |
1020 | } |
1021 | s->palette_is_set = 1; |
1022 | break; |
1023 | } |
1024 | case TIFF_PLANAR: |
1025 | s->planar = value == 2; |
1026 | break; |
1027 | case TIFF_YCBCR_SUBSAMPLING: |
1028 | if (count != 2) { |
1029 | av_log(s->avctx, AV_LOG_ERROR, "subsample count invalid\n"); |
1030 | return AVERROR_INVALIDDATA; |
1031 | } |
1032 | for (i = 0; i < count; i++) { |
1033 | s->subsampling[i] = ff_tget(&s->gb, type, s->le); |
1034 | if (s->subsampling[i] <= 0) { |
1035 | av_log(s->avctx, AV_LOG_ERROR, "subsampling %d is invalid\n", s->subsampling[i]); |
1036 | return AVERROR_INVALIDDATA; |
1037 | } |
1038 | } |
1039 | break; |
1040 | case TIFF_T4OPTIONS: |
1041 | if (s->compr == TIFF_G3) |
1042 | s->fax_opts = value; |
1043 | break; |
1044 | case TIFF_T6OPTIONS: |
1045 | if (s->compr == TIFF_G4) |
1046 | s->fax_opts = value; |
1047 | break; |
1048 | #define ADD_METADATA(count, name, sep)\ |
1049 | if ((ret = add_metadata(count, type, name, sep, s, frame)) < 0) {\ |
1050 | av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");\ |
1051 | goto end;\ |
1052 | } |
1053 | case TIFF_MODEL_PIXEL_SCALE: |
1054 | ADD_METADATA(count, "ModelPixelScaleTag", NULL); |
1055 | break; |
1056 | case TIFF_MODEL_TRANSFORMATION: |
1057 | ADD_METADATA(count, "ModelTransformationTag", NULL); |
1058 | break; |
1059 | case TIFF_MODEL_TIEPOINT: |
1060 | ADD_METADATA(count, "ModelTiepointTag", NULL); |
1061 | break; |
1062 | case TIFF_GEO_KEY_DIRECTORY: |
1063 | if (s->geotag_count) { |
1064 | avpriv_request_sample(s->avctx, "Multiple geo key directories\n"); |
1065 | return AVERROR_INVALIDDATA; |
1066 | } |
1067 | ADD_METADATA(1, "GeoTIFF_Version", NULL); |
1068 | ADD_METADATA(2, "GeoTIFF_Key_Revision", "."); |
1069 | s->geotag_count = ff_tget_short(&s->gb, s->le); |
1070 | if (s->geotag_count > count / 4 - 1) { |
1071 | s->geotag_count = count / 4 - 1; |
1072 | av_log(s->avctx, AV_LOG_WARNING, "GeoTIFF key directory buffer shorter than specified\n"); |
1073 | } |
1074 | if ( bytestream2_get_bytes_left(&s->gb) < s->geotag_count * sizeof(int16_t) * 4 |
1075 | || s->geotag_count == 0) { |
1076 | s->geotag_count = 0; |
1077 | return -1; |
1078 | } |
1079 | s->geotags = av_mallocz_array(s->geotag_count, sizeof(TiffGeoTag)); |
1080 | if (!s->geotags) { |
1081 | av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n"); |
1082 | s->geotag_count = 0; |
1083 | goto end; |
1084 | } |
1085 | for (i = 0; i < s->geotag_count; i++) { |
1086 | s->geotags[i].key = ff_tget_short(&s->gb, s->le); |
1087 | s->geotags[i].type = ff_tget_short(&s->gb, s->le); |
1088 | s->geotags[i].count = ff_tget_short(&s->gb, s->le); |
1089 | |
1090 | if (!s->geotags[i].type) |
1091 | s->geotags[i].val = get_geokey_val(s->geotags[i].key, ff_tget_short(&s->gb, s->le)); |
1092 | else |
1093 | s->geotags[i].offset = ff_tget_short(&s->gb, s->le); |
1094 | } |
1095 | break; |
1096 | case TIFF_GEO_DOUBLE_PARAMS: |
1097 | if (count >= INT_MAX / sizeof(int64_t)) |
1098 | return AVERROR_INVALIDDATA; |
1099 | if (bytestream2_get_bytes_left(&s->gb) < count * sizeof(int64_t)) |
1100 | return AVERROR_INVALIDDATA; |
1101 | dp = av_malloc_array(count, sizeof(double)); |
1102 | if (!dp) { |
1103 | av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n"); |
1104 | goto end; |
1105 | } |
1106 | for (i = 0; i < count; i++) |
1107 | dp[i] = ff_tget_double(&s->gb, s->le); |
1108 | for (i = 0; i < s->geotag_count; i++) { |
1109 | if (s->geotags[i].type == TIFF_GEO_DOUBLE_PARAMS) { |
1110 | if (s->geotags[i].count == 0 |
1111 | || s->geotags[i].offset + s->geotags[i].count > count) { |
1112 | av_log(s->avctx, AV_LOG_WARNING, "Invalid GeoTIFF key %d\n", s->geotags[i].key); |
1113 | } else { |
1114 | char *ap = doubles2str(&dp[s->geotags[i].offset], s->geotags[i].count, ", "); |
1115 | if (!ap) { |
1116 | av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n"); |
1117 | av_freep(&dp); |
1118 | return AVERROR(ENOMEM); |
1119 | } |
1120 | s->geotags[i].val = ap; |
1121 | } |
1122 | } |
1123 | } |
1124 | av_freep(&dp); |
1125 | break; |
1126 | case TIFF_GEO_ASCII_PARAMS: |
1127 | pos = bytestream2_tell(&s->gb); |
1128 | for (i = 0; i < s->geotag_count; i++) { |
1129 | if (s->geotags[i].type == TIFF_GEO_ASCII_PARAMS) { |
1130 | if (s->geotags[i].count == 0 |
1131 | || s->geotags[i].offset + s->geotags[i].count > count) { |
1132 | av_log(s->avctx, AV_LOG_WARNING, "Invalid GeoTIFF key %d\n", s->geotags[i].key); |
1133 | } else { |
1134 | char *ap; |
1135 | |
1136 | bytestream2_seek(&s->gb, pos + s->geotags[i].offset, SEEK_SET); |
1137 | if (bytestream2_get_bytes_left(&s->gb) < s->geotags[i].count) |
1138 | return AVERROR_INVALIDDATA; |
1139 | ap = av_malloc(s->geotags[i].count); |
1140 | if (!ap) { |
1141 | av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n"); |
1142 | return AVERROR(ENOMEM); |
1143 | } |
1144 | bytestream2_get_bufferu(&s->gb, ap, s->geotags[i].count); |
1145 | ap[s->geotags[i].count - 1] = '\0'; //replace the "|" delimiter with a 0 byte |
1146 | s->geotags[i].val = ap; |
1147 | } |
1148 | } |
1149 | } |
1150 | break; |
1151 | case TIFF_ARTIST: |
1152 | ADD_METADATA(count, "artist", NULL); |
1153 | break; |
1154 | case TIFF_COPYRIGHT: |
1155 | ADD_METADATA(count, "copyright", NULL); |
1156 | break; |
1157 | case TIFF_DATE: |
1158 | ADD_METADATA(count, "date", NULL); |
1159 | break; |
1160 | case TIFF_DOCUMENT_NAME: |
1161 | ADD_METADATA(count, "document_name", NULL); |
1162 | break; |
1163 | case TIFF_HOST_COMPUTER: |
1164 | ADD_METADATA(count, "computer", NULL); |
1165 | break; |
1166 | case TIFF_IMAGE_DESCRIPTION: |
1167 | ADD_METADATA(count, "description", NULL); |
1168 | break; |
1169 | case TIFF_MAKE: |
1170 | ADD_METADATA(count, "make", NULL); |
1171 | break; |
1172 | case TIFF_MODEL: |
1173 | ADD_METADATA(count, "model", NULL); |
1174 | break; |
1175 | case TIFF_PAGE_NAME: |
1176 | ADD_METADATA(count, "page_name", NULL); |
1177 | break; |
1178 | case TIFF_PAGE_NUMBER: |
1179 | ADD_METADATA(count, "page_number", " / "); |
1180 | break; |
1181 | case TIFF_SOFTWARE_NAME: |
1182 | ADD_METADATA(count, "software", NULL); |
1183 | break; |
1184 | default: |
1185 | if (s->avctx->err_recognition & AV_EF_EXPLODE) { |
1186 | av_log(s->avctx, AV_LOG_ERROR, |
1187 | "Unknown or unsupported tag %d/0X%0X\n", |
1188 | tag, tag); |
1189 | return AVERROR_INVALIDDATA; |
1190 | } |
1191 | } |
1192 | end: |
1193 | if (s->bpp > 64U) { |
1194 | av_log(s->avctx, AV_LOG_ERROR, |
1195 | "This format is not supported (bpp=%d, %d components)\n", |
1196 | s->bpp, count); |
1197 | s->bpp = 0; |
1198 | return AVERROR_INVALIDDATA; |
1199 | } |
1200 | bytestream2_seek(&s->gb, start, SEEK_SET); |
1201 | return 0; |
1202 | } |
1203 | |
1204 | static int decode_frame(AVCodecContext *avctx, |
1205 | void *data, int *got_frame, AVPacket *avpkt) |
1206 | { |
1207 | TiffContext *const s = avctx->priv_data; |
1208 | AVFrame *const p = data; |
1209 | ThreadFrame frame = { .f = data }; |
1210 | unsigned off; |
1211 | int le, ret, plane, planes; |
1212 | int i, j, entries, stride; |
1213 | unsigned soff, ssize; |
1214 | uint8_t *dst; |
1215 | GetByteContext stripsizes; |
1216 | GetByteContext stripdata; |
1217 | |
1218 | bytestream2_init(&s->gb, avpkt->data, avpkt->size); |
1219 | |
1220 | // parse image header |
1221 | if ((ret = ff_tdecode_header(&s->gb, &le, &off))) { |
1222 | av_log(avctx, AV_LOG_ERROR, "Invalid TIFF header\n"); |
1223 | return ret; |
1224 | } else if (off >= UINT_MAX - 14 || avpkt->size < off + 14) { |
1225 | av_log(avctx, AV_LOG_ERROR, "IFD offset is greater than image size\n"); |
1226 | return AVERROR_INVALIDDATA; |
1227 | } |
1228 | s->le = le; |
1229 | // TIFF_BPP is not a required tag and defaults to 1 |
1230 | s->bppcount = s->bpp = 1; |
1231 | s->photometric = TIFF_PHOTOMETRIC_NONE; |
1232 | s->compr = TIFF_RAW; |
1233 | s->fill_order = 0; |
1234 | free_geotags(s); |
1235 | |
1236 | // Reset these offsets so we can tell if they were set this frame |
1237 | s->stripsizesoff = s->strippos = 0; |
1238 | /* parse image file directory */ |
1239 | bytestream2_seek(&s->gb, off, SEEK_SET); |
1240 | entries = ff_tget_short(&s->gb, le); |
1241 | if (bytestream2_get_bytes_left(&s->gb) < entries * 12) |
1242 | return AVERROR_INVALIDDATA; |
1243 | for (i = 0; i < entries; i++) { |
1244 | if ((ret = tiff_decode_tag(s, p)) < 0) |
1245 | return ret; |
1246 | } |
1247 | |
1248 | for (i = 0; i<s->geotag_count; i++) { |
1249 | const char *keyname = get_geokey_name(s->geotags[i].key); |
1250 | if (!keyname) { |
1251 | av_log(avctx, AV_LOG_WARNING, "Unknown or unsupported GeoTIFF key %d\n", s->geotags[i].key); |
1252 | continue; |
1253 | } |
1254 | if (get_geokey_type(s->geotags[i].key) != s->geotags[i].type) { |
1255 | av_log(avctx, AV_LOG_WARNING, "Type of GeoTIFF key %d is wrong\n", s->geotags[i].key); |
1256 | continue; |
1257 | } |
1258 | ret = av_dict_set(avpriv_frame_get_metadatap(p), keyname, s->geotags[i].val, 0); |
1259 | if (ret<0) { |
1260 | av_log(avctx, AV_LOG_ERROR, "Writing metadata with key '%s' failed\n", keyname); |
1261 | return ret; |
1262 | } |
1263 | } |
1264 | |
1265 | if (!s->strippos && !s->stripoff) { |
1266 | av_log(avctx, AV_LOG_ERROR, "Image data is missing\n"); |
1267 | return AVERROR_INVALIDDATA; |
1268 | } |
1269 | /* now we have the data and may start decoding */ |
1270 | if ((ret = init_image(s, &frame)) < 0) |
1271 | return ret; |
1272 | |
1273 | if (s->strips == 1 && !s->stripsize) { |
1274 | av_log(avctx, AV_LOG_WARNING, "Image data size missing\n"); |
1275 | s->stripsize = avpkt->size - s->stripoff; |
1276 | } |
1277 | |
1278 | if (s->stripsizesoff) { |
1279 | if (s->stripsizesoff >= (unsigned)avpkt->size) |
1280 | return AVERROR_INVALIDDATA; |
1281 | bytestream2_init(&stripsizes, avpkt->data + s->stripsizesoff, |
1282 | avpkt->size - s->stripsizesoff); |
1283 | } |
1284 | if (s->strippos) { |
1285 | if (s->strippos >= (unsigned)avpkt->size) |
1286 | return AVERROR_INVALIDDATA; |
1287 | bytestream2_init(&stripdata, avpkt->data + s->strippos, |
1288 | avpkt->size - s->strippos); |
1289 | } |
1290 | |
1291 | if (s->rps <= 0 || s->rps % s->subsampling[1]) { |
1292 | av_log(avctx, AV_LOG_ERROR, "rps %d invalid\n", s->rps); |
1293 | return AVERROR_INVALIDDATA; |
1294 | } |
1295 | |
1296 | planes = s->planar ? s->bppcount : 1; |
1297 | for (plane = 0; plane < planes; plane++) { |
1298 | stride = p->linesize[plane]; |
1299 | dst = p->data[plane]; |
1300 | for (i = 0; i < s->height; i += s->rps) { |
1301 | if (s->stripsizesoff) |
1302 | ssize = ff_tget(&stripsizes, s->sstype, le); |
1303 | else |
1304 | ssize = s->stripsize; |
1305 | |
1306 | if (s->strippos) |
1307 | soff = ff_tget(&stripdata, s->sot, le); |
1308 | else |
1309 | soff = s->stripoff; |
1310 | |
1311 | if (soff > avpkt->size || ssize > avpkt->size - soff) { |
1312 | av_log(avctx, AV_LOG_ERROR, "Invalid strip size/offset\n"); |
1313 | return AVERROR_INVALIDDATA; |
1314 | } |
1315 | if ((ret = tiff_unpack_strip(s, p, dst, stride, avpkt->data + soff, ssize, i, |
1316 | FFMIN(s->rps, s->height - i))) < 0) { |
1317 | if (avctx->err_recognition & AV_EF_EXPLODE) |
1318 | return ret; |
1319 | break; |
1320 | } |
1321 | dst += s->rps * stride; |
1322 | } |
1323 | if (s->predictor == 2) { |
1324 | if (s->photometric == TIFF_PHOTOMETRIC_YCBCR) { |
1325 | av_log(s->avctx, AV_LOG_ERROR, "predictor == 2 with YUV is unsupported"); |
1326 | return AVERROR_PATCHWELCOME; |
1327 | } |
1328 | dst = p->data[plane]; |
1329 | soff = s->bpp >> 3; |
1330 | if (s->planar) |
1331 | soff = FFMAX(soff / s->bppcount, 1); |
1332 | ssize = s->width * soff; |
1333 | if (s->avctx->pix_fmt == AV_PIX_FMT_RGB48LE || |
1334 | s->avctx->pix_fmt == AV_PIX_FMT_RGBA64LE || |
1335 | s->avctx->pix_fmt == AV_PIX_FMT_GRAY16LE || |
1336 | s->avctx->pix_fmt == AV_PIX_FMT_YA16LE || |
1337 | s->avctx->pix_fmt == AV_PIX_FMT_GBRP16LE || |
1338 | s->avctx->pix_fmt == AV_PIX_FMT_GBRAP16LE) { |
1339 | for (i = 0; i < s->height; i++) { |
1340 | for (j = soff; j < ssize; j += 2) |
1341 | AV_WL16(dst + j, AV_RL16(dst + j) + AV_RL16(dst + j - soff)); |
1342 | dst += stride; |
1343 | } |
1344 | } else if (s->avctx->pix_fmt == AV_PIX_FMT_RGB48BE || |
1345 | s->avctx->pix_fmt == AV_PIX_FMT_RGBA64BE || |
1346 | s->avctx->pix_fmt == AV_PIX_FMT_GRAY16BE || |
1347 | s->avctx->pix_fmt == AV_PIX_FMT_YA16BE || |
1348 | s->avctx->pix_fmt == AV_PIX_FMT_GBRP16BE || |
1349 | s->avctx->pix_fmt == AV_PIX_FMT_GBRAP16BE) { |
1350 | for (i = 0; i < s->height; i++) { |
1351 | for (j = soff; j < ssize; j += 2) |
1352 | AV_WB16(dst + j, AV_RB16(dst + j) + AV_RB16(dst + j - soff)); |
1353 | dst += stride; |
1354 | } |
1355 | } else { |
1356 | for (i = 0; i < s->height; i++) { |
1357 | for (j = soff; j < ssize; j++) |
1358 | dst[j] += dst[j - soff]; |
1359 | dst += stride; |
1360 | } |
1361 | } |
1362 | } |
1363 | |
1364 | if (s->photometric == TIFF_PHOTOMETRIC_WHITE_IS_ZERO) { |
1365 | dst = p->data[plane]; |
1366 | for (i = 0; i < s->height; i++) { |
1367 | for (j = 0; j < stride; j++) |
1368 | dst[j] = (s->avctx->pix_fmt == AV_PIX_FMT_PAL8 ? (1<<s->bpp) - 1 : 255) - dst[j]; |
1369 | dst += stride; |
1370 | } |
1371 | } |
1372 | } |
1373 | |
1374 | if (s->planar && s->bppcount > 2) { |
1375 | FFSWAP(uint8_t*, p->data[0], p->data[2]); |
1376 | FFSWAP(int, p->linesize[0], p->linesize[2]); |
1377 | FFSWAP(uint8_t*, p->data[0], p->data[1]); |
1378 | FFSWAP(int, p->linesize[0], p->linesize[1]); |
1379 | } |
1380 | |
1381 | *got_frame = 1; |
1382 | |
1383 | return avpkt->size; |
1384 | } |
1385 | |
1386 | static av_cold int tiff_init(AVCodecContext *avctx) |
1387 | { |
1388 | TiffContext *s = avctx->priv_data; |
1389 | |
1390 | s->width = 0; |
1391 | s->height = 0; |
1392 | s->subsampling[0] = |
1393 | s->subsampling[1] = 1; |
1394 | s->avctx = avctx; |
1395 | ff_lzw_decode_open(&s->lzw); |
1396 | ff_ccitt_unpack_init(); |
1397 | |
1398 | return 0; |
1399 | } |
1400 | |
1401 | static av_cold int tiff_end(AVCodecContext *avctx) |
1402 | { |
1403 | TiffContext *const s = avctx->priv_data; |
1404 | |
1405 | free_geotags(s); |
1406 | |
1407 | ff_lzw_decode_close(&s->lzw); |
1408 | av_freep(&s->deinvert_buf); |
1409 | return 0; |
1410 | } |
1411 | |
1412 | AVCodec ff_tiff_decoder = { |
1413 | .name = "tiff", |
1414 | .long_name = NULL_IF_CONFIG_SMALL("TIFF image"), |
1415 | .type = AVMEDIA_TYPE_VIDEO, |
1416 | .id = AV_CODEC_ID_TIFF, |
1417 | .priv_data_size = sizeof(TiffContext), |
1418 | .init = tiff_init, |
1419 | .close = tiff_end, |
1420 | .decode = decode_frame, |
1421 | .init_thread_copy = ONLY_IF_THREADS_ENABLED(tiff_init), |
1422 | .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, |
1423 | }; |
1424 |