3 * Copyright (c) 2007 Bartlomiej Wolowiec
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
25 * @author Bartlomiej Wolowiec
33 #include "libavutil/imgutils.h"
34 #include "libavutil/log.h"
35 #include "libavutil/opt.h"
36 #include "libavutil/pixdesc.h"
38 #include "bytestream.h"
45 #define TIFF_MAX_ENTRY 32
47 /** sizes of various TIFF field types (string size = 1)*/
48 static const uint8_t type_sizes2
[14] = {
49 0, 1, 1, 2, 4, 8, 1, 1, 2, 4, 8, 4, 8, 4
52 typedef struct TiffEncoderContext
{
53 AVClass
*class; ///< for private options
54 AVCodecContext
*avctx
;
56 int width
; ///< picture width
57 int height
; ///< picture height
58 unsigned int bpp
; ///< bits per pixel
59 int compr
; ///< compression level
60 int bpp_tab_size
; ///< bpp_tab size
61 enum TiffPhotometric photometric_interpretation
; ///< photometric interpretation
62 int strips
; ///< number of strips
63 uint32_t *strip_sizes
;
64 unsigned int strip_sizes_size
;
65 uint32_t *strip_offsets
;
66 unsigned int strip_offsets_size
;
68 unsigned int yuv_line_size
;
69 int rps
; ///< row per strip
70 uint8_t entries
[TIFF_MAX_ENTRY
* 12]; ///< entries in header
71 int num_entries
; ///< number of entries
72 uint8_t **buf
; ///< actual position in buffer
73 uint8_t *buf_start
; ///< pointer to first byte in buffer
74 int buf_size
; ///< buffer size
75 uint16_t subsampling
[2]; ///< YUV subsampling factors
76 struct LZWEncodeState
*lzws
; ///< LZW encode state
77 uint32_t dpi
; ///< image resolution in DPI
81 * Check free space in buffer.
83 * @param s Tiff context
84 * @param need Needed bytes
85 * @return 0 - ok, 1 - no free space
87 static inline int check_size(TiffEncoderContext
*s
, uint64_t need
)
89 if (s
->buf_size
< *s
->buf
- s
->buf_start
+ need
) {
90 *s
->buf
= s
->buf_start
+ s
->buf_size
+ 1;
91 av_log(s
->avctx
, AV_LOG_ERROR
, "Buffer is too small\n");
98 * Put n values to buffer.
100 * @param p pointer to pointer to output buffer
101 * @param n number of values
102 * @param val pointer to values
103 * @param type type of values
104 * @param flip = 0 - normal copy, >0 - flip
106 static void tnput(uint8_t **p
, int n
, const uint8_t *val
, enum TiffTypes type
,
111 flip
^= ((int[]) { 0, 0, 0, 1, 3, 3 })[type
];
113 for (i
= 0; i
< n
* type_sizes2
[type
]; i
++)
114 *(*p
)++ = val
[i
^ flip
];
118 * Add entry to directory in tiff header.
120 * @param s Tiff context
121 * @param tag tag that identifies the entry
122 * @param type entry type
123 * @param count the number of values
124 * @param ptr_val pointer to values
126 static void add_entry(TiffEncoderContext
*s
, enum TiffTags tag
,
127 enum TiffTypes type
, int count
, const void *ptr_val
)
129 uint8_t *entries_ptr
= s
->entries
+ 12 * s
->num_entries
;
131 av_assert0(s
->num_entries
< TIFF_MAX_ENTRY
);
133 bytestream_put_le16(&entries_ptr
, tag
);
134 bytestream_put_le16(&entries_ptr
, type
);
135 bytestream_put_le32(&entries_ptr
, count
);
137 if (type_sizes
[type
] * (int64_t)count
<= 4) {
138 tnput(&entries_ptr
, count
, ptr_val
, type
, 0);
140 bytestream_put_le32(&entries_ptr
, *s
->buf
- s
->buf_start
);
141 check_size(s
, count
* (int64_t)type_sizes2
[type
]);
142 tnput(s
->buf
, count
, ptr_val
, type
, 0);
148 static void add_entry1(TiffEncoderContext
*s
,
149 enum TiffTags tag
, enum TiffTypes type
, int val
)
153 add_entry(s
, tag
, type
, 1, type
== TIFF_SHORT
? (void *)&w
: (void *)&dw
);
157 * Encode one strip in tiff file.
159 * @param s Tiff context
160 * @param src input buffer
161 * @param dst output buffer
162 * @param n size of input buffer
163 * @param compr compression method
164 * @return number of output bytes. If an output error is encountered, -1 is returned
166 static int encode_strip(TiffEncoderContext
*s
, const int8_t *src
,
167 uint8_t *dst
, int n
, int compr
)
172 case TIFF_ADOBE_DEFLATE
:
174 unsigned long zlen
= s
->buf_size
- (*s
->buf
- s
->buf_start
);
175 if (compress(dst
, &zlen
, src
, n
) != Z_OK
) {
176 av_log(s
->avctx
, AV_LOG_ERROR
, "Compressing failed\n");
183 if (check_size(s
, n
))
188 return ff_rle_encode(dst
, s
->buf_size
- (*s
->buf
- s
->buf_start
),
189 src
, 1, n
, 2, 0xff, -1, 0);
191 return ff_lzw_encode(s
->lzws
, src
, n
);
197 static void pack_yuv(TiffEncoderContext
*s
, const AVFrame
*p
,
198 uint8_t *dst
, int lnum
)
201 int w
= (s
->width
- 1) / s
->subsampling
[0] + 1;
202 uint8_t *pu
= &p
->data
[1][lnum
/ s
->subsampling
[1] * p
->linesize
[1]];
203 uint8_t *pv
= &p
->data
[2][lnum
/ s
->subsampling
[1] * p
->linesize
[2]];
204 if (s
->width
% s
->subsampling
[0] || s
->height
% s
->subsampling
[1]) {
205 for (i
= 0; i
< w
; i
++) {
206 for (j
= 0; j
< s
->subsampling
[1]; j
++)
207 for (k
= 0; k
< s
->subsampling
[0]; k
++)
208 *dst
++ = p
->data
[0][FFMIN(lnum
+ j
, s
->height
-1) * p
->linesize
[0] +
209 FFMIN(i
* s
->subsampling
[0] + k
, s
->width
-1)];
214 for (i
= 0; i
< w
; i
++) {
215 for (j
= 0; j
< s
->subsampling
[1]; j
++)
216 for (k
= 0; k
< s
->subsampling
[0]; k
++)
217 *dst
++ = p
->data
[0][(lnum
+ j
) * p
->linesize
[0] +
218 i
* s
->subsampling
[0] + k
];
225 static int encode_frame(AVCodecContext
*avctx
, AVPacket
*pkt
,
226 const AVFrame
*pict
, int *got_packet
)
228 const AVPixFmtDescriptor
*desc
= av_pix_fmt_desc_get(avctx
->pix_fmt
);
229 TiffEncoderContext
*s
= avctx
->priv_data
;
230 const AVFrame
*const p
= pict
;
236 uint32_t res
[2] = { s
->dpi
, 1 }; // image resolution (72/1)
239 int is_yuv
= 0, alpha
= 0;
240 int shift_h
, shift_v
;
243 s
->width
= avctx
->width
;
244 s
->height
= avctx
->height
;
245 s
->subsampling
[0] = 1;
246 s
->subsampling
[1] = 1;
248 avctx
->bits_per_coded_sample
=
249 s
->bpp
= av_get_bits_per_pixel(desc
);
250 s
->bpp_tab_size
= desc
->nb_components
;
252 switch (avctx
->pix_fmt
) {
253 case AV_PIX_FMT_RGBA64LE
:
254 case AV_PIX_FMT_RGBA
:
256 case AV_PIX_FMT_RGB48LE
:
257 case AV_PIX_FMT_RGB24
:
258 s
->photometric_interpretation
= TIFF_PHOTOMETRIC_RGB
;
260 case AV_PIX_FMT_GRAY8
:
261 avctx
->bits_per_coded_sample
= 0x28;
262 case AV_PIX_FMT_GRAY8A
:
263 alpha
= avctx
->pix_fmt
== AV_PIX_FMT_GRAY8A
;
264 case AV_PIX_FMT_GRAY16LE
:
265 case AV_PIX_FMT_MONOBLACK
:
266 s
->photometric_interpretation
= TIFF_PHOTOMETRIC_BLACK_IS_ZERO
;
268 case AV_PIX_FMT_PAL8
:
269 s
->photometric_interpretation
= TIFF_PHOTOMETRIC_PALETTE
;
271 case AV_PIX_FMT_MONOWHITE
:
272 s
->photometric_interpretation
= TIFF_PHOTOMETRIC_WHITE_IS_ZERO
;
274 case AV_PIX_FMT_YUV420P
:
275 case AV_PIX_FMT_YUV422P
:
276 case AV_PIX_FMT_YUV440P
:
277 case AV_PIX_FMT_YUV444P
:
278 case AV_PIX_FMT_YUV410P
:
279 case AV_PIX_FMT_YUV411P
:
280 av_pix_fmt_get_chroma_sub_sample(avctx
->pix_fmt
, &shift_h
, &shift_v
);
281 s
->photometric_interpretation
= TIFF_PHOTOMETRIC_YCBCR
;
282 s
->subsampling
[0] = 1 << shift_h
;
283 s
->subsampling
[1] = 1 << shift_v
;
287 av_log(s
->avctx
, AV_LOG_ERROR
,
288 "This colors format is not supported\n");
292 for (i
= 0; i
< s
->bpp_tab_size
; i
++)
293 bpp_tab
[i
] = desc
->comp
[i
].depth_minus1
+ 1;
295 if (s
->compr
== TIFF_DEFLATE
||
296 s
->compr
== TIFF_ADOBE_DEFLATE
||
297 s
->compr
== TIFF_LZW
)
298 // best choice for DEFLATE
301 // suggest size of strip
302 s
->rps
= FFMAX(8192 / (((s
->width
* s
->bpp
) >> 3) + 1), 1);
304 s
->rps
= ((s
->rps
- 1) / s
->subsampling
[1] + 1) * s
->subsampling
[1];
306 strips
= (s
->height
- 1) / s
->rps
+ 1;
308 bytes_per_row
= (((s
->width
- 1) / s
->subsampling
[0] + 1) * s
->bpp
*
309 s
->subsampling
[0] * s
->subsampling
[1] + 7) >> 3;
310 packet_size
= avctx
->height
* bytes_per_row
* 2 +
311 avctx
->height
* 4 + FF_MIN_BUFFER_SIZE
;
313 if ((ret
= ff_alloc_packet2(avctx
, pkt
, packet_size
)) < 0)
316 s
->buf_start
= pkt
->data
;
318 s
->buf_size
= pkt
->size
;
320 if (check_size(s
, 8))
324 bytestream_put_le16(&ptr
, 0x4949);
325 bytestream_put_le16(&ptr
, 42);
328 bytestream_put_le32(&ptr
, 0);
330 if (strips
> INT_MAX
/ FFMAX(sizeof(s
->strip_sizes
[0]), sizeof(s
->strip_offsets
[0]))) {
331 ret
= AVERROR(ENOMEM
);
334 av_fast_padded_mallocz(&s
->strip_sizes
, &s
->strip_sizes_size
, sizeof(s
->strip_sizes
[0]) * strips
);
335 av_fast_padded_mallocz(&s
->strip_offsets
, &s
->strip_offsets_size
, sizeof(s
->strip_offsets
[0]) * strips
);
337 if (!s
->strip_sizes
|| !s
->strip_offsets
) {
338 ret
= AVERROR(ENOMEM
);
343 av_fast_padded_malloc(&s
->yuv_line
, &s
->yuv_line_size
, bytes_per_row
);
344 if (s
->yuv_line
== NULL
) {
345 av_log(s
->avctx
, AV_LOG_ERROR
, "Not enough memory\n");
346 ret
= AVERROR(ENOMEM
);
352 if (s
->compr
== TIFF_DEFLATE
|| s
->compr
== TIFF_ADOBE_DEFLATE
) {
357 zlen
= bytes_per_row
* s
->rps
;
358 zbuf
= av_malloc(zlen
);
360 ret
= AVERROR(ENOMEM
);
363 s
->strip_offsets
[0] = ptr
- pkt
->data
;
365 for (j
= 0; j
< s
->rps
; j
++) {
367 pack_yuv(s
, p
, s
->yuv_line
, j
);
368 memcpy(zbuf
+ zn
, s
->yuv_line
, bytes_per_row
);
369 j
+= s
->subsampling
[1] - 1;
371 memcpy(zbuf
+ j
* bytes_per_row
,
372 p
->data
[0] + j
* p
->linesize
[0], bytes_per_row
);
375 ret
= encode_strip(s
, zbuf
, ptr
, zn
, s
->compr
);
378 av_log(s
->avctx
, AV_LOG_ERROR
, "Encode strip failed\n");
382 s
->strip_sizes
[0] = ptr
- pkt
->data
- s
->strip_offsets
[0];
386 if (s
->compr
== TIFF_LZW
) {
387 s
->lzws
= av_malloc(ff_lzw_encode_state_size
);
389 ret
= AVERROR(ENOMEM
);
393 for (i
= 0; i
< s
->height
; i
++) {
394 if (s
->strip_sizes
[i
/ s
->rps
] == 0) {
395 if (s
->compr
== TIFF_LZW
) {
396 ff_lzw_encode_init(s
->lzws
, ptr
,
397 s
->buf_size
- (*s
->buf
- s
->buf_start
),
398 12, FF_LZW_TIFF
, put_bits
);
400 s
->strip_offsets
[i
/ s
->rps
] = ptr
- pkt
->data
;
403 pack_yuv(s
, p
, s
->yuv_line
, i
);
404 ret
= encode_strip(s
, s
->yuv_line
, ptr
, bytes_per_row
, s
->compr
);
405 i
+= s
->subsampling
[1] - 1;
407 ret
= encode_strip(s
, p
->data
[0] + i
* p
->linesize
[0],
408 ptr
, bytes_per_row
, s
->compr
);
410 av_log(s
->avctx
, AV_LOG_ERROR
, "Encode strip failed\n");
413 s
->strip_sizes
[i
/ s
->rps
] += ret
;
415 if (s
->compr
== TIFF_LZW
&&
416 (i
== s
->height
- 1 || i
% s
->rps
== s
->rps
- 1)) {
417 ret
= ff_lzw_encode_flush(s
->lzws
, flush_put_bits
);
418 s
->strip_sizes
[(i
/ s
->rps
)] += ret
;
422 if (s
->compr
== TIFF_LZW
)
428 add_entry1(s
, TIFF_SUBFILE
, TIFF_LONG
, 0);
429 add_entry1(s
, TIFF_WIDTH
, TIFF_LONG
, s
->width
);
430 add_entry1(s
, TIFF_HEIGHT
, TIFF_LONG
, s
->height
);
433 add_entry(s
, TIFF_BPP
, TIFF_SHORT
, s
->bpp_tab_size
, bpp_tab
);
435 add_entry1(s
, TIFF_COMPR
, TIFF_SHORT
, s
->compr
);
436 add_entry1(s
, TIFF_PHOTOMETRIC
, TIFF_SHORT
, s
->photometric_interpretation
);
437 add_entry(s
, TIFF_STRIP_OFFS
, TIFF_LONG
, strips
, s
->strip_offsets
);
440 add_entry1(s
, TIFF_SAMPLES_PER_PIXEL
, TIFF_SHORT
, s
->bpp_tab_size
);
442 add_entry1(s
, TIFF_ROWSPERSTRIP
, TIFF_LONG
, s
->rps
);
443 add_entry(s
, TIFF_STRIP_SIZE
, TIFF_LONG
, strips
, s
->strip_sizes
);
444 add_entry(s
, TIFF_XRES
, TIFF_RATIONAL
, 1, res
);
445 if (avctx
->sample_aspect_ratio
.num
> 0 &&
446 avctx
->sample_aspect_ratio
.den
> 0) {
447 AVRational y
= av_mul_q(av_make_q(s
->dpi
, 1),
448 avctx
->sample_aspect_ratio
);
452 add_entry(s
, TIFF_YRES
, TIFF_RATIONAL
, 1, res
);
453 add_entry1(s
, TIFF_RES_UNIT
, TIFF_SHORT
, 2);
455 if (!(avctx
->flags
& CODEC_FLAG_BITEXACT
))
456 add_entry(s
, TIFF_SOFTWARE_NAME
, TIFF_STRING
,
457 strlen(LIBAVCODEC_IDENT
) + 1, LIBAVCODEC_IDENT
);
459 if (avctx
->pix_fmt
== AV_PIX_FMT_PAL8
) {
460 uint16_t pal
[256 * 3];
461 for (i
= 0; i
< 256; i
++) {
462 uint32_t rgb
= *(uint32_t *) (p
->data
[1] + i
* 4);
463 pal
[i
] = ((rgb
>> 16) & 0xff) * 257;
464 pal
[i
+ 256] = ((rgb
>> 8) & 0xff) * 257;
465 pal
[i
+ 512] = (rgb
& 0xff) * 257;
467 add_entry(s
, TIFF_PAL
, TIFF_SHORT
, 256 * 3, pal
);
470 add_entry1(s
,TIFF_EXTRASAMPLES
, TIFF_SHORT
, 2);
472 /** according to CCIR Recommendation 601.1 */
473 uint32_t refbw
[12] = { 15, 1, 235, 1, 128, 1, 240, 1, 128, 1, 240, 1 };
474 add_entry(s
, TIFF_YCBCR_SUBSAMPLING
, TIFF_SHORT
, 2, s
->subsampling
);
475 if (avctx
->chroma_sample_location
== AVCHROMA_LOC_TOPLEFT
)
476 add_entry1(s
, TIFF_YCBCR_POSITIONING
, TIFF_SHORT
, 2);
477 add_entry(s
, TIFF_REFERENCE_BW
, TIFF_RATIONAL
, 6, refbw
);
479 // write offset to dir
480 bytestream_put_le32(&offset
, ptr
- pkt
->data
);
482 if (check_size(s
, 6 + s
->num_entries
* 12)) {
483 ret
= AVERROR(EINVAL
);
486 bytestream_put_le16(&ptr
, s
->num_entries
); // write tag count
487 bytestream_put_buffer(&ptr
, s
->entries
, s
->num_entries
* 12);
488 bytestream_put_le32(&ptr
, 0);
490 pkt
->size
= ptr
- pkt
->data
;
491 pkt
->flags
|= AV_PKT_FLAG_KEY
;
495 return ret
< 0 ? ret
: 0;
498 static av_cold
int encode_init(AVCodecContext
*avctx
)
500 TiffEncoderContext
*s
= avctx
->priv_data
;
502 avctx
->coded_frame
= av_frame_alloc();
503 if (!avctx
->coded_frame
)
504 return AVERROR(ENOMEM
);
506 avctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_I
;
507 avctx
->coded_frame
->key_frame
= 1;
513 static av_cold
int encode_close(AVCodecContext
*avctx
)
515 TiffEncoderContext
*s
= avctx
->priv_data
;
517 av_frame_free(&avctx
->coded_frame
);
518 av_freep(&s
->strip_sizes
);
519 av_freep(&s
->strip_offsets
);
520 av_freep(&s
->yuv_line
);
525 #define OFFSET(x) offsetof(TiffEncoderContext, x)
526 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
527 static const AVOption options
[] = {
528 {"dpi", "set the image resolution (in dpi)", OFFSET(dpi
), AV_OPT_TYPE_INT
, {.i64
= 72}, 1, 0x10000, AV_OPT_FLAG_VIDEO_PARAM
|AV_OPT_FLAG_ENCODING_PARAM
},
529 { "compression_algo", NULL
, OFFSET(compr
), AV_OPT_TYPE_INT
, { .i64
= TIFF_PACKBITS
}, TIFF_RAW
, TIFF_DEFLATE
, VE
, "compression_algo" },
530 { "packbits", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= TIFF_PACKBITS
}, 0, 0, VE
, "compression_algo" },
531 { "raw", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= TIFF_RAW
}, 0, 0, VE
, "compression_algo" },
532 { "lzw", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= TIFF_LZW
}, 0, 0, VE
, "compression_algo" },
534 { "deflate", NULL
, 0, AV_OPT_TYPE_CONST
, { .i64
= TIFF_DEFLATE
}, 0, 0, VE
, "compression_algo" },
539 static const AVClass tiffenc_class
= {
540 .class_name
= "TIFF encoder",
541 .item_name
= av_default_item_name
,
543 .version
= LIBAVUTIL_VERSION_INT
,
546 AVCodec ff_tiff_encoder
= {
548 .long_name
= NULL_IF_CONFIG_SMALL("TIFF image"),
549 .type
= AVMEDIA_TYPE_VIDEO
,
550 .id
= AV_CODEC_ID_TIFF
,
551 .priv_data_size
= sizeof(TiffEncoderContext
),
553 .close
= encode_close
,
554 .capabilities
= CODEC_CAP_FRAME_THREADS
| CODEC_CAP_INTRA_ONLY
,
555 .encode2
= encode_frame
,
556 .pix_fmts
= (const enum AVPixelFormat
[]) {
557 AV_PIX_FMT_RGB24
, AV_PIX_FMT_PAL8
, AV_PIX_FMT_GRAY8
,
558 AV_PIX_FMT_GRAY8A
, AV_PIX_FMT_GRAY16LE
,
559 AV_PIX_FMT_MONOBLACK
, AV_PIX_FMT_MONOWHITE
,
560 AV_PIX_FMT_YUV420P
, AV_PIX_FMT_YUV422P
, AV_PIX_FMT_YUV440P
, AV_PIX_FMT_YUV444P
,
561 AV_PIX_FMT_YUV410P
, AV_PIX_FMT_YUV411P
, AV_PIX_FMT_RGB48LE
,
562 AV_PIX_FMT_RGBA
, AV_PIX_FMT_RGBA64LE
,
565 .priv_class
= &tiffenc_class
,