Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge commit 'c598b569fb3d1f4b6c4868fe64f6989254df5186'

Browse Source 
* commit 'c598b569fb3d1f4b6c4868fe64f6989254df5186':
  png: K&R formatting cosmetics

Conflicts:
	libavcodec/png.c
	libavcodec/pngdec.c
	libavcodec/pngenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
pull/293/head
Michael Niedermayer 11 years ago
parent b361a0bf1f c598b569fb
commit a00d4c5956
4 changed files with 183 additions and 166 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      libavcodec/png.c
  2. 186
      libavcodec/pngdec.c
  3. 9
      libavcodec/pngdsp.c
  4. 152
      libavcodec/pngenc.c

2
libavcodec/png.c
Unescape View File

@ -66,7 +66,7 @@ int ff_png_pass_row_size(int pass, int bits_per_pixel, int width)
xmin = ff_png_pass_xmin[pass]; xmin = ff_png_pass_xmin[pass];
if (width <= xmin) if (width <= xmin)
return 0; return 0;
shift = ff_png_pass_xshift[pass]; shift = ff_png_pass_xshift[pass];
pass_width = (width - xmin + (1 << shift) - 1) >> shift; pass_width = (width - xmin + (1 << shift) - 1) >> shift;
return (pass_width * bits_per_pixel + 7) >> 3; return (pass_width * bits_per_pixel + 7) >> 3;
} }

186
libavcodec/pngdec.c
Unescape View File

