}            if (s->zstream.avail_out == 0) {                if (!(s->state & PNG_ALLIMAGE)) {                    png_handle_row(s);                }                s->zstream.avail_out = s->crow_size;                s->zstream.next_out = s->crow_buf;            }        }        length -= buf_size;    }    return 0;}static int png_read(ByteIOContext *f,                     int (*alloc_cb)(void *opaque, AVImageInfo *info), void *opaque){    AVImageInfo info1, *info = &info1;    PNGDecodeState s1, *s = &s1;    uint32_t tag, length;    int ret, crc;    uint8_t buf[8];    /* check signature */    ret = get_buffer(f, buf, 8);    if (ret != 8)        return -1;    if (memcmp(buf, pngsig, 8) != 0)        return -1;    memset(s, 0, sizeof(PNGDecodeState));    /* init the zlib */    s->zstream.zalloc = png_zalloc;    s->zstream.zfree = png_zfree;    s->zstream.opaque = NULL;    ret = inflateInit(&s->zstream);    if (ret != Z_OK)        return -1;    for(;;) {        if (url_feof(f))            goto fail;        length = get_be32(f);        if (length > 0x7fffffff)            goto fail;        tag = get_le32(f);#ifdef DEBUG        printf("png: tag=%c%c%c%c length=%u\n",                (tag & 0xff),               ((tag >> 8) & 0xff),               ((tag >> 16) & 0xff),               ((tag >> 24) & 0xff), length);#endif        switch(tag) {        case MKTAG('I', 'H', 'D', 'R'):            if (length != 13)                goto fail;            s->width = get_be32(f);            s->height = get_be32(f);            s->bit_depth = get_byte(f);            s->color_type = get_byte(f);            s->compression_type = get_byte(f);            s->filter_type = get_byte(f);            s->interlace_type = get_byte(f);            crc = get_be32(f);            s->state |= PNG_IHDR;#ifdef DEBUG            printf("width=%d height=%d depth=%d color_type=%d compression_type=%d filter_type=%d interlace_type=%d\n",                    s->width, s->height, s->bit_depth, s->color_type,                    s->compression_type, s->filter_type, s->interlace_type);#endif            break;        case MKTAG('I', 'D', 'A', 'T'):            if (!(s->state & PNG_IHDR))                goto fail;            if (!(s->state & PNG_IDAT)) {                /* init image info */                info->width = s->width;                info->height = s->height;                info->interleaved = (s->interlace_type != 0);                s->channels = png_get_nb_channels(s->color_type);                s->bits_per_pixel = s->bit_depth * s->channels;                s->bpp = (s->bits_per_pixel + 7) >> 3;                s->row_size = (info->width * s->bits_per_pixel + 7) >> 3;                if (s->bit_depth == 8 &&                     s->color_type == PNG_COLOR_TYPE_RGB) {                    info->pix_fmt = PIX_FMT_RGB24;                } else if (s->bit_depth == 8 &&                            s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {                    info->pix_fmt = PIX_FMT_RGBA32;                } else if (s->bit_depth == 8 &&                            s->color_type == PNG_COLOR_TYPE_GRAY) {                    info->pix_fmt = PIX_FMT_GRAY8;                } else if (s->bit_depth == 1 &&                            s->color_type == PNG_COLOR_TYPE_GRAY) {                    info->pix_fmt = PIX_FMT_MONOBLACK;                } else if (s->color_type == PNG_COLOR_TYPE_PALETTE) {                    info->pix_fmt = PIX_FMT_PAL8;                } else {                    goto fail;                }                ret = alloc_cb(opaque, info);                if (ret)                     goto the_end;                /* compute the compressed row size */                if (!s->interlace_type) {                    s->crow_size = s->row_size + 1;                } else {                    s->pass = 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;                }#ifdef DEBUG                printf("row_size=%d crow_size =%d\n",                        s->row_size, s->crow_size);#endif                s->image_buf = info->pict.data[0];                s->image_linesize = info->pict.linesize[0];                /* copy the palette if needed */                if (s->color_type == PNG_COLOR_TYPE_PALETTE)                    memcpy(info->pict.data[1], s->palette, 256 * sizeof(uint32_t));                /* empty row is used if differencing to the first row */                s->last_row = av_mallocz(s->row_size);                if (!s->last_row)                    goto fail;                if (s->interlace_type ||                    s->color_type == PNG_COLOR_TYPE_RGB_ALPHA) {                    s->tmp_row = av_malloc(s->row_size);                    if (!s->tmp_row)                        goto fail;                }                /* compressed row */                s->crow_buf = av_malloc(s->row_size + 1);                if (!s->crow_buf)                    goto fail;                s->zstream.avail_out = s->crow_size;                s->zstream.next_out = s->crow_buf;            }            s->state |= PNG_IDAT;            if (png_decode_idat(s, f, length) < 0)                goto fail;            /* skip crc */            crc = get_be32(f);            break;        case MKTAG('P', 'L', 'T', 'E'):            {                int n, i, r, g, b;                                if ((length % 3) != 0 || length > 256 * 3)                    goto skip_tag;                /* read the palette */                n = length / 3;                for(i=0;i<n;i++) {                    r = get_byte(f);                    g = get_byte(f);                    b = get_byte(f);                    s->palette[i] = (0xff << 24) | (r << 16) | (g << 8) | b;                }                for(;i<256;i++) {                    s->palette[i] = (0xff << 24);                }                s->state |= PNG_PLTE;                crc = get_be32(f);            }            break;        case MKTAG('t', 'R', 'N', 'S'):            {                int v, i;                /* read the transparency. XXX: Only palette mode supported */                if (s->color_type != PNG_COLOR_TYPE_PALETTE ||                    length > 256 ||                    !(s->state & PNG_PLTE))                    goto skip_tag;                for(i=0;i<length;i++) {                    v = get_byte(f);                    s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);                }                crc = get_be32(f);            }            break;        case MKTAG('I', 'E', 'N', 'D'):            if (!(s->state & PNG_ALLIMAGE))                goto fail;            crc = get_be32(f);            goto exit_loop;        default:            /* skip tag */        skip_tag:            url_fskip(f, length + 4);            break;        }    } exit_loop:    ret = 0; the_end:    inflateEnd(&s->zstream);    av_free(s->crow_buf);    av_free(s->last_row);    av_free(s->tmp_row);    return ret; fail:    ret = -1;    goto the_end;}static void png_write_chunk(ByteIOContext *f, uint32_t tag,                            const uint8_t *buf, int length){    uint32_t crc;    uint8_t tagbuf[4];    put_be32(f, length);    crc = crc32(0, Z_NULL, 0);    tagbuf[0] = tag;    tagbuf[1] = tag >> 8;    tagbuf[2] = tag >> 16;    tagbuf[3] = tag >> 24;    crc = crc32(crc, tagbuf, 4);    put_le32(f, tag);    if (length > 0) {        crc = crc32(crc, buf, length);        put_buffer(f, buf, length);    }    put_be32(f, crc);}/* XXX: use avcodec generic function ? */static void to_be32(uint8_t *p, uint32_t v){    p[0] = v >> 24;    p[1] = v >> 16;    p[2] = v >> 8;    p[3] = v;}typedef struct PNGEncodeState {    ByteIOContext *f;    z_stream zstream;    uint8_t buf[IOBUF_SIZE];} PNGEncodeState;/* XXX: do filtering */static int png_write_row(PNGEncodeState *s, const uint8_t *data, int size){    int ret;    s->zstream.avail_in = size;    s->zstream.next_in = (uint8_t *)data;    while (s->zstream.avail_in > 0) {        ret = deflate(&s->zstream, Z_NO_FLUSH);        if (ret != Z_OK)            return -1;        if (s->zstream.avail_out == 0) {            png_write_chunk(s->f, MKTAG('I', 'D', 'A', 'T'), s->buf, IOBUF_SIZE);            s->zstream.avail_out = IOBUF_SIZE;            s->zstream.next_out = s->buf;        }    }    return 0;}static int png_write(ByteIOContext *f, AVImageInfo *info){    PNGEncodeState s1, *s = &s1;    int bit_depth, color_type, y, len, row_size, ret, is_progressive;    int bits_per_pixel, pass_row_size;    uint8_t *ptr;    uint8_t *crow_buf = NULL;    uint8_t *tmp_buf = NULL;        s->f = f;    is_progressive = info->interleaved;    switch(info->pix_fmt) {    case PIX_FMT_RGBA32:        bit_depth = 8;        color_type = PNG_COLOR_TYPE_RGB_ALPHA;        break;    case PIX_FMT_RGB24:        bit_depth = 8;        color_type = PNG_COLOR_TYPE_RGB;        break;    case PIX_FMT_GRAY8:        bit_depth = 8;        color_type = PNG_COLOR_TYPE_GRAY;        break;    case PIX_FMT_MONOBLACK:        bit_depth = 1;        color_type = PNG_COLOR_TYPE_GRAY;        break;    case PIX_FMT_PAL8:        bit_depth = 8;        color_type = PNG_COLOR_TYPE_PALETTE;        break;    default:        return -1;    }    bits_per_pixel = png_get_nb_channels(color_type) * bit_depth;    row_size = (info->width * bits_per_pixel + 7) >> 3;    s->zstream.zalloc = png_zalloc;    s->zstream.zfree = png_zfree;    s->zstream.opaque = NULL;    ret = deflateInit2(&s->zstream, Z_DEFAULT_COMPRESSION,                       Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY);    if (ret != Z_OK)        return -1;    crow_buf = av_malloc(row_size + 1);    if (!crow_buf)        goto fail;    if (is_progressive) {        tmp_buf = av_malloc(row_size + 1);        if (!tmp_buf)            goto fail;    }    /* write png header */    put_buffer(f, pngsig, 8);        to_be32(s->buf, info->width);    to_be32(s->buf + 4, info->height);    s->buf[8] = bit_depth;    s->buf[9] = color_type;    s->buf[10] = 0; /* compression type */    s->buf[11] = 0; /* filter type */    s->buf[12] = is_progressive; /* interlace type */        png_write_chunk(f, MKTAG('I', 'H', 'D', 'R'), s->buf, 13);    /* put the palette if needed */    if (color_type == PNG_COLOR_TYPE_PALETTE) {        int has_alpha, alpha, i;        unsigned int v;        uint32_t *palette;        uint8_t *alpha_ptr;                palette = (uint32_t *)info->pict.data[1];        ptr = s->buf;        alpha_ptr = s->buf + 256 * 3;        has_alpha = 0;        for(i = 0; i < 256; i++) {            v = palette[i];            alpha = v >> 24;            if (alpha != 0xff)                has_alpha = 1;            *alpha_ptr++ = alpha;            ptr[0] = v >> 16;            ptr[1] = v >> 8;            ptr[2] = v;            ptr += 3;        }        png_write_chunk(f, MKTAG('P', 'L', 'T', 'E'), s->buf, 256 * 3);        if (has_alpha) {            png_write_chunk(f, MKTAG('t', 'R', 'N', 'S'), s->buf + 256 * 3, 256);        }    }    /* now put each row */    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++) {            /* NOTE: a pass is completely omited if no pixels would be               output */            pass_row_size = png_pass_row_size(pass, bits_per_pixel, info->width);            if (pass_row_size > 0) {                for(y = 0; y < info->height; y++) {                    if ((png_pass_ymask[pass] << (y & 7)) & 0x80) {                        ptr = info->pict.data[0] + y * info->pict.linesize[0];                        if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) {                            convert_from_rgba32(tmp_buf, ptr, info->width);                            ptr1 = tmp_buf;                        } else {                            ptr1 = ptr;                        }                        png_get_interlaced_row(crow_buf + 1, pass_row_size,                                                bits_per_pixel, pass,                                                ptr1, info->width);                        crow_buf[0] = PNG_FILTER_VALUE_NONE;                        png_write_row(s, crow_buf, pass_row_size + 1);                    }                }            }        }    } else {        for(y = 0; y < info->height; y++) {            ptr = info->pict.data[0] + y * info->pict.linesize[0];            if (color_type == PNG_COLOR_TYPE_RGB_ALPHA)                convert_from_rgba32(crow_buf + 1, ptr, info->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);        }    }    /* compress last bytes */    for(;;) {        ret = deflate(&s->zstream, Z_FINISH);        if (ret == Z_OK || ret == Z_STREAM_END) {            len = IOBUF_SIZE - s->zstream.avail_out;            if (len > 0) {                png_write_chunk(f, MKTAG('I', 'D', 'A', 'T'), s->buf, len);            }            s->zstream.avail_out = IOBUF_SIZE;            s->zstream.next_out = s->buf;            if (ret == Z_STREAM_END)                break;        } else {            goto fail;        }    }    png_write_chunk(f, MKTAG('I', 'E', 'N', 'D'), NULL, 0);    put_flush_packet(f);    ret = 0; the_end:    av_free(crow_buf);    av_free(tmp_buf);    deflateEnd(&s->zstream);    return ret; fail:    ret = -1;    goto the_end;}AVImageFormat png_image_format = {    "png",    "png",    png_probe,    png_read,    (1 << PIX_FMT_RGBA32) | (1 << PIX_FMT_RGB24) | (1 << PIX_FMT_GRAY8) |     (1 << PIX_FMT_MONOBLACK) | (1 << PIX_FMT_PAL8),    png_write,    AVIMAGE_INTERLEAVED,};#endif