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
35 #include "libavutil/attributes.h"
36 #include "libavutil/avstring.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/imgutils.h"
40 #include "bytestream.h"
46 #include "tiff_data.h"
49 typedef struct TiffContext
{
50 AVCodecContext
*avctx
;
54 unsigned int bpp
, bppcount
;
55 uint32_t palette
[256];
59 enum TiffPhotometric photometric
;
67 int strips
, rps
, sstype
;
69 int stripsizesoff
, stripsize
, stripoff
, strippos
;
72 uint8_t *deinvert_buf
;
73 int deinvert_buf_size
;
75 unsigned int yuv_line_size
;
81 static void free_geotags(TiffContext
*const s
)
84 for (i
= 0; i
< s
->geotag_count
; i
++) {
85 if (s
->geotags
[i
].val
)
86 av_freep(&s
->geotags
[i
].val
);
88 av_freep(&s
->geotags
);
92 #define RET_GEOKEY(TYPE, array, element)\
93 if (key >= TIFF_##TYPE##_KEY_ID_OFFSET &&\
94 key - TIFF_##TYPE##_KEY_ID_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_name_type_map))\
95 return ff_tiff_##array##_name_type_map[key - TIFF_##TYPE##_KEY_ID_OFFSET].element;
97 static const char *get_geokey_name(int key
)
99 RET_GEOKEY(VERT
, vert
, name
);
100 RET_GEOKEY(PROJ
, proj
, name
);
101 RET_GEOKEY(GEOG
, geog
, name
);
102 RET_GEOKEY(CONF
, conf
, name
);
107 static int get_geokey_type(int key
)
109 RET_GEOKEY(VERT
, vert
, type
);
110 RET_GEOKEY(PROJ
, proj
, type
);
111 RET_GEOKEY(GEOG
, geog
, type
);
112 RET_GEOKEY(CONF
, conf
, type
);
114 return AVERROR_INVALIDDATA
;
117 static int cmp_id_key(const void *id
, const void *k
)
119 return *(const int*)id
- ((const TiffGeoTagKeyName
*)k
)->key
;
122 static const char *search_keyval(const TiffGeoTagKeyName
*keys
, int n
, int id
)
124 TiffGeoTagKeyName
*r
= bsearch(&id
, keys
, n
, sizeof(keys
[0]), cmp_id_key
);
131 static char *get_geokey_val(int key
, int val
)
135 if (val
== TIFF_GEO_KEY_UNDEFINED
)
136 return av_strdup("undefined");
137 if (val
== TIFF_GEO_KEY_USER_DEFINED
)
138 return av_strdup("User-Defined");
140 #define RET_GEOKEY_VAL(TYPE, array)\
141 if (val >= TIFF_##TYPE##_OFFSET &&\
142 val - TIFF_##TYPE##_OFFSET < FF_ARRAY_ELEMS(ff_tiff_##array##_codes))\
143 return av_strdup(ff_tiff_##array##_codes[val - TIFF_##TYPE##_OFFSET]);
146 case TIFF_GT_MODEL_TYPE_GEOKEY
:
147 RET_GEOKEY_VAL(GT_MODEL_TYPE
, gt_model_type
);
149 case TIFF_GT_RASTER_TYPE_GEOKEY
:
150 RET_GEOKEY_VAL(GT_RASTER_TYPE
, gt_raster_type
);
152 case TIFF_GEOG_LINEAR_UNITS_GEOKEY
:
153 case TIFF_PROJ_LINEAR_UNITS_GEOKEY
:
154 case TIFF_VERTICAL_UNITS_GEOKEY
:
155 RET_GEOKEY_VAL(LINEAR_UNIT
, linear_unit
);
157 case TIFF_GEOG_ANGULAR_UNITS_GEOKEY
:
158 case TIFF_GEOG_AZIMUTH_UNITS_GEOKEY
:
159 RET_GEOKEY_VAL(ANGULAR_UNIT
, angular_unit
);
161 case TIFF_GEOGRAPHIC_TYPE_GEOKEY
:
162 RET_GEOKEY_VAL(GCS_TYPE
, gcs_type
);
163 RET_GEOKEY_VAL(GCSE_TYPE
, gcse_type
);
165 case TIFF_GEOG_GEODETIC_DATUM_GEOKEY
:
166 RET_GEOKEY_VAL(GEODETIC_DATUM
, geodetic_datum
);
167 RET_GEOKEY_VAL(GEODETIC_DATUM_E
, geodetic_datum_e
);
169 case TIFF_GEOG_ELLIPSOID_GEOKEY
:
170 RET_GEOKEY_VAL(ELLIPSOID
, ellipsoid
);
172 case TIFF_GEOG_PRIME_MERIDIAN_GEOKEY
:
173 RET_GEOKEY_VAL(PRIME_MERIDIAN
, prime_meridian
);
175 case TIFF_PROJECTED_CS_TYPE_GEOKEY
:
176 ap
= av_strdup(search_keyval(ff_tiff_proj_cs_type_codes
, FF_ARRAY_ELEMS(ff_tiff_proj_cs_type_codes
), val
));
179 case TIFF_PROJECTION_GEOKEY
:
180 ap
= av_strdup(search_keyval(ff_tiff_projection_codes
, FF_ARRAY_ELEMS(ff_tiff_projection_codes
), val
));
183 case TIFF_PROJ_COORD_TRANS_GEOKEY
:
184 RET_GEOKEY_VAL(COORD_TRANS
, coord_trans
);
186 case TIFF_VERTICAL_CS_TYPE_GEOKEY
:
187 RET_GEOKEY_VAL(VERT_CS
, vert_cs
);
188 RET_GEOKEY_VAL(ORTHO_VERT_CS
, ortho_vert_cs
);
195 snprintf(ap
, 14, "Unknown-%d", val
);
199 static char *doubles2str(double *dp
, int count
, const char *sep
)
203 uint64_t component_len
;
204 if (!sep
) sep
= ", ";
205 component_len
= 24LL + strlen(sep
);
206 if (count
>= (INT_MAX
- 1)/component_len
)
208 ap
= av_malloc(component_len
* count
+ 1);
213 for (i
= 0; i
< count
; i
++) {
214 unsigned l
= snprintf(ap
, component_len
, "%.15g%s", dp
[i
], sep
);
215 if(l
>= component_len
) {
221 ap0
[strlen(ap0
) - strlen(sep
)] = '\0';
225 static int add_metadata(int count
, int type
,
226 const char *name
, const char *sep
, TiffContext
*s
, AVFrame
*frame
)
229 case TIFF_DOUBLE
: return ff_tadd_doubles_metadata(count
, name
, sep
, &s
->gb
, s
->le
, avpriv_frame_get_metadatap(frame
));
230 case TIFF_SHORT
: return ff_tadd_shorts_metadata(count
, name
, sep
, &s
->gb
, s
->le
, 0, avpriv_frame_get_metadatap(frame
));
231 case TIFF_STRING
: return ff_tadd_string_metadata(count
, name
, &s
->gb
, s
->le
, avpriv_frame_get_metadatap(frame
));
232 default : return AVERROR_INVALIDDATA
;
236 static void av_always_inline
horizontal_fill(unsigned int bpp
, uint8_t* dst
,
237 int usePtr
, const uint8_t *src
,
238 uint8_t c
, int width
, int offset
)
242 while (--width
>= 0) {
243 dst
[(width
+offset
)*8+7] = (usePtr
? src
[width
] : c
) & 0x1;
244 dst
[(width
+offset
)*8+6] = (usePtr
? src
[width
] : c
) >> 1 & 0x1;
245 dst
[(width
+offset
)*8+5] = (usePtr
? src
[width
] : c
) >> 2 & 0x1;
246 dst
[(width
+offset
)*8+4] = (usePtr
? src
[width
] : c
) >> 3 & 0x1;
247 dst
[(width
+offset
)*8+3] = (usePtr
? src
[width
] : c
) >> 4 & 0x1;
248 dst
[(width
+offset
)*8+2] = (usePtr
? src
[width
] : c
) >> 5 & 0x1;
249 dst
[(width
+offset
)*8+1] = (usePtr
? src
[width
] : c
) >> 6 & 0x1;
250 dst
[(width
+offset
)*8+0] = (usePtr
? src
[width
] : c
) >> 7;
254 while (--width
>= 0) {
255 dst
[(width
+offset
)*4+3] = (usePtr
? src
[width
] : c
) & 0x3;
256 dst
[(width
+offset
)*4+2] = (usePtr
? src
[width
] : c
) >> 2 & 0x3;
257 dst
[(width
+offset
)*4+1] = (usePtr
? src
[width
] : c
) >> 4 & 0x3;
258 dst
[(width
+offset
)*4+0] = (usePtr
? src
[width
] : c
) >> 6;
262 while (--width
>= 0) {
263 dst
[(width
+offset
)*2+1] = (usePtr
? src
[width
] : c
) & 0xF;
264 dst
[(width
+offset
)*2+0] = (usePtr
? src
[width
] : c
) >> 4;
269 memcpy(dst
+ offset
, src
, width
);
271 memset(dst
+ offset
, c
, width
);
276 static int deinvert_buffer(TiffContext
*s
, const uint8_t *src
, int size
)
280 av_fast_padded_malloc(&s
->deinvert_buf
, &s
->deinvert_buf_size
, size
);
281 if (!s
->deinvert_buf
)
282 return AVERROR(ENOMEM
);
283 for (i
= 0; i
< size
; i
++)
284 s
->deinvert_buf
[i
] = ff_reverse
[src
[i
]];
289 static void unpack_yuv(TiffContext
*s
, AVFrame
*p
,
290 const uint8_t *src
, int lnum
)
293 int w
= (s
->width
- 1) / s
->subsampling
[0] + 1;
294 uint8_t *pu
= &p
->data
[1][lnum
/ s
->subsampling
[1] * p
->linesize
[1]];
295 uint8_t *pv
= &p
->data
[2][lnum
/ s
->subsampling
[1] * p
->linesize
[2]];
296 if (s
->width
% s
->subsampling
[0] || s
->height
% s
->subsampling
[1]) {
297 for (i
= 0; i
< w
; i
++) {
298 for (j
= 0; j
< s
->subsampling
[1]; j
++)
299 for (k
= 0; k
< s
->subsampling
[0]; k
++)
300 p
->data
[0][FFMIN(lnum
+ j
, s
->height
-1) * p
->linesize
[0] +
301 FFMIN(i
* s
->subsampling
[0] + k
, s
->width
-1)] = *src
++;
306 for (i
= 0; i
< w
; i
++) {
307 for (j
= 0; j
< s
->subsampling
[1]; j
++)
308 for (k
= 0; k
< s
->subsampling
[0]; k
++)
309 p
->data
[0][(lnum
+ j
) * p
->linesize
[0] +
310 i
* s
->subsampling
[0] + k
] = *src
++;
318 static int tiff_uncompress(uint8_t *dst
, unsigned long *len
, const uint8_t *src
,
321 z_stream zstream
= { 0 };
324 zstream
.next_in
= (uint8_t *)src
;
325 zstream
.avail_in
= size
;
326 zstream
.next_out
= dst
;
327 zstream
.avail_out
= *len
;
328 zret
= inflateInit(&zstream
);
330 av_log(NULL
, AV_LOG_ERROR
, "Inflate init error: %d\n", zret
);
333 zret
= inflate(&zstream
, Z_SYNC_FLUSH
);
334 inflateEnd(&zstream
);
335 *len
= zstream
.total_out
;
336 return zret
== Z_STREAM_END
? Z_OK
: zret
;
339 static int tiff_unpack_zlib(TiffContext
*s
, AVFrame
*p
, uint8_t *dst
, int stride
,
340 const uint8_t *src
, int size
, int width
, int lines
,
341 int strip_start
, int is_yuv
)
344 unsigned long outlen
;
346 outlen
= width
* lines
;
347 zbuf
= av_malloc(outlen
);
349 return AVERROR(ENOMEM
);
351 if ((ret
= deinvert_buffer(s
, src
, size
)) < 0) {
355 src
= s
->deinvert_buf
;
357 ret
= tiff_uncompress(zbuf
, &outlen
, src
, size
);
359 av_log(s
->avctx
, AV_LOG_ERROR
,
360 "Uncompressing failed (%lu of %lu) with error %d\n", outlen
,
361 (unsigned long)width
* lines
, ret
);
363 return AVERROR_UNKNOWN
;
366 for (line
= 0; line
< lines
; line
++) {
367 if (s
->bpp
< 8 && s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
) {
368 horizontal_fill(s
->bpp
, dst
, 1, src
, 0, width
, 0);
370 memcpy(dst
, src
, width
);
373 unpack_yuv(s
, p
, dst
, strip_start
+ line
);
374 line
+= s
->subsampling
[1] - 1;
385 static int tiff_uncompress_lzma(uint8_t *dst
, uint64_t *len
, const uint8_t *src
,
388 lzma_stream stream
= LZMA_STREAM_INIT
;
391 stream
.next_in
= (uint8_t *)src
;
392 stream
.avail_in
= size
;
393 stream
.next_out
= dst
;
394 stream
.avail_out
= *len
;
395 ret
= lzma_stream_decoder(&stream
, UINT64_MAX
, 0);
396 if (ret
!= LZMA_OK
) {
397 av_log(NULL
, AV_LOG_ERROR
, "LZMA init error: %d\n", ret
);
400 ret
= lzma_code(&stream
, LZMA_RUN
);
402 *len
= stream
.total_out
;
403 return ret
== LZMA_STREAM_END
? LZMA_OK
: ret
;
406 static int tiff_unpack_lzma(TiffContext
*s
, AVFrame
*p
, uint8_t *dst
, int stride
,
407 const uint8_t *src
, int size
, int width
, int lines
,
408 int strip_start
, int is_yuv
)
410 uint64_t outlen
= width
* lines
;
412 uint8_t *buf
= av_malloc(outlen
);
414 return AVERROR(ENOMEM
);
416 if ((ret
= deinvert_buffer(s
, src
, size
)) < 0) {
420 src
= s
->deinvert_buf
;
422 ret
= tiff_uncompress_lzma(buf
, &outlen
, src
, size
);
423 if (ret
!= LZMA_OK
) {
424 av_log(s
->avctx
, AV_LOG_ERROR
,
425 "Uncompressing failed (%"PRIu64
" of %"PRIu64
") with error %d\n", outlen
,
426 (uint64_t)width
* lines
, ret
);
428 return AVERROR_UNKNOWN
;
431 for (line
= 0; line
< lines
; line
++) {
432 if (s
->bpp
< 8 && s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
) {
433 horizontal_fill(s
->bpp
, dst
, 1, src
, 0, width
, 0);
435 memcpy(dst
, src
, width
);
438 unpack_yuv(s
, p
, dst
, strip_start
+ line
);
439 line
+= s
->subsampling
[1] - 1;
449 static int tiff_unpack_fax(TiffContext
*s
, uint8_t *dst
, int stride
,
450 const uint8_t *src
, int size
, int width
, int lines
)
454 uint8_t *src2
= av_malloc((unsigned)size
+
455 FF_INPUT_BUFFER_PADDING_SIZE
);
458 av_log(s
->avctx
, AV_LOG_ERROR
,
459 "Error allocating temporary buffer\n");
460 return AVERROR(ENOMEM
);
462 if (s
->fax_opts
& 2) {
463 avpriv_request_sample(s
->avctx
, "Uncompressed fax mode");
465 return AVERROR_PATCHWELCOME
;
467 if (!s
->fill_order
) {
468 memcpy(src2
, src
, size
);
470 for (i
= 0; i
< size
; i
++)
471 src2
[i
] = ff_reverse
[src
[i
]];
473 memset(src2
+ size
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
474 ret
= ff_ccitt_unpack(s
->avctx
, src2
, size
, dst
, lines
, stride
,
475 s
->compr
, s
->fax_opts
);
476 if (s
->bpp
< 8 && s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
)
477 for (line
= 0; line
< lines
; line
++) {
478 horizontal_fill(s
->bpp
, dst
, 1, dst
, 0, width
, 0);
485 static int tiff_unpack_strip(TiffContext
*s
, AVFrame
*p
, uint8_t *dst
, int stride
,
486 const uint8_t *src
, int size
, int strip_start
, int lines
)
489 int c
, line
, pixels
, code
, ret
;
490 const uint8_t *ssrc
= src
;
491 int width
= ((s
->width
* s
->bpp
) + 7) >> 3;
492 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(p
->format
);
493 int is_yuv
= !(desc
->flags
& AV_PIX_FMT_FLAG_RGB
) &&
494 (desc
->flags
& AV_PIX_FMT_FLAG_PLANAR
) &&
495 desc
->nb_components
>= 3;
498 width
/= s
->bppcount
;
501 return AVERROR_INVALIDDATA
;
504 int bytes_per_row
= (((s
->width
- 1) / s
->subsampling
[0] + 1) * s
->bpp
*
505 s
->subsampling
[0] * s
->subsampling
[1] + 7) >> 3;
506 av_fast_padded_malloc(&s
->yuv_line
, &s
->yuv_line_size
, bytes_per_row
);
507 if (s
->yuv_line
== NULL
) {
508 av_log(s
->avctx
, AV_LOG_ERROR
, "Not enough memory\n");
509 return AVERROR(ENOMEM
);
513 width
= s
->width
* s
->subsampling
[1] + 2*(s
->width
/ s
->subsampling
[0]);
514 av_assert0(width
<= bytes_per_row
);
515 av_assert0(s
->bpp
== 24);
518 if (s
->compr
== TIFF_DEFLATE
|| s
->compr
== TIFF_ADOBE_DEFLATE
) {
520 return tiff_unpack_zlib(s
, p
, dst
, stride
, src
, size
, width
, lines
,
521 strip_start
, is_yuv
);
523 av_log(s
->avctx
, AV_LOG_ERROR
,
524 "zlib support not enabled, "
525 "deflate compression not supported\n");
526 return AVERROR(ENOSYS
);
529 if (s
->compr
== TIFF_LZMA
) {
531 return tiff_unpack_lzma(s
, p
, dst
, stride
, src
, size
, width
, lines
,
532 strip_start
, is_yuv
);
534 av_log(s
->avctx
, AV_LOG_ERROR
,
535 "LZMA support not enabled\n");
536 return AVERROR(ENOSYS
);
539 if (s
->compr
== TIFF_LZW
) {
541 if ((ret
= deinvert_buffer(s
, src
, size
)) < 0)
543 ssrc
= src
= s
->deinvert_buf
;
545 if (size
> 1 && !src
[0] && (src
[1]&1)) {
546 av_log(s
->avctx
, AV_LOG_ERROR
, "Old style LZW is unsupported\n");
548 if ((ret
= ff_lzw_decode_init(s
->lzw
, 8, src
, size
, FF_LZW_TIFF
)) < 0) {
549 av_log(s
->avctx
, AV_LOG_ERROR
, "Error initializing LZW decoder\n");
552 for (line
= 0; line
< lines
; line
++) {
553 pixels
= ff_lzw_decode(s
->lzw
, dst
, width
);
554 if (pixels
< width
) {
555 av_log(s
->avctx
, AV_LOG_ERROR
, "Decoded only %i bytes of %i\n",
557 return AVERROR_INVALIDDATA
;
559 if (s
->bpp
< 8 && s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
)
560 horizontal_fill(s
->bpp
, dst
, 1, dst
, 0, width
, 0);
562 unpack_yuv(s
, p
, dst
, strip_start
+ line
);
563 line
+= s
->subsampling
[1] - 1;
569 if (s
->compr
== TIFF_CCITT_RLE
||
570 s
->compr
== TIFF_G3
||
571 s
->compr
== TIFF_G4
) {
573 return AVERROR_INVALIDDATA
;
575 return tiff_unpack_fax(s
, dst
, stride
, src
, size
, width
, lines
);
578 bytestream2_init(&s
->gb
, src
, size
);
579 bytestream2_init_writer(&pb
, dst
, is_yuv
? s
->yuv_line_size
: (stride
* lines
));
581 for (line
= 0; line
< lines
; line
++) {
582 if (src
- ssrc
> size
) {
583 av_log(s
->avctx
, AV_LOG_ERROR
, "Source data overread\n");
584 return AVERROR_INVALIDDATA
;
587 if (bytestream2_get_bytes_left(&s
->gb
) == 0 || bytestream2_get_eof(&pb
))
589 bytestream2_seek_p(&pb
, stride
* line
, SEEK_SET
);
592 if (ssrc
+ size
- src
< width
)
593 return AVERROR_INVALIDDATA
;
595 if (!s
->fill_order
) {
596 horizontal_fill(s
->bpp
* (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
),
597 dst
, 1, src
, 0, width
, 0);
600 for (i
= 0; i
< width
; i
++)
601 dst
[i
] = ff_reverse
[src
[i
]];
606 for (pixels
= 0; pixels
< width
;) {
607 if (ssrc
+ size
- src
< 2) {
608 av_log(s
->avctx
, AV_LOG_ERROR
, "Read went out of bounds\n");
609 return AVERROR_INVALIDDATA
;
611 code
= s
->fill_order
? (int8_t) ff_reverse
[*src
++]: (int8_t) *src
++;
614 if (pixels
+ code
> width
||
615 ssrc
+ size
- src
< code
) {
616 av_log(s
->avctx
, AV_LOG_ERROR
,
617 "Copy went out of bounds\n");
618 return AVERROR_INVALIDDATA
;
620 horizontal_fill(s
->bpp
* (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
),
621 dst
, 1, src
, 0, code
, pixels
);
624 } else if (code
!= -128) { // -127..-1
626 if (pixels
+ code
> width
) {
627 av_log(s
->avctx
, AV_LOG_ERROR
,
628 "Run went out of bounds\n");
629 return AVERROR_INVALIDDATA
;
632 horizontal_fill(s
->bpp
* (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
),
633 dst
, 0, NULL
, c
, code
, pixels
);
639 for (i
= 0; i
< width
; i
++)
640 dst
[i
] = ff_reverse
[dst
[i
]];
645 unpack_yuv(s
, p
, dst
, strip_start
+ line
);
646 line
+= s
->subsampling
[1] - 1;
653 static int init_image(TiffContext
*s
, ThreadFrame
*frame
)
656 int create_gray_palette
= 0;
658 switch (s
->planar
* 1000 + s
->bpp
* 10 + s
->bppcount
) {
660 if (!s
->palette_is_set
) {
661 s
->avctx
->pix_fmt
= AV_PIX_FMT_MONOBLACK
;
666 s
->avctx
->pix_fmt
= AV_PIX_FMT_PAL8
;
667 if (!s
->palette_is_set
) {
668 create_gray_palette
= 1;
672 s
->avctx
->pix_fmt
= s
->palette_is_set
? AV_PIX_FMT_PAL8
: AV_PIX_FMT_GRAY8
;
675 if (s
->photometric
== TIFF_PHOTOMETRIC_YCBCR
) {
676 if (s
->subsampling
[0] == 1 && s
->subsampling
[1] == 1) {
677 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV444P
;
678 } else if (s
->subsampling
[0] == 2 && s
->subsampling
[1] == 1) {
679 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV422P
;
680 } else if (s
->subsampling
[0] == 4 && s
->subsampling
[1] == 1) {
681 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV411P
;
682 } else if (s
->subsampling
[0] == 1 && s
->subsampling
[1] == 2) {
683 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV440P
;
684 } else if (s
->subsampling
[0] == 2 && s
->subsampling
[1] == 2) {
685 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
686 } else if (s
->subsampling
[0] == 4 && s
->subsampling
[1] == 4) {
687 s
->avctx
->pix_fmt
= AV_PIX_FMT_YUV410P
;
689 av_log(s
->avctx
, AV_LOG_ERROR
, "Unsupported YCbCr subsampling\n");
690 return AVERROR_PATCHWELCOME
;
693 s
->avctx
->pix_fmt
= AV_PIX_FMT_RGB24
;
696 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_GRAY16LE
: AV_PIX_FMT_GRAY16BE
;
699 s
->avctx
->pix_fmt
= AV_PIX_FMT_YA8
;
702 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_YA16LE
: AV_PIX_FMT_YA16BE
;
705 s
->avctx
->pix_fmt
= AV_PIX_FMT_RGBA
;
708 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_RGB48LE
: AV_PIX_FMT_RGB48BE
;
711 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_RGBA64LE
: AV_PIX_FMT_RGBA64BE
;
714 s
->avctx
->pix_fmt
= AV_PIX_FMT_GBRP
;
717 s
->avctx
->pix_fmt
= AV_PIX_FMT_GBRAP
;
720 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_GBRP16LE
: AV_PIX_FMT_GBRP16BE
;
723 s
->avctx
->pix_fmt
= s
->le
? AV_PIX_FMT_GBRAP16LE
: AV_PIX_FMT_GBRAP16BE
;
726 av_log(s
->avctx
, AV_LOG_ERROR
,
727 "This format is not supported (bpp=%d, bppcount=%d)\n",
728 s
->bpp
, s
->bppcount
);
729 return AVERROR_INVALIDDATA
;
732 if (s
->photometric
== TIFF_PHOTOMETRIC_YCBCR
) {
733 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(s
->avctx
->pix_fmt
);
734 if((desc
->flags
& AV_PIX_FMT_FLAG_RGB
) ||
735 !(desc
->flags
& AV_PIX_FMT_FLAG_PLANAR
) ||
736 desc
->nb_components
< 3) {
737 av_log(s
->avctx
, AV_LOG_ERROR
, "Unsupported YCbCr variant\n");
738 return AVERROR_INVALIDDATA
;
742 if (s
->width
!= s
->avctx
->width
|| s
->height
!= s
->avctx
->height
) {
743 ret
= ff_set_dimensions(s
->avctx
, s
->width
, s
->height
);
747 if ((ret
= ff_thread_get_buffer(s
->avctx
, frame
, 0)) < 0)
749 if (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
) {
750 if (!create_gray_palette
)
751 memcpy(frame
->f
->data
[1], s
->palette
, sizeof(s
->palette
));
753 /* make default grayscale pal */
755 uint32_t *pal
= (uint32_t *)frame
->f
->data
[1];
756 for (i
= 0; i
< 1<<s
->bpp
; i
++)
757 pal
[i
] = 0xFFU
<< 24 | i
* 255 / ((1<<s
->bpp
) - 1) * 0x010101;
763 static void set_sar(TiffContext
*s
, unsigned tag
, unsigned num
, unsigned den
)
765 int offset
= tag
== TIFF_YRES
? 2 : 0;
766 s
->res
[offset
++] = num
;
767 s
->res
[offset
] = den
;
768 if (s
->res
[0] && s
->res
[1] && s
->res
[2] && s
->res
[3])
769 av_reduce(&s
->avctx
->sample_aspect_ratio
.num
, &s
->avctx
->sample_aspect_ratio
.den
,
770 s
->res
[2] * (uint64_t)s
->res
[1], s
->res
[0] * (uint64_t)s
->res
[3], INT32_MAX
);
773 static int tiff_decode_tag(TiffContext
*s
, AVFrame
*frame
)
775 unsigned tag
, type
, count
, off
, value
= 0, value2
= 0;
781 ret
= ff_tread_tag(&s
->gb
, s
->le
, &tag
, &type
, &count
, &start
);
786 off
= bytestream2_tell(&s
->gb
);
792 value
= ff_tget(&s
->gb
, type
, s
->le
);
795 value
= ff_tget(&s
->gb
, TIFF_LONG
, s
->le
);
796 value2
= ff_tget(&s
->gb
, TIFF_LONG
, s
->le
);
816 av_log(s
->avctx
, AV_LOG_ERROR
,
817 "This format is not supported (bpp=%d, %d components)\n",
819 return AVERROR_INVALIDDATA
;
830 if (bytestream2_get_bytes_left(&s
->gb
) < type_sizes
[type
] * count
)
831 return AVERROR_INVALIDDATA
;
832 for (i
= 0; i
< count
; i
++)
833 s
->bpp
+= ff_tget(&s
->gb
, type
, s
->le
);
840 av_log(s
->avctx
, AV_LOG_ERROR
,
841 "This format is not supported (bpp=%d, %d components)\n",
844 return AVERROR_INVALIDDATA
;
847 case TIFF_SAMPLES_PER_PIXEL
:
849 av_log(s
->avctx
, AV_LOG_ERROR
,
850 "Samples per pixel requires a single value, many provided\n");
851 return AVERROR_INVALIDDATA
;
854 av_log(s
->avctx
, AV_LOG_ERROR
,
855 "Samples per pixel %d is too large\n", value
);
856 return AVERROR_INVALIDDATA
;
858 if (s
->bppcount
== 1)
876 case TIFF_ADOBE_DEFLATE
:
880 av_log(s
->avctx
, AV_LOG_ERROR
, "Deflate: ZLib not compiled in\n");
881 return AVERROR(ENOSYS
);
885 avpriv_report_missing_feature(s
->avctx
, "JPEG compression");
886 return AVERROR_PATCHWELCOME
;
891 av_log(s
->avctx
, AV_LOG_ERROR
, "LZMA not compiled in\n");
892 return AVERROR(ENOSYS
);
895 av_log(s
->avctx
, AV_LOG_ERROR
, "Unknown compression method %i\n",
897 return AVERROR_INVALIDDATA
;
900 case TIFF_ROWSPERSTRIP
:
901 if (!value
|| (type
== TIFF_LONG
&& value
== UINT_MAX
))
903 s
->rps
= FFMIN(value
, s
->height
);
905 case TIFF_STRIP_OFFS
:
916 case TIFF_STRIP_SIZE
:
918 s
->stripsizesoff
= 0;
919 s
->stripsize
= value
;
922 s
->stripsizesoff
= off
;
929 set_sar(s
, tag
, value
, value2
);
931 case TIFF_TILE_BYTE_COUNTS
:
932 case TIFF_TILE_LENGTH
:
933 case TIFF_TILE_OFFSETS
:
934 case TIFF_TILE_WIDTH
:
935 av_log(s
->avctx
, AV_LOG_ERROR
, "Tiled images are not supported\n");
936 return AVERROR_PATCHWELCOME
;
939 s
->predictor
= value
;
941 case TIFF_PHOTOMETRIC
:
943 case TIFF_PHOTOMETRIC_WHITE_IS_ZERO
:
944 case TIFF_PHOTOMETRIC_BLACK_IS_ZERO
:
945 case TIFF_PHOTOMETRIC_RGB
:
946 case TIFF_PHOTOMETRIC_PALETTE
:
947 case TIFF_PHOTOMETRIC_YCBCR
:
948 s
->photometric
= value
;
950 case TIFF_PHOTOMETRIC_ALPHA_MASK
:
951 case TIFF_PHOTOMETRIC_SEPARATED
:
952 case TIFF_PHOTOMETRIC_CIE_LAB
:
953 case TIFF_PHOTOMETRIC_ICC_LAB
:
954 case TIFF_PHOTOMETRIC_ITU_LAB
:
955 case TIFF_PHOTOMETRIC_CFA
:
956 case TIFF_PHOTOMETRIC_LOG_L
:
957 case TIFF_PHOTOMETRIC_LOG_LUV
:
958 case TIFF_PHOTOMETRIC_LINEAR_RAW
:
959 avpriv_report_missing_feature(s
->avctx
,
960 "PhotometricInterpretation 0x%04X",
962 return AVERROR_PATCHWELCOME
;
964 av_log(s
->avctx
, AV_LOG_ERROR
, "PhotometricInterpretation %u is "
966 return AVERROR_INVALIDDATA
;
969 case TIFF_FILL_ORDER
:
970 if (value
< 1 || value
> 2) {
971 av_log(s
->avctx
, AV_LOG_ERROR
,
972 "Unknown FillOrder value %d, trying default one\n", value
);
975 s
->fill_order
= value
- 1;
978 GetByteContext pal_gb
[3];
979 off
= type_sizes
[type
];
980 if (count
/ 3 > 256 ||
981 bytestream2_get_bytes_left(&s
->gb
) < count
/ 3 * off
* 3)
982 return AVERROR_INVALIDDATA
;
984 pal_gb
[0] = pal_gb
[1] = pal_gb
[2] = s
->gb
;
985 bytestream2_skip(&pal_gb
[1], count
/ 3 * off
);
986 bytestream2_skip(&pal_gb
[2], count
/ 3 * off
* 2);
988 off
= (type_sizes
[type
] - 1) << 3;
989 for (i
= 0; i
< count
/ 3; i
++) {
990 uint32_t p
= 0xFF000000;
991 p
|= (ff_tget(&pal_gb
[0], type
, s
->le
) >> off
) << 16;
992 p
|= (ff_tget(&pal_gb
[1], type
, s
->le
) >> off
) << 8;
993 p
|= ff_tget(&pal_gb
[2], type
, s
->le
) >> off
;
996 s
->palette_is_set
= 1;
1000 s
->planar
= value
== 2;
1002 case TIFF_YCBCR_SUBSAMPLING
:
1004 av_log(s
->avctx
, AV_LOG_ERROR
, "subsample count invalid\n");
1005 return AVERROR_INVALIDDATA
;
1007 for (i
= 0; i
< count
; i
++)
1008 s
->subsampling
[i
] = ff_tget(&s
->gb
, type
, s
->le
);
1010 case TIFF_T4OPTIONS
:
1011 if (s
->compr
== TIFF_G3
)
1012 s
->fax_opts
= value
;
1014 case TIFF_T6OPTIONS
:
1015 if (s
->compr
== TIFF_G4
)
1016 s
->fax_opts
= value
;
1018 #define ADD_METADATA(count, name, sep)\
1019 if ((ret = add_metadata(count, type, name, sep, s, frame)) < 0) {\
1020 av_log(s->avctx, AV_LOG_ERROR, "Error allocating temporary buffer\n");\
1023 case TIFF_MODEL_PIXEL_SCALE
:
1024 ADD_METADATA(count
, "ModelPixelScaleTag", NULL
);
1026 case TIFF_MODEL_TRANSFORMATION
:
1027 ADD_METADATA(count
, "ModelTransformationTag", NULL
);
1029 case TIFF_MODEL_TIEPOINT
:
1030 ADD_METADATA(count
, "ModelTiepointTag", NULL
);
1032 case TIFF_GEO_KEY_DIRECTORY
:
1033 ADD_METADATA(1, "GeoTIFF_Version", NULL
);
1034 ADD_METADATA(2, "GeoTIFF_Key_Revision", ".");
1035 s
->geotag_count
= ff_tget_short(&s
->gb
, s
->le
);
1036 if (s
->geotag_count
> count
/ 4 - 1) {
1037 s
->geotag_count
= count
/ 4 - 1;
1038 av_log(s
->avctx
, AV_LOG_WARNING
, "GeoTIFF key directory buffer shorter than specified\n");
1040 if (bytestream2_get_bytes_left(&s
->gb
) < s
->geotag_count
* sizeof(int16_t) * 4) {
1041 s
->geotag_count
= 0;
1044 s
->geotags
= av_mallocz_array(s
->geotag_count
, sizeof(TiffGeoTag
));
1046 av_log(s
->avctx
, AV_LOG_ERROR
, "Error allocating temporary buffer\n");
1047 s
->geotag_count
= 0;
1050 for (i
= 0; i
< s
->geotag_count
; i
++) {
1051 s
->geotags
[i
].key
= ff_tget_short(&s
->gb
, s
->le
);
1052 s
->geotags
[i
].type
= ff_tget_short(&s
->gb
, s
->le
);
1053 s
->geotags
[i
].count
= ff_tget_short(&s
->gb
, s
->le
);
1055 if (!s
->geotags
[i
].type
)
1056 s
->geotags
[i
].val
= get_geokey_val(s
->geotags
[i
].key
, ff_tget_short(&s
->gb
, s
->le
));
1058 s
->geotags
[i
].offset
= ff_tget_short(&s
->gb
, s
->le
);
1061 case TIFF_GEO_DOUBLE_PARAMS
:
1062 if (count
>= INT_MAX
/ sizeof(int64_t))
1063 return AVERROR_INVALIDDATA
;
1064 if (bytestream2_get_bytes_left(&s
->gb
) < count
* sizeof(int64_t))
1065 return AVERROR_INVALIDDATA
;
1066 dp
= av_malloc_array(count
, sizeof(double));
1068 av_log(s
->avctx
, AV_LOG_ERROR
, "Error allocating temporary buffer\n");
1071 for (i
= 0; i
< count
; i
++)
1072 dp
[i
] = ff_tget_double(&s
->gb
, s
->le
);
1073 for (i
= 0; i
< s
->geotag_count
; i
++) {
1074 if (s
->geotags
[i
].type
== TIFF_GEO_DOUBLE_PARAMS
) {
1075 if (s
->geotags
[i
].count
== 0
1076 || s
->geotags
[i
].offset
+ s
->geotags
[i
].count
> count
) {
1077 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid GeoTIFF key %d\n", s
->geotags
[i
].key
);
1079 char *ap
= doubles2str(&dp
[s
->geotags
[i
].offset
], s
->geotags
[i
].count
, ", ");
1081 av_log(s
->avctx
, AV_LOG_ERROR
, "Error allocating temporary buffer\n");
1083 return AVERROR(ENOMEM
);
1085 s
->geotags
[i
].val
= ap
;
1091 case TIFF_GEO_ASCII_PARAMS
:
1092 pos
= bytestream2_tell(&s
->gb
);
1093 for (i
= 0; i
< s
->geotag_count
; i
++) {
1094 if (s
->geotags
[i
].type
== TIFF_GEO_ASCII_PARAMS
) {
1095 if (s
->geotags
[i
].count
== 0
1096 || s
->geotags
[i
].offset
+ s
->geotags
[i
].count
> count
) {
1097 av_log(s
->avctx
, AV_LOG_WARNING
, "Invalid GeoTIFF key %d\n", s
->geotags
[i
].key
);
1101 bytestream2_seek(&s
->gb
, pos
+ s
->geotags
[i
].offset
, SEEK_SET
);
1102 if (bytestream2_get_bytes_left(&s
->gb
) < s
->geotags
[i
].count
)
1103 return AVERROR_INVALIDDATA
;
1104 ap
= av_malloc(s
->geotags
[i
].count
);
1106 av_log(s
->avctx
, AV_LOG_ERROR
, "Error allocating temporary buffer\n");
1107 return AVERROR(ENOMEM
);
1109 bytestream2_get_bufferu(&s
->gb
, ap
, s
->geotags
[i
].count
);
1110 ap
[s
->geotags
[i
].count
- 1] = '\0'; //replace the "|" delimiter with a 0 byte
1111 s
->geotags
[i
].val
= ap
;
1117 ADD_METADATA(count
, "artist", NULL
);
1119 case TIFF_COPYRIGHT
:
1120 ADD_METADATA(count
, "copyright", NULL
);
1123 ADD_METADATA(count
, "date", NULL
);
1125 case TIFF_DOCUMENT_NAME
:
1126 ADD_METADATA(count
, "document_name", NULL
);
1128 case TIFF_HOST_COMPUTER
:
1129 ADD_METADATA(count
, "computer", NULL
);
1131 case TIFF_IMAGE_DESCRIPTION
:
1132 ADD_METADATA(count
, "description", NULL
);
1135 ADD_METADATA(count
, "make", NULL
);
1138 ADD_METADATA(count
, "model", NULL
);
1140 case TIFF_PAGE_NAME
:
1141 ADD_METADATA(count
, "page_name", NULL
);
1143 case TIFF_PAGE_NUMBER
:
1144 ADD_METADATA(count
, "page_number", " / ");
1146 case TIFF_SOFTWARE_NAME
:
1147 ADD_METADATA(count
, "software", NULL
);
1150 if (s
->avctx
->err_recognition
& AV_EF_EXPLODE
) {
1151 av_log(s
->avctx
, AV_LOG_ERROR
,
1152 "Unknown or unsupported tag %d/0X%0X\n",
1154 return AVERROR_INVALIDDATA
;
1158 bytestream2_seek(&s
->gb
, start
, SEEK_SET
);
1162 static int decode_frame(AVCodecContext
*avctx
,
1163 void *data
, int *got_frame
, AVPacket
*avpkt
)
1165 TiffContext
*const s
= avctx
->priv_data
;
1166 AVFrame
*const p
= data
;
1167 ThreadFrame frame
= { .f
= data
};
1169 int le
, ret
, plane
, planes
;
1170 int i
, j
, entries
, stride
;
1171 unsigned soff
, ssize
;
1173 GetByteContext stripsizes
;
1174 GetByteContext stripdata
;
1176 bytestream2_init(&s
->gb
, avpkt
->data
, avpkt
->size
);
1178 // parse image header
1179 if ((ret
= ff_tdecode_header(&s
->gb
, &le
, &off
))) {
1180 av_log(avctx
, AV_LOG_ERROR
, "Invalid TIFF header\n");
1182 } else if (off
>= UINT_MAX
- 14 || avpkt
->size
< off
+ 14) {
1183 av_log(avctx
, AV_LOG_ERROR
, "IFD offset is greater than image size\n");
1184 return AVERROR_INVALIDDATA
;
1187 // TIFF_BPP is not a required tag and defaults to 1
1188 s
->bppcount
= s
->bpp
= 1;
1189 s
->photometric
= TIFF_PHOTOMETRIC_NONE
;
1190 s
->compr
= TIFF_RAW
;
1194 // Reset these offsets so we can tell if they were set this frame
1195 s
->stripsizesoff
= s
->strippos
= 0;
1196 /* parse image file directory */
1197 bytestream2_seek(&s
->gb
, off
, SEEK_SET
);
1198 entries
= ff_tget_short(&s
->gb
, le
);
1199 if (bytestream2_get_bytes_left(&s
->gb
) < entries
* 12)
1200 return AVERROR_INVALIDDATA
;
1201 for (i
= 0; i
< entries
; i
++) {
1202 if ((ret
= tiff_decode_tag(s
, p
)) < 0)
1206 for (i
= 0; i
<s
->geotag_count
; i
++) {
1207 const char *keyname
= get_geokey_name(s
->geotags
[i
].key
);
1209 av_log(avctx
, AV_LOG_WARNING
, "Unknown or unsupported GeoTIFF key %d\n", s
->geotags
[i
].key
);
1212 if (get_geokey_type(s
->geotags
[i
].key
) != s
->geotags
[i
].type
) {
1213 av_log(avctx
, AV_LOG_WARNING
, "Type of GeoTIFF key %d is wrong\n", s
->geotags
[i
].key
);
1216 ret
= av_dict_set(avpriv_frame_get_metadatap(p
), keyname
, s
->geotags
[i
].val
, 0);
1218 av_log(avctx
, AV_LOG_ERROR
, "Writing metadata with key '%s' failed\n", keyname
);
1223 if (!s
->strippos
&& !s
->stripoff
) {
1224 av_log(avctx
, AV_LOG_ERROR
, "Image data is missing\n");
1225 return AVERROR_INVALIDDATA
;
1227 /* now we have the data and may start decoding */
1228 if ((ret
= init_image(s
, &frame
)) < 0)
1231 if (s
->strips
== 1 && !s
->stripsize
) {
1232 av_log(avctx
, AV_LOG_WARNING
, "Image data size missing\n");
1233 s
->stripsize
= avpkt
->size
- s
->stripoff
;
1236 if (s
->stripsizesoff
) {
1237 if (s
->stripsizesoff
>= (unsigned)avpkt
->size
)
1238 return AVERROR_INVALIDDATA
;
1239 bytestream2_init(&stripsizes
, avpkt
->data
+ s
->stripsizesoff
,
1240 avpkt
->size
- s
->stripsizesoff
);
1243 if (s
->strippos
>= (unsigned)avpkt
->size
)
1244 return AVERROR_INVALIDDATA
;
1245 bytestream2_init(&stripdata
, avpkt
->data
+ s
->strippos
,
1246 avpkt
->size
- s
->strippos
);
1250 av_log(avctx
, AV_LOG_ERROR
, "rps %d invalid\n", s
->rps
);
1251 return AVERROR_INVALIDDATA
;
1254 planes
= s
->planar
? s
->bppcount
: 1;
1255 for (plane
= 0; plane
< planes
; plane
++) {
1256 stride
= p
->linesize
[plane
];
1257 dst
= p
->data
[plane
];
1258 for (i
= 0; i
< s
->height
; i
+= s
->rps
) {
1259 if (s
->stripsizesoff
)
1260 ssize
= ff_tget(&stripsizes
, s
->sstype
, le
);
1262 ssize
= s
->stripsize
;
1265 soff
= ff_tget(&stripdata
, s
->sot
, le
);
1269 if (soff
> avpkt
->size
|| ssize
> avpkt
->size
- soff
) {
1270 av_log(avctx
, AV_LOG_ERROR
, "Invalid strip size/offset\n");
1271 return AVERROR_INVALIDDATA
;
1273 if ((ret
= tiff_unpack_strip(s
, p
, dst
, stride
, avpkt
->data
+ soff
, ssize
, i
,
1274 FFMIN(s
->rps
, s
->height
- i
))) < 0) {
1275 if (avctx
->err_recognition
& AV_EF_EXPLODE
)
1279 dst
+= s
->rps
* stride
;
1281 if (s
->predictor
== 2) {
1282 if (s
->photometric
== TIFF_PHOTOMETRIC_YCBCR
) {
1283 av_log(s
->avctx
, AV_LOG_ERROR
, "predictor == 2 with YUV is unsupported");
1284 return AVERROR_PATCHWELCOME
;
1286 dst
= p
->data
[plane
];
1289 soff
= FFMAX(soff
/ s
->bppcount
, 1);
1290 ssize
= s
->width
* soff
;
1291 if (s
->avctx
->pix_fmt
== AV_PIX_FMT_RGB48LE
||
1292 s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBA64LE
||
1293 s
->avctx
->pix_fmt
== AV_PIX_FMT_GBRP16LE
||
1294 s
->avctx
->pix_fmt
== AV_PIX_FMT_GBRAP16LE
) {
1295 for (i
= 0; i
< s
->height
; i
++) {
1296 for (j
= soff
; j
< ssize
; j
+= 2)
1297 AV_WL16(dst
+ j
, AV_RL16(dst
+ j
) + AV_RL16(dst
+ j
- soff
));
1300 } else if (s
->avctx
->pix_fmt
== AV_PIX_FMT_RGB48BE
||
1301 s
->avctx
->pix_fmt
== AV_PIX_FMT_RGBA64BE
||
1302 s
->avctx
->pix_fmt
== AV_PIX_FMT_GBRP16BE
||
1303 s
->avctx
->pix_fmt
== AV_PIX_FMT_GBRAP16BE
) {
1304 for (i
= 0; i
< s
->height
; i
++) {
1305 for (j
= soff
; j
< ssize
; j
+= 2)
1306 AV_WB16(dst
+ j
, AV_RB16(dst
+ j
) + AV_RB16(dst
+ j
- soff
));
1310 for (i
= 0; i
< s
->height
; i
++) {
1311 for (j
= soff
; j
< ssize
; j
++)
1312 dst
[j
] += dst
[j
- soff
];
1318 if (s
->photometric
== TIFF_PHOTOMETRIC_WHITE_IS_ZERO
) {
1319 dst
= p
->data
[plane
];
1320 for (i
= 0; i
< s
->height
; i
++) {
1321 for (j
= 0; j
< p
->linesize
[plane
]; j
++)
1322 dst
[j
] = (s
->avctx
->pix_fmt
== AV_PIX_FMT_PAL8
? (1<<s
->bpp
) - 1 : 255) - dst
[j
];
1328 if (s
->planar
&& s
->bppcount
> 2) {
1329 FFSWAP(uint8_t*, p
->data
[0], p
->data
[2]);
1330 FFSWAP(int, p
->linesize
[0], p
->linesize
[2]);
1331 FFSWAP(uint8_t*, p
->data
[0], p
->data
[1]);
1332 FFSWAP(int, p
->linesize
[0], p
->linesize
[1]);
1340 static av_cold
int tiff_init(AVCodecContext
*avctx
)
1342 TiffContext
*s
= avctx
->priv_data
;
1347 s
->subsampling
[1] = 1;
1349 ff_lzw_decode_open(&s
->lzw
);
1350 ff_ccitt_unpack_init();
1355 static av_cold
int tiff_end(AVCodecContext
*avctx
)
1357 TiffContext
*const s
= avctx
->priv_data
;
1361 ff_lzw_decode_close(&s
->lzw
);
1362 av_freep(&s
->deinvert_buf
);
1366 AVCodec ff_tiff_decoder
= {
1368 .long_name
= NULL_IF_CONFIG_SMALL("TIFF image"),
1369 .type
= AVMEDIA_TYPE_VIDEO
,
1370 .id
= AV_CODEC_ID_TIFF
,
1371 .priv_data_size
= sizeof(TiffContext
),
1374 .decode
= decode_frame
,
1375 .init_thread_copy
= ONLY_IF_THREADS_ENABLED(tiff_init
),
1376 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_FRAME_THREADS
,