From c598b569fb3d1f4b6c4868fe64f6989254df5186 Mon Sep 17 00:00:00 2001 From: Vittorio Giovara Date: Fri, 14 Mar 2014 18:32:00 +0100 Subject: png: K&R formatting cosmetics --- libavcodec/pngenc.c | 158 ++++++++++++++++++++++++++++------------------------ 1 file changed, 84 insertions(+), 74 deletions(-) (limited to 'libavcodec/pngenc.c') diff --git a/libavcodec/pngenc.c b/libavcodec/pngenc.c index f58f7158a3..ccc5f7dada 100644 --- a/libavcodec/pngenc.c +++ b/libavcodec/pngenc.c @@ -18,6 +18,7 @@ * 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" @@ -53,11 +54,11 @@ static void png_get_interlaced_row(uint8_t *dst, int row_size, const uint8_t *s; mask = ff_png_pass_mask[pass]; - switch(bits_per_pixel) { + switch (bits_per_pixel) { case 1: memset(dst, 0, row_size); dst_x = 0; - for(x = 0; x < width; x++) { + for (x = 0; x < width; x++) { j = (x & 7); if ((mask << j) & 0x80) { b = (src[x >> 3] >> (7 - j)) & 1; @@ -70,7 +71,7 @@ static void png_get_interlaced_row(uint8_t *dst, int row_size, bpp = bits_per_pixel >> 3; d = dst; s = src; - for(x = 0; x < width; x++) { + for (x = 0; x < width; x++) { j = x & 7; if ((mask << j) & 0x80) { memcpy(d, s, bpp); @@ -82,17 +83,18 @@ 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) +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++) { + 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; + p = b - c; pc = a - c; pa = abs(p); @@ -114,27 +116,27 @@ static void png_filter_row(DSPContext *dsp, uint8_t *dst, int filter_type, { int i; - switch(filter_type) { + 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); + 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++) + 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); + 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++) + 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); + sub_png_paeth_prediction(dst + i, src + i, top + i, size - i, bpp); break; } } @@ -144,26 +146,26 @@ static uint8_t *png_choose_filter(PNGEncContext *s, uint8_t *dst, { int pred = s->filter_type; assert(bpp || !pred); - if(!top && pred) + if (!top && pred) pred = PNG_FILTER_VALUE_SUB; - if(pred == PNG_FILTER_VALUE_MIXED) { + 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); + 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((int8_t)buf1[i]); - if(cost < bcost) { + for (i = 0; i <= size; i++) + cost += abs((int8_t) buf1[i]); + if (cost < bcost) { bcost = cost; - FFSWAP(uint8_t*, buf1, buf2); + FFSWAP(uint8_t *, buf1, buf2); } } return buf2; } else { - png_filter_row(&s->dsp, dst+1, pred, src, top, size, bpp); + png_filter_row(&s->dsp, dst + 1, pred, src, top, size, bpp); dst[0] = pred; return dst; } @@ -176,13 +178,13 @@ static void convert_from_rgb32(uint8_t *dst, const uint8_t *src, int width) unsigned int v; d = dst; - for(j = 0; j < width; j++) { - v = ((const uint32_t *)src)[j]; + for (j = 0; j < width; j++) { + v = ((const uint32_t *) src)[j]; d[0] = v >> 16; d[1] = v >> 8; d[2] = v; d[3] = v >> 24; - d += 4; + d += 4; } } @@ -211,16 +213,17 @@ static int png_write_row(PNGEncContext *s, const uint8_t *data, int size) int ret; s->zstream.avail_in = size; - s->zstream.next_in = (uint8_t *)data; + 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) { - if(s->bytestream_end - s->bytestream > IOBUF_SIZE + 100) - png_write_chunk(&s->bytestream, MKTAG('I', 'D', 'A', 'T'), s->buf, IOBUF_SIZE); + if (s->bytestream_end - s->bytestream > IOBUF_SIZE + 100) + png_write_chunk(&s->bytestream, + MKTAG('I', 'D', 'A', 'T'), s->buf, IOBUF_SIZE); s->zstream.avail_out = IOBUF_SIZE; - s->zstream.next_out = s->buf; + s->zstream.next_out = s->buf; } } return 0; @@ -229,55 +232,55 @@ static int png_write_row(PNGEncContext *s, const uint8_t *data, int size) static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet) { - PNGEncContext *s = avctx->priv_data; - const AVFrame * const p = pict; + PNGEncContext *s = avctx->priv_data; + const AVFrame *const p = pict; int bit_depth, color_type, y, len, row_size, ret, is_progressive; 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 *ptr, *top, *crow_buf, *crow; + uint8_t *crow_base = NULL; uint8_t *progressive_buf = NULL; - uint8_t *rgba_buf = NULL; - uint8_t *top_buf = NULL; + uint8_t *rgba_buf = NULL; + uint8_t *top_buf = NULL; is_progressive = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT); - switch(avctx->pix_fmt) { + switch (avctx->pix_fmt) { case AV_PIX_FMT_RGB32: - bit_depth = 8; + bit_depth = 8; color_type = PNG_COLOR_TYPE_RGB_ALPHA; break; case AV_PIX_FMT_RGB24: - bit_depth = 8; + bit_depth = 8; color_type = PNG_COLOR_TYPE_RGB; break; case AV_PIX_FMT_GRAY16BE: - bit_depth = 16; + bit_depth = 16; color_type = PNG_COLOR_TYPE_GRAY; break; case AV_PIX_FMT_GRAY8: - bit_depth = 8; + bit_depth = 8; color_type = PNG_COLOR_TYPE_GRAY; break; case AV_PIX_FMT_MONOBLACK: - bit_depth = 1; + bit_depth = 1; color_type = PNG_COLOR_TYPE_GRAY; break; case AV_PIX_FMT_PAL8: - bit_depth = 8; + bit_depth = 8; color_type = PNG_COLOR_TYPE_PALETTE; break; default: return -1; } bits_per_pixel = ff_png_get_nb_channels(color_type) * bit_depth; - row_size = (avctx->width * bits_per_pixel + 7) >> 3; + row_size = (avctx->width * bits_per_pixel + 7) >> 3; s->zstream.zalloc = ff_png_zalloc; - s->zstream.zfree = ff_png_zfree; + s->zstream.zfree = ff_png_zfree; s->zstream.opaque = NULL; - compression_level = avctx->compression_level == FF_COMPRESSION_DEFAULT ? - Z_DEFAULT_COMPRESSION : - av_clip(avctx->compression_level, 0, 9); + compression_level = avctx->compression_level == FF_COMPRESSION_DEFAULT + ? Z_DEFAULT_COMPRESSION + : av_clip(avctx->compression_level, 0, 9); ret = deflateInit2(&s->zstream, compression_level, Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY); if (ret != Z_OK) @@ -301,7 +304,8 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, 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 + // pixel data should be aligned, but there's a control byte before it + crow_buf = crow_base + 15; if (is_progressive) { progressive_buf = av_malloc(row_size + 1); if (!progressive_buf) @@ -324,8 +328,8 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, AV_WB32(s->buf, avctx->width); AV_WB32(s->buf + 4, avctx->height); - s->buf[8] = bit_depth; - s->buf[9] = color_type; + 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 */ @@ -339,40 +343,42 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, uint32_t *palette; uint8_t *alpha_ptr; - palette = (uint32_t *)p->data[1]; - ptr = s->buf; + palette = (uint32_t *)p->data[1]; + ptr = s->buf; alpha_ptr = s->buf + 256 * 3; has_alpha = 0; - for(i = 0; i < 256; i++) { - v = palette[i]; + for (i = 0; i < 256; i++) { + v = palette[i]; alpha = v >> 24; if (alpha && alpha != 0xff) has_alpha = 1; *alpha_ptr++ = alpha; bytestream_put_be24(&ptr, v); } - png_write_chunk(&s->bytestream, MKTAG('P', 'L', 'T', 'E'), s->buf, 256 * 3); + png_write_chunk(&s->bytestream, + MKTAG('P', 'L', 'T', 'E'), s->buf, 256 * 3); if (has_alpha) { - png_write_chunk(&s->bytestream, MKTAG('t', 'R', 'N', 'S'), s->buf + 256 * 3, 256); + png_write_chunk(&s->bytestream, + 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; + s->zstream.next_out = s->buf; if (is_progressive) { int pass; - for(pass = 0; pass < NB_PASSES; pass++) { + for (pass = 0; pass < NB_PASSES; pass++) { /* NOTE: a pass is completely omitted if no pixels would be - output */ + * 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++) { + 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); + FFSWAP(uint8_t *, progressive_buf, top_buf); if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) { convert_from_rgb32(rgba_buf, ptr, avctx->width); ptr = rgba_buf; @@ -380,29 +386,30 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, png_get_interlaced_row(progressive_buf, pass_row_size, bits_per_pixel, pass, ptr, avctx->width); - crow = png_choose_filter(s, crow_buf, progressive_buf, top, pass_row_size, bits_per_pixel>>3); + 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++) { + for (y = 0; y < avctx->height; y++) { ptr = p->data[0] + y * p->linesize[0]; if (color_type == PNG_COLOR_TYPE_RGB_ALPHA) { - FFSWAP(uint8_t*, rgba_buf, top_buf); + 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); + 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 */ - for(;;) { + for (;;) { ret = deflate(&s->zstream, Z_FINISH); if (ret == Z_OK || ret == Z_STREAM_END) { len = IOBUF_SIZE - s->zstream.avail_out; @@ -410,7 +417,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, png_write_chunk(&s->bytestream, MKTAG('I', 'D', 'A', 'T'), s->buf, len); } s->zstream.avail_out = IOBUF_SIZE; - s->zstream.next_out = s->buf; + s->zstream.next_out = s->buf; if (ret == Z_STREAM_END) break; } else { @@ -424,19 +431,20 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, *got_packet = 1; ret = 0; - the_end: +the_end: av_free(crow_base); av_free(progressive_buf); av_free(rgba_buf); av_free(top_buf); deflateEnd(&s->zstream); return ret; - fail: +fail: ret = -1; goto the_end; } -static av_cold int png_enc_init(AVCodecContext *avctx){ +static av_cold int png_enc_init(AVCodecContext *avctx) +{ PNGEncContext *s = avctx->priv_data; avctx->coded_frame = av_frame_alloc(); @@ -448,8 +456,10 @@ static av_cold int png_enc_init(AVCodecContext *avctx){ 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 == AV_PIX_FMT_MONOBLACK) + s->filter_type = av_clip(avctx->prediction_method, + PNG_FILTER_VALUE_NONE, + PNG_FILTER_VALUE_MIXED); + if (avctx->pix_fmt == AV_PIX_FMT_MONOBLACK) s->filter_type = PNG_FILTER_VALUE_NONE; return 0; @@ -470,7 +480,7 @@ AVCodec ff_png_encoder = { .init = png_enc_init, .close = png_enc_close, .encode2 = encode_frame, - .pix_fmts = (const enum AVPixelFormat[]){ + .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_RGB24, AV_PIX_FMT_RGB32, AV_PIX_FMT_PAL8, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_MONOBLACK, AV_PIX_FMT_NONE -- cgit v1.2.3