Merge commit '801c39e1e3058fc4ba822bfb5d8612d777111e32'
[ffmpeg.git] / libavcodec / pngenc.c
1 /*
2  * PNG image format
3  * Copyright (c) 2003 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 #include "avcodec.h"
23 #include "internal.h"
24 #include "bytestream.h"
25 #include "dsputil.h"
26 #include "png.h"
27
28 #include "libavutil/avassert.h"
29 #include "libavutil/opt.h"
30
31 #include <zlib.h>
32
33 #define IOBUF_SIZE 4096
34
35 typedef struct PNGEncContext {
36     AVClass *class;
37     DSPContext dsp;
38
39     uint8_t *bytestream;
40     uint8_t *bytestream_start;
41     uint8_t *bytestream_end;
42
43     int filter_type;
44
45     z_stream zstream;
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
49 } PNGEncContext;
50
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)
54 {
55     int x, mask, dst_x, j, b, bpp;
56     uint8_t *d;
57     const uint8_t *s;
58     static const int masks[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
59
60     mask = masks[pass];
61     switch (bits_per_pixel) {
62     case 1:
63         memset(dst, 0, row_size);
64         dst_x = 0;
65         for (x = 0; x < width; x++) {
66             j = (x & 7);
67             if ((mask << j) & 0x80) {
68                 b = (src[x >> 3] >> (7 - j)) & 1;
69                 dst[dst_x >> 3] |= b << (7 - (dst_x & 7));
70                 dst_x++;
71             }
72         }
73         break;
74     default:
75         bpp = bits_per_pixel >> 3;
76         d = dst;
77         s = src;
78         for (x = 0; x < width; x++) {
79             j = x & 7;
80             if ((mask << j) & 0x80) {
81                 memcpy(d, s, bpp);
82                 d += bpp;
83             }
84             s += bpp;
85         }
86         break;
87     }
88 }
89
90 static void sub_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top,
91                                      int w, int bpp)
92 {
93     int i;
94     for (i = 0; i < w; i++) {
95         int a, b, c, p, pa, pb, pc;
96
97         a = src[i - bpp];
98         b = top[i];
99         c = top[i - bpp];
100
101         p  = b - c;
102         pc = a - c;
103
104         pa = abs(p);
105         pb = abs(pc);
106         pc = abs(p + pc);
107
108         if (pa <= pb && pa <= pc)
109             p = a;
110         else if (pb <= pc)
111             p = b;
112         else
113             p = c;
114         dst[i] = src[i] - p;
115     }
116 }
117
118 static void sub_left_prediction(DSPContext *dsp, uint8_t *dst, const uint8_t *src, int bpp, int size)
119 {
120     const uint8_t *src1 = src + bpp;
121     const uint8_t *src2 = src;
122     int x, unaligned_w;
123
124     memcpy(dst, src, bpp);
125     dst += bpp;
126     size -= bpp;
127     unaligned_w = FFMIN(32 - bpp, size);
128     for (x = 0; x < unaligned_w; x++)
129         *dst++ = *src1++ - *src2++;
130     size -= unaligned_w;
131     dsp->diff_bytes(dst, src1, src2, size);
132 }
133
134 static void png_filter_row(DSPContext *dsp, uint8_t *dst, int filter_type,
135                            uint8_t *src, uint8_t *top, int size, int bpp)
136 {
137     int i;
138
139     switch (filter_type) {
140     case PNG_FILTER_VALUE_NONE:
141         memcpy(dst, src, size);
142         break;
143     case PNG_FILTER_VALUE_SUB:
144         sub_left_prediction(dsp, dst, src, bpp, size);
145         break;
146     case PNG_FILTER_VALUE_UP:
147         dsp->diff_bytes(dst, src, top, size);
148         break;
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);
154         break;
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);
159         break;
160     }
161 }
162
163 static uint8_t *png_choose_filter(PNGEncContext *s, uint8_t *dst,
164                                   uint8_t *src, uint8_t *top, int size, int bpp)
165 {
166     int pred = s->filter_type;
167     av_assert0(bpp || !pred);
168     if (!top && pred)
169         pred = PNG_FILTER_VALUE_SUB;
170     if (pred == PNG_FILTER_VALUE_MIXED) {
171         int i;
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->dsp, buf1 + 1, pred, src, top, size, bpp);
176             buf1[0] = pred;
177             cost = 0;
178             for (i = 0; i <= size; i++)
179                 cost += abs((int8_t) buf1[i]);
180             if (cost < bcost) {
181                 bcost = cost;
182                 FFSWAP(uint8_t *, buf1, buf2);
183             }
184         }
185         return buf2;
186     } else {
187         png_filter_row(&s->dsp, dst + 1, pred, src, top, size, bpp);
188         dst[0] = pred;
189         return dst;
190     }
191 }
192
193 static void png_write_chunk(uint8_t **f, uint32_t tag,
194                             const uint8_t *buf, int length)
195 {
196     uint32_t crc;
197     uint8_t tagbuf[4];
198
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));
204     if (length > 0) {
205         crc = crc32(crc, buf, length);
206         memcpy(*f, buf, length);
207         *f += length;
208     }
209     bytestream_put_be32(f, crc);
210 }
211
212 /* XXX: do filtering */
213 static int png_write_row(PNGEncContext *s, const uint8_t *data, int size)
214 {
215     int ret;
216
217     s->zstream.avail_in = size;
218     s->zstream.next_in  = (uint8_t *)data;
219     while (s->zstream.avail_in > 0) {
220         ret = deflate(&s->zstream, Z_NO_FLUSH);
221         if (ret != Z_OK)
222             return -1;
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;
229         }
230     }
231     return 0;
232 }
233
234 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
235                         const AVFrame *pict, int *got_packet)
236 {
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;
247
248     is_progressive = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
249     switch (avctx->pix_fmt) {
250     case AV_PIX_FMT_RGBA64BE:
251         bit_depth = 16;
252         color_type = PNG_COLOR_TYPE_RGB_ALPHA;
253         break;
254     case AV_PIX_FMT_RGB48BE:
255         bit_depth = 16;
256         color_type = PNG_COLOR_TYPE_RGB;
257         break;
258     case AV_PIX_FMT_RGBA:
259         bit_depth  = 8;
260         color_type = PNG_COLOR_TYPE_RGB_ALPHA;
261         break;
262     case AV_PIX_FMT_RGB24:
263         bit_depth  = 8;
264         color_type = PNG_COLOR_TYPE_RGB;
265         break;
266     case AV_PIX_FMT_GRAY16BE:
267         bit_depth  = 16;
268         color_type = PNG_COLOR_TYPE_GRAY;
269         break;
270     case AV_PIX_FMT_GRAY8:
271         bit_depth  = 8;
272         color_type = PNG_COLOR_TYPE_GRAY;
273         break;
274     case AV_PIX_FMT_GRAY8A:
275         bit_depth = 8;
276         color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
277         break;
278     case AV_PIX_FMT_MONOBLACK:
279         bit_depth  = 1;
280         color_type = PNG_COLOR_TYPE_GRAY;
281         break;
282     case AV_PIX_FMT_PAL8:
283         bit_depth  = 8;
284         color_type = PNG_COLOR_TYPE_PALETTE;
285         break;
286     default:
287         return -1;
288     }
289     bits_per_pixel = ff_png_get_nb_channels(color_type) * bit_depth;
290     row_size       = (avctx->width * bits_per_pixel + 7) >> 3;
291
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);
300     if (ret != Z_OK)
301         return -1;
302
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)
310         return ret;
311
312     s->bytestream_start =
313     s->bytestream       = pkt->data;
314     s->bytestream_end   = pkt->data + pkt->size;
315
316     crow_base = av_malloc((row_size + 32) << (s->filter_type == PNG_FILTER_VALUE_MIXED));
317     if (!crow_base)
318         goto fail;
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)
324             goto fail;
325     }
326     if (is_progressive) {
327         top_buf = av_malloc(row_size + 1);
328         if (!top_buf)
329             goto fail;
330     }
331
332     /* write png header */
333     AV_WB64(s->bytestream, PNGSIG);
334     s->bytestream += 8;
335
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 */
343
344     png_write_chunk(&s->bytestream, MKTAG('I', 'H', 'D', 'R'), s->buf, 13);
345
346     if (s->dpm) {
347       AV_WB32(s->buf, s->dpm);
348       AV_WB32(s->buf + 4, s->dpm);
349       s->buf[8] = 1; /* unit specifier is meter */
350     } else {
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 */
354     }
355     png_write_chunk(&s->bytestream, MKTAG('p', 'H', 'Y', 's'), s->buf, 9);
356
357     /* put the palette if needed */
358     if (color_type == PNG_COLOR_TYPE_PALETTE) {
359         int has_alpha, alpha, i;
360         unsigned int v;
361         uint32_t *palette;
362         uint8_t *alpha_ptr;
363
364         palette   = (uint32_t *)p->data[1];
365         ptr       = s->buf;
366         alpha_ptr = s->buf + 256 * 3;
367         has_alpha = 0;
368         for (i = 0; i < 256; i++) {
369             v     = palette[i];
370             alpha = v >> 24;
371             if (alpha != 0xff)
372                 has_alpha = 1;
373             *alpha_ptr++ = alpha;
374             bytestream_put_be24(&ptr, v);
375         }
376         png_write_chunk(&s->bytestream,
377                         MKTAG('P', 'L', 'T', 'E'), s->buf, 256 * 3);
378         if (has_alpha) {
379             png_write_chunk(&s->bytestream,
380                             MKTAG('t', 'R', 'N', 'S'), s->buf + 256 * 3, 256);
381         }
382     }
383
384     /* now put each row */
385     s->zstream.avail_out = IOBUF_SIZE;
386     s->zstream.next_out  = s->buf;
387     if (is_progressive) {
388         int pass;
389
390         for (pass = 0; pass < NB_PASSES; pass++) {
391             /* NOTE: a pass is completely omitted if no pixels would be
392              * output */
393             pass_row_size = ff_png_pass_row_size(pass, bits_per_pixel, avctx->width);
394             if (pass_row_size > 0) {
395                 top = NULL;
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,
402                                                ptr, avctx->width);
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;
407                     }
408             }
409         }
410     } else {
411         top = NULL;
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);
417             top = ptr;
418         }
419     }
420     /* compress last bytes */
421     for (;;) {
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);
427             }
428             s->zstream.avail_out = IOBUF_SIZE;
429             s->zstream.next_out  = s->buf;
430             if (ret == Z_STREAM_END)
431                 break;
432         } else {
433             goto fail;
434         }
435     }
436     png_write_chunk(&s->bytestream, MKTAG('I', 'E', 'N', 'D'), NULL, 0);
437
438     pkt->size   = s->bytestream - s->bytestream_start;
439     pkt->flags |= AV_PKT_FLAG_KEY;
440     *got_packet = 1;
441     ret         = 0;
442
443 the_end:
444     av_free(crow_base);
445     av_free(progressive_buf);
446     av_free(top_buf);
447     deflateEnd(&s->zstream);
448     return ret;
449 fail:
450     ret = -1;
451     goto the_end;
452 }
453
454 static av_cold int png_enc_init(AVCodecContext *avctx)
455 {
456     PNGEncContext *s = avctx->priv_data;
457
458     switch (avctx->pix_fmt) {
459     case AV_PIX_FMT_RGBA:
460         avctx->bits_per_coded_sample = 32;
461         break;
462     case AV_PIX_FMT_RGB24:
463         avctx->bits_per_coded_sample = 24;
464         break;
465     case AV_PIX_FMT_GRAY8:
466         avctx->bits_per_coded_sample = 0x28;
467         break;
468     case AV_PIX_FMT_MONOBLACK:
469         avctx->bits_per_coded_sample = 1;
470         break;
471     case AV_PIX_FMT_PAL8:
472         avctx->bits_per_coded_sample = 8;
473     }
474
475     avctx->coded_frame = av_frame_alloc();
476     if (!avctx->coded_frame)
477         return AVERROR(ENOMEM);
478
479     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
480     avctx->coded_frame->key_frame = 1;
481
482     ff_dsputil_init(&s->dsp, avctx);
483
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;
489
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);
493     } else if (s->dpi) {
494       s->dpm = s->dpi * 10000 / 254;
495     }
496
497     return 0;
498 }
499
500 static av_cold int png_enc_close(AVCodecContext *avctx)
501 {
502     av_frame_free(&avctx->coded_frame);
503     return 0;
504 }
505
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},
511     { NULL }
512 };
513
514 static const AVClass pngenc_class = {
515     .class_name = "PNG encoder",
516     .item_name  = av_default_item_name,
517     .option     = options,
518     .version    = LIBAVUTIL_VERSION_INT,
519 };
520
521 AVCodec ff_png_encoder = {
522     .name           = "png",
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,
534         AV_PIX_FMT_PAL8,
535         AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,
536         AV_PIX_FMT_GRAY16BE,
537         AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE
538     },
539     .priv_class     = &pngenc_class,
540 };