3 * Copyright (c) 2003 Fabrice Bellard
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
24 #include "bytestream.h"
25 #include "huffyuvencdsp.h"
28 #include "libavutil/avassert.h"
29 #include "libavutil/opt.h"
33 #define IOBUF_SIZE 4096
35 typedef struct PNGEncContext
{
37 HuffYUVEncDSPContext hdsp
;
40 uint8_t *bytestream_start
;
41 uint8_t *bytestream_end
;
46 uint8_t buf
[IOBUF_SIZE
];
47 int dpi
; ///< Physical pixel density, in dots per inch, if set
48 int dpm
; ///< Physical pixel density, in dots per meter, if set
51 static void png_get_interlaced_row(uint8_t *dst
, int row_size
,
52 int bits_per_pixel
, int pass
,
53 const uint8_t *src
, int width
)
55 int x
, mask
, dst_x
, j
, b
, bpp
;
58 static const int masks
[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
61 switch (bits_per_pixel
) {
63 memset(dst
, 0, row_size
);
65 for (x
= 0; x
< width
; x
++) {
67 if ((mask
<< j
) & 0x80) {
68 b
= (src
[x
>> 3] >> (7 - j
)) & 1;
69 dst
[dst_x
>> 3] |= b
<< (7 - (dst_x
& 7));
75 bpp
= bits_per_pixel
>> 3;
78 for (x
= 0; x
< width
; x
++) {
80 if ((mask
<< j
) & 0x80) {
90 static void sub_png_paeth_prediction(uint8_t *dst
, uint8_t *src
, uint8_t *top
,
94 for (i
= 0; i
< w
; i
++) {
95 int a
, b
, c
, p
, pa
, pb
, pc
;
108 if (pa
<= pb
&& pa
<= pc
)
118 static void sub_left_prediction(PNGEncContext
*c
, uint8_t *dst
, const uint8_t *src
, int bpp
, int size
)
120 const uint8_t *src1
= src
+ bpp
;
121 const uint8_t *src2
= src
;
124 memcpy(dst
, src
, bpp
);
127 unaligned_w
= FFMIN(32 - bpp
, size
);
128 for (x
= 0; x
< unaligned_w
; x
++)
129 *dst
++ = *src1
++ - *src2
++;
131 c
->hdsp
.diff_bytes(dst
, src1
, src2
, size
);
134 static void png_filter_row(PNGEncContext
*c
, uint8_t *dst
, int filter_type
,
135 uint8_t *src
, uint8_t *top
, int size
, int bpp
)
139 switch (filter_type
) {
140 case PNG_FILTER_VALUE_NONE
:
141 memcpy(dst
, src
, size
);
143 case PNG_FILTER_VALUE_SUB
:
144 sub_left_prediction(c
, dst
, src
, bpp
, size
);
146 case PNG_FILTER_VALUE_UP
:
147 c
->hdsp
.diff_bytes(dst
, src
, top
, size
);
149 case PNG_FILTER_VALUE_AVG
:
150 for (i
= 0; i
< bpp
; i
++)
151 dst
[i
] = src
[i
] - (top
[i
] >> 1);
152 for (; i
< size
; i
++)
153 dst
[i
] = src
[i
] - ((src
[i
- bpp
] + top
[i
]) >> 1);
155 case PNG_FILTER_VALUE_PAETH
:
156 for (i
= 0; i
< bpp
; i
++)
157 dst
[i
] = src
[i
] - top
[i
];
158 sub_png_paeth_prediction(dst
+ i
, src
+ i
, top
+ i
, size
- i
, bpp
);
163 static uint8_t *png_choose_filter(PNGEncContext
*s
, uint8_t *dst
,
164 uint8_t *src
, uint8_t *top
, int size
, int bpp
)
166 int pred
= s
->filter_type
;
167 av_assert0(bpp
|| !pred
);
169 pred
= PNG_FILTER_VALUE_SUB
;
170 if (pred
== PNG_FILTER_VALUE_MIXED
) {
172 int cost
, bcost
= INT_MAX
;
173 uint8_t *buf1
= dst
, *buf2
= dst
+ size
+ 16;
174 for (pred
= 0; pred
< 5; pred
++) {
175 png_filter_row(s
, buf1
+ 1, pred
, src
, top
, size
, bpp
);
178 for (i
= 0; i
<= size
; i
++)
179 cost
+= abs((int8_t) buf1
[i
]);
182 FFSWAP(uint8_t *, buf1
, buf2
);
187 png_filter_row(s
, dst
+ 1, pred
, src
, top
, size
, bpp
);
193 static void png_write_chunk(uint8_t **f
, uint32_t tag
,
194 const uint8_t *buf
, int length
)
199 bytestream_put_be32(f
, length
);
200 crc
= crc32(0, Z_NULL
, 0);
201 AV_WL32(tagbuf
, tag
);
202 crc
= crc32(crc
, tagbuf
, 4);
203 bytestream_put_be32(f
, av_bswap32(tag
));
205 crc
= crc32(crc
, buf
, length
);
206 memcpy(*f
, buf
, length
);
209 bytestream_put_be32(f
, crc
);
212 /* XXX: do filtering */
213 static int png_write_row(PNGEncContext
*s
, const uint8_t *data
, int size
)
217 s
->zstream
.avail_in
= size
;
218 s
->zstream
.next_in
= data
;
219 while (s
->zstream
.avail_in
> 0) {
220 ret
= deflate(&s
->zstream
, Z_NO_FLUSH
);
223 if (s
->zstream
.avail_out
== 0) {
224 if (s
->bytestream_end
- s
->bytestream
> IOBUF_SIZE
+ 100)
225 png_write_chunk(&s
->bytestream
,
226 MKTAG('I', 'D', 'A', 'T'), s
->buf
, IOBUF_SIZE
);
227 s
->zstream
.avail_out
= IOBUF_SIZE
;
228 s
->zstream
.next_out
= s
->buf
;
234 static int encode_frame(AVCodecContext
*avctx
, AVPacket
*pkt
,
235 const AVFrame
*pict
, int *got_packet
)
237 PNGEncContext
*s
= avctx
->priv_data
;
238 const AVFrame
*const p
= pict
;
239 int bit_depth
, color_type
, y
, len
, row_size
, ret
, is_progressive
;
240 int bits_per_pixel
, pass_row_size
, enc_row_size
;
241 int64_t max_packet_size
;
242 int compression_level
;
243 uint8_t *ptr
, *top
, *crow_buf
, *crow
;
244 uint8_t *crow_base
= NULL
;
245 uint8_t *progressive_buf
= NULL
;
246 uint8_t *top_buf
= NULL
;
248 is_progressive
= !!(avctx
->flags
& CODEC_FLAG_INTERLACED_DCT
);
249 switch (avctx
->pix_fmt
) {
250 case AV_PIX_FMT_RGBA64BE
:
252 color_type
= PNG_COLOR_TYPE_RGB_ALPHA
;
254 case AV_PIX_FMT_RGB48BE
:
256 color_type
= PNG_COLOR_TYPE_RGB
;
258 case AV_PIX_FMT_RGBA
:
260 color_type
= PNG_COLOR_TYPE_RGB_ALPHA
;
262 case AV_PIX_FMT_RGB24
:
264 color_type
= PNG_COLOR_TYPE_RGB
;
266 case AV_PIX_FMT_GRAY16BE
:
268 color_type
= PNG_COLOR_TYPE_GRAY
;
270 case AV_PIX_FMT_GRAY8
:
272 color_type
= PNG_COLOR_TYPE_GRAY
;
274 case AV_PIX_FMT_GRAY8A
:
276 color_type
= PNG_COLOR_TYPE_GRAY_ALPHA
;
278 case AV_PIX_FMT_MONOBLACK
:
280 color_type
= PNG_COLOR_TYPE_GRAY
;
282 case AV_PIX_FMT_PAL8
:
284 color_type
= PNG_COLOR_TYPE_PALETTE
;
289 bits_per_pixel
= ff_png_get_nb_channels(color_type
) * bit_depth
;
290 row_size
= (avctx
->width
* bits_per_pixel
+ 7) >> 3;
292 s
->zstream
.zalloc
= ff_png_zalloc
;
293 s
->zstream
.zfree
= ff_png_zfree
;
294 s
->zstream
.opaque
= NULL
;
295 compression_level
= avctx
->compression_level
== FF_COMPRESSION_DEFAULT
296 ? Z_DEFAULT_COMPRESSION
297 : av_clip(avctx
->compression_level
, 0, 9);
298 ret
= deflateInit2(&s
->zstream
, compression_level
,
299 Z_DEFLATED
, 15, 8, Z_DEFAULT_STRATEGY
);
303 enc_row_size
= deflateBound(&s
->zstream
, row_size
);
304 max_packet_size
= avctx
->height
* (int64_t)(enc_row_size
+
305 ((enc_row_size
+ IOBUF_SIZE
- 1) / IOBUF_SIZE
) * 12)
306 + FF_MIN_BUFFER_SIZE
;
307 if (max_packet_size
> INT_MAX
)
308 return AVERROR(ENOMEM
);
309 if ((ret
= ff_alloc_packet2(avctx
, pkt
, max_packet_size
)) < 0)
312 s
->bytestream_start
=
313 s
->bytestream
= pkt
->data
;
314 s
->bytestream_end
= pkt
->data
+ pkt
->size
;
316 crow_base
= av_malloc((row_size
+ 32) << (s
->filter_type
== PNG_FILTER_VALUE_MIXED
));
319 // pixel data should be aligned, but there's a control byte before it
320 crow_buf
= crow_base
+ 15;
321 if (is_progressive
) {
322 progressive_buf
= av_malloc(row_size
+ 1);
323 if (!progressive_buf
)
326 if (is_progressive
) {
327 top_buf
= av_malloc(row_size
+ 1);
332 /* write png header */
333 AV_WB64(s
->bytestream
, PNGSIG
);
336 AV_WB32(s
->buf
, avctx
->width
);
337 AV_WB32(s
->buf
+ 4, avctx
->height
);
338 s
->buf
[8] = bit_depth
;
339 s
->buf
[9] = color_type
;
340 s
->buf
[10] = 0; /* compression type */
341 s
->buf
[11] = 0; /* filter type */
342 s
->buf
[12] = is_progressive
; /* interlace type */
344 png_write_chunk(&s
->bytestream
, MKTAG('I', 'H', 'D', 'R'), s
->buf
, 13);
347 AV_WB32(s
->buf
, s
->dpm
);
348 AV_WB32(s
->buf
+ 4, s
->dpm
);
349 s
->buf
[8] = 1; /* unit specifier is meter */
351 AV_WB32(s
->buf
, avctx
->sample_aspect_ratio
.num
);
352 AV_WB32(s
->buf
+ 4, avctx
->sample_aspect_ratio
.den
);
353 s
->buf
[8] = 0; /* unit specifier is unknown */
355 png_write_chunk(&s
->bytestream
, MKTAG('p', 'H', 'Y', 's'), s
->buf
, 9);
357 /* put the palette if needed */
358 if (color_type
== PNG_COLOR_TYPE_PALETTE
) {
359 int has_alpha
, alpha
, i
;
364 palette
= (uint32_t *)p
->data
[1];
366 alpha_ptr
= s
->buf
+ 256 * 3;
368 for (i
= 0; i
< 256; i
++) {
373 *alpha_ptr
++ = alpha
;
374 bytestream_put_be24(&ptr
, v
);
376 png_write_chunk(&s
->bytestream
,
377 MKTAG('P', 'L', 'T', 'E'), s
->buf
, 256 * 3);
379 png_write_chunk(&s
->bytestream
,
380 MKTAG('t', 'R', 'N', 'S'), s
->buf
+ 256 * 3, 256);
384 /* now put each row */
385 s
->zstream
.avail_out
= IOBUF_SIZE
;
386 s
->zstream
.next_out
= s
->buf
;
387 if (is_progressive
) {
390 for (pass
= 0; pass
< NB_PASSES
; pass
++) {
391 /* NOTE: a pass is completely omitted if no pixels would be
393 pass_row_size
= ff_png_pass_row_size(pass
, bits_per_pixel
, avctx
->width
);
394 if (pass_row_size
> 0) {
396 for (y
= 0; y
< avctx
->height
; y
++)
397 if ((ff_png_pass_ymask
[pass
] << (y
& 7)) & 0x80) {
398 ptr
= p
->data
[0] + y
* p
->linesize
[0];
399 FFSWAP(uint8_t *, progressive_buf
, top_buf
);
400 png_get_interlaced_row(progressive_buf
, pass_row_size
,
401 bits_per_pixel
, pass
,
403 crow
= png_choose_filter(s
, crow_buf
, progressive_buf
,
404 top
, pass_row_size
, bits_per_pixel
>> 3);
405 png_write_row(s
, crow
, pass_row_size
+ 1);
406 top
= progressive_buf
;
412 for (y
= 0; y
< avctx
->height
; y
++) {
413 ptr
= p
->data
[0] + y
* p
->linesize
[0];
414 crow
= png_choose_filter(s
, crow_buf
, ptr
, top
,
415 row_size
, bits_per_pixel
>> 3);
416 png_write_row(s
, crow
, row_size
+ 1);
420 /* compress last bytes */
422 ret
= deflate(&s
->zstream
, Z_FINISH
);
423 if (ret
== Z_OK
|| ret
== Z_STREAM_END
) {
424 len
= IOBUF_SIZE
- s
->zstream
.avail_out
;
425 if (len
> 0 && s
->bytestream_end
- s
->bytestream
> len
+ 100) {
426 png_write_chunk(&s
->bytestream
, MKTAG('I', 'D', 'A', 'T'), s
->buf
, len
);
428 s
->zstream
.avail_out
= IOBUF_SIZE
;
429 s
->zstream
.next_out
= s
->buf
;
430 if (ret
== Z_STREAM_END
)
436 png_write_chunk(&s
->bytestream
, MKTAG('I', 'E', 'N', 'D'), NULL
, 0);
438 pkt
->size
= s
->bytestream
- s
->bytestream_start
;
439 pkt
->flags
|= AV_PKT_FLAG_KEY
;
445 av_free(progressive_buf
);
447 deflateEnd(&s
->zstream
);
454 static av_cold
int png_enc_init(AVCodecContext
*avctx
)
456 PNGEncContext
*s
= avctx
->priv_data
;
458 switch (avctx
->pix_fmt
) {
459 case AV_PIX_FMT_RGBA
:
460 avctx
->bits_per_coded_sample
= 32;
462 case AV_PIX_FMT_RGB24
:
463 avctx
->bits_per_coded_sample
= 24;
465 case AV_PIX_FMT_GRAY8
:
466 avctx
->bits_per_coded_sample
= 0x28;
468 case AV_PIX_FMT_MONOBLACK
:
469 avctx
->bits_per_coded_sample
= 1;
471 case AV_PIX_FMT_PAL8
:
472 avctx
->bits_per_coded_sample
= 8;
475 avctx
->coded_frame
= av_frame_alloc();
476 if (!avctx
->coded_frame
)
477 return AVERROR(ENOMEM
);
479 avctx
->coded_frame
->pict_type
= AV_PICTURE_TYPE_I
;
480 avctx
->coded_frame
->key_frame
= 1;
482 ff_huffyuvencdsp_init(&s
->hdsp
);
484 s
->filter_type
= av_clip(avctx
->prediction_method
,
485 PNG_FILTER_VALUE_NONE
,
486 PNG_FILTER_VALUE_MIXED
);
487 if (avctx
->pix_fmt
== AV_PIX_FMT_MONOBLACK
)
488 s
->filter_type
= PNG_FILTER_VALUE_NONE
;
490 if (s
->dpi
&& s
->dpm
) {
491 av_log(avctx
, AV_LOG_ERROR
, "Only one of 'dpi' or 'dpm' options should be set\n");
492 return AVERROR(EINVAL
);
494 s
->dpm
= s
->dpi
* 10000 / 254;
500 static av_cold
int png_enc_close(AVCodecContext
*avctx
)
502 av_frame_free(&avctx
->coded_frame
);
506 #define OFFSET(x) offsetof(PNGEncContext, x)
507 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
508 static const AVOption options
[] = {
509 {"dpi", "Set image resolution (in dots per inch)", OFFSET(dpi
), AV_OPT_TYPE_INT
, {.i64
= 0}, 0, 0x10000, VE
},
510 {"dpm", "Set image resolution (in dots per meter)", OFFSET(dpm
), AV_OPT_TYPE_INT
, {.i64
= 0}, 0, 0x10000, VE
},
514 static const AVClass pngenc_class
= {
515 .class_name
= "PNG encoder",
516 .item_name
= av_default_item_name
,
518 .version
= LIBAVUTIL_VERSION_INT
,
521 AVCodec ff_png_encoder
= {
523 .long_name
= NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
524 .type
= AVMEDIA_TYPE_VIDEO
,
525 .id
= AV_CODEC_ID_PNG
,
526 .priv_data_size
= sizeof(PNGEncContext
),
527 .init
= png_enc_init
,
528 .close
= png_enc_close
,
529 .encode2
= encode_frame
,
530 .capabilities
= CODEC_CAP_FRAME_THREADS
| CODEC_CAP_INTRA_ONLY
,
531 .pix_fmts
= (const enum AVPixelFormat
[]) {
532 AV_PIX_FMT_RGB24
, AV_PIX_FMT_RGBA
,
533 AV_PIX_FMT_RGB48BE
, AV_PIX_FMT_RGBA64BE
,
535 AV_PIX_FMT_GRAY8
, AV_PIX_FMT_GRAY8A
,
537 AV_PIX_FMT_MONOBLACK
, AV_PIX_FMT_NONE
539 .priv_class
= &pngenc_class
,