/*
* PNG image format
- * Copyright (c) 2003 Fabrice Bellard.
+ * Copyright (c) 2003 Fabrice Bellard
*
- * This file is part of FFmpeg.
+ * This file is part of Libav.
*
- * FFmpeg is free software; you can redistribute it and/or
+ * Libav 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.1 of the License, or (at your option) any later version.
*
- * FFmpeg is distributed in the hope that it will be useful,
+ * Libav 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 FFmpeg; if not, write to the Free Software
+ * License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "avcodec.h"
#include "bytestream.h"
+#include "dsputil.h"
#include "png.h"
-#include <dsputil.h>
/* TODO:
* - add 2, 4 and 16 bit depth support
buf1[0] = pred;
cost = 0;
for(i=0; i<=size; i++)
- cost += abs(0x80 - (buf1[i] ^ 0x80));
+ cost += abs((int8_t)buf1[i]);
if(cost < bcost) {
bcost = cost;
FFSWAP(uint8_t*, buf1, buf2);
crc = crc32(0, Z_NULL, 0);
AV_WL32(tagbuf, tag);
crc = crc32(crc, tagbuf, 4);
- bytestream_put_be32(f, bswap_32(tag));
+ bytestream_put_be32(f, av_bswap32(tag));
if (length > 0) {
crc = crc32(crc, buf, length);
memcpy(*f, buf, length);
return 0;
}
-static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
+static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
+ const AVFrame *pict, int *got_packet)
+{
PNGEncContext *s = avctx->priv_data;
- AVFrame *pict = data;
- AVFrame * const p= (AVFrame*)&s->picture;
+ AVFrame * const p= &s->picture;
int bit_depth, color_type, y, len, row_size, ret, is_progressive;
- int bits_per_pixel, pass_row_size;
+ int bits_per_pixel, pass_row_size, enc_row_size, max_packet_size;
int compression_level;
uint8_t *ptr, *top;
uint8_t *crow_base = NULL, *crow_buf, *crow;
uint8_t *top_buf = NULL;
*p = *pict;
- p->pict_type= FF_I_TYPE;
+ p->pict_type= AV_PICTURE_TYPE_I;
p->key_frame= 1;
- s->bytestream_start=
- s->bytestream= buf;
- s->bytestream_end= buf+buf_size;
-
is_progressive = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
switch(avctx->pix_fmt) {
- case PIX_FMT_RGB32:
+ case AV_PIX_FMT_RGB32:
bit_depth = 8;
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
break;
- case PIX_FMT_RGB24:
+ case AV_PIX_FMT_RGB24:
bit_depth = 8;
color_type = PNG_COLOR_TYPE_RGB;
break;
- case PIX_FMT_GRAY8:
+ case AV_PIX_FMT_GRAY8:
bit_depth = 8;
color_type = PNG_COLOR_TYPE_GRAY;
break;
- case PIX_FMT_MONOBLACK:
+ case AV_PIX_FMT_MONOBLACK:
bit_depth = 1;
color_type = PNG_COLOR_TYPE_GRAY;
break;
- case PIX_FMT_PAL8:
+ case AV_PIX_FMT_PAL8:
bit_depth = 8;
color_type = PNG_COLOR_TYPE_PALETTE;
break;
Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY);
if (ret != Z_OK)
return -1;
+
+ enc_row_size = deflateBound(&s->zstream, row_size);
+ max_packet_size = avctx->height * (enc_row_size +
+ ((enc_row_size + IOBUF_SIZE - 1) / IOBUF_SIZE) * 12)
+ + FF_MIN_BUFFER_SIZE;
+ if (!pkt->data &&
+ (ret = av_new_packet(pkt, max_packet_size)) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Could not allocate output packet of size %d.\n",
+ max_packet_size);
+ return ret;
+ }
+
+ s->bytestream_start =
+ s->bytestream = pkt->data;
+ s->bytestream_end = pkt->data + pkt->size;
+
crow_base = av_malloc((row_size + 32) << (s->filter_type == PNG_FILTER_VALUE_MIXED));
if (!crow_base)
goto fail;
int pass;
for(pass = 0; pass < NB_PASSES; pass++) {
- /* NOTE: a pass is completely omited if no pixels would be
+ /* NOTE: a pass is completely omitted if no pixels would be
output */
pass_row_size = ff_png_pass_row_size(pass, bits_per_pixel, avctx->width);
if (pass_row_size > 0) {
}
png_write_chunk(&s->bytestream, MKTAG('I', 'E', 'N', 'D'), NULL, 0);
- ret = s->bytestream - s->bytestream_start;
+ pkt->size = s->bytestream - s->bytestream_start;
+ pkt->flags |= AV_PKT_FLAG_KEY;
+ *got_packet = 1;
+ ret = 0;
+
the_end:
av_free(crow_base);
av_free(progressive_buf);
goto the_end;
}
-static int png_enc_init(AVCodecContext *avctx){
+static av_cold int png_enc_init(AVCodecContext *avctx){
PNGEncContext *s = avctx->priv_data;
- avcodec_get_frame_defaults((AVFrame*)&s->picture);
- avctx->coded_frame= (AVFrame*)&s->picture;
- dsputil_init(&s->dsp, avctx);
+ avcodec_get_frame_defaults(&s->picture);
+ avctx->coded_frame= &s->picture;
+ ff_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)
+ if(avctx->pix_fmt == AV_PIX_FMT_MONOBLACK)
s->filter_type = PNG_FILTER_VALUE_NONE;
return 0;
}
-AVCodec png_encoder = {
- "png",
- CODEC_TYPE_VIDEO,
- CODEC_ID_PNG,
- sizeof(PNGEncContext),
- png_enc_init,
- encode_frame,
- NULL, //encode_end,
- .pix_fmts= (enum PixelFormat[]){PIX_FMT_RGB24, PIX_FMT_RGB32, PIX_FMT_PAL8, PIX_FMT_GRAY8, PIX_FMT_MONOBLACK, -1},
+AVCodec ff_png_encoder = {
+ .name = "png",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_PNG,
+ .priv_data_size = sizeof(PNGEncContext),
+ .init = png_enc_init,
+ .encode2 = encode_frame,
+ .pix_fmts = (const enum AVPixelFormat[]){
+ AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_PAL8, AV_PIX_FMT_GRAY8,
+ AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE
+ },
+ .long_name = NULL_IF_CONFIG_SMALL("PNG (Portable Network Graphics) image"),
};
projects / ffmpeg / blobdiff