2 * Copyright (c) 2006 Konstantin Shishkov
4 * This file is part of FFmpeg.
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.
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.
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
24 * @author Konstantin Shishkov
32 #define LZMA_API_STATIC
38 #include "libavutil/attributes.h"
39 #include "libavutil/avstring.h"
40 #include "libavutil/error.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/mem.h"
43 #include "libavutil/opt.h"
44 #include "libavutil/reverse.h"
46 #include "bytestream.h"
47 #include "codec_internal.h"
52 #include "tiff_common.h"
53 #include "tiff_data.h"
58 typedef struct TiffContext
{
60 AVCodecContext
*avctx
;
63 /* JPEG decoding for DNG */
64 AVCodecContext
*avctx_mjpeg
; // wrapper context for MJPEG
65 AVPacket
*jpkt
; // encoded JPEG tile
66 AVFrame
*jpgframe
; // decoded JPEG tile
72 enum TiffType tiff_type
;
74 unsigned int bpp
, bppcount
;
75 uint32_t palette
[256];
79 enum TiffPhotometric photometric
;
93 float analog_balance
[4];
94 float as_shot_neutral
[4];
95 float as_shot_white
[4];
96 float color_matrix
[3][4];
97 float camera_calibration
[4][4];
101 unsigned white_level
;
102 uint16_t dng_lut
[65536];
107 int strips
, rps
, sstype
;
109 int stripsizesoff
, stripsize
, stripoff
, strippos
;
114 int tile_byte_counts_offset
, tile_offsets_offset
;
115 int tile_width
, tile_length
;
119 uint8_t *deinvert_buf
;
120 int deinvert_buf_size
;
122 unsigned int yuv_line_size
;
128 static const float d65_white
[3] = { 0.950456f
, 1.f
, 1.088754f
};
130 static void tiff_set_type(TiffContext
*s
, enum TiffType tiff_type
) {
131 if (s
->tiff_type
< tiff_type
) // Prioritize higher-valued entries
132 s
->tiff_type
= tiff_type
;
135 static void free_geotags(TiffContext
*const s
)
137 for (int i
= 0; i
< s
->geotag_count
; i
++)
138 av_freep(&s
->geotags
[i
].val
);
139 av_freep(&s
->geotags
);
143 static const char *get_geokey_name(int key
)
145 #define RET_GEOKEY_STR(TYPE, array)\
146 if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\
147 key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_name_type_map))\
148 return tiff_##array##_name_type_string + tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].offset;
150 RET_GEOKEY_STR(VERT
, vert
);
151 RET_GEOKEY_STR(PROJ
, proj
);
152 RET_GEOKEY_STR(GEOG
, geog
);
153 RET_GEOKEY_STR(CONF
, conf
);
158 static int get_geokey_type(int key
)
160 #define RET_GEOKEY_TYPE(TYPE, array)\
161 if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\
162 key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_name_type_map))\
163 return tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].type;
164 RET_GEOKEY_TYPE(VERT
, vert
);
165 RET_GEOKEY_TYPE(PROJ
, proj
);
166 RET_GEOKEY_TYPE(GEOG
, geog
);
167 RET_GEOKEY_TYPE(CONF
, conf
);
169 return AVERROR_INVALIDDATA
;
172 static int cmp_id_key(const void *id
, const void *k
)
174 return *(const int*)id
- ((const TiffGeoTagKeyName
*)k
)->key
;
177 static const char *search_keyval(const TiffGeoTagKeyName
*keys
, int n
, int id
)
179 const TiffGeoTagKeyName
*r
= bsearch(&id
, keys
, n
, sizeof(keys
[0]), cmp_id_key
);
186 static const char *get_geokey_val(int key
, uint16_t val
)
188 if (val
== TIFF_GEO_KEY_UNDEFINED
)
190 if (val
== TIFF_GEO_KEY_USER_DEFINED
)
191 return "User-Defined";
193 #define RET_GEOKEY_VAL(TYPE, array)\
194 if (val >= TIFF_##TYPE##_OFFSET &&\
195 val - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(tiff_##array##_codes))\
196 return tiff_##array##_codes[val - TIFF_##TYPE##_OFFSET];
199 case TIFF_GT_MODEL_TYPE_GEOKEY
:
200 RET_GEOKEY_VAL(GT_MODEL_TYPE
, gt_model_type
);
202 case TIFF_GT_RASTER_TYPE_GEOKEY
:
203 RET_GEOKEY_VAL(GT_RASTER_TYPE
, gt_raster_type
);
205 case TIFF_GEOG_LINEAR_UNITS_GEOKEY
:
206 case TIFF_PROJ_LINEAR_UNITS_GEOKEY
:
207 case TIFF_VERTICAL_UNITS_GEOKEY
:
208 RET_GEOKEY_VAL(LINEAR_UNIT
, linear_unit
);
210 case TIFF_GEOG_ANGULAR_UNITS_GEOKEY
:
211 case TIFF_GEOG_AZIMUTH_UNITS_GEOKEY
:
212 RET_GEOKEY_VAL(ANGULAR_UNIT
, angular_unit
);
214 case TIFF_GEOGRAPHIC_TYPE_GEOKEY
:
215 RET_GEOKEY_VAL(GCS_TYPE
, gcs_type
);
216 RET_GEOKEY_VAL(GCSE_TYPE
, gcse_type
);
218 case TIFF_GEOG_GEODETIC_DATUM_GEOKEY
:
219 RET_GEOKEY_VAL(GEODETIC_DATUM
, geodetic_datum
);
220 RET_GEOKEY_VAL(GEODETIC_DATUM_E
, geodetic_datum_e
);
222 case TIFF_GEOG_ELLIPSOID_GEOKEY
:
223 RET_GEOKEY_VAL(ELLIPSOID
, ellipsoid
);
225 case TIFF_GEOG_PRIME_MERIDIAN_GEOKEY
:
226 RET_GEOKEY_VAL(PRIME_MERIDIAN
, prime_meridian
);
228 case TIFF_PROJECTED_CS_TYPE_GEOKEY
:
229 return search_keyval(tiff_proj_cs_type_codes
, FF_ARRAY_ELEMS(tiff_proj_cs_type_codes
), val
);
230 case TIFF_PROJECTION_GEOKEY
:
231 return search_keyval(tiff_projection_codes
, FF_ARRAY_ELEMS(tiff_projection_codes
), val
);
232 case TIFF_PROJ_COORD_TRANS_GEOKEY
:
233 RET_GEOKEY_VAL(COORD_TRANS
, coord_trans
);
235 case TIFF_VERTICAL_CS_TYPE_GEOKEY
:
236 RET_GEOKEY_VAL(VERT_CS
, vert_cs
);
237 RET_GEOKEY_VAL(ORTHO_VERT_CS
, ortho_vert_cs
);
245 static char *doubles2str(double *dp
, int count
, const char *sep
)
249 uint64_t component_len
;
250 if (!sep
) sep
= ", ";
251 component_len
= 24LL + strlen(sep
);
252 if (count
>= (INT_MAX
- 1)/component_len
)
254 ap
= av_malloc(component_len
* count
+ 1);
259 for (i
= 0; i
< count
; i
++) {
260 unsigned l
= snprintf(ap
, component_len
, "%.15g%s", dp
[i
], sep
);
261 if(l
>= component_len
) {
267 ap0
[strlen(ap0
) - strlen(sep
)] = '\0';
271 static int add_metadata(int count
, int type
,
272 const char *name
, const char *sep
, TiffContext
*s
, AVFrame
*frame
)
275 case TIFF_DOUBLE
: return ff_tadd_doubles_metadata(count
, name
, sep
, &s
->gb
, s
->le
, &frame
->metadata
);
276 case TIFF_SHORT
: return ff_tadd_shorts_metadata(count
, name
, sep
, &s
->gb
, s
->le
, 0, &frame
->metadata
);
277 case TIFF_STRING
: return ff_tadd_string_metadata(count
, name
, &s
->gb
, s
->le
, &frame
->metadata
);
278 default : return AVERROR_INVALIDDATA
;
283 * Map stored raw sensor values into linear reference values (see: DNG Specification - Chapter 5)
285 static uint16_t av_always_inline
dng_process_color16(uint16_t value
,
292 // Lookup table lookup
295 // Black level subtraction
297 value_norm
= ((float)value
- black_level
) * scale_factor
;
299 value
= av_clip_uint16(lrintf(value_norm
));
304 static uint16_t av_always_inline
dng_process_color8(uint16_t value
,
309 return dng_process_color16(value
, lut
, black_level
, scale_factor
) >> 8;
312 static void av_always_inline
dng_blit(TiffContext
*s
, uint8_t *dst
, int dst_stride
,
313 const uint8_t *src
, int src_stride
, int width
, int height
,
314 int is_single_comp
, int is_u16
, int odd_line
)
316 float scale_factor
[4];
320 for (int i
= 0; i
< 4; i
++)
321 scale_factor
[i
] = s
->premultiply
[s
->pattern
[i
]] * 65535.f
/ (s
->white_level
- s
->black_level
[i
]);
323 for (int i
= 0; i
< 4; i
++)
324 scale_factor
[i
] = s
->premultiply
[ i
] * 65535.f
/ (s
->white_level
- s
->black_level
[i
]);
327 if (is_single_comp
) {
329 return; /* <= 8bpp unsupported */
331 /* Image is double the width and half the height we need, each row comprises 2 rows of the output
332 (split vertically in the middle). */
333 for (line
= 0; line
< height
/ 2; line
++) {
334 uint16_t *dst_u16
= (uint16_t *)dst
;
335 const uint16_t *src_u16
= (const uint16_t *)src
;
337 /* Blit first half of input row row to initial row of output */
338 for (col
= 0; col
< width
; col
++)
339 *dst_u16
++ = dng_process_color16(*src_u16
++, s
->dng_lut
, s
->black_level
[col
&1], scale_factor
[col
&1]);
341 /* Advance the destination pointer by a row (source pointer remains in the same place) */
342 dst
+= dst_stride
* sizeof(uint16_t);
343 dst_u16
= (uint16_t *)dst
;
345 /* Blit second half of input row row to next row of output */
346 for (col
= 0; col
< width
; col
++)
347 *dst_u16
++ = dng_process_color16(*src_u16
++, s
->dng_lut
, s
->black_level
[(col
&1) + 2], scale_factor
[(col
&1) + 2]);
349 dst
+= dst_stride
* sizeof(uint16_t);
350 src
+= src_stride
* sizeof(uint16_t);
353 /* Input and output image are the same size and the MJpeg decoder has done per-component
354 deinterleaving, so blitting here is straightforward. */
356 for (line
= 0; line
< height
; line
++) {
357 uint16_t *dst_u16
= (uint16_t *)dst
;
358 const uint16_t *src_u16
= (const uint16_t *)src
;
360 for (col
= 0; col
< width
; col
++)
361 *dst_u16
++ = dng_process_color16(*src_u16
++, s
->dng_lut
,
362 s
->black_level
[(col
&1) + 2 * ((line
&1) + odd_line
)],
363 scale_factor
[(col
&1) + 2 * ((line
&1) + odd_line
)]);
365 dst
+= dst_stride
* sizeof(uint16_t);
366 src
+= src_stride
* sizeof(uint16_t);
369 for (line
= 0; line
< height
; line
++) {
370 uint8_t *dst_u8
= dst
;
371 const uint8_t *src_u8
= src
;
373 for (col
= 0; col
< width
; col
++)
374 *dst_u8
++ = dng_process_color8(*src_u8
++, s
->dng_lut
,
375 s
->black_level
[(col
&1) + 2 * ((line
&1) + odd_line
)],
376 scale_factor
[(col
&1) + 2 * ((line
&1) + odd_line
)]);
385 static void av_always_inline
horizontal_fill(TiffContext
*s
,
386 unsigned int bpp
, uint8_t* dst
,
387 int usePtr
, const uint8_t *src
,
388 uint8_t c
, int width
, int offset
)
392 while (--width
>= 0) {
393 dst
[(width
+offset
)*8+7] = (usePtr
? src
[width
] : c
) & 0x1;
394 dst
[(width
+offset
)*8+6] = (usePtr
? src
[width
] : c
) >> 1 & 0x1;
395 dst
[(width
+offset
)*8+5] = (usePtr
? src
[width
] : c
) >> 2 & 0x1;
396 dst
[(width
+offset
)*8+4] = (usePtr
? src
[width
] : c
) >> 3 & 0x1;
397 dst
[(width
+offset
)*8+3] = (usePtr
? src
[width
] : c
) >> 4 & 0x1;
398 dst
[(width
+offset
)*8+2] = (usePtr
? src
[width
] : c
) >> 5 & 0x1;
399 dst
[(width
+offset
)*8+1] = (usePtr
? src
[width
] : c
) >> 6 & 0x1;
400 dst
[(width
+offset
)*8+0] = (usePtr
? src
[width
] : c
) >> 7;
404 while (--width
>= 0) {
405 dst
[(width
+offset
)*4+3] = (usePtr
? src
[width
] : c
) & 0x3;
406 dst
[(width
+offset
)*4+2] = (usePtr
? src
[width
] : c
) >> 2 & 0x3;
407 dst
[(width
+offset
)*4+1] = (usePtr
? src
[width
] : c
) >> 4 & 0x3;
408 dst
[(width
+offset
)*4+0] = (usePtr
? src
[width
] : c
) >> 6;
412 while (--width
>= 0) {
413 dst
[(width
+offset
)*2+1] = (usePtr
? src
[width
] : c
) & 0xF;
414 dst
[(width
+offset
)*2+0] = (usePtr
? src
[width
] : c
) >> 4;
420 uint16_t *dst16
= (uint16_t *)dst
;
421 int is_dng
= (s
->tiff_type
== TIFF_TYPE_DNG
|| s
->tiff_type
== TIFF_TYPE_CINEMADNG
);
422 uint8_t shift
= is_dng
? 0 : 16 - bpp
;
425 av_unused
int ret
= init_get_bits8(&gb
, src
, width
);
426 av_assert1(ret
>= 0);
427 for (int i
= 0; i
< s
->width
; i
++) {
428 dst16
[i
] = get_bits(&gb
, bpp
) << shift
;
434 memcpy(dst
+ offset
, src
, width
);
436 memset(dst
+ offset
, c
, width
);
441 static int deinvert_buffer(TiffContext
*s
, const uint8_t *src
, int size
)
445 av_fast_padded_malloc(&s
->deinvert_buf
, &s
->deinvert_buf_size
, size
);
446 if (!s
->deinvert_buf
)
447 return AVERROR(ENOMEM
);
448 for (i
= 0; i
< size
; i
++)
449 s
->deinvert_buf
[i
] = ff_reverse
[src
[i
]];
454 static void unpack_gray(TiffContext
*s
, AVFrame
*p
,
455 const uint8_t *src
, int lnum
, int width
, int bpp
)
458 uint16_t *dst
= (uint16_t *)(p
->data
[0] + lnum
* p
->linesize
[0]);
460 av_unused
int ret
= init_get_bits8(&gb
, src
, width
);
461 av_assert1(ret
>= 0);
463 for (int i
= 0; i
< s
->width
; i
++) {
464 dst
[i
] = get_bits(&gb
, bpp
);
468 static void unpack_yuv(TiffContext
*s
, AVFrame
*p
,
469 const uint8_t *src
, int lnum
)
472 int w
= (s
->width
- 1) / s
->subsampling
[0] + 1;
473 uint8_t *pu
= &p
->data
[1][lnum
/ s
->subsampling
[1] * p
->linesize
[1]];
474 uint8_t *pv
= &p
->data
[2][lnum
/ s
->subsampling
[1] * p
->linesize
[2]];
475 if (s
->width
% s
->subsampling
[0] || s
->height
% s
->subsampling
[1]) {
476 for (i
= 0; i
< w
; i
++) {
477 for (j
= 0; j
< s
->subsampling
[1]; j
++)
478 for (k
= 0; k
< s
->subsampling
[0]; k
++)
479 p
->data
[0][FFMIN(lnum
+ j
, s
->height
-1) * p
->linesize
[0] +
480 FFMIN(i
* s
->subsampling
[0] + k
, s
->width
-1)] = *src
++;
485 for (i
= 0; i
< w
; i
++) {
486 for (j
= 0; j
< s
->subsampling
[1]; j
++)
487 for (k
= 0; k
< s
->subsampling
[0]; k
++)
488 p
->data
[0][(lnum
+ j
) * p
->linesize
[0] +
489 i
* s
->subsampling
[0] + k
] = *src
++;
497 static int tiff_uncompress(uint8_t *dst
, unsigned long *len
, const uint8_t *src
,
500 z_stream zstream
= { 0 };
503 zstream
.next_in
= src
;
504 zstream
.avail_in
= size
;
505 zstream
.next_out
= dst
;
506 zstream
.avail_out
= *len
;
507 zret
= inflateInit(&zstream
);
509 av_log(NULL
, AV_LOG_ERROR
, "Inflate init error: %d\n", zret
);
512 zret
= inflate(&zstream
, Z_SYNC_FLUSH
);
513 inflateEnd(&zstream
);
514 *len
= zstream
.total_out
;
515 return zret
== Z_STREAM_END
? Z_OK
: zret
;
518 static int tiff_unpack_zlib(TiffContext
*s
, AVFrame
*p
, uint8_t *dst
, int stride
,
519 const uint8_t *src
, int size
, int width
, int lines
,
520 int strip_start
, int is_yuv
)
523 unsigned long outlen
;
525 outlen
= width
* lines
;
526 zbuf
= av_malloc(outlen
);
528 return AVERROR(ENOMEM
);
530 if ((ret
= deinvert_buffer(s
, src
, size
)) < 0) {
534 src
= s
->deinvert_buf
;
536 ret
= tiff_uncompress(zbuf
, &outlen
, src
, size
);
538 av_log(s
->avctx
, AV_LOG_ERROR
,
539 "Uncompressing failed (%lu of %lu) with error %d\n", outlen
,
540 (unsigned long)width
* lines
, ret
);
542 return AVERROR_UNKNOWN
;
545 for (line
= 0; line
< lines
; line
++) {
546 if (s
->bpp
< 8 && s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
) {
547 horizontal_fill(s
, s
->bpp
, dst
, 1, src
, 0, width
, 0);
549 memcpy(dst
, src
, width
);
552 unpack_yuv(s
, p
, dst
, strip_start
+ line
);
553 line
+= s
->subsampling
[1] - 1;
564 static int tiff_uncompress_lzma(uint8_t *dst
, uint64_t *len
, const uint8_t *src
,
567 lzma_stream stream
= LZMA_STREAM_INIT
;
570 stream
.next_in
= src
;
571 stream
.avail_in
= size
;
572 stream
.next_out
= dst
;
573 stream
.avail_out
= *len
;
574 ret
= lzma_stream_decoder(&stream
, UINT64_MAX
, 0);
575 if (ret
!= LZMA_OK
) {
576 av_log(NULL
, AV_LOG_ERROR
, "LZMA init error: %d\n", ret
);
579 ret
= lzma_code(&stream
, LZMA_RUN
);
581 *len
= stream
.total_out
;
582 return ret
== LZMA_STREAM_END
? LZMA_OK
: ret
;
585 static int tiff_unpack_lzma(TiffContext
*s
, AVFrame
*p
, uint8_t *dst
, int stride
,
586 const uint8_t *src
, int size
, int width
, int lines
,
587 int strip_start
, int is_yuv
)
589 uint64_t outlen
= width
* (uint64_t)lines
;
591 uint8_t *buf
= av_malloc(outlen
);
593 return AVERROR(ENOMEM
);
595 if ((ret
= deinvert_buffer(s
, src
, size
)) < 0) {
599 src
= s
->deinvert_buf
;
601 ret
= tiff_uncompress_lzma(buf
, &outlen
, src
, size
);
602 if (ret
!= LZMA_OK
) {
603 av_log(s
->avctx
, AV_LOG_ERROR
,
604 "Uncompressing failed (%"PRIu64
" of %"PRIu64
") with error %d\n", outlen
,
605 (uint64_t)width
* lines
, ret
);
607 return AVERROR_UNKNOWN
;
610 for (line
= 0; line
< lines
; line
++) {
611 if (s
->bpp
< 8 && s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
) {
612 horizontal_fill(s
, s
->bpp
, dst
, 1, src
, 0, width
, 0);
614 memcpy(dst
, src
, width
);
617 unpack_yuv(s
, p
, dst
, strip_start
+ line
);
618 line
+= s
->subsampling
[1] - 1;
628 static int tiff_unpack_fax(TiffContext
*s
, uint8_t *dst
, int stride
,
629 const uint8_t *src
, int size
, int width
, int lines
)
635 if ((ret
= deinvert_buffer(s
, src
, size
)) < 0)
637 src
= s
->deinvert_buf
;
639 ret
= ff_ccitt_unpack(s
->avctx
, src
, size
, dst
, lines
, stride
,
640 s
->compr
, s
->fax_opts
);
641 if (s
->bpp
< 8 && s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
)
642 for (line
= 0; line
< lines
; line
++) {
643 horizontal_fill(s
, s
->bpp
, dst
, 1, dst
, 0, width
, 0);
649 static int dng_decode_jpeg(AVCodecContext
*avctx
, AVFrame
*frame
,
650 int tile_byte_count
, int dst_x
, int dst_y
, int w
, int h
)
652 TiffContext
*s
= avctx
->priv_data
;
653 uint8_t *dst_data
, *src_data
;
654 uint32_t dst_offset
; /* offset from dst buffer in pixels */
655 int is_single_comp
, is_u16
, pixel_size
;
658 if (tile_byte_count
< 0 || tile_byte_count
> bytestream2_get_bytes_left(&s
->gb
))
659 return AVERROR_INVALIDDATA
;
661 /* Prepare a packet and send to the MJPEG decoder */
662 av_packet_unref(s
->jpkt
);
663 s
->jpkt
->data
= (uint8_t*)s
->gb
.buffer
;
664 s
->jpkt
->size
= tile_byte_count
;
667 MJpegDecodeContext
*mjpegdecctx
= s
->avctx_mjpeg
->priv_data
;
668 /* We have to set this information here, there is no way to know if a given JPEG is a DNG-embedded
669 image or not from its own data (and we need that information when decoding it). */
670 mjpegdecctx
->bayer
= 1;
673 ret
= avcodec_send_packet(s
->avctx_mjpeg
, s
->jpkt
);
675 av_log(avctx
, AV_LOG_ERROR
, "Error submitting a packet for decoding\n");
679 ret
= avcodec_receive_frame(s
->avctx_mjpeg
, s
->jpgframe
);
681 av_log(avctx
, AV_LOG_ERROR
, "JPEG decoding error: %s.\n", av_err2str(ret
));
683 /* Normally skip, error if explode */
684 if (avctx
->err_recognition
& AV_EF_EXPLODE
)
685 return AVERROR_INVALIDDATA
;
690 is_u16
= (s
->bpp
> 8);
692 /* Copy the outputted tile's pixels from 'jpgframe' to 'frame' (final buffer) */
694 if (s
->jpgframe
->width
!= s
->avctx_mjpeg
->width
||
695 s
->jpgframe
->height
!= s
->avctx_mjpeg
->height
||
696 s
->jpgframe
->format
!= s
->avctx_mjpeg
->pix_fmt
)
697 return AVERROR_INVALIDDATA
;
699 /* See dng_blit for explanation */
700 if (s
->avctx_mjpeg
->width
== w
* 2 &&
701 s
->avctx_mjpeg
->height
== h
/ 2 &&
702 s
->avctx_mjpeg
->pix_fmt
== AV_PIX_FMT_GRAY16LE
) {
704 } else if (s
->avctx_mjpeg
->width
>= w
&&
705 s
->avctx_mjpeg
->height
>= h
&&
706 s
->avctx_mjpeg
->pix_fmt
== (is_u16
? AV_PIX_FMT_GRAY16
: AV_PIX_FMT_GRAY8
)
710 return AVERROR_INVALIDDATA
;
712 pixel_size
= (is_u16
? sizeof(uint16_t) : sizeof(uint8_t));
714 if (is_single_comp
&& !is_u16
) {
715 av_log(s
->avctx
, AV_LOG_ERROR
, "DNGs with bpp <= 8 and 1 component are unsupported\n");
716 av_frame_unref(s
->jpgframe
);
717 return AVERROR_PATCHWELCOME
;
720 dst_offset
= dst_x
+ frame
->linesize
[0] * dst_y
/ pixel_size
;
721 dst_data
= frame
->data
[0] + dst_offset
* pixel_size
;
722 src_data
= s
->jpgframe
->data
[0];
726 frame
->linesize
[0] / pixel_size
,
728 s
->jpgframe
->linesize
[0] / pixel_size
,
734 av_frame_unref(s
->jpgframe
);
739 static int tiff_unpack_strip(TiffContext
*s
, AVFrame
*p
, uint8_t *dst
, int stride
,
740 const uint8_t *src
, int size
, int strip_start
, int lines
)
743 int c
, line
, pixels
, code
, ret
;
744 const uint8_t *ssrc
= src
;
745 int width
= ((s
->width
* s
->bpp
) + 7) >> 3;
746 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(p
->format
);
747 int is_yuv
= !(desc
->flags
& AV_PIX_FMT_FLAG_RGB
) &&
748 (desc
->flags
& AV_PIX_FMT_FLAG_PLANAR
) &&
749 desc
->nb_components
>= 3;
753 width
/= s
->bppcount
;
756 return AVERROR_INVALIDDATA
;
759 int bytes_per_row
= (((s
->width
- 1) / s
->subsampling
[0] + 1) * s
->bpp
*
760 s
->subsampling
[0] * s
->subsampling
[1] + 7) >> 3;
761 av_fast_padded_malloc(&s
->yuv_line
, &s
->yuv_line_size
, bytes_per_row
);
762 if (s
->yuv_line
== NULL
) {
763 av_log(s
->avctx
, AV_LOG_ERROR
, "Not enough memory\n");
764 return AVERROR(ENOMEM
);
769 width
= (s
->width
- 1) / s
->subsampling
[0] + 1;
770 width
= width
* s
->subsampling
[0] * s
->subsampling
[1] + 2*width
;
771 av_assert0(width
<= bytes_per_row
);
772 av_assert0(s
->bpp
== 24);
775 av_assert0(width
== (s
->bpp
* s
->width
+ 7) >> 3);
777 av_assert0(!(s
->is_bayer
&& is_yuv
));
778 if (p
->format
== AV_PIX_FMT_GRAY12
) {
779 av_fast_padded_malloc(&s
->yuv_line
, &s
->yuv_line_size
, width
);
780 if (s
->yuv_line
== NULL
) {
781 av_log(s
->avctx
, AV_LOG_ERROR
, "Not enough memory\n");
782 return AVERROR(ENOMEM
);
788 if (s
->compr
== TIFF_DEFLATE
|| s
->compr
== TIFF_ADOBE_DEFLATE
) {
790 return tiff_unpack_zlib(s
, p
, dst
, stride
, src
, size
, width
, lines
,
791 strip_start
, is_yuv
);
793 av_log(s
->avctx
, AV_LOG_ERROR
,
794 "zlib support not enabled, "
795 "deflate compression not supported\n");
796 return AVERROR(ENOSYS
);
799 if (s
->compr
== TIFF_LZMA
) {
801 return tiff_unpack_lzma(s
, p
, dst
, stride
, src
, size
, width
, lines
,
802 strip_start
, is_yuv
);
804 av_log(s
->avctx
, AV_LOG_ERROR
,
805 "LZMA support not enabled\n");
806 return AVERROR(ENOSYS
);
809 if (s
->compr
== TIFF_LZW
) {
811 if ((ret
= deinvert_buffer(s
, src
, size
)) < 0)
813 ssrc
= src
= s
->deinvert_buf
;
815 if (size
> 1 && !src
[0] && (src
[1]&1)) {
816 av_log(s
->avctx
, AV_LOG_ERROR
, "Old style LZW is unsupported\n");
818 if ((ret
= ff_lzw_decode_init(s
->lzw
, 8, src
, size
, FF_LZW_TIFF
)) < 0) {
819 av_log(s
->avctx
, AV_LOG_ERROR
, "Error initializing LZW decoder\n");
822 for (line
= 0; line
< lines
; line
++) {
823 pixels
= ff_lzw_decode(s
->lzw
, dst
, width
);
824 if (pixels
< width
) {
825 av_log(s
->avctx
, AV_LOG_ERROR
, "Decoded only %i bytes of %i\n",
827 return AVERROR_INVALIDDATA
;
829 if (s
->bpp
< 8 && s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
)
830 horizontal_fill(s
, s
->bpp
, dst
, 1, dst
, 0, width
, 0);
832 unpack_yuv(s
, p
, dst
, strip_start
+ line
);
833 line
+= s
->subsampling
[1] - 1;
834 } else if (p
->format
== AV_PIX_FMT_GRAY12
) {
835 unpack_gray(s
, p
, dst
, strip_start
+ line
, width
, s
->bpp
);
841 if (s
->compr
== TIFF_CCITT_RLE
||
842 s
->compr
== TIFF_G3
||
843 s
->compr
== TIFF_G4
) {
844 if (is_yuv
|| p
->format
== AV_PIX_FMT_GRAY12
)
845 return AVERROR_INVALIDDATA
;
847 return tiff_unpack_fax(s
, dst
, stride
, src
, size
, width
, lines
);
850 bytestream2_init(&s
->gb
, src
, size
);
851 bytestream2_init_writer(&pb
, dst
, is_yuv
? s
->yuv_line_size
: (stride
* lines
));
853 is_dng
= (s
->tiff_type
== TIFF_TYPE_DNG
|| s
->tiff_type
== TIFF_TYPE_CINEMADNG
);
855 /* Decode JPEG-encoded DNGs with strips */
856 if (s
->compr
== TIFF_NEWJPEG
&& is_dng
) {
858 av_log(s
->avctx
, AV_LOG_ERROR
, "More than one DNG JPEG strips unsupported\n");
859 return AVERROR_PATCHWELCOME
;
862 return AVERROR_PATCHWELCOME
;
863 if ((ret
= dng_decode_jpeg(s
->avctx
, p
, s
->stripsize
, 0, 0, s
->width
, s
->height
)) < 0)
868 if (is_dng
&& stride
== 0)
869 return AVERROR_INVALIDDATA
;
871 for (line
= 0; line
< lines
; line
++) {
872 if (src
- ssrc
> size
) {
873 av_log(s
->avctx
, AV_LOG_ERROR
, "Source data overread\n");
874 return AVERROR_INVALIDDATA
;
877 if (bytestream2_get_bytes_left(&s
->gb
) == 0 || bytestream2_get_eof(&pb
))
879 bytestream2_seek_p(&pb
, stride
* line
, SEEK_SET
);
882 if (ssrc
+ size
- src
< width
)
883 return AVERROR_INVALIDDATA
;
885 if (!s
->fill_order
) {
886 horizontal_fill(s
, s
->bpp
* (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
|| s
->is_bayer
),
887 dst
, 1, src
, 0, width
, 0);
890 for (i
= 0; i
< width
; i
++)
891 dst
[i
] = ff_reverse
[src
[i
]];
894 /* Color processing for DNG images with uncompressed strips (non-tiled) */
896 int is_u16
, pixel_size_bytes
, pixel_size_bits
, elements
;
898 is_u16
= (s
->bpp
/ s
->bppcount
> 8);
899 pixel_size_bits
= (is_u16
? 16 : 8);
900 pixel_size_bytes
= (is_u16
? sizeof(uint16_t) : sizeof(uint8_t));
902 elements
= width
/ pixel_size_bytes
* pixel_size_bits
/ s
->bpp
* s
->bppcount
; // need to account for [1, 16] bpp
903 av_assert0 (elements
* pixel_size_bytes
<= FFABS(stride
));
906 0, // no stride, only 1 line
908 0, // no stride, only 1 line
911 0, // single-component variation is only preset in JPEG-encoded DNGs
913 (line
+ strip_start
)&1);
919 for (pixels
= 0; pixels
< width
;) {
920 if (ssrc
+ size
- src
< 2) {
921 av_log(s
->avctx
, AV_LOG_ERROR
, "Read went out of bounds\n");
922 return AVERROR_INVALIDDATA
;
924 code
= s
->fill_order
? (int8_t) ff_reverse
[*src
++]: (int8_t) *src
++;
927 if (pixels
+ code
> width
||
928 ssrc
+ size
- src
< code
) {
929 av_log(s
->avctx
, AV_LOG_ERROR
,
930 "Copy went out of bounds\n");
931 return AVERROR_INVALIDDATA
;
933 horizontal_fill(s
, s
->bpp
* (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
),
934 dst
, 1, src
, 0, code
, pixels
);
937 } else if (code
!= -128) { // -127..-1
939 if (pixels
+ code
> width
) {
940 av_log(s
->avctx
, AV_LOG_ERROR
,
941 "Run went out of bounds\n");
942 return AVERROR_INVALIDDATA
;
945 horizontal_fill(s
, s
->bpp
* (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
),
946 dst
, 0, NULL
, c
, code
, pixels
);
952 for (i
= 0; i
< width
; i
++)
953 dst
[i
] = ff_reverse
[dst
[i
]];
958 unpack_yuv(s
, p
, dst
, strip_start
+ line
);
959 line
+= s
->subsampling
[1] - 1;
960 } else if (p
->format
== AV_PIX_FMT_GRAY12
) {
961 unpack_gray(s
, p
, dst
, strip_start
+ line
, width
, s
->bpp
);
968 static int dng_decode_tiles(AVCodecContext
*avctx
, AVFrame
*frame
,
969 const AVPacket
*avpkt
)
971 TiffContext
*s
= avctx
->priv_data
;
973 int tile_offset_offset
, tile_offset
;
974 int tile_byte_count_offset
, tile_byte_count
;
975 int tile_count_x
, tile_count_y
;
976 int tile_width
, tile_length
;
977 int has_width_leftover
, has_height_leftover
;
978 int tile_x
= 0, tile_y
= 0;
979 int pos_x
= 0, pos_y
= 0;
982 if (s
->tile_width
<= 0 || s
->tile_length
<= 0)
983 return AVERROR_INVALIDDATA
;
985 has_width_leftover
= (s
->width
% s
->tile_width
!= 0);
986 has_height_leftover
= (s
->height
% s
->tile_length
!= 0);
988 /* Calculate tile counts (round up) */
989 tile_count_x
= (s
->width
+ s
->tile_width
- 1) / s
->tile_width
;
990 tile_count_y
= (s
->height
+ s
->tile_length
- 1) / s
->tile_length
;
992 /* Iterate over the number of tiles */
993 for (tile_idx
= 0; tile_idx
< tile_count_x
* tile_count_y
; tile_idx
++) {
994 tile_x
= tile_idx
% tile_count_x
;
995 tile_y
= tile_idx
/ tile_count_x
;
997 if (has_width_leftover
&& tile_x
== tile_count_x
- 1) // If on the right-most tile
998 tile_width
= s
->width
% s
->tile_width
;
1000 tile_width
= s
->tile_width
;
1002 if (has_height_leftover
&& tile_y
== tile_count_y
- 1) // If on the bottom-most tile
1003 tile_length
= s
->height
% s
->tile_length
;
1005 tile_length
= s
->tile_length
;
1007 /* Read tile offset */
1008 tile_offset_offset
= s
->tile_offsets_offset
+ tile_idx
* sizeof(int);
1009 bytestream2_seek(&s
->gb
, tile_offset_offset
, SEEK_SET
);
1010 tile_offset
= ff_tget_long(&s
->gb
, s
->le
);
1012 /* Read tile byte size */
1013 tile_byte_count_offset
= s
->tile_byte_counts_offset
+ tile_idx
* sizeof(int);
1014 bytestream2_seek(&s
->gb
, tile_byte_count_offset
, SEEK_SET
);
1015 tile_byte_count
= ff_tget_long(&s
->gb
, s
->le
);
1017 /* Seek to tile data */
1018 bytestream2_seek(&s
->gb
, tile_offset
, SEEK_SET
);
1020 /* Decode JPEG tile and copy it in the reference frame */
1021 ret
= dng_decode_jpeg(avctx
, frame
, tile_byte_count
, pos_x
, pos_y
, tile_width
, tile_length
);
1026 /* Advance current positions */
1027 pos_x
+= tile_width
;
1028 if (tile_x
== tile_count_x
- 1) { // If on the right edge
1030 pos_y
+= tile_length
;
1034 /* Frame is ready to be output */
1035 frame
->pict_type
= AV_PICTURE_TYPE_I
;
1036 frame
->flags
|= AV_FRAME_FLAG_KEY
;
1041 static int init_image(TiffContext
*s
, AVFrame
*frame
)
1044 int create_gray_palette
= 0;
1046 // make sure there is no aliasing in the following switch
1047 if (s
->bpp
> 128 || s
->bppcount
>= 10) {
1048 av_log(s
->avctx
, AV_LOG_ERROR
,
1049 "Unsupported image parameters: bpp=%d, bppcount=%d\n",
1050 s
->bpp
, s
->bppcount
);
1051 return AVERROR_INVALIDDATA
;
1054 switch (s
->planar
* 10000 + s
->bpp
* 10 + s
->bppcount
+ s
->is_bayer
* 100000) {
1056 if (!s
->palette_is_set
) {
1057 s
->avctx
->pix_fmt
= AV_PIX_FMT_MONOBLACK
;
1062 s
->avctx
->pix_fmt
= AV_PIX_FMT_PAL8
;
1063 if (!s
->palette_is_set
) {
1064 create_gray_palette
= 1;
1068 s
->avctx
->pix_fmt
= s
->palette_is_set
? AV_PIX_FMT_PAL8
: AV_PIX_FMT_GRAY8
;
1071 s
->avctx
->pix_fmt
= AV_PIX_FMT_GRAY12
;
1074 switch (AV_RL32(s
->pattern
)) {
1076 s
->avctx
->pix_fmt
= AV_PIX_FMT_BAYER_RGGB8
;
1079 s
->avctx
->pix_fmt
= AV_PIX_FMT_BAYER_BGGR8
;
1082 s
->avctx
->pix_fmt
= AV_PIX_FMT_BAYER_GBRG8
;
1085 s
->avctx
->pix_fmt
= AV_PIX_FMT_BAYER_GRBG8
;
1088 av_log(s
->avctx
, AV_LOG_ERROR
, "Unsupported Bayer pattern: 0x%X\n",
1089 AV_RL32(s
->pattern
));
1090 return AVERROR_PATCHWELCOME
;
1097 switch (AV_RL32(s
->pattern
)) {
1099 s
->avctx
->pix_fmt
= AV_PIX_FMT_BAYER_RGGB16
;
1102 s
->avctx
->pix_fmt
= AV_PIX_FMT_BAYER_BGGR16
;
1105 s
->avctx
->pix_fmt
= AV_PIX_FMT_BAYER_GBRG16
;
1108 s
->avctx
->pix_fmt
= AV_PIX_FMT_BAYER_GRBG16
;
1111 av_log(s
->avctx
, AV_LOG_ERROR
, "Unsupported Bayer pattern: 0x%X\n",
1112 AV_RL32(s
->pattern
));
1113 return AVERROR_PATCHWELCOME
;
1117 if (s
->photometric
== TIFF_PHOTOMETRIC_YCBCR
) {
1118 if (s
->subsampling
[0] == 1 && s
->subsampling
[1] == 1) {
1119 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV444P
;
1120 } else if (s
->subsampling
[0] == 2 && s
->subsampling
[1] == 1) {
1121 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV422P
;
1122 } else if (s
->subsampling
[0] == 4 && s
->subsampling
[1] == 1) {
1123 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV411P
;
1124 } else if (s
->subsampling
[0] == 1 && s
->subsampling
[1] == 2) {
1125 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV440P
;
1126 } else if (s
->subsampling
[0] == 2 && s
->subsampling
[1] == 2) {
1127 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
1128 } else if (s
->subsampling
[0] == 4 && s
->subsampling
[1] == 4) {
1129 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV410P
;
1131 av_log(s
->avctx
, AV_LOG_ERROR
, "Unsupported YCbCr subsampling\n");
1132 return AVERROR_PATCHWELCOME
;
1135 s
->avctx
->pix_fmt
= AV_PIX_FMT_RGB24
;
1138 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_GRAY16LE
: AV_PIX_FMT_GRAY16BE
;
1141 s
->avctx
->pix_fmt
= AV_PIX_FMT_YA8
;
1144 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_YA16LE
: AV_PIX_FMT_YA16BE
;
1147 s
->avctx
->pix_fmt
= s
->photometric
== TIFF_PHOTOMETRIC_SEPARATED
? AV_PIX_FMT_RGB0
: AV_PIX_FMT_RGBA
;
1150 if (s
->photometric
== TIFF_PHOTOMETRIC_SEPARATED
)
1151 s
->avctx
->pix_fmt
= AV_PIX_FMT_RGBA
;
1153 av_log(s
->avctx
, AV_LOG_ERROR
,
1154 "bpp=40 without PHOTOMETRIC_SEPARATED is unsupported\n");
1155 return AVERROR_PATCHWELCOME
;
1159 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_RGB48LE
: AV_PIX_FMT_RGB48BE
;
1162 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_RGBA64LE
: AV_PIX_FMT_RGBA64BE
;
1165 s
->avctx
->pix_fmt
= AV_PIX_FMT_GBRP
;
1168 s
->avctx
->pix_fmt
= AV_PIX_FMT_GBRAP
;
1171 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_GBRP16LE
: AV_PIX_FMT_GBRP16BE
;
1174 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_GBRAP16LE
: AV_PIX_FMT_GBRAP16BE
;
1177 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_RGBF32LE
: AV_PIX_FMT_RGBF32BE
;
1180 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_RGBAF32LE
: AV_PIX_FMT_RGBAF32BE
;
1183 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_GBRPF32LE
: AV_PIX_FMT_GBRPF32BE
;
1186 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_GBRAPF32LE
: AV_PIX_FMT_GBRAPF32BE
;
1189 av_log(s
->avctx
, AV_LOG_ERROR
,
1190 "This format is not supported (bpp=%d, bppcount=%d)\n",
1191 s
->bpp
, s
->bppcount
);
1192 return AVERROR_INVALIDDATA
;
1195 if (s
->photometric
== TIFF_PHOTOMETRIC_YCBCR
) {
1196 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(s
->avctx
->pix_fmt
);
1197 if((desc
->flags
& AV_PIX_FMT_FLAG_RGB
) ||
1198 !(desc
->flags
& AV_PIX_FMT_FLAG_PLANAR
) ||
1199 desc
->nb_components
< 3) {
1200 av_log(s
->avctx
, AV_LOG_ERROR
, "Unsupported YCbCr variant\n");
1201 return AVERROR_INVALIDDATA
;
1205 if (s
->width
!= s
->avctx
->width
|| s
->height
!= s
->avctx
->height
) {
1206 ret
= ff_set_dimensions(s
->avctx
, s
->width
, s
->height
);
1211 if (s
->avctx
->skip_frame
>= AVDISCARD_ALL
)
1214 if ((ret
= ff_thread_get_buffer(s
->avctx
, frame
, 0)) < 0)
1216 if (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
) {
1217 if (!create_gray_palette
)
1218 memcpy(frame
->data
[1], s
->palette
, sizeof(s
->palette
));
1220 /* make default grayscale pal */
1222 uint32_t *pal
= (uint32_t *)frame
->data
[1];
1223 for (i
= 0; i
< 1<<s
->bpp
; i
++)
1224 pal
[i
] = 0xFFU
<< 24 | i
* 255 / ((1<<s
->bpp
) - 1) * 0x010101;
1230 static void set_sar(TiffContext
*s
, unsigned tag
, unsigned num
, unsigned den
)
1232 int offset
= tag
== TIFF_YRES
? 2 : 0;
1233 s
->res
[offset
++] = num
;
1234 s
->res
[offset
] = den
;
1235 if (s
->res
[0] && s
->res
[1] && s
->res
[2] && s
->res
[3]) {
1236 uint64_t num
= s
->res
[2] * (uint64_t)s
->res
[1];
1237 uint64_t den
= s
->res
[0] * (uint64_t)s
->res
[3];
1238 if (num
> INT64_MAX
|| den
> INT64_MAX
) {
1242 av_reduce(&s
->avctx
->sample_aspect_ratio
.num
, &s
->avctx
->sample_aspect_ratio
.den
,
1243 num
, den
, INT32_MAX
);
1244 if (!s
->avctx
->sample_aspect_ratio
.den
)
1245 s
->avctx
->sample_aspect_ratio
= (AVRational
) {0, 1};
1249 static int tiff_decode_tag(TiffContext
*s
, AVFrame
*frame
)
1251 AVFrameSideData
*sd
;
1252 GetByteContext gb_temp
;
1253 unsigned tag
, type
, count
, off
, value
= 0, value2
= 1; // value2 is a denominator so init. to 1
1259 ret
= ff_tread_tag(&s
->gb
, s
->le
, &tag
, &type
, &count
, &start
);
1263 if (tag
<= s
->last_tag
)
1264 return AVERROR_INVALIDDATA
;
1266 // We ignore TIFF_STRIP_SIZE as it is sometimes in the logic but wrong order around TIFF_STRIP_OFFS
1267 if (tag
!= TIFF_STRIP_SIZE
)
1270 off
= bytestream2_tell(&s
->gb
);
1276 value
= ff_tget(&s
->gb
, type
, s
->le
);
1279 value
= ff_tget_long(&s
->gb
, s
->le
);
1280 value2
= ff_tget_long(&s
->gb
, s
->le
);
1282 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid denominator in rational\n");
1298 s
->is_thumbnail
= (value
!= 0);
1301 if (value
> INT_MAX
)
1302 return AVERROR_INVALIDDATA
;
1306 if (value
> INT_MAX
)
1307 return AVERROR_INVALIDDATA
;
1311 if (count
> 5 || count
<= 0) {
1312 av_log(s
->avctx
, AV_LOG_ERROR
,
1313 "This format is not supported (bpp=%d, %d components)\n",
1315 return AVERROR_INVALIDDATA
;
1317 s
->bppcount
= count
;
1326 if (bytestream2_get_bytes_left(&s
->gb
) < type_sizes
[type
] * count
)
1327 return AVERROR_INVALIDDATA
;
1328 for (i
= 0; i
< count
; i
++)
1329 s
->bpp
+= ff_tget(&s
->gb
, type
, s
->le
);
1336 case TIFF_SAMPLES_PER_PIXEL
:
1338 av_log(s
->avctx
, AV_LOG_ERROR
,
1339 "Samples per pixel requires a single value, many provided\n");
1340 return AVERROR_INVALIDDATA
;
1342 if (value
> 5 || value
<= 0) {
1343 av_log(s
->avctx
, AV_LOG_ERROR
,
1344 "Invalid samples per pixel %d\n", value
);
1345 return AVERROR_INVALIDDATA
;
1347 if (s
->bppcount
== 1)
1349 s
->bppcount
= value
;
1353 av_log(s
->avctx
, AV_LOG_DEBUG
, "compression: %d\n", s
->compr
);
1359 case TIFF_CCITT_RLE
:
1366 case TIFF_ADOBE_DEFLATE
:
1370 av_log(s
->avctx
, AV_LOG_ERROR
, "Deflate: ZLib not compiled in\n");
1371 return AVERROR(ENOSYS
);
1381 av_log(s
->avctx
, AV_LOG_ERROR
, "LZMA not compiled in\n");
1382 return AVERROR(ENOSYS
);
1385 av_log(s
->avctx
, AV_LOG_ERROR
, "Unknown compression method %i\n",
1387 return AVERROR_INVALIDDATA
;
1390 case TIFF_ROWSPERSTRIP
:
1391 if (!value
|| (type
== TIFF_LONG
&& value
== UINT_MAX
))
1393 s
->rps
= FFMIN(value
, s
->height
);
1395 case TIFF_STRIP_OFFS
:
1397 if (value
> INT_MAX
) {
1398 av_log(s
->avctx
, AV_LOG_ERROR
,
1399 "strippos %u too large\n", value
);
1400 return AVERROR_INVALIDDATA
;
1403 s
->stripoff
= value
;
1407 if (s
->strips
== s
->bppcount
)
1411 case TIFF_STRIP_SIZE
:
1413 if (value
> INT_MAX
) {
1414 av_log(s
->avctx
, AV_LOG_ERROR
,
1415 "stripsize %u too large\n", value
);
1416 return AVERROR_INVALIDDATA
;
1418 s
->stripsizesoff
= 0;
1419 s
->stripsize
= value
;
1422 s
->stripsizesoff
= off
;
1429 set_sar(s
, tag
, value
, value2
);
1431 case TIFF_TILE_OFFSETS
:
1432 s
->tile_offsets_offset
= off
;
1435 case TIFF_TILE_BYTE_COUNTS
:
1436 s
->tile_byte_counts_offset
= off
;
1438 case TIFF_TILE_LENGTH
:
1439 if (value
> INT_MAX
)
1440 return AVERROR_INVALIDDATA
;
1441 s
->tile_length
= value
;
1443 case TIFF_TILE_WIDTH
:
1444 if (value
> INT_MAX
)
1445 return AVERROR_INVALIDDATA
;
1446 s
->tile_width
= value
;
1448 case TIFF_PREDICTOR
:
1449 if (value
> INT_MAX
)
1450 return AVERROR_INVALIDDATA
;
1451 s
->predictor
= value
;
1457 s
->sub_ifd
= ff_tget_long(&s
->gb
, s
->le
); /** Only get the first SubIFD */
1459 case TIFF_GRAY_RESPONSE_CURVE
:
1460 case DNG_LINEARIZATION_TABLE
:
1461 if (count
< 1 || count
> FF_ARRAY_ELEMS(s
->dng_lut
))
1462 return AVERROR_INVALIDDATA
;
1463 for (int i
= 0; i
< count
; i
++)
1464 s
->dng_lut
[i
] = ff_tget(&s
->gb
, type
, s
->le
);
1465 s
->white_level
= s
->dng_lut
[count
-1];
1467 case DNG_BLACK_LEVEL
:
1468 if (count
> FF_ARRAY_ELEMS(s
->black_level
))
1469 return AVERROR_INVALIDDATA
;
1470 s
->black_level
[0] = value
/ (float)value2
;
1471 for (int i
= 0; i
< count
&& count
> 1; i
++) {
1472 if (type
== TIFF_RATIONAL
) {
1473 value
= ff_tget_long(&s
->gb
, s
->le
);
1474 value2
= ff_tget_long(&s
->gb
, s
->le
);
1476 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid denominator\n");
1480 s
->black_level
[i
] = value
/ (float)value2
;
1481 } else if (type
== TIFF_SRATIONAL
) {
1482 int value
= ff_tget_long(&s
->gb
, s
->le
);
1483 int value2
= ff_tget_long(&s
->gb
, s
->le
);
1485 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid denominator\n");
1489 s
->black_level
[i
] = value
/ (float)value2
;
1491 s
->black_level
[i
] = ff_tget(&s
->gb
, type
, s
->le
);
1494 for (int i
= count
; i
< 4 && count
> 0; i
++)
1495 s
->black_level
[i
] = s
->black_level
[count
- 1];
1497 case DNG_WHITE_LEVEL
:
1498 s
->white_level
= value
;
1500 case TIFF_CFA_PATTERN_DIM
:
1501 if (count
!= 2 || (ff_tget(&s
->gb
, type
, s
->le
) != 2 &&
1502 ff_tget(&s
->gb
, type
, s
->le
) != 2)) {
1503 av_log(s
->avctx
, AV_LOG_ERROR
, "CFA Pattern dimensions are not 2x2\n");
1504 return AVERROR_INVALIDDATA
;
1507 case TIFF_CFA_PATTERN
:
1509 s
->pattern
[0] = ff_tget(&s
->gb
, type
, s
->le
);
1510 s
->pattern
[1] = ff_tget(&s
->gb
, type
, s
->le
);
1511 s
->pattern
[2] = ff_tget(&s
->gb
, type
, s
->le
);
1512 s
->pattern
[3] = ff_tget(&s
->gb
, type
, s
->le
);
1514 case TIFF_PHOTOMETRIC
:
1516 case TIFF_PHOTOMETRIC_WHITE_IS_ZERO
:
1517 case TIFF_PHOTOMETRIC_BLACK_IS_ZERO
:
1518 case TIFF_PHOTOMETRIC_RGB
:
1519 case TIFF_PHOTOMETRIC_PALETTE
:
1520 case TIFF_PHOTOMETRIC_SEPARATED
:
1521 case TIFF_PHOTOMETRIC_YCBCR
:
1522 case TIFF_PHOTOMETRIC_CFA
:
1523 case TIFF_PHOTOMETRIC_LINEAR_RAW
: // Used by DNG images
1524 s
->photometric
= value
;
1526 case TIFF_PHOTOMETRIC_ALPHA_MASK
:
1527 case TIFF_PHOTOMETRIC_CIE_LAB
:
1528 case TIFF_PHOTOMETRIC_ICC_LAB
:
1529 case TIFF_PHOTOMETRIC_ITU_LAB
:
1530 case TIFF_PHOTOMETRIC_LOG_L
:
1531 case TIFF_PHOTOMETRIC_LOG_LUV
:
1532 avpriv_report_missing_feature(s
->avctx
,
1533 "PhotometricInterpretation 0x%04X",
1535 return AVERROR_PATCHWELCOME
;
1537 av_log(s
->avctx
, AV_LOG_ERROR
, "PhotometricInterpretation %u is "
1538 "unknown\n", value
);
1539 return AVERROR_INVALIDDATA
;
1542 case TIFF_FILL_ORDER
:
1543 if (value
< 1 || value
> 2) {
1544 av_log(s
->avctx
, AV_LOG_ERROR
,
1545 "Unknown FillOrder value %d, trying default one\n", value
);
1548 s
->fill_order
= value
- 1;
1551 GetByteContext pal_gb
[3];
1552 off
= type_sizes
[type
];
1553 if (count
/ 3 > 256 ||
1554 bytestream2_get_bytes_left(&s
->gb
) < count
/ 3 * off
* 3)
1555 return AVERROR_INVALIDDATA
;
1557 pal_gb
[0] = pal_gb
[1] = pal_gb
[2] = s
->gb
;
1558 bytestream2_skip(&pal_gb
[1], count
/ 3 * off
);
1559 bytestream2_skip(&pal_gb
[2], count
/ 3 * off
* 2);
1561 off
= (type_sizes
[type
] - 1) << 3;
1563 av_log(s
->avctx
, AV_LOG_ERROR
, "palette shift %d is out of range\n", off
);
1564 return AVERROR_INVALIDDATA
;
1567 for (i
= 0; i
< count
/ 3; i
++) {
1568 uint32_t p
= 0xFF000000;
1569 p
|= (ff_tget(&pal_gb
[0], type
, s
->le
) >> off
) << 16;
1570 p
|= (ff_tget(&pal_gb
[1], type
, s
->le
) >> off
) << 8;
1571 p
|= ff_tget(&pal_gb
[2], type
, s
->le
) >> off
;
1574 s
->palette_is_set
= 1;
1578 s
->planar
= value
== 2;
1580 case TIFF_YCBCR_SUBSAMPLING
:
1582 av_log(s
->avctx
, AV_LOG_ERROR
, "subsample count invalid\n");
1583 return AVERROR_INVALIDDATA
;
1585 for (i
= 0; i
< count
; i
++) {
1586 s
->subsampling
[i
] = ff_tget(&s
->gb
, type
, s
->le
);
1587 if (s
->subsampling
[i
] <= 0) {
1588 av_log(s
->avctx
, AV_LOG_ERROR
, "subsampling %d is invalid\n", s
->subsampling
[i
]);
1589 s
->subsampling
[i
] = 1;
1590 return AVERROR_INVALIDDATA
;
1594 case TIFF_T4OPTIONS
:
1595 if (s
->compr
== TIFF_G3
) {
1596 if (value
> INT_MAX
)
1597 return AVERROR_INVALIDDATA
;
1598 s
->fax_opts
= value
;
1601 case TIFF_T6OPTIONS
:
1602 if (s
->compr
== TIFF_G4
) {
1603 if (value
> INT_MAX
)
1604 return AVERROR_INVALIDDATA
;
1605 s
->fax_opts
= value
;
1608 #define ADD_METADATA(count, name, sep)\
1609 if ((ret = add_metadata(count, type, name, sep, s, frame)) < 0) {\
1610 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");\
1613 case TIFF_MODEL_PIXEL_SCALE
:
1614 ADD_METADATA(count
, "ModelPixelScaleTag", NULL
);
1616 case TIFF_MODEL_TRANSFORMATION
:
1617 ADD_METADATA(count
, "ModelTransformationTag", NULL
);
1619 case TIFF_MODEL_TIEPOINT
:
1620 ADD_METADATA(count
, "ModelTiepointTag", NULL
);
1622 case TIFF_GEO_KEY_DIRECTORY
:
1623 if (s
->geotag_count
) {
1624 avpriv_request_sample(s
->avctx
, "Multiple geo key directories");
1625 return AVERROR_INVALIDDATA
;
1627 ADD_METADATA(1, "GeoTIFF_Version", NULL
);
1628 ADD_METADATA(2, "GeoTIFF_Key_Revision", ".");
1629 s
->geotag_count
= ff_tget_short(&s
->gb
, s
->le
);
1630 if (s
->geotag_count
> count
/ 4 - 1) {
1631 s
->geotag_count
= count
/ 4 - 1;
1632 av_log(s
->avctx
, AV_LOG_WARNING
, "GeoTIFF key directory buffer shorter than specified\n");
1634 if ( bytestream2_get_bytes_left(&s
->gb
) < s
->geotag_count
* sizeof(int16_t) * 4
1635 || s
->geotag_count
== 0) {
1636 s
->geotag_count
= 0;
1639 s
->geotags
= av_calloc(s
->geotag_count
, sizeof(*s
->geotags
));
1641 av_log(s
->avctx
, AV_LOG_ERROR
, "Error allocating temporary buffer\n");
1642 s
->geotag_count
= 0;
1645 for (i
= 0; i
< s
->geotag_count
; i
++) {
1647 s
->geotags
[i
].key
= ff_tget_short(&s
->gb
, s
->le
);
1648 s
->geotags
[i
].type
= ff_tget_short(&s
->gb
, s
->le
);
1649 s
->geotags
[i
].count
= ff_tget_short(&s
->gb
, s
->le
);
1650 val
= ff_tget_short(&s
->gb
, s
->le
);
1652 if (!s
->geotags
[i
].type
) {
1653 const char *str
= get_geokey_val(s
->geotags
[i
].key
, val
);
1655 s
->geotags
[i
].val
= str
? av_strdup(str
) : av_asprintf("Unknown-%u", val
);
1656 if (!s
->geotags
[i
].val
)
1657 return AVERROR(ENOMEM
);
1659 s
->geotags
[i
].offset
= val
;
1662 case TIFF_GEO_DOUBLE_PARAMS
:
1663 if (count
>= INT_MAX
/ sizeof(int64_t))
1664 return AVERROR_INVALIDDATA
;
1665 if (bytestream2_get_bytes_left(&s
->gb
) < count
* sizeof(int64_t))
1666 return AVERROR_INVALIDDATA
;
1667 dp
= av_malloc_array(count
, sizeof(double));
1669 av_log(s
->avctx
, AV_LOG_ERROR
, "Error allocating temporary buffer\n");
1672 for (i
= 0; i
< count
; i
++)
1673 dp
[i
] = ff_tget_double(&s
->gb
, s
->le
);
1674 for (i
= 0; i
< s
->geotag_count
; i
++) {
1675 if (s
->geotags
[i
].type
== TIFF_GEO_DOUBLE_PARAMS
) {
1676 if (s
->geotags
[i
].count
== 0
1677 || s
->geotags
[i
].offset
+ s
->geotags
[i
].count
> count
) {
1678 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid GeoTIFF key %d\n", s
->geotags
[i
].key
);
1679 } else if (s
->geotags
[i
].val
) {
1680 av_log(s
->avctx
, AV_LOG_WARNING
, "Duplicate GeoTIFF key %d\n", s
->geotags
[i
].key
);
1682 char *ap
= doubles2str(&dp
[s
->geotags
[i
].offset
], s
->geotags
[i
].count
, ", ");
1684 av_log(s
->avctx
, AV_LOG_ERROR
, "Error allocating temporary buffer\n");
1686 return AVERROR(ENOMEM
);
1688 s
->geotags
[i
].val
= ap
;
1694 case TIFF_GEO_ASCII_PARAMS
:
1695 pos
= bytestream2_tell(&s
->gb
);
1696 for (i
= 0; i
< s
->geotag_count
; i
++) {
1697 if (s
->geotags
[i
].type
== TIFF_GEO_ASCII_PARAMS
) {
1698 if (s
->geotags
[i
].count
== 0
1699 || s
->geotags
[i
].offset
+ s
->geotags
[i
].count
> count
) {
1700 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid GeoTIFF key %d\n", s
->geotags
[i
].key
);
1704 bytestream2_seek(&s
->gb
, pos
+ s
->geotags
[i
].offset
, SEEK_SET
);
1705 if (bytestream2_get_bytes_left(&s
->gb
) < s
->geotags
[i
].count
)
1706 return AVERROR_INVALIDDATA
;
1707 if (s
->geotags
[i
].val
)
1708 return AVERROR_INVALIDDATA
;
1709 ap
= av_malloc(s
->geotags
[i
].count
);
1711 av_log(s
->avctx
, AV_LOG_ERROR
, "Error allocating temporary buffer\n");
1712 return AVERROR(ENOMEM
);
1714 bytestream2_get_bufferu(&s
->gb
, ap
, s
->geotags
[i
].count
);
1715 ap
[s
->geotags
[i
].count
- 1] = '\0'; //replace the "|" delimiter with a 0 byte
1716 s
->geotags
[i
].val
= ap
;
1721 case TIFF_ICC_PROFILE
:
1723 bytestream2_seek(&gb_temp
, off
, SEEK_SET
);
1725 if (bytestream2_get_bytes_left(&gb_temp
) < count
)
1726 return AVERROR_INVALIDDATA
;
1728 ret
= ff_frame_new_side_data(s
->avctx
, frame
, AV_FRAME_DATA_ICC_PROFILE
, count
, &sd
);
1732 bytestream2_get_bufferu(&gb_temp
, sd
->data
, count
);
1735 ADD_METADATA(count
, "artist", NULL
);
1737 case TIFF_COPYRIGHT
:
1738 ADD_METADATA(count
, "copyright", NULL
);
1741 ADD_METADATA(count
, "date", NULL
);
1743 case TIFF_DOCUMENT_NAME
:
1744 ADD_METADATA(count
, "document_name", NULL
);
1746 case TIFF_HOST_COMPUTER
:
1747 ADD_METADATA(count
, "computer", NULL
);
1749 case TIFF_IMAGE_DESCRIPTION
:
1750 ADD_METADATA(count
, "description", NULL
);
1753 ADD_METADATA(count
, "make", NULL
);
1756 ADD_METADATA(count
, "model", NULL
);
1758 case TIFF_PAGE_NAME
:
1759 ADD_METADATA(count
, "page_name", NULL
);
1761 case TIFF_PAGE_NUMBER
:
1762 ADD_METADATA(count
, "page_number", " / ");
1763 // need to seek back to re-read the page number
1764 bytestream2_seek(&s
->gb
, -count
* sizeof(uint16_t), SEEK_CUR
);
1765 // read the page number
1766 s
->cur_page
= ff_tget_short(&s
->gb
, s
->le
);
1767 // get back to where we were before the previous seek
1768 bytestream2_seek(&s
->gb
, count
* sizeof(uint16_t) - sizeof(uint16_t), SEEK_CUR
);
1770 case TIFF_SOFTWARE_NAME
:
1771 ADD_METADATA(count
, "software", NULL
);
1775 unsigned int ver
[4];
1776 ver
[0] = ff_tget(&s
->gb
, type
, s
->le
);
1777 ver
[1] = ff_tget(&s
->gb
, type
, s
->le
);
1778 ver
[2] = ff_tget(&s
->gb
, type
, s
->le
);
1779 ver
[3] = ff_tget(&s
->gb
, type
, s
->le
);
1781 av_log(s
->avctx
, AV_LOG_DEBUG
, "DNG file, version %u.%u.%u.%u\n",
1782 ver
[0], ver
[1], ver
[2], ver
[3]);
1784 tiff_set_type(s
, TIFF_TYPE_DNG
);
1787 case DNG_ANALOG_BALANCE
:
1788 if (type
!= TIFF_RATIONAL
)
1791 for (int i
= 0; i
< 3; i
++) {
1792 value
= ff_tget_long(&s
->gb
, s
->le
);
1793 value2
= ff_tget_long(&s
->gb
, s
->le
);
1795 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid denominator\n");
1799 s
->analog_balance
[i
] = value
/ (float)value2
;
1802 case DNG_AS_SHOT_NEUTRAL
:
1803 if (type
!= TIFF_RATIONAL
)
1806 for (int i
= 0; i
< 3; i
++) {
1807 value
= ff_tget_long(&s
->gb
, s
->le
);
1808 value2
= ff_tget_long(&s
->gb
, s
->le
);
1810 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid denominator\n");
1814 s
->as_shot_neutral
[i
] = value
/ (float)value2
;
1817 case DNG_AS_SHOT_WHITE_XY
:
1818 if (type
!= TIFF_RATIONAL
)
1821 for (int i
= 0; i
< 2; i
++) {
1822 value
= ff_tget_long(&s
->gb
, s
->le
);
1823 value2
= ff_tget_long(&s
->gb
, s
->le
);
1825 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid denominator\n");
1829 s
->as_shot_white
[i
] = value
/ (float)value2
;
1831 s
->as_shot_white
[2] = 1.f
- s
->as_shot_white
[0] - s
->as_shot_white
[1];
1832 for (int i
= 0; i
< 3; i
++) {
1833 s
->as_shot_white
[i
] /= d65_white
[i
];
1836 case DNG_COLOR_MATRIX1
:
1837 case DNG_COLOR_MATRIX2
:
1838 for (int i
= 0; i
< 3; i
++) {
1839 for (int j
= 0; j
< 3; j
++) {
1840 int value
= ff_tget_long(&s
->gb
, s
->le
);
1841 int value2
= ff_tget_long(&s
->gb
, s
->le
);
1843 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid denominator\n");
1846 s
->color_matrix
[i
][j
] = value
/ (float)value2
;
1848 s
->use_color_matrix
= 1;
1851 case DNG_CAMERA_CALIBRATION1
:
1852 case DNG_CAMERA_CALIBRATION2
:
1853 for (int i
= 0; i
< 3; i
++) {
1854 for (int j
= 0; j
< 3; j
++) {
1855 int value
= ff_tget_long(&s
->gb
, s
->le
);
1856 int value2
= ff_tget_long(&s
->gb
, s
->le
);
1858 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid denominator\n");
1861 s
->camera_calibration
[i
][j
] = value
/ (float)value2
;
1865 case CINEMADNG_TIME_CODES
:
1866 case CINEMADNG_FRAME_RATE
:
1867 case CINEMADNG_T_STOP
:
1868 case CINEMADNG_REEL_NAME
:
1869 case CINEMADNG_CAMERA_LABEL
:
1870 tiff_set_type(s
, TIFF_TYPE_CINEMADNG
);
1873 if (s
->avctx
->err_recognition
& AV_EF_EXPLODE
) {
1874 av_log(s
->avctx
, AV_LOG_ERROR
,
1875 "Unknown or unsupported tag %d/0x%0X\n",
1877 return AVERROR_INVALIDDATA
;
1881 if (s
->bpp
> 128U) {
1882 av_log(s
->avctx
, AV_LOG_ERROR
,
1883 "This format is not supported (bpp=%d, %d components)\n",
1886 return AVERROR_INVALIDDATA
;
1888 bytestream2_seek(&s
->gb
, start
, SEEK_SET
);
1892 static const float xyz2rgb
[3][3] = {
1893 { 0.412453f
, 0.357580f
, 0.180423f
},
1894 { 0.212671f
, 0.715160f
, 0.072169f
},
1895 { 0.019334f
, 0.119193f
, 0.950227f
},
1898 static void camera_xyz_coeff(TiffContext
*s
,
1899 float rgb2cam
[3][4],
1900 double cam2xyz
[4][3])
1902 double cam2rgb
[4][3], num
;
1905 for (i
= 0; i
< 3; i
++) {
1906 for (j
= 0; j
< 3; j
++) {
1908 for (k
= 0; k
< 3; k
++)
1909 cam2rgb
[i
][j
] += cam2xyz
[i
][k
] * xyz2rgb
[k
][j
];
1913 for (i
= 0; i
< 3; i
++) {
1914 for (num
= j
= 0; j
< 3; j
++)
1915 num
+= cam2rgb
[i
][j
];
1918 for (j
= 0; j
< 3; j
++)
1919 cam2rgb
[i
][j
] /= num
;
1920 s
->premultiply
[i
] = 1.f
/ num
;
1924 static int decode_frame(AVCodecContext
*avctx
, AVFrame
*p
,
1925 int *got_frame
, AVPacket
*avpkt
)
1927 TiffContext
*const s
= avctx
->priv_data
;
1928 unsigned off
, last_off
= 0;
1929 int le
, ret
, plane
, planes
;
1930 int i
, j
, entries
, stride
;
1931 unsigned soff
, ssize
;
1933 GetByteContext stripsizes
;
1934 GetByteContext stripdata
;
1935 int retry_for_subifd
, retry_for_page
;
1937 int has_tile_bits
, has_strip_bits
;
1939 bytestream2_init(&s
->gb
, avpkt
->data
, avpkt
->size
);
1941 // parse image header
1942 if ((ret
= ff_tdecode_header(&s
->gb
, &le
, &off
))) {
1943 av_log(avctx
, AV_LOG_ERROR
, "Invalid TIFF header\n");
1945 } else if (off
>= UINT_MAX
- 14 || avpkt
->size
< off
+ 14) {
1946 av_log(avctx
, AV_LOG_ERROR
, "IFD offset is greater than image size\n");
1947 return AVERROR_INVALIDDATA
;
1950 // TIFF_BPP is not a required tag and defaults to 1
1952 s
->tiff_type
= TIFF_TYPE_TIFF
;
1953 s
->use_color_matrix
= 0;
1955 s
->is_thumbnail
= 0;
1956 s
->bppcount
= s
->bpp
= 1;
1957 s
->photometric
= TIFF_PHOTOMETRIC_NONE
;
1958 s
->compr
= TIFF_RAW
;
1967 for (i
= 0; i
< 65536; i
++)
1970 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->black_level
); i
++)
1971 s
->black_level
[i
] = 0.f
;
1973 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->as_shot_neutral
); i
++)
1974 s
->as_shot_neutral
[i
] = 0.f
;
1976 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->as_shot_white
); i
++)
1977 s
->as_shot_white
[i
] = 1.f
;
1979 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->analog_balance
); i
++)
1980 s
->analog_balance
[i
] = 1.f
;
1982 for (i
= 0; i
< FF_ARRAY_ELEMS(s
->premultiply
); i
++)
1983 s
->premultiply
[i
] = 1.f
;
1985 for (i
= 0; i
< 4; i
++)
1986 for (j
= 0; j
< 4; j
++)
1987 s
->camera_calibration
[i
][j
] = i
== j
;
1991 // Reset these offsets so we can tell if they were set this frame
1992 s
->stripsizesoff
= s
->strippos
= 0;
1993 /* parse image file directory */
1994 bytestream2_seek(&s
->gb
, off
, SEEK_SET
);
1995 entries
= ff_tget_short(&s
->gb
, le
);
1996 if (bytestream2_get_bytes_left(&s
->gb
) < entries
* 12)
1997 return AVERROR_INVALIDDATA
;
1998 for (i
= 0; i
< entries
; i
++) {
1999 if ((ret
= tiff_decode_tag(s
, p
)) < 0)
2003 if (s
->get_thumbnail
&& !s
->is_thumbnail
) {
2004 av_log(avctx
, AV_LOG_INFO
, "No embedded thumbnail present\n");
2008 /** whether we should process this IFD's SubIFD */
2009 retry_for_subifd
= s
->sub_ifd
&& (s
->get_subimage
|| (!s
->get_thumbnail
&& s
->is_thumbnail
));
2010 /** whether we should process this multi-page IFD's next page */
2011 retry_for_page
= s
->get_page
&& s
->cur_page
+ 1 < s
->get_page
; // get_page is 1-indexed
2013 if (retry_for_page
) {
2014 // set offset to the next IFD
2015 off
= ff_tget_long(&s
->gb
, le
);
2016 } else if (retry_for_subifd
) {
2017 // set offset to the SubIFD
2021 if (retry_for_subifd
|| retry_for_page
) {
2023 av_log(avctx
, AV_LOG_ERROR
, "Requested entry not found\n");
2024 return AVERROR_INVALIDDATA
;
2026 if (off
<= last_off
) {
2027 avpriv_request_sample(s
->avctx
, "non increasing IFD offset");
2028 return AVERROR_INVALIDDATA
;
2031 if (off
>= UINT_MAX
- 14 || avpkt
->size
< off
+ 14) {
2032 av_log(avctx
, AV_LOG_ERROR
, "IFD offset is greater than image size\n");
2033 return AVERROR_INVALIDDATA
;
2039 /* At this point we've decided on which (Sub)IFD to process */
2041 is_dng
= (s
->tiff_type
== TIFF_TYPE_DNG
|| s
->tiff_type
== TIFF_TYPE_CINEMADNG
);
2043 for (i
= 0; i
<s
->geotag_count
; i
++) {
2044 const char *keyname
= get_geokey_name(s
->geotags
[i
].key
);
2046 av_log(avctx
, AV_LOG_WARNING
, "Unknown or unsupported GeoTIFF key %d\n", s
->geotags
[i
].key
);
2049 if (get_geokey_type(s
->geotags
[i
].key
) != s
->geotags
[i
].type
) {
2050 av_log(avctx
, AV_LOG_WARNING
, "Type of GeoTIFF key %d is wrong\n", s
->geotags
[i
].key
);
2053 ret
= av_dict_set(&p
->metadata
, keyname
, s
->geotags
[i
].val
, AV_DICT_DONT_STRDUP_VAL
);
2054 s
->geotags
[i
].val
= NULL
;
2056 av_log(avctx
, AV_LOG_ERROR
, "Writing metadata with key '%s' failed\n", keyname
);
2062 double cam2xyz
[4][3];
2063 float cmatrix
[3][4];
2064 float pmin
= FLT_MAX
;
2067 for (i
= 0; i
< 3; i
++) {
2068 for (j
= 0; j
< 3; j
++)
2069 s
->camera_calibration
[i
][j
] *= s
->analog_balance
[i
];
2072 if (!s
->use_color_matrix
) {
2073 for (i
= 0; i
< 3; i
++) {
2074 if (s
->camera_calibration
[i
][i
])
2075 s
->premultiply
[i
] /= s
->camera_calibration
[i
][i
];
2078 for (int c
= 0; c
< 3; c
++) {
2079 for (i
= 0; i
< 3; i
++) {
2081 for (j
= 0; j
< 3; j
++)
2082 cam2xyz
[c
][i
] += s
->camera_calibration
[c
][j
] * s
->color_matrix
[j
][i
] * s
->as_shot_white
[i
];
2086 camera_xyz_coeff(s
, cmatrix
, cam2xyz
);
2089 for (int c
= 0; c
< 3; c
++)
2090 pmin
= fminf(pmin
, s
->premultiply
[c
]);
2092 for (int c
= 0; c
< 3; c
++)
2093 s
->premultiply
[c
] /= pmin
;
2095 if (s
->bpp
% s
->bppcount
)
2096 return AVERROR_INVALIDDATA
;
2097 bps
= s
->bpp
/ s
->bppcount
;
2098 if (bps
< 8 || bps
> 32)
2099 return AVERROR_INVALIDDATA
;
2101 if (s
->white_level
== 0)
2102 s
->white_level
= (1LL << bps
) - 1; /* Default value as per the spec */
2104 if (s
->white_level
<= s
->black_level
[0]) {
2105 av_log(avctx
, AV_LOG_ERROR
, "BlackLevel (%g) must be less than WhiteLevel (%"PRId32
")\n",
2106 s
->black_level
[0], s
->white_level
);
2107 return AVERROR_INVALIDDATA
;
2111 return AVERROR_PATCHWELCOME
;
2114 if (!s
->is_tiled
&& !s
->strippos
&& !s
->stripoff
) {
2115 av_log(avctx
, AV_LOG_ERROR
, "Image data is missing\n");
2116 return AVERROR_INVALIDDATA
;
2119 has_tile_bits
= s
->is_tiled
|| s
->tile_byte_counts_offset
|| s
->tile_offsets_offset
|| s
->tile_width
|| s
->tile_length
;
2120 has_strip_bits
= s
->strippos
|| s
->strips
|| s
->stripoff
|| s
->rps
|| s
->sot
|| s
->sstype
|| s
->stripsize
|| s
->stripsizesoff
;
2122 if (has_tile_bits
&& has_strip_bits
) {
2123 int tiled_dng
= s
->is_tiled
&& is_dng
;
2124 av_log(avctx
, tiled_dng
? AV_LOG_WARNING
: AV_LOG_ERROR
, "Tiled TIFF is not allowed to strip\n");
2126 return AVERROR_INVALIDDATA
;
2129 /* now we have the data and may start decoding */
2130 if ((ret
= init_image(s
, p
)) <= 0)
2133 if (!s
->is_tiled
|| has_strip_bits
) {
2134 if (s
->strips
== 1 && !s
->stripsize
) {
2135 av_log(avctx
, AV_LOG_WARNING
, "Image data size missing\n");
2136 s
->stripsize
= avpkt
->size
- s
->stripoff
;
2139 if (s
->stripsizesoff
) {
2140 if (s
->stripsizesoff
>= (unsigned)avpkt
->size
)
2141 return AVERROR_INVALIDDATA
;
2142 bytestream2_init(&stripsizes
, avpkt
->data
+ s
->stripsizesoff
,
2143 avpkt
->size
- s
->stripsizesoff
);
2146 if (s
->strippos
>= (unsigned)avpkt
->size
)
2147 return AVERROR_INVALIDDATA
;
2148 bytestream2_init(&stripdata
, avpkt
->data
+ s
->strippos
,
2149 avpkt
->size
- s
->strippos
);
2152 if (s
->rps
<= 0 || s
->rps
% s
->subsampling
[1]) {
2153 av_log(avctx
, AV_LOG_ERROR
, "rps %d invalid\n", s
->rps
);
2154 return AVERROR_INVALIDDATA
;
2158 if (s
->photometric
== TIFF_PHOTOMETRIC_LINEAR_RAW
||
2159 s
->photometric
== TIFF_PHOTOMETRIC_CFA
) {
2160 p
->color_trc
= AVCOL_TRC_LINEAR
;
2161 } else if (s
->photometric
== TIFF_PHOTOMETRIC_BLACK_IS_ZERO
) {
2162 p
->color_trc
= AVCOL_TRC_GAMMA22
;
2165 /* Handle DNG images with JPEG-compressed tiles */
2167 if (is_dng
&& s
->is_tiled
) {
2169 avpriv_report_missing_feature(avctx
, "DNG uncompressed tiled images");
2170 return AVERROR_PATCHWELCOME
;
2171 } else if (!s
->is_bayer
) {
2172 avpriv_report_missing_feature(avctx
, "DNG JPG-compressed tiled non-bayer-encoded images");
2173 return AVERROR_PATCHWELCOME
;
2175 if ((ret
= dng_decode_tiles(avctx
, p
, avpkt
)) > 0)
2181 /* Handle TIFF images and DNG images with uncompressed strips (non-tiled) */
2183 planes
= s
->planar
? s
->bppcount
: 1;
2184 for (plane
= 0; plane
< planes
; plane
++) {
2185 uint8_t *five_planes
= NULL
;
2186 int remaining
= avpkt
->size
;
2188 stride
= p
->linesize
[plane
];
2189 dst
= p
->data
[plane
];
2190 if (s
->photometric
== TIFF_PHOTOMETRIC_SEPARATED
&&
2191 s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBA
) {
2192 stride
= stride
* 5 / 4;
2194 dst
= av_malloc(stride
* s
->height
);
2196 return AVERROR(ENOMEM
);
2198 for (i
= 0; i
< s
->height
; i
+= s
->rps
) {
2200 dst
+= s
->rps
* stride
;
2201 if (s
->stripsizesoff
)
2202 ssize
= ff_tget(&stripsizes
, s
->sstype
, le
);
2204 ssize
= s
->stripsize
;
2207 soff
= ff_tget(&stripdata
, s
->sot
, le
);
2211 if (soff
> avpkt
->size
|| ssize
> avpkt
->size
- soff
|| ssize
> remaining
) {
2212 av_log(avctx
, AV_LOG_ERROR
, "Invalid strip size/offset\n");
2213 av_freep(&five_planes
);
2214 return AVERROR_INVALIDDATA
;
2217 if ((ret
= tiff_unpack_strip(s
, p
, dst
, stride
, avpkt
->data
+ soff
, ssize
, i
,
2218 FFMIN(s
->rps
, s
->height
- i
))) < 0) {
2219 if (avctx
->err_recognition
& AV_EF_EXPLODE
) {
2220 av_freep(&five_planes
);
2226 decoded_height
= FFMIN(i
, s
->height
);
2228 if (s
->predictor
== 2) {
2229 if (s
->photometric
== TIFF_PHOTOMETRIC_YCBCR
) {
2230 av_log(s
->avctx
, AV_LOG_ERROR
, "predictor == 2 with YUV is unsupported");
2231 return AVERROR_PATCHWELCOME
;
2233 dst
= five_planes
? five_planes
: p
->data
[plane
];
2236 soff
= FFMAX(soff
/ s
->bppcount
, 1);
2237 ssize
= s
->width
* soff
;
2238 if (s
->avctx
->pix_fmt
== AV_PIX_FMT_RGB48LE
||
2239 s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBA64LE
||
2240 s
->avctx
->pix_fmt
== AV_PIX_FMT_GRAY16LE
||
2241 s
->avctx
->pix_fmt
== AV_PIX_FMT_YA16LE
||
2242 s
->avctx
->pix_fmt
== AV_PIX_FMT_GBRP16LE
||
2243 s
->avctx
->pix_fmt
== AV_PIX_FMT_GBRAP16LE
) {
2244 for (i
= 0; i
< decoded_height
; i
++) {
2245 for (j
= soff
; j
< ssize
; j
+= 2)
2246 AV_WL16(dst
+ j
, AV_RL16(dst
+ j
) + AV_RL16(dst
+ j
- soff
));
2249 } else if (s
->avctx
->pix_fmt
== AV_PIX_FMT_RGB48BE
||
2250 s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBA64BE
||
2251 s
->avctx
->pix_fmt
== AV_PIX_FMT_GRAY16BE
||
2252 s
->avctx
->pix_fmt
== AV_PIX_FMT_YA16BE
||
2253 s
->avctx
->pix_fmt
== AV_PIX_FMT_GBRP16BE
||
2254 s
->avctx
->pix_fmt
== AV_PIX_FMT_GBRAP16BE
) {
2255 for (i
= 0; i
< decoded_height
; i
++) {
2256 for (j
= soff
; j
< ssize
; j
+= 2)
2257 AV_WB16(dst
+ j
, AV_RB16(dst
+ j
) + AV_RB16(dst
+ j
- soff
));
2261 for (i
= 0; i
< decoded_height
; i
++) {
2262 for (j
= soff
; j
< ssize
; j
++)
2263 dst
[j
] += dst
[j
- soff
];
2269 /* Floating point predictor
2270 TIFF Technical Note 3 http://chriscox.org/TIFFTN3d1.pdf */
2271 if (s
->predictor
== 3) {
2272 int channels
= s
->bppcount
;
2277 dst
= five_planes
? five_planes
: p
->data
[plane
];
2280 soff
= FFMAX(soff
/ s
->bppcount
, 1);
2283 ssize
= s
->width
* soff
;
2284 bpc
= FFMAX(soff
/ s
->bppcount
, 1); /* Bytes per component */
2285 group_size
= s
->width
* channels
;
2287 tmpbuf
= av_malloc(ssize
);
2289 av_free(five_planes
);
2290 return AVERROR(ENOMEM
);
2293 if (s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBF32LE
||
2294 s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBAF32LE
) {
2295 for (i
= 0; i
< decoded_height
; i
++) {
2296 /* Copy first sample byte for each channel */
2297 for (j
= 0; j
< channels
; j
++)
2300 /* Decode horizontal differences */
2301 for (j
= channels
; j
< ssize
; j
++)
2302 tmpbuf
[j
] = dst
[j
] + tmpbuf
[j
-channels
];
2304 /* Combine shuffled bytes from their separate groups. Each
2305 byte of every floating point value in a row of pixels is
2306 split and combined into separate groups. A group of all
2307 the sign/exponents bytes in the row and groups for each
2308 of the upper, mid, and lower mantissa bytes in the row. */
2309 for (j
= 0; j
< group_size
; j
++) {
2310 for (int k
= 0; k
< bpc
; k
++) {
2311 dst
[bpc
* j
+ k
] = tmpbuf
[(bpc
- k
- 1) * group_size
+ j
];
2316 } else if (s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBF32BE
||
2317 s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBAF32BE
) {
2318 /* Same as LE only the shuffle at the end is reversed */
2319 for (i
= 0; i
< decoded_height
; i
++) {
2320 for (j
= 0; j
< channels
; j
++)
2323 for (j
= channels
; j
< ssize
; j
++)
2324 tmpbuf
[j
] = dst
[j
] + tmpbuf
[j
-channels
];
2326 for (j
= 0; j
< group_size
; j
++) {
2327 for (int k
= 0; k
< bpc
; k
++) {
2328 dst
[bpc
* j
+ k
] = tmpbuf
[k
* group_size
+ j
];
2334 av_log(s
->avctx
, AV_LOG_ERROR
, "unsupported floating point pixel format\n");
2339 if (s
->photometric
== TIFF_PHOTOMETRIC_WHITE_IS_ZERO
) {
2340 int c
= (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
? (1<<s
->bpp
) - 1 : 255);
2341 dst
= p
->data
[plane
];
2342 for (i
= 0; i
< s
->height
; i
++) {
2343 for (j
= 0; j
< stride
; j
++)
2344 dst
[j
] = c
- dst
[j
];
2349 if (s
->photometric
== TIFF_PHOTOMETRIC_SEPARATED
&&
2350 (s
->avctx
->pix_fmt
== AV_PIX_FMT_RGB0
|| s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBA
)) {
2351 int x
= s
->avctx
->pix_fmt
== AV_PIX_FMT_RGB0
? 4 : 5;
2352 uint8_t *src
= five_planes
? five_planes
: p
->data
[plane
];
2353 dst
= p
->data
[plane
];
2354 for (i
= 0; i
< s
->height
; i
++) {
2355 for (j
= 0; j
< s
->width
; j
++) {
2356 int k
= 255 - src
[x
* j
+ 3];
2357 int r
= (255 - src
[x
* j
]) * k
;
2358 int g
= (255 - src
[x
* j
+ 1]) * k
;
2359 int b
= (255 - src
[x
* j
+ 2]) * k
;
2360 dst
[4 * j
] = r
* 257 >> 16;
2361 dst
[4 * j
+ 1] = g
* 257 >> 16;
2362 dst
[4 * j
+ 2] = b
* 257 >> 16;
2363 dst
[4 * j
+ 3] = s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBA
? src
[x
* j
+ 4] : 255;
2366 dst
+= p
->linesize
[plane
];
2368 av_freep(&five_planes
);
2369 } else if (s
->photometric
== TIFF_PHOTOMETRIC_SEPARATED
&&
2370 s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBA64BE
) {
2371 dst
= p
->data
[plane
];
2372 for (i
= 0; i
< s
->height
; i
++) {
2373 for (j
= 0; j
< s
->width
; j
++) {
2374 uint64_t k
= 65535 - AV_RB16(dst
+ 8 * j
+ 6);
2375 uint64_t r
= (65535 - AV_RB16(dst
+ 8 * j
)) * k
;
2376 uint64_t g
= (65535 - AV_RB16(dst
+ 8 * j
+ 2)) * k
;
2377 uint64_t b
= (65535 - AV_RB16(dst
+ 8 * j
+ 4)) * k
;
2378 AV_WB16(dst
+ 8 * j
, r
* 65537 >> 32);
2379 AV_WB16(dst
+ 8 * j
+ 2, g
* 65537 >> 32);
2380 AV_WB16(dst
+ 8 * j
+ 4, b
* 65537 >> 32);
2381 AV_WB16(dst
+ 8 * j
+ 6, 65535);
2383 dst
+= p
->linesize
[plane
];
2388 if (s
->planar
&& s
->bppcount
> 2) {
2389 FFSWAP(uint8_t*, p
->data
[0], p
->data
[2]);
2390 FFSWAP(int, p
->linesize
[0], p
->linesize
[2]);
2391 FFSWAP(uint8_t*, p
->data
[0], p
->data
[1]);
2392 FFSWAP(int, p
->linesize
[0], p
->linesize
[1]);
2395 if (s
->is_bayer
&& s
->white_level
&& s
->bpp
== 16 && !is_dng
) {
2396 uint16_t *dst
= (uint16_t *)p
->data
[0];
2397 for (i
= 0; i
< s
->height
; i
++) {
2398 for (j
= 0; j
< s
->width
; j
++)
2399 dst
[j
] = FFMIN((dst
[j
] / (float)s
->white_level
) * 65535, 65535);
2409 static av_cold
int tiff_init(AVCodecContext
*avctx
)
2411 TiffContext
*s
= avctx
->priv_data
;
2412 const AVCodec
*codec
;
2418 s
->subsampling
[1] = 1;
2420 ff_lzw_decode_open(&s
->lzw
);
2422 return AVERROR(ENOMEM
);
2423 ff_ccitt_unpack_init();
2425 /* Allocate JPEG frame */
2426 s
->jpgframe
= av_frame_alloc();
2427 s
->jpkt
= av_packet_alloc();
2428 if (!s
->jpgframe
|| !s
->jpkt
)
2429 return AVERROR(ENOMEM
);
2431 /* Prepare everything needed for JPEG decoding */
2432 codec
= avcodec_find_decoder(AV_CODEC_ID_MJPEG
);
2435 s
->avctx_mjpeg
= avcodec_alloc_context3(codec
);
2436 if (!s
->avctx_mjpeg
)
2437 return AVERROR(ENOMEM
);
2438 s
->avctx_mjpeg
->flags
= avctx
->flags
;
2439 s
->avctx_mjpeg
->flags2
= avctx
->flags2
;
2440 s
->avctx_mjpeg
->idct_algo
= avctx
->idct_algo
;
2441 s
->avctx_mjpeg
->max_pixels
= avctx
->max_pixels
;
2442 ret
= avcodec_open2(s
->avctx_mjpeg
, codec
, NULL
);
2450 static av_cold
int tiff_end(AVCodecContext
*avctx
)
2452 TiffContext
*const s
= avctx
->priv_data
;
2456 ff_lzw_decode_close(&s
->lzw
);
2457 av_freep(&s
->deinvert_buf
);
2458 s
->deinvert_buf_size
= 0;
2459 av_freep(&s
->yuv_line
);
2460 s
->yuv_line_size
= 0;
2461 av_frame_free(&s
->jpgframe
);
2462 av_packet_free(&s
->jpkt
);
2463 avcodec_free_context(&s
->avctx_mjpeg
);
2467 #define OFFSET(x) offsetof(TiffContext, x)
2468 static const AVOption tiff_options
[] = {
2469 { "subimage", "decode subimage instead if available", OFFSET(get_subimage
), AV_OPT_TYPE_BOOL
, {.i64
=0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM
| AV_OPT_FLAG_VIDEO_PARAM
},
2470 { "thumbnail", "decode embedded thumbnail subimage instead if available", OFFSET(get_thumbnail
), AV_OPT_TYPE_BOOL
, {.i64
=0}, 0, 1, AV_OPT_FLAG_DECODING_PARAM
| AV_OPT_FLAG_VIDEO_PARAM
},
2471 { "page", "page number of multi-page image to decode (starting from 1)", OFFSET(get_page
), AV_OPT_TYPE_INT
, {.i64
=0}, 0, UINT16_MAX
, AV_OPT_FLAG_DECODING_PARAM
| AV_OPT_FLAG_VIDEO_PARAM
},
2475 static const AVClass tiff_decoder_class
= {
2476 .class_name
= "TIFF decoder",
2477 .item_name
= av_default_item_name
,
2478 .option
= tiff_options
,
2479 .version
= LIBAVUTIL_VERSION_INT
,
2482 const FFCodec ff_tiff_decoder
= {
2484 CODEC_LONG_NAME("TIFF image"),
2485 .p
.type
= AVMEDIA_TYPE_VIDEO
,
2486 .p
.id
= AV_CODEC_ID_TIFF
,
2487 .priv_data_size
= sizeof(TiffContext
),
2490 FF_CODEC_DECODE_CB(decode_frame
),
2491 .p
.capabilities
= AV_CODEC_CAP_DR1
| AV_CODEC_CAP_FRAME_THREADS
,
2492 .caps_internal
= FF_CODEC_CAP_INIT_CLEANUP
| FF_CODEC_CAP_ICC_PROFILES
|
2493 FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
,
2494 .p
.priv_class
= &tiff_decoder_class
,