@ -85,8 +85,8 @@ static const uint8_t png_pass_dsp_mask[NB_PASSES] = {
}; };
/* NOTE: we try to construct a good looking image at each pass. width /* NOTE: we try to construct a good looking image at each pass. width
is the original image width. We also do pixel format conversion at * is the original image width. We also do pixel format conversion at
this stage */ * this stage */
static void png_put_interlaced_row(uint8_t *dst, int width, static void png_put_interlaced_row(uint8_t *dst, int width,
int bits_per_pixel, int pass, int bits_per_pixel, int pass,
int color_type, const uint8_t *src) int color_type, const uint8_t *src)
@ -157,7 +157,8 @@ static void png_put_interlaced_row(uint8_t *dst, int width,
} }
} }
void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp) void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top,
int w, int bpp)
{ {
int i; int i;
for (i = 0; i < w; i++) { for (i = 0; i < w; i++) {
@ -184,29 +185,35 @@ void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top, int w
} }
} }
#define UNROLL1(bpp, op) {\ #define UNROLL1(bpp, op) { \
r = dst[0];\ r = dst[0]; \
if(bpp >= 2) g = dst[1];\ if (bpp >= 2) \
if(bpp >= 3) b = dst[2];\ g = dst[1]; \
if(bpp >= 4) a = dst[3];\ if (bpp >= 3) \
for(; i <= size - bpp; i+=bpp) {\ b = dst[2]; \
dst[i+0] = r = op(r, src[i+0], last[i+0]);\ if (bpp >= 4) \
if(bpp == 1) continue;\ a = dst[3]; \
dst[i+1] = g = op(g, src[i+1], last[i+1]);\ for (; i <= size - bpp; i += bpp) { \
if(bpp == 2) continue;\ dst[i + 0] = r = op(r, src[i + 0], last[i + 0]); \
dst[i+2] = b = op(b, src[i+2], last[i+2]);\ if (bpp == 1) \
if(bpp == 3) continue;\ continue; \
dst[i+3] = a = op(a, src[i+3], last[i+3]);\ dst[i + 1] = g = op(g, src[i + 1], last[i + 1]); \
}\ if (bpp == 2) \
continue; \
dst[i + 2] = b = op(b, src[i + 2], last[i + 2]); \
if (bpp == 3) \
continue; \
dst[i + 3] = a = op(a, src[i + 3], last[i + 3]); \
} \
} }
#define UNROLL_FILTER(op)\ #define UNROLL_FILTER(op)\
if(bpp == 1) UNROLL1(1, op)\ if (bpp == 1) UNROLL1(1, op)\
else if(bpp == 2) UNROLL1(2, op)\ else if (bpp == 2) UNROLL1(2, op)\
else if(bpp == 3) UNROLL1(3, op)\ else if (bpp == 3) UNROLL1(3, op)\
else if(bpp == 4) UNROLL1(4, op)\ else if (bpp == 4) UNROLL1(4, op)\
for (; i < size; i++) {\ for (; i < size; i++) {\
dst[i] = op(dst[i-bpp], src[i], last[i]);\ dst[i] = op(dst[i - bpp], src[i], last[i]);\
}\ }\
/* NOTE: 'dst' can be equal to 'last' */ /* NOTE: 'dst' can be equal to 'last' */
@ -220,18 +227,17 @@ static void png_filter_row(PNGDSPContext *dsp, uint8_t *dst, int filter_type,
memcpy(dst, src, size); memcpy(dst, src, size);
break; break;
case PNG_FILTER_VALUE_SUB: case PNG_FILTER_VALUE_SUB:
for (i = 0; i < bpp; i++) { for (i = 0; i < bpp; i++)
dst[i] = src[i]; dst[i] = src[i];
}
if (bpp == 4) { if (bpp == 4) {
p = *(int*)dst; p = *(int *)dst;
for (; i < size; i += bpp) { for (; i < size; i += bpp) {
unsigned s = *(int*)(src + i); unsigned s = *(int *)(src + i);
p = ((s & 0x7f7f7f7f) + (p & 0x7f7f7f7f)) ^ ((s ^ p) & 0x80808080); p = ((s & 0x7f7f7f7f) + (p & 0x7f7f7f7f)) ^ ((s ^ p) & 0x80808080);
*(int*)(dst + i) = p; *(int *)(dst + i) = p;
} }
} else { } else {
#define OP_SUB(x,s,l) x+s #define OP_SUB(x, s, l) x + s
UNROLL_FILTER(OP_SUB); UNROLL_FILTER(OP_SUB);
} }
break; break;
@ -240,19 +246,20 @@ static void png_filter_row(PNGDSPContext *dsp, uint8_t *dst, int filter_type,
break; break;
case PNG_FILTER_VALUE_AVG: case PNG_FILTER_VALUE_AVG:
for (i = 0; i < bpp; i++) { for (i = 0; i < bpp; i++) {
p = (last[i] >> 1); p = (last[i] >> 1);
dst[i] = p + src[i]; dst[i] = p + src[i];
} }
#define OP_AVG(x,s,l) (((x + l) >> 1) + s) & 0xff #define OP_AVG(x, s, l) (((x + l) >> 1) + s) & 0xff
UNROLL_FILTER(OP_AVG); UNROLL_FILTER(OP_AVG);
break; break;
case PNG_FILTER_VALUE_PAETH: case PNG_FILTER_VALUE_PAETH:
for (i = 0; i < bpp; i++) { for (i = 0; i < bpp; i++) {
p = last[i]; p = last[i];
dst[i] = p + src[i]; dst[i] = p + src[i];
} }
if (bpp > 2 && size > 4) { if (bpp > 2 && size > 4) {
// would write off the end of the array if we let it process the last pixel with bpp=3 /* would write off the end of the array if we let it process
* the last pixel with bpp=3 */
int w = bpp == 4 ? size : size - 3; int w = bpp == 4 ? size : size - 3;
dsp->add_paeth_prediction(dst + i, src + i, last + i, w - i, bpp); dsp->add_paeth_prediction(dst + i, src + i, last + i, w - i, bpp);
i = w; i = w;
@ -269,9 +276,9 @@ static void deloco_ ## NAME(TYPE *dst, int size, int alpha) \
{ \ { \
int i; \ int i; \
for (i = 0; i < size; i += 3 + alpha) { \ for (i = 0; i < size; i += 3 + alpha) { \
int g = dst [i+1]; \ int g = dst [i + 1]; \
dst[i+0] += g; \ dst[i + 0] += g; \
dst[i+2] += g; \ dst[i + 2] += g; \
} \ } \
} }
@ -322,12 +329,12 @@ static void png_handle_row(PNGDecContext *s)
ptr = s->image_buf + s->image_linesize * s->y; ptr = s->image_buf + s->image_linesize * s->y;
if ((ff_png_pass_ymask[s->pass] << (s->y & 7)) & 0x80) { if ((ff_png_pass_ymask[s->pass] << (s->y & 7)) & 0x80) {
/* if we already read one row, it is time to stop to /* if we already read one row, it is time to stop to
wait for the next one */ * wait for the next one */
if (got_line) if (got_line)
break; break;
png_filter_row(&s->dsp, s->tmp_row, s->crow_buf[0], s->crow_buf + 1, png_filter_row(&s->dsp, s->tmp_row, s->crow_buf[0], s->crow_buf + 1,
s->last_row, s->pass_row_size, s->bpp); s->last_row, s->pass_row_size, s->bpp);
FFSWAP(uint8_t*, s->last_row, s->tmp_row); FFSWAP(uint8_t *, s->last_row, s->tmp_row);
FFSWAP(unsigned int, s->last_row_size, s->tmp_row_size); FFSWAP(unsigned int, s->last_row_size, s->tmp_row_size);
got_line = 1; got_line = 1;
} }
@ -346,8 +353,8 @@ static void png_handle_row(PNGDecContext *s)
s->pass++; s->pass++;
s->y = 0; s->y = 0;
s->pass_row_size = ff_png_pass_row_size(s->pass, s->pass_row_size = ff_png_pass_row_size(s->pass,
s->bits_per_pixel, s->bits_per_pixel,
s->width); s->width);
s->crow_size = s->pass_row_size + 1; s->crow_size = s->pass_row_size + 1;
if (s->pass_row_size != 0) if (s->pass_row_size != 0)
break; break;
@ -356,7 +363,7 @@ static void png_handle_row(PNGDecContext *s)
} }
} }
} }
the_end: ; the_end:;
} }
} }
@ -382,7 +389,8 @@ static int png_decode_idat(PNGDecContext *s, int length)
s->zstream.next_out = s->crow_buf; s->zstream.next_out = s->crow_buf;
} }
if (ret == Z_STREAM_END && s->zstream.avail_in > 0) { if (ret == Z_STREAM_END && s->zstream.avail_in > 0) {
av_log(NULL, AV_LOG_WARNING, "%d undecompressed bytes left in buffer\n", s->zstream.avail_in); av_log(NULL, AV_LOG_WARNING,
"%d undecompressed bytes left in buffer\n", s->zstream.avail_in);
return 0; return 0;
} }
} }
@ -509,9 +517,9 @@ static int decode_frame(AVCodecContext *avctx,
void *data, int *got_frame, void *data, int *got_frame,
AVPacket *avpkt) AVPacket *avpkt)
{ {
PNGDecContext * const s = avctx->priv_data; PNGDecContext *const s = avctx->priv_data;
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
AVFrame *p; AVFrame *p;
AVDictionary *metadata = NULL; AVDictionary *metadata = NULL;
uint32_t tag, length; uint32_t tag, length;
@ -584,7 +592,7 @@ static int decode_frame(AVCodecContext *avctx,
s->state |= PNG_IHDR; s->state |= PNG_IHDR;
if (avctx->debug & FF_DEBUG_PICT_INFO) if (avctx->debug & FF_DEBUG_PICT_INFO)
av_log(avctx, AV_LOG_DEBUG, "width=%d height=%d depth=%d color_type=%d " av_log(avctx, AV_LOG_DEBUG, "width=%d height=%d depth=%d color_type=%d "
"compression_type=%d filter_type=%d interlace_type=%d\n", "compression_type=%d filter_type=%d interlace_type=%d\n",
s->width, s->height, s->bit_depth, s->color_type, s->width, s->height, s->bit_depth, s->color_type,
s->compression_type, s->filter_type, s->interlace_type); s->compression_type, s->filter_type, s->interlace_type);
break; break;
@ -660,10 +668,10 @@ static int decode_frame(AVCodecContext *avctx,
if (!s->interlace_type) { if (!s->interlace_type) {
s->crow_size = s->row_size + 1; s->crow_size = s->row_size + 1;
} else { } else {
s->pass = 0; s->pass = 0;
s->pass_row_size = ff_png_pass_row_size(s->pass, s->pass_row_size = ff_png_pass_row_size(s->pass,
s->bits_per_pixel, s->bits_per_pixel,
s->width); s->width);
s->crow_size = s->pass_row_size + 1; s->crow_size = s->pass_row_size + 1;
} }
av_dlog(avctx, "row_size=%d crow_size =%d\n", av_dlog(avctx, "row_size=%d crow_size =%d\n",
@ -699,42 +707,41 @@ static int decode_frame(AVCodecContext *avctx,
bytestream2_skip(&s->gb, 4); /* crc */ bytestream2_skip(&s->gb, 4); /* crc */
break; break;
case MKTAG('P', 'L', 'T', 'E'): case MKTAG('P', 'L', 'T', 'E'):
{ {
int n, i, r, g, b; int n, i, r, g, b;
if ((length % 3) != 0 || length > 256 * 3) if ((length % 3) != 0 || length > 256 * 3)
goto skip_tag; goto skip_tag;
/* read the palette */ /* read the palette */
n = length / 3; n = length / 3;
for (i = 0; i < n; i++) { for (i = 0; i < n; i++) {
r = bytestream2_get_byte(&s->gb); r = bytestream2_get_byte(&s->gb);
g = bytestream2_get_byte(&s->gb); g = bytestream2_get_byte(&s->gb);
b = bytestream2_get_byte(&s->gb); b = bytestream2_get_byte(&s->gb);
s->palette[i] = (0xFFU << 24) | (r << 16) | (g << 8) | b; s->palette[i] = (0xFFU << 24) | (r << 16) | (g << 8) | b;
}
for (; i < 256; i++) {
s->palette[i] = (0xFFU << 24);
}
s->state |= PNG_PLTE;
bytestream2_skip(&s->gb, 4); /* crc */
} }
break; for (; i < 256; i++)
s->palette[i] = (0xFFU << 24);
s->state |= PNG_PLTE;
bytestream2_skip(&s->gb, 4); /* crc */
}
break;
case MKTAG('t', 'R', 'N', 'S'): case MKTAG('t', 'R', 'N', 'S'):
{ {
int v, i; int v, i;
/* read the transparency. XXX: Only palette mode supported */ /* read the transparency. XXX: Only palette mode supported */
if (s->color_type != PNG_COLOR_TYPE_PALETTE || if (s->color_type != PNG_COLOR_TYPE_PALETTE ||
length > 256 || length > 256 ||
!(s->state & PNG_PLTE)) !(s->state & PNG_PLTE))
goto skip_tag; goto skip_tag;
for (i = 0; i < length; i++) { for (i = 0; i < length; i++) {
v = bytestream2_get_byte(&s->gb); v = bytestream2_get_byte(&s->gb);
s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24); s->palette[i] = (s->palette[i] & 0x00ffffff) | (v << 24);
}
bytestream2_skip(&s->gb, 4); /* crc */
} }
break; bytestream2_skip(&s->gb, 4); /* crc */
}
break;
case MKTAG('t', 'E', 'X', 't'): case MKTAG('t', 'E', 'X', 't'):
if (decode_text_chunk(s, length, 0, &metadata) < 0) if (decode_text_chunk(s, length, 0, &metadata) < 0)
av_log(avctx, AV_LOG_WARNING, "Broken tEXt chunk\n"); av_log(avctx, AV_LOG_WARNING, "Broken tEXt chunk\n");
@ -755,12 +762,12 @@ static int decode_frame(AVCodecContext *avctx,
goto exit_loop; goto exit_loop;
default: default:
/* skip tag */ /* skip tag */
skip_tag: skip_tag:
bytestream2_skip(&s->gb, length + 4); bytestream2_skip(&s->gb, length + 4);
break; break;
} }
} }
exit_loop: exit_loop:
if (s->bits_per_pixel == 1 && s->color_type == PNG_COLOR_TYPE_PALETTE){ if (s->bits_per_pixel == 1 && s->color_type == PNG_COLOR_TYPE_PALETTE){
int i, j, k; int i, j, k;
@ -834,9 +841,9 @@ static int decode_frame(AVCodecContext *avctx,
} }
} }
/* handle p-frames only if a predecessor frame is available */ /* handle p-frames only if a predecessor frame is available */
if (s->last_picture.f->data[0]) { if (s->last_picture.f->data[0]) {
if ( !(avpkt->flags & AV_PKT_FLAG_KEY) && avctx->codec_tag != AV_RL32("MPNG") if ( !(avpkt->flags & AV_PKT_FLAG_KEY) && avctx->codec_tag != AV_RL32("MPNG")
&& s->last_picture.f->width == p->width && s->last_picture.f->width == p->width
&& s->last_picture.f->height== p->height && s->last_picture.f->height== p->height
&& s->last_picture.f->format== p->format && s->last_picture.f->format== p->format
@ -847,9 +854,8 @@ static int decode_frame(AVCodecContext *avctx,
ff_thread_await_progress(&s->last_picture, INT_MAX, 0); ff_thread_await_progress(&s->last_picture, INT_MAX, 0);
for (j = 0; j < s->height; j++) { for (j = 0; j < s->height; j++) {
for (i = 0; i < s->width * s->bpp; i++) { for (i = 0; i < s->width * s->bpp; i++)
pd[i] += pd_last[i]; pd[i] += pd_last[i];
}
pd += s->image_linesize; pd += s->image_linesize;
pd_last += s->image_linesize; pd_last += s->image_linesize;
} }
@ -866,11 +872,11 @@ static int decode_frame(AVCodecContext *avctx,
*got_frame = 1; *got_frame = 1;
ret = bytestream2_tell(&s->gb); ret = bytestream2_tell(&s->gb);
the_end: the_end:
inflateEnd(&s->zstream); inflateEnd(&s->zstream);
s->crow_buf = NULL; s->crow_buf = NULL;
return ret; return ret;
fail: fail:
av_dict_free(&metadata); av_dict_free(&metadata);
ff_thread_report_progress(&s->picture, INT_MAX, 0); ff_thread_report_progress(&s->picture, INT_MAX, 0);
ret = AVERROR_INVALIDDATA; ret = AVERROR_INVALIDDATA;

9
libavcodec/pngdsp.c
Unescape View File

@ -25,13 +25,13 @@
#include "pngdsp.h" #include "pngdsp.h"
// 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size // 0x7f7f7f7f or 0x7f7f7f7f7f7f7f7f or whatever, depending on the cpu's native arithmetic size
#define pb_7f (~0UL/255 * 0x7f) #define pb_7f (~0UL / 255 * 0x7f)
#define pb_80 (~0UL/255 * 0x80) #define pb_80 (~0UL / 255 * 0x80)
static void add_bytes_l2_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w) static void add_bytes_l2_c(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w)
{ {
long i; long i;
for (i = 0; i <= w - (int)sizeof(long); i += sizeof(long)) { for (i = 0; i <= w - (int) sizeof(long); i += sizeof(long)) {
long a = *(long *)(src1 + i); long a = *(long *)(src1 + i);
long b = *(long *)(src2 + i); long b = *(long *)(src2 + i);
*(long *)(dst + i) = ((a & pb_7f) + (b & pb_7f)) ^ ((a ^ b) & pb_80); *(long *)(dst + i) = ((a & pb_7f) + (b & pb_7f)) ^ ((a ^ b) & pb_80);
@ -45,5 +45,6 @@ av_cold void ff_pngdsp_init(PNGDSPContext *dsp)
dsp->add_bytes_l2 = add_bytes_l2_c; dsp->add_bytes_l2 = add_bytes_l2_c;
dsp->add_paeth_prediction = ff_add_png_paeth_prediction; dsp->add_paeth_prediction = ff_add_png_paeth_prediction;
if (ARCH_X86) ff_pngdsp_init_x86(dsp); if (ARCH_X86)
ff_pngdsp_init_x86(dsp);
} }

152
libavcodec/pngenc.c
Unescape View File

@ -18,6 +18,7 @@
* License along with FFmpeg; if not, write to the Free Software * License along with FFmpeg; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/ */
#include "avcodec.h" #include "avcodec.h"
#include "internal.h" #include "internal.h"
#include "bytestream.h" #include "bytestream.h"
@ -57,11 +58,11 @@ static void png_get_interlaced_row(uint8_t *dst, int row_size,
static const int masks[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff}; static const int masks[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
mask = masks[pass]; mask = masks[pass];
switch(bits_per_pixel) { switch (bits_per_pixel) {
case 1: case 1:
memset(dst, 0, row_size); memset(dst, 0, row_size);
dst_x = 0; dst_x = 0;
for(x = 0; x < width; x++) { for (x = 0; x < width; x++) {
j = (x & 7); j = (x & 7);
if ((mask << j) & 0x80) { if ((mask << j) & 0x80) {
b = (src[x >> 3] >> (7 - j)) & 1; b = (src[x >> 3] >> (7 - j)) & 1;
@ -74,7 +75,7 @@ static void png_get_interlaced_row(uint8_t *dst, int row_size,
bpp = bits_per_pixel >> 3; bpp = bits_per_pixel >> 3;
d = dst; d = dst;
s = src; s = src;
for(x = 0; x < width; x++) { for (x = 0; x < width; x++) {
j = x & 7; j = x & 7;
if ((mask << j) & 0x80) { if ((mask << j) & 0x80) {
memcpy(d, s, bpp); memcpy(d, s, bpp);
@ -86,17 +87,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; int i;
for(i = 0; i < w; i++) { for (i = 0; i < w; i++) {
int a, b, c, p, pa, pb, pc; int a, b, c, p, pa, pb, pc;
a = src[i - bpp]; a = src[i - bpp];
b = top[i]; b = top[i];
c = top[i - bpp]; c = top[i - bpp];
p = b - c; p = b - c;
pc = a - c; pc = a - c;
pa = abs(p); pa = abs(p);
@ -134,7 +136,7 @@ static void png_filter_row(DSPContext *dsp, uint8_t *dst, int filter_type,
{ {
int i; int i;
switch(filter_type) { switch (filter_type) {
case PNG_FILTER_VALUE_NONE: case PNG_FILTER_VALUE_NONE:
memcpy(dst, src, size); memcpy(dst, src, size);
break; break;
@ -145,15 +147,15 @@ static void png_filter_row(DSPContext *dsp, uint8_t *dst, int filter_type,
dsp->diff_bytes(dst, src, top, size); dsp->diff_bytes(dst, src, top, size);
break; break;
case PNG_FILTER_VALUE_AVG: case PNG_FILTER_VALUE_AVG:
for(i = 0; i < bpp; i++) for (i = 0; i < bpp; i++)
dst[i] = src[i] - (top[i] >> 1); dst[i] = src[i] - (top[i] >> 1);
for(; i < size; i++) for (; i < size; i++)
dst[i] = src[i] - ((src[i-bpp] + top[i]) >> 1); dst[i] = src[i] - ((src[i - bpp] + top[i]) >> 1);
break; break;
case PNG_FILTER_VALUE_PAETH: case PNG_FILTER_VALUE_PAETH:
for(i = 0; i < bpp; i++) for (i = 0; i < bpp; i++)
dst[i] = src[i] - top[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; break;
} }
} }
@ -163,26 +165,26 @@ static uint8_t *png_choose_filter(PNGEncContext *s, uint8_t *dst,
{ {
int pred = s->filter_type; int pred = s->filter_type;
av_assert0(bpp || !pred); av_assert0(bpp || !pred);
if(!top && pred) if (!top && pred)
pred = PNG_FILTER_VALUE_SUB; pred = PNG_FILTER_VALUE_SUB;
if(pred == PNG_FILTER_VALUE_MIXED) { if (pred == PNG_FILTER_VALUE_MIXED) {
int i; int i;
int cost, bcost = INT_MAX; int cost, bcost = INT_MAX;
uint8_t *buf1 = dst, *buf2 = dst + size + 16; uint8_t *buf1 = dst, *buf2 = dst + size + 16;
for(pred=0; pred<5; pred++) { for (pred = 0; pred < 5; pred++) {
png_filter_row(&s->dsp, buf1+1, pred, src, top, size, bpp); png_filter_row(&s->dsp, buf1 + 1, pred, src, top, size, bpp);
buf1[0] = pred; buf1[0] = pred;
cost = 0; cost = 0;
for(i=0; i<=size; i++) for (i = 0; i <= size; i++)
cost += abs((int8_t)buf1[i]); cost += abs((int8_t) buf1[i]);
if(cost < bcost) { if (cost < bcost) {
bcost = cost; bcost = cost;
FFSWAP(uint8_t*, buf1, buf2); FFSWAP(uint8_t *, buf1, buf2);
} }
} }
return buf2; return buf2;
} else { } 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; dst[0] = pred;
return dst; return dst;
} }
@ -213,16 +215,17 @@ static int png_write_row(PNGEncContext *s, const uint8_t *data, int size)
int ret; int ret;
s->zstream.avail_in = size; 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) { while (s->zstream.avail_in > 0) {
ret = deflate(&s->zstream, Z_NO_FLUSH); ret = deflate(&s->zstream, Z_NO_FLUSH);
if (ret != Z_OK) if (ret != Z_OK)
return -1; return -1;
if (s->zstream.avail_out == 0) { if (s->zstream.avail_out == 0) {
if(s->bytestream_end - s->bytestream > IOBUF_SIZE + 100) if (s->bytestream_end - s->bytestream > IOBUF_SIZE + 100)
png_write_chunk(&s->bytestream, MKTAG('I', 'D', 'A', 'T'), s->buf, IOBUF_SIZE); png_write_chunk(&s->bytestream,
MKTAG('I', 'D', 'A', 'T'), s->buf, IOBUF_SIZE);
s->zstream.avail_out = IOBUF_SIZE; s->zstream.avail_out = IOBUF_SIZE;
s->zstream.next_out = s->buf; s->zstream.next_out = s->buf;
} }
} }
return 0; return 0;
@ -231,41 +234,41 @@ static int png_write_row(PNGEncContext *s, const uint8_t *data, int size)
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pict, int *got_packet) const AVFrame *pict, int *got_packet)
{ {
PNGEncContext *s = avctx->priv_data; PNGEncContext *s = avctx->priv_data;
const AVFrame * const p = pict; const AVFrame *const p = pict;
int bit_depth, color_type, y, len, row_size, ret, is_progressive; int bit_depth, color_type, y, len, row_size, ret, is_progressive;
int bits_per_pixel, pass_row_size, enc_row_size; int bits_per_pixel, pass_row_size, enc_row_size;
int64_t max_packet_size; int64_t max_packet_size;
int compression_level; int compression_level;
uint8_t *ptr, *top; uint8_t *ptr, *top, *crow_buf, *crow;
uint8_t *crow_base = NULL, *crow_buf, *crow; uint8_t *crow_base = NULL;
uint8_t *progressive_buf = NULL; uint8_t *progressive_buf = NULL;
uint8_t *top_buf = NULL; uint8_t *top_buf = NULL;
is_progressive = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT); is_progressive = !!(avctx->flags & CODEC_FLAG_INTERLACED_DCT);
switch(avctx->pix_fmt) { switch (avctx->pix_fmt) {
case AV_PIX_FMT_RGBA64BE: case AV_PIX_FMT_RGBA64BE:
bit_depth = 16; bit_depth = 16;
color_type = PNG_COLOR_TYPE_RGB_ALPHA; color_type = PNG_COLOR_TYPE_RGB_ALPHA;
break; break;
case AV_PIX_FMT_RGB48BE: case AV_PIX_FMT_RGB48BE:
bit_depth = 16; bit_depth = 16;
color_type = PNG_COLOR_TYPE_RGB; color_type = PNG_COLOR_TYPE_RGB;
break; break;
case AV_PIX_FMT_RGBA: case AV_PIX_FMT_RGBA:
bit_depth = 8; bit_depth = 8;
color_type = PNG_COLOR_TYPE_RGB_ALPHA; color_type = PNG_COLOR_TYPE_RGB_ALPHA;
break; break;
case AV_PIX_FMT_RGB24: case AV_PIX_FMT_RGB24:
bit_depth = 8; bit_depth = 8;
color_type = PNG_COLOR_TYPE_RGB; color_type = PNG_COLOR_TYPE_RGB;
break; break;
case AV_PIX_FMT_GRAY16BE: case AV_PIX_FMT_GRAY16BE:
bit_depth = 16; bit_depth = 16;
color_type = PNG_COLOR_TYPE_GRAY; color_type = PNG_COLOR_TYPE_GRAY;
break; break;
case AV_PIX_FMT_GRAY8: case AV_PIX_FMT_GRAY8:
bit_depth = 8; bit_depth = 8;
color_type = PNG_COLOR_TYPE_GRAY; color_type = PNG_COLOR_TYPE_GRAY;
break; break;
case AV_PIX_FMT_GRAY8A: case AV_PIX_FMT_GRAY8A:
@ -273,25 +276,25 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
color_type = PNG_COLOR_TYPE_GRAY_ALPHA; color_type = PNG_COLOR_TYPE_GRAY_ALPHA;
break; break;
case AV_PIX_FMT_MONOBLACK: case AV_PIX_FMT_MONOBLACK:
bit_depth = 1; bit_depth = 1;
color_type = PNG_COLOR_TYPE_GRAY; color_type = PNG_COLOR_TYPE_GRAY;
break; break;
case AV_PIX_FMT_PAL8: case AV_PIX_FMT_PAL8:
bit_depth = 8; bit_depth = 8;
color_type = PNG_COLOR_TYPE_PALETTE; color_type = PNG_COLOR_TYPE_PALETTE;
break; break;
default: default:
return -1; return -1;
} }
bits_per_pixel = ff_png_get_nb_channels(color_type) * bit_depth; 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.zalloc = ff_png_zalloc;
s->zstream.zfree = ff_png_zfree; s->zstream.zfree = ff_png_zfree;
s->zstream.opaque = NULL; s->zstream.opaque = NULL;
compression_level = avctx->compression_level == FF_COMPRESSION_DEFAULT ? compression_level = avctx->compression_level == FF_COMPRESSION_DEFAULT
Z_DEFAULT_COMPRESSION : ? Z_DEFAULT_COMPRESSION
av_clip(avctx->compression_level, 0, 9); : av_clip(avctx->compression_level, 0, 9);
ret = deflateInit2(&s->zstream, compression_level, ret = deflateInit2(&s->zstream, compression_level,
Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY); Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY);
if (ret != Z_OK) if (ret != Z_OK)
@ -313,7 +316,8 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
crow_base = av_malloc((row_size + 32) << (s->filter_type == PNG_FILTER_VALUE_MIXED)); crow_base = av_malloc((row_size + 32) << (s->filter_type == PNG_FILTER_VALUE_MIXED));
if (!crow_base) if (!crow_base)
goto fail; 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) { if (is_progressive) {
progressive_buf = av_malloc(row_size + 1); progressive_buf = av_malloc(row_size + 1);
if (!progressive_buf) if (!progressive_buf)
@ -331,8 +335,8 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
AV_WB32(s->buf, avctx->width); AV_WB32(s->buf, avctx->width);
AV_WB32(s->buf + 4, avctx->height); AV_WB32(s->buf + 4, avctx->height);
s->buf[8] = bit_depth; s->buf[8] = bit_depth;
s->buf[9] = color_type; s->buf[9] = color_type;
s->buf[10] = 0; /* compression type */ s->buf[10] = 0; /* compression type */
s->buf[11] = 0; /* filter type */ s->buf[11] = 0; /* filter type */
s->buf[12] = is_progressive; /* interlace type */ s->buf[12] = is_progressive; /* interlace type */
@ -357,61 +361,64 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
uint32_t *palette; uint32_t *palette;
uint8_t *alpha_ptr; uint8_t *alpha_ptr;
palette = (uint32_t *)p->data[1]; palette = (uint32_t *)p->data[1];
ptr = s->buf; ptr = s->buf;
alpha_ptr = s->buf + 256 * 3; alpha_ptr = s->buf + 256 * 3;
has_alpha = 0; has_alpha = 0;
for(i = 0; i < 256; i++) { for (i = 0; i < 256; i++) {
v = palette[i]; v = palette[i];
alpha = v >> 24; alpha = v >> 24;
if (alpha != 0xff) if (alpha != 0xff)
has_alpha = 1; has_alpha = 1;
*alpha_ptr++ = alpha; *alpha_ptr++ = alpha;
bytestream_put_be24(&ptr, v); 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) { 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 */ /* now put each row */
s->zstream.avail_out = IOBUF_SIZE; s->zstream.avail_out = IOBUF_SIZE;
s->zstream.next_out = s->buf; s->zstream.next_out = s->buf;
if (is_progressive) { if (is_progressive) {
int pass; 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 /* 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); pass_row_size = ff_png_pass_row_size(pass, bits_per_pixel, avctx->width);
if (pass_row_size > 0) { if (pass_row_size > 0) {
top = NULL; 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) { if ((ff_png_pass_ymask[pass] << (y & 7)) & 0x80) {
ptr = p->data[0] + y * p->linesize[0]; ptr = p->data[0] + y * p->linesize[0];
FFSWAP(uint8_t*, progressive_buf, top_buf); FFSWAP(uint8_t *, progressive_buf, top_buf);
png_get_interlaced_row(progressive_buf, pass_row_size, png_get_interlaced_row(progressive_buf, pass_row_size,
bits_per_pixel, pass, bits_per_pixel, pass,
ptr, avctx->width); 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); png_write_row(s, crow, pass_row_size + 1);
top = progressive_buf; top = progressive_buf;
} }
}
} }
} }
} else { } else {
top = NULL; top = NULL;
for(y = 0; y < avctx->height; y++) { for (y = 0; y < avctx->height; y++) {
ptr = p->data[0] + y * p->linesize[0]; ptr = p->data[0] + y * p->linesize[0];
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); png_write_row(s, crow, row_size + 1);
top = ptr; top = ptr;
} }
} }
/* compress last bytes */ /* compress last bytes */
for(;;) { for (;;) {
ret = deflate(&s->zstream, Z_FINISH); ret = deflate(&s->zstream, Z_FINISH);
if (ret == Z_OK || ret == Z_STREAM_END) { if (ret == Z_OK || ret == Z_STREAM_END) {
len = IOBUF_SIZE - s->zstream.avail_out; len = IOBUF_SIZE - s->zstream.avail_out;
@ -419,7 +426,7 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
png_write_chunk(&s->bytestream, MKTAG('I', 'D', 'A', 'T'), s->buf, len); png_write_chunk(&s->bytestream, MKTAG('I', 'D', 'A', 'T'), s->buf, len);
} }
s->zstream.avail_out = IOBUF_SIZE; s->zstream.avail_out = IOBUF_SIZE;
s->zstream.next_out = s->buf; s->zstream.next_out = s->buf;
if (ret == Z_STREAM_END) if (ret == Z_STREAM_END)
break; break;
} else { } else {
@ -433,21 +440,22 @@ static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
*got_packet = 1; *got_packet = 1;
ret = 0; ret = 0;
the_end: the_end:
av_free(crow_base); av_free(crow_base);
av_free(progressive_buf); av_free(progressive_buf);
av_free(top_buf); av_free(top_buf);
deflateEnd(&s->zstream); deflateEnd(&s->zstream);
return ret; return ret;
fail: fail:
ret = -1; ret = -1;
goto the_end; 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; PNGEncContext *s = avctx->priv_data;
switch(avctx->pix_fmt) { switch (avctx->pix_fmt) {
case AV_PIX_FMT_RGBA: case AV_PIX_FMT_RGBA:
avctx->bits_per_coded_sample = 32; avctx->bits_per_coded_sample = 32;
break; break;
@ -473,8 +481,10 @@ static av_cold int png_enc_init(AVCodecContext *avctx){
ff_dsputil_init(&s->dsp, avctx); ff_dsputil_init(&s->dsp, avctx);
s->filter_type = av_clip(avctx->prediction_method, PNG_FILTER_VALUE_NONE, PNG_FILTER_VALUE_MIXED); s->filter_type = av_clip(avctx->prediction_method,
if(avctx->pix_fmt == AV_PIX_FMT_MONOBLACK) PNG_FILTER_VALUE_NONE,
PNG_FILTER_VALUE_MIXED);
if (avctx->pix_fmt == AV_PIX_FMT_MONOBLACK)
s->filter_type = PNG_FILTER_VALUE_NONE; s->filter_type = PNG_FILTER_VALUE_NONE;
if (s->dpi && s->dpm) { if (s->dpi && s->dpm) {
@ -518,7 +528,7 @@ AVCodec ff_png_encoder = {
.close = png_enc_close, .close = png_enc_close,
.encode2 = encode_frame, .encode2 = encode_frame,
.capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY, .capabilities = CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
.pix_fmts = (const enum AVPixelFormat[]){ .pix_fmts = (const enum AVPixelFormat[]) {
AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA, AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE, AV_PIX_FMT_RGB48BE, AV_PIX_FMT_RGBA64BE,
AV_PIX_FMT_PAL8, AV_PIX_FMT_PAL8,

Write Preview
Loading…
Cancel
Save