/* * PNG image format * Copyright (c) 2003 Fabrice Bellard. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */#include "avformat.h"/* TODO: * - add 2, 4 and 16 bit depth support * - use filters when generating a png (better compression) */#ifdef CONFIG_ZLIB#include <zlib.h>//#define DEBUG#define PNG_COLOR_MASK_PALETTE    1#define PNG_COLOR_MASK_COLOR      2#define PNG_COLOR_MASK_ALPHA      4#define PNG_COLOR_TYPE_GRAY 0#define PNG_COLOR_TYPE_PALETTE  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)#define PNG_COLOR_TYPE_RGB        (PNG_COLOR_MASK_COLOR)#define PNG_COLOR_TYPE_RGB_ALPHA  (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_ALPHA)#define PNG_COLOR_TYPE_GRAY_ALPHA (PNG_COLOR_MASK_ALPHA)#define PNG_FILTER_VALUE_NONE  0#define PNG_FILTER_VALUE_SUB   1#define PNG_FILTER_VALUE_UP    2#define PNG_FILTER_VALUE_AVG   3#define PNG_FILTER_VALUE_PAETH 4#define PNG_IHDR      0x0001#define PNG_IDAT      0x0002#define PNG_ALLIMAGE  0x0004#define PNG_PLTE      0x0008#define NB_PASSES 7#define IOBUF_SIZE 4096typedef struct PNGDecodeState {    int state;    int width, height;    int bit_depth;    int color_type;    int compression_type;    int interlace_type;    int filter_type;    int channels;    int bits_per_pixel;    int bpp;        uint8_t *image_buf;    int image_linesize;    uint32_t palette[256];    uint8_t *crow_buf;    uint8_t *last_row;    uint8_t *tmp_row;    int pass;    int crow_size; /* compressed row size (include filter type) */    int row_size; /* decompressed row size */    int pass_row_size; /* decompress row size of the current pass */    int y;    z_stream zstream;} PNGDecodeState;static const uint8_t pngsig[8] = {137, 80, 78, 71, 13, 10, 26, 10};/* Mask to determine which y pixels are valid in a pass */static const uint8_t png_pass_ymask[NB_PASSES] = {    0x80, 0x80, 0x08, 0x88, 0x22, 0xaa, 0x55,};/* Mask to determine which y pixels can be written in a pass */static const uint8_t png_pass_dsp_ymask[NB_PASSES] = {    0xff, 0xff, 0x0f, 0xcc, 0x33, 0xff, 0x55,};/* minimum x value */static const uint8_t png_pass_xmin[NB_PASSES] = {    0, 4, 0, 2, 0, 1, 0};/* x shift to get row width */static const uint8_t png_pass_xshift[NB_PASSES] = {    3, 3, 2, 2, 1, 1, 0};/* Mask to determine which pixels are valid in a pass */static const uint8_t png_pass_mask[NB_PASSES] = {    0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};/* Mask to determine which pixels to overwrite while displaying */static const uint8_t png_pass_dsp_mask[NB_PASSES] = {     0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff};static int png_probe(AVProbeData *pd){    if (pd->buf_size >= 8 &&        memcmp(pd->buf, pngsig, 8) == 0)        return AVPROBE_SCORE_MAX;    else        return 0;}static void *png_zalloc(void *opaque, unsigned int items, unsigned int size){    return av_malloc(items * size);}static void png_zfree(void *opaque, void *ptr){    av_free(ptr);}static int png_get_nb_channels(int color_type){    int channels;    channels = 1;    if ((color_type & (PNG_COLOR_MASK_COLOR | PNG_COLOR_MASK_PALETTE)) ==        PNG_COLOR_MASK_COLOR)        channels = 3;    if (color_type & PNG_COLOR_MASK_ALPHA)        channels++;    return channels;}/* compute the row size of an interleaved pass */static int png_pass_row_size(int pass, int bits_per_pixel, int width){    int shift, xmin, pass_width;    xmin = png_pass_xmin[pass];    if (width <= xmin)        return 0;    shift = png_pass_xshift[pass];    pass_width = (width - xmin + (1 << shift) - 1) >> shift;    return (pass_width * bits_per_pixel + 7) >> 3;}/* NOTE: we try to construct a good looking image at each pass. width   is the original image width. We also do pixel format convertion at   this stage */static void png_put_interlaced_row(uint8_t *dst, int width,                                    int bits_per_pixel, int pass,                                    int color_type, const uint8_t *src){    int x, mask, dsp_mask, j, src_x, b, bpp;    uint8_t *d;    const uint8_t *s;        mask = png_pass_mask[pass];    dsp_mask = png_pass_dsp_mask[pass];    switch(bits_per_pixel) {    case 1:        /* we must intialize the line to zero before writing to it */        if (pass == 0)            memset(dst, 0, (width + 7) >> 3);        src_x = 0;        for(x = 0; x < width; x++) {            j = (x & 7);            if ((dsp_mask << j) & 0x80) {                b = (src[src_x >> 3] >> (7 - (src_x & 7))) & 1;                dst[x >> 3] |= b << (7 - j);            }            if ((mask << j) & 0x80)                src_x++;        }        break;    default:        bpp = bits_per_pixel >> 3;        d = dst;        s = src;        if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {            for(x = 0; x < width; x++) {                j = x & 7;                if ((dsp_mask << j) & 0x80) {                    *(uint32_t *)d = (s[3] << 24) | (s[0] << 16) | (s[1] << 8) | s[2];                }                d += bpp;                if ((mask << j) & 0x80)                    s += bpp;            }        } else {            for(x = 0; x < width; x++) {                j = x & 7;                if ((dsp_mask << j) & 0x80) {                    memcpy(d, s, bpp);                }                d += bpp;                if ((mask << j) & 0x80)                    s += bpp;            }        }        break;    }}static void png_get_interlaced_row(uint8_t *dst, int row_size,                                    int bits_per_pixel, int pass,                                    const uint8_t *src, int width){    int x, mask, dst_x, j, b, bpp;    uint8_t *d;    const uint8_t *s;    mask = png_pass_mask[pass];    switch(bits_per_pixel) {    case 1:        memset(dst, 0, row_size);        dst_x = 0;        for(x = 0; x < width; x++) {            j = (x & 7);            if ((mask << j) & 0x80) {                b = (src[x >> 3] >> (7 - j)) & 1;                dst[dst_x >> 3] |= b << (7 - (dst_x & 7));                dst_x++;            }        }        break;    default:        bpp = bits_per_pixel >> 3;        d = dst;        s = src;        for(x = 0; x < width; x++) {            j = x & 7;            if ((mask << j) & 0x80) {                memcpy(d, s, bpp);                d += bpp;            }            s += bpp;        }        break;    }}/* XXX: optimize *//* NOTE: 'dst' can be equal to 'last' */static void png_filter_row(uint8_t *dst, int filter_type,                            uint8_t *src, uint8_t *last, int size, int bpp){    int i, p;    switch(filter_type) {    case PNG_FILTER_VALUE_NONE:        memcpy(dst, src, size);        break;    case PNG_FILTER_VALUE_SUB:        for(i = 0; i < bpp; i++) {            dst[i] = src[i];        }        for(i = bpp; i < size; i++) {            p = dst[i - bpp];            dst[i] = p + src[i];        }        break;    case PNG_FILTER_VALUE_UP:        for(i = 0; i < size; i++) {            p = last[i];            dst[i] = p + src[i];        }        break;    case PNG_FILTER_VALUE_AVG:        for(i = 0; i < bpp; i++) {            p = (last[i] >> 1);            dst[i] = p + src[i];        }        for(i = bpp; i < size; i++) {            p = ((dst[i - bpp] + last[i]) >> 1);            dst[i] = p + src[i];        }        break;    case PNG_FILTER_VALUE_PAETH:        for(i = 0; i < bpp; i++) {            p = last[i];            dst[i] = p + src[i];        }        for(i = bpp; i < size; i++) {            int a, b, c, pa, pb, pc;            a = dst[i - bpp];            b = last[i];            c = last[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] = p + src[i];        }        break;    }}static void convert_from_rgba32(uint8_t *dst, const uint8_t *src, int width){    uint8_t *d;    int j;    unsigned int v;        d = dst;    for(j = 0; j < width; j++) {        v = ((uint32_t *)src)[j];        d[0] = v >> 16;        d[1] = v >> 8;        d[2] = v;        d[3] = v >> 24;        d += 4;    }}static void convert_to_rgba32(uint8_t *dst, const uint8_t *src, int width){    int j;    unsigned int r, g, b, a;    for(j = 0;j < width; j++) {        r = src[0];        g = src[1];        b = src[2];        a = src[3];        *(uint32_t *)dst = (a << 24) | (r << 16) | (g << 8) | b;        dst += 4;        src += 4;    }}/* process exactly one decompressed row */static void png_handle_row(PNGDecodeState *s){    uint8_t *ptr, *last_row;    int got_line;        if (!s->interlace_type) {        ptr = s->image_buf + s->image_linesize * s->y;        /* need to swap bytes correctly for RGB_ALPHA */        if (s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {            png_filter_row(s->tmp_row, s->crow_buf[0], s->crow_buf + 1,                            s->last_row, s->row_size, s->bpp);            memcpy(s->last_row, s->tmp_row, s->row_size);            convert_to_rgba32(ptr, s->tmp_row, s->width);        } else {            /* in normal case, we avoid one copy */            if (s->y == 0)                last_row = s->last_row;            else                last_row = ptr - s->image_linesize;                        png_filter_row(ptr, s->crow_buf[0], s->crow_buf + 1,                            last_row, s->row_size, s->bpp);        }        s->y++;        if (s->y == s->height) {            s->state |= PNG_ALLIMAGE;        }    } else {        got_line = 0;        for(;;) {            ptr = s->image_buf + s->image_linesize * s->y;            if ((png_pass_ymask[s->pass] << (s->y & 7)) & 0x80) {                /* if we already read one row, it is time to stop to                   wait for the next one */                if (got_line)                    break;                png_filter_row(s->tmp_row, s->crow_buf[0], s->crow_buf + 1,                                s->last_row, s->pass_row_size, s->bpp);                memcpy(s->last_row, s->tmp_row, s->pass_row_size);                got_line = 1;            }            if ((png_pass_dsp_ymask[s->pass] << (s->y & 7)) & 0x80) {                /* NOTE: rgba32 is handled directly in png_put_interlaced_row */                png_put_interlaced_row(ptr, s->width, s->bits_per_pixel, s->pass,                                        s->color_type, s->last_row);            }            s->y++;            if (s->y == s->height) {                for(;;) {                    if (s->pass == NB_PASSES - 1) {                        s->state |= PNG_ALLIMAGE;                        goto the_end;                    } else {                        s->pass++;                        s->y = 0;                        s->pass_row_size = png_pass_row_size(s->pass,                                                              s->bits_per_pixel,                                                              s->width);                        s->crow_size = s->pass_row_size + 1;                        if (s->pass_row_size != 0)                            break;                        /* skip pass if empty row */                    }                }            }        }    the_end: ;    }}static int png_decode_idat(PNGDecodeState *s, ByteIOContext *f, int length){    uint8_t buf[IOBUF_SIZE];    int buf_size;    int ret;    while (length > 0) {        /* read the buffer */        buf_size = IOBUF_SIZE;        if (buf_size > length)            buf_size = length;        ret = get_buffer(f, buf, buf_size);        if (ret != buf_size)            return -1;        s->zstream.avail_in = buf_size;        s->zstream.next_in = buf;        /* decode one line if possible */        while (s->zstream.avail_in > 0) {            ret = inflate(&s->zstream, Z_PARTIAL_FLUSH);            if (ret != Z_OK && ret != Z_STREAM_END) {                return -1;