int
SplashDecodePng(Splash * splash, png_rw_ptr read_func, void *io_ptr)
{
int stride;
ImageFormat srcFormat;
png_uint_32 i, rowbytes;
png_bytepp row_pointers = NULL;
png_bytep image_data = NULL;
int success = 0;
double gamma;
png_structp png_ptr = NULL;
png_infop info_ptr = NULL;
png_uint_32 width, height;
int bit_depth, color_type;
ImageRect srcRect, dstRect;
png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr) {
goto done;
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
goto done;
}
#ifdef __APPLE__
/* use setjmp/longjmp versions that do not save/restore the signal mask */
if (_setjmp(png_set_longjmp_fn(png_ptr, _longjmp, sizeof(jmp_buf)))) {
#else
if (setjmp(png_jmpbuf(png_ptr))) {
#endif
goto done;
}
png_set_read_fn(png_ptr, io_ptr, read_func);
png_set_sig_bytes(png_ptr, SIG_BYTES); /* we already read the 8 signature bytes */
png_read_info(png_ptr, info_ptr); /* read all PNG info up to image data */
png_get_IHDR(png_ptr, info_ptr, &width, &height, &bit_depth, &color_type,
NULL, NULL, NULL);
/* expand palette images to RGB, low-bit-depth grayscale images to 8 bits,
* transparency chunks to full alpha channel; strip 16-bit-per-sample
* images to 8 bits per sample; and convert grayscale to RGB[A]
* this may be sub-optimal but this simplifies implementation */
png_set_expand(png_ptr);
png_set_tRNS_to_alpha(png_ptr);
png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
png_set_strip_16(png_ptr);
png_set_gray_to_rgb(png_ptr);
if (png_get_gAMA(png_ptr, info_ptr, &gamma))
png_set_gamma(png_ptr, 2.2, gamma);
png_set_interlace_handling(png_ptr);
png_read_update_info(png_ptr, info_ptr);
rowbytes = png_get_rowbytes(png_ptr, info_ptr);
if (!SAFE_TO_ALLOC(rowbytes, height)) {
goto done;
}
if ((image_data = (unsigned char *) malloc(rowbytes * height)) == NULL) {
goto done;
}
if (!SAFE_TO_ALLOC(height, sizeof(png_bytep))) {
goto done;
}
if ((row_pointers = (png_bytepp) malloc(height * sizeof(png_bytep)))
== NULL) {
goto done;
}
for (i = 0; i < height; ++i)
row_pointers[i] = image_data + i * rowbytes;
png_read_image(png_ptr, row_pointers);
SplashCleanup(splash);
splash->width = width;
splash->height = height;
if (!SAFE_TO_ALLOC(splash->width, splash->imageFormat.depthBytes)) {
goto done;
}
stride = splash->width * splash->imageFormat.depthBytes;
if (!SAFE_TO_ALLOC(splash->height, stride)) {
goto done;
}
splash->frameCount = 1;
splash->frames = (SplashImage *)
malloc(sizeof(SplashImage) * splash->frameCount);
if (splash->frames == NULL) {
goto done;
}
splash->loopCount = 1;
splash->frames[0].bitmapBits = malloc(stride * splash->height);
if (splash->frames[0].bitmapBits == NULL) {
free(splash->frames);
goto done;
}
splash->frames[0].delay = 0;
/* FIXME: sort out the real format */
initFormat(&srcFormat, 0xFF000000, 0x00FF0000, 0x0000FF00, 0x000000FF);
srcFormat.byteOrder = BYTE_ORDER_MSBFIRST;
initRect(&srcRect, 0, 0, width, height, 1, rowbytes,
image_data, &srcFormat);
initRect(&dstRect, 0, 0, width, height, 1, stride,
splash->frames[0].bitmapBits, &splash->imageFormat);
convertRect(&srcRect, &dstRect, CVT_COPY);
SplashInitFrameShape(splash, 0);
png_read_end(png_ptr, NULL);
success = 1;
done:
free(row_pointers);
free(image_data);
png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
return success;
}
int
SplashDecodePngStream(Splash * splash, SplashStream * stream)
{
unsigned char sig[SIG_BYTES];
int success = 0;
stream->read(stream, sig, SIG_BYTES);
if (png_sig_cmp(sig, 0, SIG_BYTES)) {
goto done;
}
success = SplashDecodePng(splash, my_png_read_stream, stream);
done:
return success;
}
int GImageWrite_Png(GImage *gi, FILE *fp, int progressive) {
struct _GImage *base = gi->list_len==0?gi->u.image:gi->u.images[0];
png_structp png_ptr;
png_infop info_ptr;
png_byte **rows;
int i;
int bit_depth;
int color_type;
int num_palette;
png_bytep trans_alpha = NULL;
png_color_16p trans_color = NULL;
png_colorp palette = NULL;
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
(void *)NULL, user_error_fn, user_warning_fn);
if (!png_ptr) {
return(false);
}
info_ptr = png_create_info_struct(png_ptr);
if (!info_ptr) {
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return(false);
}
#if (PNG_LIBPNG_VER < 10500)
if (setjmp(png_ptr->jmpbuf))
#else
if (setjmp(*png_set_longjmp_fn(png_ptr, longjmp, sizeof (jmp_buf))))
#endif
{
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return(false);
}
png_init_io(png_ptr, fp);
bit_depth = 8;
num_palette = base->clut==NULL?2:base->clut->clut_len;
if ( base->image_type==it_index || base->image_type==it_bitmap ) {
color_type = PNG_COLOR_TYPE_PALETTE;
if ( num_palette<=2 )
bit_depth=1;
else if ( num_palette<=4 )
bit_depth=2;
else if ( num_palette<=16 )
bit_depth=4;
} else {
color_type = PNG_COLOR_TYPE_RGB;
if ( base->image_type == it_rgba )
color_type = PNG_COLOR_TYPE_RGB_ALPHA;
}
png_set_IHDR(png_ptr, info_ptr, base->width, base->height,
bit_depth, color_type, progressive,
PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
if ( base->image_type==it_index || base->image_type==it_bitmap ) {
palette = (png_color *) galloc(num_palette*sizeof(png_color));
if ( base->clut==NULL ) {
palette[0].red = palette[0].green = palette[0].blue = 0;
palette[1].red = palette[1].green = palette[1].blue = 0xff;
} else {
for ( i=0; i<num_palette; ++i ) {
long col = base->clut->clut[i];
palette[i].red = COLOR_RED(col);
palette[i].green = COLOR_GREEN(col);
palette[i].blue = COLOR_BLUE(col);
}
}
png_set_PLTE(png_ptr, info_ptr, palette, num_palette);
if ( num_palette<=16 )
png_set_packing(png_ptr);
if ( base->trans!=-1 ) {
trans_alpha = (png_bytep) galloc(1);
trans_alpha[0] = base->trans;
}
} else {
if ( base->trans!=-1 ) {
trans_color = (png_color_16p) galloc(sizeof(png_color_16));
trans_color->red = COLOR_RED(base->trans);
trans_color->green = COLOR_GREEN(base->trans);
trans_color->blue = COLOR_BLUE(base->trans);
}
}
if ( base->trans!=-1 ) {
png_set_tRNS(png_ptr, info_ptr, trans_alpha, 1, trans_color);
}
png_write_info(png_ptr, info_ptr);
if (color_type == PNG_COLOR_TYPE_RGB)
png_set_filler(png_ptr, '\0', PNG_FILLER_BEFORE);
rows = (png_byte **) galloc(base->height*sizeof(png_byte *));
for ( i=0; i<base->height; ++i )
rows[i] = (png_byte *) (base->data + i*base->bytes_per_line);
png_write_image(png_ptr,rows);
png_write_end(png_ptr, info_ptr);
if ( trans_alpha!=NULL ) gfree(trans_alpha);
if ( trans_color!=NULL ) gfree(trans_color);
if ( palette!=NULL ) gfree(palette);
png_destroy_write_struct(&png_ptr, &info_ptr);
gfree(rows);
return( 1 );
}
#if (PNG_LIBPNG_VER < 10500)
if (setjmp(png_ptr->jmpbuf))
#else
if (setjmp(*png_set_longjmp_fn(png_ptr, longjmp, sizeof (jmp_buf))))
#endif
{
png_destroy_write_struct(&png_ptr, (png_infopp)NULL);
return(false);
}
