Lines
66.67 %
Functions
73.91 %
Branches
58.42 %
/* cairo - a vector graphics library with display and print output
*
* Copyright © 2003 University of Southern California
* This library is free software; you can redistribute it and/or
* modify it either under the terms of the GNU Lesser General Public
* License version 2.1 as published by the Free Software Foundation
* (the "LGPL") or, at your option, under the terms of the Mozilla
* Public License Version 1.1 (the "MPL"). If you do not alter this
* notice, a recipient may use your version of this file under either
* the MPL or the LGPL.
* You should have received a copy of the LGPL along with this library
* in the file COPYING-LGPL-2.1; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
* You should have received a copy of the MPL along with this library
* in the file COPYING-MPL-1.1
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
* OF ANY KIND, either express or implied. See the LGPL or the MPL for
* the specific language governing rights and limitations.
* The Original Code is the cairo graphics library.
* The Initial Developer of the Original Code is University of Southern
* California.
* Contributor(s):
* Carl D. Worth <cworth@cworth.org>
* Kristian Høgsberg <krh@redhat.com>
* Chris Wilson <chris@chris-wilson.co.uk>
*/
#include "cairoint.h"
#include "cairo-error-private.h"
#include "cairo-image-surface-private.h"
#include "cairo-output-stream-private.h"
#include <stdio.h>
#include <errno.h>
#include <png.h>
/**
* SECTION:cairo-png
* @Title: PNG Support
* @Short_Description: Reading and writing PNG images
* @See_Also: #cairo_surface_t
* The PNG functions allow reading PNG images into image surfaces, and writing
* any surface to a PNG file.
* It is a toy API. It only offers very simple support for reading and
* writing PNG files, which is sufficient for testing and
* demonstration purposes. Applications which need more control over
* the generated PNG file should access the pixel data directly, using
* cairo_image_surface_get_data() or a backend-specific access
* function, and process it with another library, e.g. gdk-pixbuf or
* libpng.
**/
* CAIRO_HAS_PNG_FUNCTIONS:
* Defined if the PNG functions are available.
* This macro can be used to conditionally compile code using the cairo
* PNG functions.
* Since: 1.0
struct png_read_closure_t {
cairo_read_func_t read_func;
void *closure;
cairo_output_stream_t *png_data;
};
/* Unpremultiplies data and converts native endian ARGB => RGBA bytes */
static void
unpremultiply_data (png_structp png, png_row_infop row_info, png_bytep data)
{
unsigned int i;
for (i = 0; i < row_info->rowbytes; i += 4) {
uint8_t *b = &data[i];
uint32_t pixel;
uint8_t alpha;
memcpy (&pixel, b, sizeof (uint32_t));
alpha = (pixel & 0xff000000) >> 24;
if (alpha == 0) {
b[0] = b[1] = b[2] = b[3] = 0;
} else {
b[0] = (((pixel & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
b[1] = (((pixel & 0x00ff00) >> 8) * 255 + alpha / 2) / alpha;
b[2] = (((pixel & 0x0000ff) >> 0) * 255 + alpha / 2) / alpha;
b[3] = alpha;
}
static uint16_t f_to_u16(float val)
if (val < 0)
return 0;
else if (val > 1)
return 65535;
else
return (uint16_t)(val * 65535.f);
unpremultiply_float (float *f, uint16_t *d16, unsigned width)
for (i = 0; i < width; i++) {
float r, g, b, a;
r = *f++;
g = *f++;
b = *f++;
a = *f++;
if (a > 0) {
*d16++ = f_to_u16(r / a);
*d16++ = f_to_u16(g / a);
*d16++ = f_to_u16(b / a);
*d16++ = f_to_u16(a);
*d16++ = 0;
premultiply_float (float *f, const uint16_t *d16, unsigned int width)
unsigned int i = width;
/* Convert d16 in place back to float */
while (i--) {
float a = d16[i * 4 + 3] / 65535.f;
f[i * 4 + 3] = a;
f[i * 4 + 2] = (float)d16[i * 4 + 2] / 65535.f * a;
f[i * 4 + 1] = (float)d16[i * 4 + 1] / 65535.f * a;
f[i * 4] = (float)d16[i * 4] / 65535.f * a;
static void convert_u16_to_float (float *f, const uint16_t *d16, unsigned int width)
f[i * 3 + 2] = (float)d16[i * 4 + 2] / 65535.f;
f[i * 3 + 1] = (float)d16[i * 4 + 1] / 65535.f;
f[i * 3] = (float)d16[i * 4] / 65535.f;
convert_float_to_u16 (float *f, uint16_t *d16, unsigned int width)
*d16++ = f_to_u16(*f++);
/* Converts native endian xRGB => RGBx bytes */
convert_data_to_bytes (png_structp png, png_row_infop row_info, png_bytep data)
b[0] = (pixel & 0xff0000) >> 16;
b[1] = (pixel & 0x00ff00) >> 8;
b[2] = (pixel & 0x0000ff) >> 0;
b[3] = 0;
/* Use a couple of simple error callbacks that do not print anything to
* stderr and rely on the user to check for errors via the #cairo_status_t
* return.
png_simple_error_callback (png_structp png,
png_const_charp error_msg)
cairo_status_t *error = png_get_error_ptr (png);
/* default to the most likely error */
if (*error == CAIRO_STATUS_SUCCESS)
*error = _cairo_error (CAIRO_STATUS_PNG_ERROR);
#ifdef PNG_SETJMP_SUPPORTED
longjmp (png_jmpbuf (png), 1);
#endif
/* if we get here, then we have to choice but to abort ... */
png_simple_warning_callback (png_structp png,
/* png does not expect to abort and will try to tidy up and continue
* loading the image after a warning. So we also want to return the
* (incorrect?) surface.
* We use our own warning callback to squelch any attempts by libpng
* to write to stderr as we may not be in control of that output.
/* Starting with libpng-1.2.30, we must explicitly specify an output_flush_fn.
* Otherwise, we will segfault if we are writing to a stream. */
png_simple_output_flush_fn (png_structp png_ptr)
static cairo_status_t
write_png (cairo_surface_t *surface,
png_rw_ptr write_func,
void *closure)
int i;
cairo_int_status_t status;
cairo_image_surface_t *image;
cairo_image_surface_t * volatile clone;
void *image_extra;
png_struct *png;
png_info *info;
png_byte **volatile rows = NULL;
png_color_16 white;
int png_color_type;
int bpc;
unsigned char *volatile u16_copy = NULL;
status = _cairo_surface_acquire_source_image (surface,
&image,
&image_extra);
if (status == CAIRO_INT_STATUS_UNSUPPORTED)
return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
else if (unlikely (status))
return status;
/* PNG complains about "Image width or height is zero in IHDR" */
if (image->width == 0 || image->height == 0) {
status = _cairo_error (CAIRO_STATUS_WRITE_ERROR);
goto BAIL1;
/* Don't coerce to a lower resolution format */
if (image->format == CAIRO_FORMAT_RGB96F ||
image->format == CAIRO_FORMAT_RGBA128F) {
u16_copy = _cairo_malloc_ab (image->width * 8, image->height);
if (!u16_copy) {
status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
clone = (cairo_image_surface_t *)cairo_surface_reference (&image->base);
/* Handle the various fallback formats (e.g. low bit-depth XServers)
* by coercing them to a simpler format using pixman.
clone = _cairo_image_surface_coerce (image);
status = clone->base.status;
if (unlikely (status))
rows = _cairo_malloc_ab (clone->height, sizeof (png_byte*));
if (unlikely (rows == NULL)) {
goto BAIL2;
for (i = 0; i < clone->height; i++)
rows[i] = (png_byte *)clone->data + i * clone->stride;
for (i = 0; i < clone->height; i++) {
float *float_line = (float *)&clone->data[i * clone->stride];
uint16_t *u16_line = (uint16_t *)&u16_copy[i * clone->width * 8];
if (image->format == CAIRO_FORMAT_RGBA128F)
unpremultiply_float (float_line, u16_line, clone->width);
convert_float_to_u16 (float_line, u16_line, clone->width);
rows[i] = (png_byte *)u16_line;
png = png_create_write_struct (PNG_LIBPNG_VER_STRING, &status,
png_simple_error_callback,
png_simple_warning_callback);
if (unlikely (png == NULL)) {
goto BAIL3;
info = png_create_info_struct (png);
if (unlikely (info == NULL)) {
goto BAIL4;
if (setjmp (png_jmpbuf (png)))
png_set_write_fn (png, closure, write_func, png_simple_output_flush_fn);
switch (clone->format) {
case CAIRO_FORMAT_ARGB32:
bpc = 8;
if (_cairo_image_analyze_transparency (clone) == CAIRO_IMAGE_IS_OPAQUE)
png_color_type = PNG_COLOR_TYPE_RGB;
png_color_type = PNG_COLOR_TYPE_RGB_ALPHA;
break;
case CAIRO_FORMAT_RGB30:
bpc = 10;
case CAIRO_FORMAT_RGB24:
case CAIRO_FORMAT_A8:
png_color_type = PNG_COLOR_TYPE_GRAY;
case CAIRO_FORMAT_A1:
bpc = 1;
#ifndef WORDS_BIGENDIAN
png_set_packswap (png);
case CAIRO_FORMAT_RGB96F:
bpc = 16;
case CAIRO_FORMAT_RGBA128F:
case CAIRO_FORMAT_INVALID:
case CAIRO_FORMAT_RGB16_565:
default:
status = _cairo_error (CAIRO_STATUS_INVALID_FORMAT);
png_set_IHDR (png, info,
clone->width,
clone->height, bpc,
png_color_type,
PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_DEFAULT,
PNG_FILTER_TYPE_DEFAULT);
white.gray = (1 << bpc) - 1;
white.red = white.blue = white.green = white.gray;
png_set_bKGD (png, info, &white);
if (0) { /* XXX extract meta-data from surface (i.e. creation date) */
png_time pt;
png_convert_from_time_t (&pt, time (NULL));
png_set_tIME (png, info, &pt);
/* We have to call png_write_info() before setting up the write
* transformation, since it stores data internally in 'png'
* that is needed for the write transformation functions to work.
png_write_info (png, info);
/* libpng treats 16-bit data as big-endian by default. Swapping the
* byte-order on little endian ensures the native-endian data can be
* provided to png_write_image. This does not affect 8-bit data.
png_set_swap (png);
if (png_color_type == PNG_COLOR_TYPE_RGB_ALPHA) {
if (clone->format != CAIRO_FORMAT_RGBA128F)
png_set_write_user_transform_fn (png, unpremultiply_data);
} else if (png_color_type == PNG_COLOR_TYPE_RGB) {
if (clone->format != CAIRO_FORMAT_RGB96F)
png_set_write_user_transform_fn (png, convert_data_to_bytes);
png_set_filler (png, 0, PNG_FILLER_AFTER);
png_write_image (png, rows);
png_write_end (png, info);
BAIL4:
png_destroy_write_struct (&png, &info);
BAIL3:
free (rows);
BAIL2:
cairo_surface_destroy (&clone->base);
free (u16_copy);
BAIL1:
_cairo_surface_release_source_image (surface, image, image_extra);
stdio_write_func (png_structp png, png_bytep data, png_size_t size)
FILE *fp;
fp = png_get_io_ptr (png);
while (size) {
size_t ret = fwrite (data, 1, size, fp);
size -= ret;
data += ret;
if (size && ferror (fp)) {
*error = _cairo_error (CAIRO_STATUS_WRITE_ERROR);
png_error (png, NULL);
* cairo_surface_write_to_png:
* @surface: a #cairo_surface_t with pixel contents
* @filename: the name of a file to write to; on Windows this filename
* is encoded in UTF-8.
* Writes the contents of @surface to a new file @filename as a PNG
* image.
* Return value: %CAIRO_STATUS_SUCCESS if the PNG file was written
* successfully. Otherwise, %CAIRO_STATUS_NO_MEMORY if memory could not
* be allocated for the operation or
* %CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface does not have
* pixel contents, or %CAIRO_STATUS_WRITE_ERROR if an I/O error occurs
* while attempting to write the file, or %CAIRO_STATUS_PNG_ERROR if libpng
* returned an error.
cairo_status_t
cairo_surface_write_to_png (cairo_surface_t *surface,
const char *filename)
cairo_status_t status;
if (surface->status)
return surface->status;
if (surface->finished)
return _cairo_error (CAIRO_STATUS_SURFACE_FINISHED);
status = _cairo_fopen (filename, "wb", &fp);
if (status != CAIRO_STATUS_SUCCESS)
return _cairo_error (status);
if (fp == NULL) {
switch (errno) {
case ENOMEM:
return _cairo_error (CAIRO_STATUS_NO_MEMORY);
return _cairo_error (CAIRO_STATUS_WRITE_ERROR);
status = write_png (surface, stdio_write_func, fp);
if (fclose (fp) && status == CAIRO_STATUS_SUCCESS)
struct png_write_closure_t {
cairo_write_func_t write_func;
stream_write_func (png_structp png, png_bytep data, png_size_t size)
struct png_write_closure_t *png_closure;
png_closure = png_get_io_ptr (png);
status = png_closure->write_func (png_closure->closure, data, size);
if (unlikely (status)) {
*error = status;
* cairo_surface_write_to_png_stream:
* @write_func: a #cairo_write_func_t
* @closure: closure data for the write function
* Writes the image surface to the write function.
* successfully. Otherwise, %CAIRO_STATUS_NO_MEMORY is returned if
* memory could not be allocated for the operation,
* pixel contents, or %CAIRO_STATUS_PNG_ERROR if libpng
cairo_surface_write_to_png_stream (cairo_surface_t *surface,
cairo_write_func_t write_func,
struct png_write_closure_t png_closure;
png_closure.write_func = write_func;
png_closure.closure = closure;
return write_png (surface, stream_write_func, &png_closure);
static inline int
multiply_alpha (int alpha, int color)
int temp = (alpha * color) + 0x80;
return ((temp + (temp >> 8)) >> 8);
/* Premultiplies data and converts RGBA bytes => native endian */
premultiply_data (png_structp png,
png_row_infop row_info,
png_bytep data)
uint8_t *base = &data[i];
uint8_t alpha = base[3];
uint32_t p;
p = 0;
uint8_t red = base[0];
uint8_t green = base[1];
uint8_t blue = base[2];
if (alpha != 0xff) {
red = multiply_alpha (alpha, red);
green = multiply_alpha (alpha, green);
blue = multiply_alpha (alpha, blue);
p = ((uint32_t)alpha << 24) | (red << 16) | (green << 8) | (blue << 0);
memcpy (base, &p, sizeof (uint32_t));
/* Converts RGBx bytes to native endian xRGB */
convert_bytes_to_data (png_structp png, png_row_infop row_info, png_bytep data)
pixel = (0xffu << 24) | (red << 16) | (green << 8) | (blue << 0);
memcpy (base, &pixel, sizeof (uint32_t));
stdio_read_func (void *closure, unsigned char *data, unsigned int size)
FILE *file = closure;
size_t ret;
ret = fread (data, 1, size, file);
if (size && (feof (file) || ferror (file)))
return _cairo_error (CAIRO_STATUS_READ_ERROR);
return CAIRO_STATUS_SUCCESS;
stream_read_func (png_structp png, png_bytep data, png_size_t size)
struct png_read_closure_t *png_closure;
status = png_closure->read_func (png_closure->closure, data, size);
_cairo_output_stream_write (png_closure->png_data, data, size);
static cairo_surface_t *
read_png (struct png_read_closure_t *png_closure)
cairo_surface_t * volatile surface;
png_struct *png = NULL;
png_byte * volatile data = NULL;
png_byte ** volatile row_pointers = NULL;
png_uint_32 png_width, png_height;
int depth, color_type, interlace, stride;
cairo_format_t format;
unsigned char *mime_data;
unsigned long mime_data_length;
png_closure->png_data = _cairo_memory_stream_create ();
/* XXX: Perhaps we'll want some other error handlers? */
png = png_create_read_struct (PNG_LIBPNG_VER_STRING,
&status,
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
goto BAIL;
png_set_read_fn (png, png_closure, stream_read_func);
status = CAIRO_STATUS_SUCCESS;
if (setjmp (png_jmpbuf (png))) {
surface = _cairo_surface_create_in_error (status);
png_read_info (png, info);
* provided to png_read_image. This does not affect 8-bit data.
png_get_IHDR (png, info,
&png_width, &png_height, &depth,
&color_type, &interlace, NULL, NULL);
if (unlikely (status)) { /* catch any early warnings */
/* convert palette/gray image to rgb */
if (color_type == PNG_COLOR_TYPE_PALETTE)
png_set_palette_to_rgb (png);
/* expand gray bit depth if needed */
if (color_type == PNG_COLOR_TYPE_GRAY)
png_set_expand_gray_1_2_4_to_8 (png);
/* transform transparency to alpha */
if (png_get_valid (png, info, PNG_INFO_tRNS))
png_set_tRNS_to_alpha (png);
if (depth < 8)
png_set_packing (png);
/* convert grayscale to RGB */
if (color_type == PNG_COLOR_TYPE_GRAY ||
color_type == PNG_COLOR_TYPE_GRAY_ALPHA)
png_set_gray_to_rgb (png);
if (interlace != PNG_INTERLACE_NONE)
png_set_interlace_handling (png);
png_set_filler (png, 0xff, PNG_FILLER_AFTER);
/* recheck header after setting EXPAND options */
png_read_update_info (png, info);
if ((depth != 8 && depth != 16) ||
! (color_type == PNG_COLOR_TYPE_RGB ||
color_type == PNG_COLOR_TYPE_RGB_ALPHA))
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_READ_ERROR));
switch (color_type) {
ASSERT_NOT_REACHED;
/* fall-through just in case ;-) */
case PNG_COLOR_TYPE_RGB_ALPHA:
if (depth == 8) {
format = CAIRO_FORMAT_ARGB32;
png_set_read_user_transform_fn (png, premultiply_data);
format = CAIRO_FORMAT_RGBA128F;
case PNG_COLOR_TYPE_RGB:
format = CAIRO_FORMAT_RGB24;
png_set_read_user_transform_fn (png, convert_bytes_to_data);
format = CAIRO_FORMAT_RGB96F;
stride = cairo_format_stride_for_width (format, png_width);
if (stride < 0) {
surface = _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_INVALID_STRIDE));
data = _cairo_malloc_ab (png_height, stride);
if (unlikely (data == NULL)) {
row_pointers = _cairo_malloc_ab (png_height, sizeof (char *));
if (unlikely (row_pointers == NULL)) {
for (i = 0; i < png_height; i++)
row_pointers[i] = &data[i * (ptrdiff_t)stride];
png_read_image (png, row_pointers);
png_read_end (png, info);
if (unlikely (status)) { /* catch any late warnings - probably hit an error already */
if (format == CAIRO_FORMAT_RGBA128F) {
i = png_height;
float *float_line = (float *)row_pointers[i];
uint16_t *u16_line = (uint16_t *)row_pointers[i];
premultiply_float (float_line, u16_line, png_width);
} else if (format == CAIRO_FORMAT_RGB96F) {
convert_u16_to_float (float_line, u16_line, png_width);
surface = cairo_image_surface_create_for_data (data, format,
png_width, png_height,
stride);
_cairo_image_surface_assume_ownership_of_data ((cairo_image_surface_t*)surface);
data = NULL;
_cairo_debug_check_image_surface_is_defined (surface);
status = _cairo_memory_stream_destroy (png_closure->png_data,
&mime_data,
&mime_data_length);
png_closure->png_data = NULL;
cairo_surface_destroy (surface);
status = cairo_surface_set_mime_data (surface,
CAIRO_MIME_TYPE_PNG,
mime_data,
mime_data_length,
free,
mime_data);
free (mime_data);
BAIL:
free (row_pointers);
free (data);
if (png != NULL)
png_destroy_read_struct (&png, &info, NULL);
if (png_closure->png_data != NULL) {
cairo_status_t status_ignored;
status_ignored = _cairo_output_stream_destroy (png_closure->png_data);
return surface;
* cairo_image_surface_create_from_png:
* @filename: name of PNG file to load. On Windows this filename
* Creates a new image surface and initializes the contents to the
* given PNG file.
* Return value: a new #cairo_surface_t initialized with the contents
* of the PNG file, or a "nil" surface if any error occurred. A nil
* surface can be checked for with cairo_surface_status(surface) which
* may return one of the following values:
* %CAIRO_STATUS_NO_MEMORY
* %CAIRO_STATUS_FILE_NOT_FOUND
* %CAIRO_STATUS_READ_ERROR
* %CAIRO_STATUS_PNG_ERROR
* Alternatively, you can allow errors to propagate through the drawing
* operations and check the status on the context upon completion
* using cairo_status().
cairo_surface_t *
cairo_image_surface_create_from_png (const char *filename)
struct png_read_closure_t png_closure;
cairo_surface_t *surface;
status = _cairo_fopen (filename, "rb", (FILE **) &png_closure.closure);
return _cairo_surface_create_in_error (status);
if (png_closure.closure == NULL) {
case ENOENT:
status = _cairo_error (CAIRO_STATUS_FILE_NOT_FOUND);
status = _cairo_error (CAIRO_STATUS_READ_ERROR);
png_closure.read_func = stdio_read_func;
surface = read_png (&png_closure);
fclose (png_closure.closure);
* cairo_image_surface_create_from_png_stream:
* @read_func: function called to read the data of the file
* @closure: data to pass to @read_func.
* Creates a new image surface from PNG data read incrementally
* via the @read_func function.
* of the PNG file or a "nil" surface if the data read is not a valid PNG image
* or memory could not be allocated for the operation. A nil
cairo_image_surface_create_from_png_stream (cairo_read_func_t read_func,
png_closure.read_func = read_func;
return read_png (&png_closure);