diff --git a/libavcodec/png.h b/libavcodec/png.h index e6fced7f37..3043471194 100644 --- a/libavcodec/png.h +++ b/libavcodec/png.h @@ -39,6 +39,7 @@ #define PNG_FILTER_VALUE_UP 2 #define PNG_FILTER_VALUE_AVG 3 #define PNG_FILTER_VALUE_PAETH 4 +#define PNG_FILTER_VALUE_MIXED 5 #define PNG_IHDR 0x0001 #define PNG_IDAT 0x0002 diff --git a/libavcodec/pngenc.c b/libavcodec/pngenc.c index 0dd5d37a1a..10ed5afad0 100644 --- a/libavcodec/pngenc.c +++ b/libavcodec/pngenc.c @@ -21,10 +21,10 @@ #include "avcodec.h" #include "bytestream.h" #include "png.h" +#include /* TODO: * - add 2, 4 and 16 bit depth support - * - use filters when generating a png (better compression) */ #include @@ -34,11 +34,15 @@ #define IOBUF_SIZE 4096 typedef struct PNGEncContext { + DSPContext dsp; + uint8_t *bytestream; uint8_t *bytestream_start; uint8_t *bytestream_end; AVFrame picture; + int filter_type; + z_stream zstream; uint8_t buf[IOBUF_SIZE]; } PNGEncContext; @@ -81,6 +85,93 @@ static void png_get_interlaced_row(uint8_t *dst, int row_size, } } +static void sub_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp) +{ + int i; + for(i = 0; i < w; i++) { + int a, b, c, p, pa, pb, pc; + + a = src[i - bpp]; + b = top[i]; + c = top[i - bpp]; + + p = b - c; + pc = a - c; + + pa = abs(p); + pb = abs(pc); + pc = abs(p + pc); + + if (pa <= pb && pa <= pc) + p = a; + else if (pb <= pc) + p = b; + else + p = c; + dst[i] = src[i] - p; + } +} + +static void png_filter_row(DSPContext *dsp, uint8_t *dst, int filter_type, + uint8_t *src, uint8_t *top, int size, int bpp) +{ + int i; + + switch(filter_type) { + case PNG_FILTER_VALUE_NONE: + memcpy(dst, src, size); + break; + case PNG_FILTER_VALUE_SUB: + dsp->diff_bytes(dst, src, src-bpp, size); + memcpy(dst, src, bpp); + break; + case PNG_FILTER_VALUE_UP: + dsp->diff_bytes(dst, src, top, size); + break; + case PNG_FILTER_VALUE_AVG: + for(i = 0; i < bpp; i++) + dst[i] = src[i] - (top[i] >> 1); + for(; i < size; i++) + dst[i] = src[i] - ((src[i-bpp] + top[i]) >> 1); + break; + case PNG_FILTER_VALUE_PAETH: + for(i = 0; i < bpp; i++) + dst[i] = src[i] - top[i]; + sub_png_paeth_prediction(dst+i, src+i, top+i, size-i, bpp); + break; + } +} + +static uint8_t *png_choose_filter(PNGEncContext *s, uint8_t *dst, + uint8_t *src, uint8_t *top, int size, int bpp) +{ + int pred = s->filter_type; + assert(bpp || !pred); + if(!top && pred) + pred = PNG_FILTER_VALUE_SUB; + if(pred == PNG_FILTER_VALUE_MIXED) { + int i; + int cost, bcost = INT_MAX; + uint8_t *buf1 = dst, *buf2 = dst + size + 16; + for(pred=0; pred<5; pred++) { + png_filter_row(&s->dsp, buf1+1, pred, src, top, size, bpp); + buf1[0] = pred; + cost = 0; + for(i=0; i<=size; i++) + cost += abs(0x80 - (buf1[i] ^ 0x80)); + if(cost < bcost) { + bcost = cost; + FFSWAP(uint8_t*, buf1, buf2); + } + } + return buf2; + } else { + png_filter_row(&s->dsp, dst+1, pred, src, top, size, bpp); + dst[0] = pred; + return dst; + } +} + static void convert_from_rgb32(uint8_t *dst, const uint8_t *src, int width) { uint8_t *d; @@ -145,9 +236,11 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, int bit_depth, color_type, y, len, row_size, ret, is_progressive; int bits_per_pixel, pass_row_size; int compression_level; - uint8_t *ptr; - uint8_t *crow_buf = NULL; - uint8_t *tmp_buf = NULL; + uint8_t *ptr, *top; + uint8_t *crow_base = NULL, *crow_buf, *crow; + uint8_t *progressive_buf = NULL; + uint8_t *rgba_buf = NULL; + uint8_t *top_buf = NULL; *p = *pict; p->pict_type= FF_I_TYPE; @@ -195,12 +288,23 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY); if (ret != Z_OK) return -1; - crow_buf = av_malloc(row_size + 1); - if (!crow_buf) + crow_base = av_malloc((row_size + 32) << (s->filter_type == PNG_FILTER_VALUE_MIXED)); + if (!crow_base) goto fail; + crow_buf = crow_base + 15; // pixel data should be aligned, but there's a control byte before it if (is_progressive) { - tmp_buf = av_malloc(row_size + 1); - if (!tmp_buf) + progressive_buf = av_malloc(row_size + 1); + if (!progressive_buf) + goto fail; + } + if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) { + rgba_buf = av_malloc(row_size + 1); + if (!rgba_buf) + goto fail; + } + if (is_progressive || color_type == PNG_COLOR_TYPE_RGB_ALPHA) { + top_buf = av_malloc(row_size + 1); + if (!top_buf) goto fail; } @@ -247,7 +351,6 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, s->zstream.avail_out = IOBUF_SIZE; s->zstream.next_out = s->buf; if (is_progressive) { - uint8_t *ptr1; int pass; for(pass = 0; pass < NB_PASSES; pass++) { @@ -255,33 +358,37 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, output */ pass_row_size = ff_png_pass_row_size(pass, bits_per_pixel, avctx->width); if (pass_row_size > 0) { + top = NULL; for(y = 0; y < avctx->height; y++) { if ((ff_png_pass_ymask[pass] << (y & 7)) & 0x80) { ptr = p->data[0] + y * p->linesize[0]; + FFSWAP(uint8_t*, progressive_buf, top_buf); if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) { - convert_from_rgb32(tmp_buf, ptr, avctx->width); - ptr1 = tmp_buf; - } else { - ptr1 = ptr; + convert_from_rgb32(rgba_buf, ptr, avctx->width); + ptr = rgba_buf; } - png_get_interlaced_row(crow_buf + 1, pass_row_size, + png_get_interlaced_row(progressive_buf, pass_row_size, bits_per_pixel, pass, - ptr1, avctx->width); - crow_buf[0] = PNG_FILTER_VALUE_NONE; - png_write_row(s, crow_buf, pass_row_size + 1); + ptr, avctx->width); + crow = png_choose_filter(s, crow_buf, progressive_buf, top, pass_row_size, bits_per_pixel>>3); + png_write_row(s, crow, pass_row_size + 1); + top = progressive_buf; } } } } } else { + top = NULL; for(y = 0; y < avctx->height; y++) { ptr = p->data[0] + y * p->linesize[0]; - if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) - convert_from_rgb32(crow_buf + 1, ptr, avctx->width); - else - memcpy(crow_buf + 1, ptr, row_size); - crow_buf[0] = PNG_FILTER_VALUE_NONE; - png_write_row(s, crow_buf, row_size + 1); + if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) { + FFSWAP(uint8_t*, rgba_buf, top_buf); + convert_from_rgb32(rgba_buf, ptr, avctx->width); + ptr = rgba_buf; + } + crow = png_choose_filter(s, crow_buf, ptr, top, row_size, bits_per_pixel>>3); + png_write_row(s, crow, row_size + 1); + top = ptr; } } /* compress last bytes */ @@ -304,8 +411,10 @@ static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, ret = s->bytestream - s->bytestream_start; the_end: - av_free(crow_buf); - av_free(tmp_buf); + av_free(crow_base); + av_free(progressive_buf); + av_free(rgba_buf); + av_free(top_buf); deflateEnd(&s->zstream); return ret; fail: @@ -318,6 +427,11 @@ static int png_enc_init(AVCodecContext *avctx){ avcodec_get_frame_defaults((AVFrame*)&s->picture); avctx->coded_frame= (AVFrame*)&s->picture; + dsputil_init(&s->dsp, avctx); + + s->filter_type = av_clip(avctx->prediction_method, PNG_FILTER_VALUE_NONE, PNG_FILTER_VALUE_MIXED); + if(avctx->pix_fmt == PIX_FMT_MONOBLACK) + s->filter_type = PNG_FILTER_VALUE_NONE; return 0; }