png.c File Reference

Portable Network Graphics (PNG) format. More...

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/umalloc.h>
#include <ipxe/pixbuf.h>
#include <ipxe/deflate.h>
#include <ipxe/png.h>

Go to the source code of this file.

Data Structures
struct	png_context
	PNG context. More...
struct	png_interlace
	A PNG interlace pass. More...
struct	png_filter
	A PNG filter. More...
struct	png_chunk_handler
	A PNG chunk handler. More...

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static const char *	png_type_name (uint32_t type)
	Transcribe PNG chunk type name (for debugging).
static void	png_interlace (struct png_context *png, unsigned int pass, struct png_interlace *interlace)
	Calculate PNG interlace pass parameters.
static unsigned int	png_pixel_len (struct png_context *png)
	Calculate PNG pixel length.
static size_t	png_scanline_len (struct png_context *png, struct png_interlace *interlace)
	Calculate PNG scanline length.
static int	png_image_header (struct image *image, struct png_context *png, size_t len)
	Handle PNG image header chunk.
static int	png_palette (struct image *image, struct png_context *png, size_t len)
	Handle PNG palette chunk.
static int	png_image_data (struct image *image, struct png_context *png, size_t len)
	Handle PNG image data chunk.
static unsigned int	png_unfilter_none (unsigned int current, unsigned int left __unused, unsigned int above __unused, unsigned int above_left __unused)
	Unfilter byte using the "None" filter.
static unsigned int	png_unfilter_sub (unsigned int current, unsigned int left, unsigned int above __unused, unsigned int above_left __unused)
	Unfilter byte using the "Sub" filter.
static unsigned int	png_unfilter_up (unsigned int current, unsigned int left __unused, unsigned int above, unsigned int above_left __unused)
	Unfilter byte using the "Up" filter.
static unsigned int	png_unfilter_average (unsigned int current, unsigned int left, unsigned int above, unsigned int above_left __unused)
	Unfilter byte using the "Average" filter.
static unsigned int	png_paeth_predictor (unsigned int a, unsigned int b, unsigned int c)
	Paeth predictor function (defined in RFC 2083).
static unsigned int	png_unfilter_paeth (unsigned int current, unsigned int left, unsigned int above, unsigned int above_left)
	Unfilter byte using the "Paeth" filter.
static int	png_unfilter_pass (struct image *image, struct png_context *png, struct png_interlace *interlace)
	Unfilter one interlace pass of PNG raw data.
static int	png_unfilter (struct image *image, struct png_context *png)
	Unfilter PNG raw data.
static unsigned int	png_pixel (unsigned int raw, unsigned int alpha, unsigned int max)
	Calculate PNG pixel component value.
static void	png_pixels_pass (struct image *image, struct png_context *png, struct png_interlace *interlace)
	Fill one interlace pass of PNG pixels.
static void	png_pixels (struct image *image, struct png_context *png)
	Fill PNG pixels.
static int	png_image_end (struct image *image, struct png_context *png, size_t len)
	Handle PNG image end chunk.
static int	png_chunk (struct image *image, struct png_context *png, uint32_t type, size_t len)
	Handle PNG chunk.
static int	png_pixbuf (struct image *image, struct pixel_buffer **pixbuf)
	Convert PNG image to pixel buffer.
static int	png_probe (struct image *image)
	Probe PNG image.
struct image_type png_image_type	__image_type (PROBE_NORMAL)
	PNG image type.

Variables
static struct png_signature	png_signature = PNG_SIGNATURE
	PNG file signature.
static uint8_t	png_interlace_passes []
	Number of interlacing passes.
static struct png_filter	png_filters []
	PNG filter types.
static struct png_chunk_handler	png_chunk_handlers []
	PNG chunk handlers.

Detailed Description

Portable Network Graphics (PNG) format.

The PNG format is defined in RFC 2083.

Definition in file png.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

png_type_name()

const char * png_type_name ( uint32_t type )

static

Transcribe PNG chunk type name (for debugging).

Parameters

type	Chunk type

Return values

name	Chunk type name

Definition at line 102 of file png.c.

                                                    {
        static union {
                uint32_t type;
                char name[ sizeof ( uint32_t ) + 1 /* NUL */ ];
        } u;
 
        u.type = type;
        return u.name;
}

References name, type, and u.

Referenced by png_chunk().

png_interlace()

void png_interlace ( struct png_context * png, unsigned int pass, struct png_interlace * interlace )

static

Calculate PNG interlace pass parameters.

Parameters

png	PNG context
pass	Pass number (0=first pass)
interlace	Interlace pass to fill in

Definition at line 119 of file png.c.

                                                              {
        unsigned int grid_width_log2;
        unsigned int grid_height_log2;
        unsigned int x_indent;
        unsigned int y_indent;
        unsigned int x_stride_log2;
        unsigned int y_stride_log2;
        unsigned int x_stride;
        unsigned int y_stride;
        unsigned int width;
        unsigned int height;
 
        /* Sanity check */
        assert ( png->passes > 0 );
 
        /* Store pass number */
        interlace->pass = pass;
 
        /* Calculate interlace grid dimensions */
        grid_width_log2 = ( png->passes / 2 );
        grid_height_log2 = ( ( png->passes - 1 ) / 2 );
 
        /* Calculate starting indents */
        interlace->x_indent = x_indent =
                ( ( pass & 1 ) ?
                  ( 1 << ( grid_width_log2 - ( pass / 2 ) - 1 ) ) : 0 );
        interlace->y_indent = y_indent =
                ( ( pass && ! ( pass & 1 ) ) ?
                  ( 1 << ( grid_height_log2 - ( ( pass - 1 ) / 2 ) - 1 ) ) : 0);
 
        /* Calculate strides */
        x_stride_log2 = ( grid_width_log2 - ( pass / 2 ) );
        y_stride_log2 =
                ( grid_height_log2 - ( pass ? ( ( pass - 1 ) / 2 ) : 0 ) );
        interlace->x_stride = x_stride = ( 1 << x_stride_log2 );
        interlace->y_stride = y_stride = ( 1 << y_stride_log2 );
 
        /* Calculate pass dimensions */
        width = png->pixbuf->width;
        height = png->pixbuf->height;
        interlace->width =
                ( ( width - x_indent + x_stride - 1 ) >> x_stride_log2 );
        interlace->height =
                ( ( height - y_indent + y_stride - 1 ) >> y_stride_log2 );
}

References assert, pixel_buffer::height, png_interlace::height, png_interlace::pass, png_context::passes, png_context::pixbuf, pixel_buffer::width, png_interlace::width, png_interlace::x_indent, png_interlace::x_stride, png_interlace::y_indent, and png_interlace::y_stride.

Referenced by png_image_header(), png_pixels(), and png_unfilter().

png_pixel_len()

unsigned int png_pixel_len ( struct png_context * png )

static

Calculate PNG pixel length.

Parameters

png	PNG context

Return values

pixel_len

Pixel length

Definition at line 172 of file png.c.

                                                              {
 
        return ( ( ( png->channels * png->depth ) + 7 ) / 8 );
}

References png_context::channels, and png_context::depth.

Referenced by png_unfilter_pass().

png_scanline_len()

size_t png_scanline_len ( struct png_context * png, struct png_interlace * interlace )

static

Calculate PNG scanline length.

Parameters

png	PNG context
interlace	Interlace pass

Return values

scanline_len

Scanline length (including filter byte), or 0 on error

Definition at line 184 of file png.c.

                                                                   {
        size_t bits;
 
        /* Calculate bit count and check for overflow */
        bits = ( interlace->width * png->channels * png->depth );
        assert ( png->channels != 0 );
        assert ( png->depth != 0 );
        if ( ( ( bits / png->channels ) / png->depth ) != interlace->width )
                return 0;
 
        /* Calculate byte length (cannot overflow) */
        return ( 1 /* Filter byte */ + ( bits / 8 ) + ( !! ( bits & 7 ) ) );
}

References assert, bits, png_context::channels, png_context::depth, and png_interlace::width.

Referenced by png_image_header(), and png_unfilter_pass().

png_image_header()

int png_image_header ( struct image * image, struct png_context * png, size_t len )

static

Handle PNG image header chunk.

Parameters

image	PNG image
png	PNG context
len	Chunk length

Return values

rc	Return status code

Definition at line 207 of file png.c.

                                           {
        const struct png_image_header *ihdr;
        struct png_interlace interlace;
        size_t scanline_len;
        size_t pass_len;
        unsigned int pass;
 
        /* Sanity check */
        if ( len != sizeof ( *ihdr ) ) {
                DBGC ( image, "PNG %s invalid IHDR length %zd\n",
                       image->name, len );
                return -EINVAL;
        }
        if ( png->pixbuf ) {
                DBGC ( image, "PNG %s duplicate IHDR\n", image->name );
                return -EINVAL;
        }
 
        /* Extract image header */
        ihdr = ( image->data + png->offset );
        DBGC ( image, "PNG %s %dx%d depth %d type %d compression %d filter %d "
               "interlace %d\n", image->name, ntohl ( ihdr->width ),
               ntohl ( ihdr->height ), ihdr->depth, ihdr->colour_type,
               ihdr->compression, ihdr->filter, ihdr->interlace );
 
        /* Sanity checks */
        if ( ihdr->compression >= PNG_COMPRESSION_UNKNOWN ) {
                DBGC ( image, "PNG %s unknown compression method %d\n",
                       image->name, ihdr->compression );
                return -ENOTSUP;
        }
        if ( ihdr->filter >= PNG_FILTER_UNKNOWN ) {
                DBGC ( image, "PNG %s unknown filter method %d\n",
                       image->name, ihdr->filter );
                return -ENOTSUP;
        }
        if ( ihdr->interlace >= PNG_INTERLACE_UNKNOWN ) {
                DBGC ( image, "PNG %s unknown interlace method %d\n",
                       image->name, ihdr->interlace );
                return -ENOTSUP;
        }
 
        /* Allocate pixel buffer */
        png->pixbuf = alloc_pixbuf ( ntohl ( ihdr->width ),
                                     ntohl ( ihdr->height ) );
        if ( ! png->pixbuf ) {
                DBGC ( image, "PNG %s could not allocate pixel buffer\n",
                       image->name );
                return -ENOMEM;
        }
 
        /* Extract bit depth */
        png->depth = ihdr->depth;
        if ( ( png->depth == 0 ) ||
             ( ( png->depth & ( png->depth - 1 ) ) != 0 ) ) {
                DBGC ( image, "PNG %s invalid depth %d\n",
                       image->name, png->depth );
                return -EINVAL;
        }
 
        /* Calculate number of channels */
        png->colour_type = ihdr->colour_type;
        png->channels = 1;
        if ( ! ( ihdr->colour_type & PNG_COLOUR_TYPE_PALETTE ) ) {
                if ( ihdr->colour_type & PNG_COLOUR_TYPE_RGB )
                        png->channels += 2;
                if ( ihdr->colour_type & PNG_COLOUR_TYPE_ALPHA )
                        png->channels += 1;
        }
 
        /* Calculate number of interlace passes */
        png->passes = png_interlace_passes[ihdr->interlace];
 
        /* Calculate length of raw data buffer */
        for ( pass = 0 ; pass < png->passes ; pass++ ) {
                png_interlace ( png, pass, &interlace );
                if ( interlace.width == 0 )
                        continue;
                scanline_len = png_scanline_len ( png, &interlace );
                if ( ! scanline_len )
                        return -ERANGE;
                pass_len = ( interlace.height * scanline_len );
                if ( ( pass_len / scanline_len ) != interlace.height )
                        return -ERANGE;
                png->raw.len += pass_len;
                if ( png->raw.len < pass_len )
                        return -ERANGE;
        }
 
        /* Allocate raw data buffer */
        png->raw.data = umalloc ( png->raw.len );
        if ( ! png->raw.data ) {
                DBGC ( image, "PNG %s could not allocate data buffer\n",
                       image->name );
                return -ENOMEM;
        }
 
        return 0;
}

References alloc_pixbuf(), png_context::channels, png_context::colour_type, png_image_header::colour_type, png_image_header::compression, deflate_chunk::data, image::data, DBGC, png_context::depth, png_image_header::depth, EINVAL, ENOMEM, ENOTSUP, ERANGE, png_image_header::filter, png_image_header::height, png_interlace::height, png_image_header::interlace, deflate_chunk::len, len, image::name, ntohl, png_context::offset, png_interlace::pass, png_context::passes, png_context::pixbuf, PNG_COLOUR_TYPE_ALPHA, PNG_COLOUR_TYPE_PALETTE, PNG_COLOUR_TYPE_RGB, PNG_COMPRESSION_UNKNOWN, PNG_FILTER_UNKNOWN, png_interlace(), png_interlace_passes, PNG_INTERLACE_UNKNOWN, png_scanline_len(), png_context::raw, umalloc(), png_image_header::width, and png_interlace::width.

png_palette()

int png_palette ( struct image * image, struct png_context * png, size_t len )

static

Handle PNG palette chunk.

Parameters

image	PNG image
png	PNG context
len	Chunk length

Return values

rc	Return status code

Definition at line 316 of file png.c.

                                      {
        const struct png_palette_entry *palette;
        unsigned int i;
 
        /* Populate palette */
        palette = ( image->data + png->offset );
        for ( i = 0 ; i < ( sizeof ( png->palette ) /
                            sizeof ( png->palette[0] ) ) ; i++ ) {
 
                /* Stop when we run out of palette data */
                if ( len < sizeof ( *palette ) )
                        break;
 
                /* Extract palette entry */
                png->palette[i] = ( ( palette->red << 16 ) |
                                    ( palette->green << 8 ) |
                                    ( palette->blue << 0 ) );
                DBGC2 ( image, "PNG %s palette entry %d is %#06x\n",
                        image->name, i, png->palette[i] );
 
                /* Move to next entry */
                palette++;
                len -= sizeof ( *palette );
        }
 
        return 0;
}

References png_palette_entry::blue, image::data, DBGC2, png_palette_entry::green, len, image::name, png_context::offset, png_context::palette, and png_palette_entry::red.

png_image_data()

int png_image_data ( struct image * image, struct png_context * png, size_t len )

static

Handle PNG image data chunk.

Parameters

image	PNG image
png	PNG context
len	Chunk length

Return values

rc	Return status code

Definition at line 353 of file png.c.

                                         {
        int rc;
 
        /* Deflate this chunk */
        if ( ( rc = deflate_inflate ( &png->deflate,
                                      ( image->data + png->offset ),
                                      len, &png->raw ) ) != 0 ) {
                DBGC ( image, "PNG %s could not decompress: %s\n",
                       image->name, strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References image::data, DBGC, png_context::deflate, deflate_inflate(), len, image::name, png_context::offset, png_context::raw, rc, and strerror().

png_unfilter_none()

unsigned int png_unfilter_none ( unsigned int current, unsigned int left __unused, unsigned int above __unused, unsigned int above_left __unused )

static

Unfilter byte using the "None" filter.

Parameters

current	Filtered current byte
left	Unfiltered left byte
above	Unfiltered above byte
above_left	Unfiltered above-left byte

Return values

current

Unfiltered current byte

Definition at line 378 of file png.c.

                                                                           {
 
        return current;
}

References __unused.

png_unfilter_sub()

unsigned int png_unfilter_sub ( unsigned int current, unsigned int left, unsigned int above __unused, unsigned int above_left __unused )

static

Unfilter byte using the "Sub" filter.

Parameters

current	Filtered current byte
left	Unfiltered left byte
above	Unfiltered above byte
above_left	Unfiltered above-left byte

Return values

current

Unfiltered current byte

Definition at line 395 of file png.c.

                                                                          {
 
        return ( current + left );
}

References __unused.

png_unfilter_up()

unsigned int png_unfilter_up ( unsigned int current, unsigned int left __unused, unsigned int above, unsigned int above_left __unused )

static

Unfilter byte using the "Up" filter.

Parameters

current	Filtered current byte
left	Unfiltered left byte
above	Unfiltered above byte
above_left	Unfiltered above-left byte

Return values

current

Unfiltered current byte

Definition at line 412 of file png.c.

                                                                         {
 
        return ( current + above );
}

References __unused.

png_unfilter_average()

unsigned int png_unfilter_average ( unsigned int current, unsigned int left, unsigned int above, unsigned int above_left __unused )

static

Unfilter byte using the "Average" filter.

Parameters

current	Filtered current byte
left	Unfiltered left byte
above	Unfiltered above byte
above_left	Unfiltered above-left byte

Return values

current

Unfiltered current byte

Definition at line 429 of file png.c.

                                                                              {
 
        return ( current + ( ( above + left ) >> 1 ) );
}

References __unused.

png_paeth_predictor()

unsigned int png_paeth_predictor ( unsigned int a, unsigned int b, unsigned int c )

static

Paeth predictor function (defined in RFC 2083).

Parameters

a	Pixel A
b	Pixel B
c	Pixel C

Return values

predictor

Predictor pixel

Definition at line 445 of file png.c.

                                                           {
        unsigned int p;
        unsigned int pa;
        unsigned int pb;
        unsigned int pc;
 
        /* Algorithm as defined in RFC 2083 section 6.6 */
        p = ( a + b - c );
        pa = abs ( p - a );
        pb = abs ( p - b );
        pc = abs ( p - c );
        if ( ( pa <= pb ) && ( pa <= pc ) ) {
                return a;
        } else if ( pb <= pc ) {
                return b;
        } else {
                return c;
        }
}

References abs.

Referenced by png_unfilter_paeth().

png_unfilter_paeth()

unsigned int png_unfilter_paeth ( unsigned int current, unsigned int left, unsigned int above, unsigned int above_left )

static

Unfilter byte using the "Paeth" filter.

Parameters

current	Filtered current byte
above_left	Unfiltered above-left byte
above	Unfiltered above byte
left	Unfiltered left byte

Return values

current

Unfiltered current byte

Definition at line 475 of file png.c.

                                                                   {
 
        return ( current + png_paeth_predictor ( left, above, above_left ) );
}

References png_paeth_predictor().

png_unfilter_pass()

int png_unfilter_pass ( struct image * image, struct png_context * png, struct png_interlace * interlace )

static

Unfilter one interlace pass of PNG raw data.

Parameters

image	PNG image
png	PNG context
interlace	Interlace pass

Return values

rc	Return status code

This routine may assume that it is impossible to overrun the raw data buffer, since the size is determined by the image dimensions.

Definition at line 520 of file png.c.

                                                                 {
        size_t pixel_len = png_pixel_len ( png );
        size_t scanline_len = png_scanline_len ( png, interlace );
        uint8_t *data = ( png->raw.data + png->raw.offset );
        struct png_filter *filter;
        unsigned int scanline;
        unsigned int byte;
        unsigned int filter_type;
        unsigned int left;
        unsigned int above;
        unsigned int above_left;
 
        /* On the first scanline of a pass, above bytes are assumed to
         * be zero.
         */
        above = 0;
 
        /* Iterate over each scanline in turn */
        for ( scanline = 0 ; scanline < interlace->height ; scanline++ ) {
 
                /* Extract filter byte and determine filter type */
                filter_type = *(data++);
                if ( filter_type >= ( sizeof ( png_filters ) /
                                      sizeof ( png_filters[0] ) ) ) {
                        DBGC ( image, "PNG %s unknown filter type %d\n",
                               image->name, filter_type );
                        return -ENOTSUP;
                }
                filter = &png_filters[filter_type];
                assert ( filter->unfilter != NULL );
                DBGC2 ( image, "PNG %s pass %d scanline %d filter type %d\n",
                        image->name, interlace->pass, scanline, filter_type );
 
                /* At the start of a line, both above-left and left
                 * bytes are taken to be zero.
                 */
                left = 0;
                above_left = 0;
 
                /* Iterate over each byte (not pixel) in turn */
                for ( byte = 0 ; byte < ( scanline_len - 1 ) ; byte++ ) {
 
                        /* Extract predictor bytes, if applicable */
                        if ( byte >= pixel_len )
                                left = *( data - pixel_len );
                        if ( scanline > 0 )
                                above = *( data - scanline_len );
                        if ( ( scanline > 0 ) && ( byte >= pixel_len ) ) {
                                above_left = *( data - scanline_len -
                                                pixel_len );
                        }
 
                        /* Unfilter current byte */
                        *data = filter->unfilter ( *data, left, above,
                                                   above_left );
                        data++;
                }
        }
 
        /* Update offset */
        png->raw.offset = ( ( ( void * ) data ) - png->raw.data );
 
        return 0;
}

References assert, data, deflate_chunk::data, DBGC, DBGC2, ENOTSUP, filter, png_interlace::height, image::name, NULL, deflate_chunk::offset, png_interlace::pass, png_filters, png_pixel_len(), png_scanline_len(), and png_context::raw.

Referenced by png_unfilter().

png_unfilter()

int png_unfilter ( struct image * image, struct png_context * png )

static

Unfilter PNG raw data.

Parameters

image	PNG image
png	PNG context

Return values

rc	Return status code

This routine may assume that it is impossible to overrun the raw data buffer, since the size is determined by the image dimensions.

Definition at line 596 of file png.c.

                                                                         {
        struct png_interlace interlace;
        unsigned int pass;
        int rc;
 
        /* Process each interlace pass */
        png->raw.offset = 0;
        for ( pass = 0 ; pass < png->passes ; pass++ ) {
 
                /* Calculate interlace pass parameters */
                png_interlace ( png, pass, &interlace );
 
                /* Skip zero-width rows (which have no filter bytes) */
                if ( interlace.width == 0 )
                        continue;
 
                /* Unfilter this pass */
                if ( ( rc = png_unfilter_pass ( image, png,
                                                &interlace ) ) != 0 )
                        return rc;
        }
        assert ( png->raw.offset == png->raw.len );
 
        return 0;
}

References assert, deflate_chunk::len, deflate_chunk::offset, png_interlace::pass, png_context::passes, png_interlace(), png_unfilter_pass(), png_context::raw, rc, and png_interlace::width.

Referenced by png_image_end().

png_pixel()

unsigned int png_pixel ( unsigned int raw, unsigned int alpha, unsigned int max )

inlinestatic

Calculate PNG pixel component value.

Parameters

raw	Raw component value
alpha	Alpha value
max	Maximum raw/alpha value

Return values

value

Component value in range 0-255

Definition at line 630 of file png.c.

                                                          {
 
        /* The basic calculation is 255*(raw/max)*(value/max).  We use
         * fixed-point arithmetic (scaling up to the maximum range for
         * a 32-bit integer), in order to get the same results for
         * alpha blending as the test cases (produced using
         * ImageMagick).
         */
        return ( ( ( ( ( 0xff00 * raw * alpha ) / max ) / max ) + 0x80 ) >> 8 );
}

References max, and raw.

Referenced by png_pixels_pass().

png_pixels_pass()

void png_pixels_pass ( struct image * image, struct png_context * png, struct png_interlace * interlace )

static

Fill one interlace pass of PNG pixels.

Parameters

image	PNG image
png	PNG context
interlace	Interlace pass

This routine may assume that it is impossible to overrun either the raw data buffer or the pixel buffer, since the sizes of both are determined by the image dimensions.

Definition at line 653 of file png.c.

                                                                {
        uint8_t channel[png->channels];
        int is_indexed = ( png->colour_type & PNG_COLOUR_TYPE_PALETTE );
        int is_rgb = ( png->colour_type & PNG_COLOUR_TYPE_RGB );
        int has_alpha = ( png->colour_type & PNG_COLOUR_TYPE_ALPHA );
        const uint8_t *data = ( png->raw.data + png->raw.offset );
        size_t data_stride;
        unsigned int pixbuf_y_index;
        unsigned int pixbuf_index;
        unsigned int pixbuf_x_stride;
        unsigned int pixbuf_y_stride;
        unsigned int y;
        unsigned int x;
        unsigned int c;
        unsigned int bits;
        unsigned int depth;
        unsigned int max;
        unsigned int alpha;
        unsigned int raw;
        unsigned int value;
        uint8_t current = 0;
        uint32_t pixel;
 
        /* We only ever use the top byte of 16-bit pixels.  Model this
         * as a bit depth of 8 with a stride of more than one.
         */
        depth = png->depth;
        data_stride = ( ( depth + 7 ) / 8 );
        if ( depth > 8 )
                depth = 8;
        max = ( ( 1 << depth ) - 1 );
 
        /* Calculate pixel buffer offset and strides */
        pixbuf_y_index = ( ( ( interlace->y_indent * png->pixbuf->width ) +
                              interlace->x_indent ) );
        pixbuf_x_stride = interlace->x_stride;
        pixbuf_y_stride = ( interlace->y_stride * png->pixbuf->width );
        DBGC2 ( image, "PNG %s pass %d %dx%d at (%d,%d) stride (%d,%d)\n",
                image->name, interlace->pass, interlace->width,
                interlace->height, interlace->x_indent, interlace->y_indent,
                interlace->x_stride, interlace->y_stride );
 
        /* Iterate over each scanline in turn */
        for ( y = 0 ; y < interlace->height ; y++ ) {
 
                /* Skip filter byte */
                data++;
 
                /* Iterate over each pixel in turn */
                bits = depth;
                pixbuf_index = pixbuf_y_index;
                for ( x = 0 ; x < interlace->width ; x++ ) {
 
                        /* Extract sample value */
                        for ( c = 0 ; c < png->channels ; c++ ) {
 
                                /* Get sample value into high bits of current */
                                current <<= depth;
                                bits -= depth;
                                if ( ! bits ) {
                                        current = *data;
                                        data += data_stride;
                                        bits = 8;
                                }
 
                                /* Extract sample value */
                                channel[c] = ( current >> ( 8 - depth ) );
                        }
 
                        /* Convert to native pixel format */
                        if ( is_indexed ) {
 
                                /* Indexed */
                                pixel = png->palette[channel[0]];
 
                        } else {
 
                                /* Determine alpha value */
                                alpha = ( has_alpha ?
                                          channel[ png->channels - 1 ] : max );
 
                                /* Convert to RGB value */
                                pixel = 0;
                                for ( c = 0 ; c < 3 ; c++ ) {
                                        raw = channel[ is_rgb ? c : 0 ];
                                        value = png_pixel ( raw, alpha, max );
                                        assert ( value <= 255 );
                                        pixel = ( ( pixel << 8 ) | value );
                                }
                        }
 
                        /* Store pixel */
                        png->pixbuf->data[pixbuf_index] = pixel;
                        pixbuf_index += pixbuf_x_stride;
                }
 
                /* Move to next output row */
                pixbuf_y_index += pixbuf_y_stride;
        }
 
        /* Update offset */
        png->raw.offset = ( ( ( const void * ) data ) - png->raw.data );
}

References assert, bits, channel, png_context::channels, png_context::colour_type, data, deflate_chunk::data, pixel_buffer::data, DBGC2, png_context::depth, png_interlace::height, max, image::name, deflate_chunk::offset, png_context::palette, png_interlace::pass, png_context::pixbuf, PNG_COLOUR_TYPE_ALPHA, PNG_COLOUR_TYPE_PALETTE, PNG_COLOUR_TYPE_RGB, png_pixel(), png_context::raw, raw, value, pixel_buffer::width, png_interlace::width, x, png_interlace::x_indent, png_interlace::x_stride, y, png_interlace::y_indent, and png_interlace::y_stride.

Referenced by png_pixels().

png_pixels()

void png_pixels ( struct image * image, struct png_context * png )

static

Fill PNG pixels.

Parameters

image	PNG image
png	PNG context

This routine may assume that it is impossible to overrun either the raw data buffer or the pixel buffer, since the sizes of both are determined by the image dimensions.

Definition at line 769 of file png.c.

                                                                        {
        struct png_interlace interlace;
        unsigned int pass;
 
        /* Process each interlace pass */
        png->raw.offset = 0;
        for ( pass = 0 ; pass < png->passes ; pass++ ) {
 
                /* Calculate interlace pass parameters */
                png_interlace ( png, pass, &interlace );
 
                /* Skip zero-width rows (which have no filter bytes) */
                if ( interlace.width == 0 )
                        continue;
 
                /* Unfilter this pass */
                png_pixels_pass ( image, png, &interlace );
        }
        assert ( png->raw.offset == png->raw.len );
}

References assert, deflate_chunk::len, deflate_chunk::offset, png_interlace::pass, png_context::passes, png_interlace(), png_pixels_pass(), png_context::raw, and png_interlace::width.

Referenced by png_image_end().

png_image_end()

int png_image_end ( struct image * image, struct png_context * png, size_t len )

static

Handle PNG image end chunk.

Parameters

image	PNG image
png	PNG context
len	Chunk length

Return values

rc	Return status code

Definition at line 798 of file png.c.

                                        {
        int rc;
 
        /* Sanity checks */
        if ( len != 0 ) {
                DBGC ( image, "PNG %s invalid IEND length %zd\n",
                       image->name, len );
                return -EINVAL;
        }
        if ( ! png->pixbuf ) {
                DBGC ( image, "PNG %s missing pixel buffer (no IHDR?)\n",
                       image->name );
                return -EINVAL;
        }
        if ( ! deflate_finished ( &png->deflate ) ) {
                DBGC ( image, "PNG %s decompression not complete\n",
                       image->name );
                return -EINVAL;
        }
        if ( png->raw.offset != png->raw.len ) {
                DBGC ( image, "PNG %s incorrect decompressed length (expected "
                       "%zd, got %zd)\n", image->name, png->raw.len,
                       png->raw.offset );
                return -EINVAL;
        }
 
        /* Unfilter raw data */
        if ( ( rc = png_unfilter ( image, png ) ) != 0 )
                return rc;
 
        /* Fill pixel buffer */
        png_pixels ( image, png );
 
        return 0;
}

References DBGC, png_context::deflate, deflate_finished(), EINVAL, deflate_chunk::len, len, image::name, deflate_chunk::offset, png_context::pixbuf, png_pixels(), png_unfilter(), png_context::raw, and rc.

png_chunk()

int png_chunk ( struct image * image, struct png_context * png, uint32_t type, size_t len )

static

Handle PNG chunk.

Parameters

image	PNG image
png	PNG context
type	Chunk type
len	Chunk length

Return values

rc	Return status code

Definition at line 868 of file png.c.

                                                   {
        struct png_chunk_handler *handler;
        unsigned int i;
 
        DBGC ( image, "PNG %s chunk type %s offset %zd length %zd\n",
               image->name, png_type_name ( type ), png->offset, len );
 
        /* Handle according to chunk type */
        for ( i = 0 ; i < ( sizeof ( png_chunk_handlers ) /
                            sizeof ( png_chunk_handlers[0] ) ) ; i++ ) {
                handler = &png_chunk_handlers[i];
                if ( handler->type == type )
                        return handler->handle ( image, png, len );
        }
 
        /* Fail if unknown chunk type is critical */
        if ( ! ( type & htonl ( PNG_CHUNK_ANCILLARY ) ) ) {
                DBGC ( image, "PNG %s unknown critical chunk type %s\n",
                       image->name, png_type_name ( type ) );
                return -ENOTSUP;
        }
 
        /* Ignore non-critical unknown chunk types */
        return 0;
}

References DBGC, ENOTSUP, png_chunk_handler::handle, htonl, len, image::name, png_context::offset, PNG_CHUNK_ANCILLARY, png_chunk_handlers, png_type_name(), png_chunk_handler::type, and type.

Referenced by png_pixbuf().

png_pixbuf()

int png_pixbuf ( struct image * image, struct pixel_buffer ** pixbuf )

static

Convert PNG image to pixel buffer.

Parameters

image	PNG image
pixbuf	Pixel buffer to fill in

Return values

rc	Return status code

Definition at line 902 of file png.c.

                                                                            {
        struct png_context *png;
        const struct png_chunk_header *header;
        const struct png_chunk_footer *footer;
        size_t remaining;
        size_t chunk_len;
        int rc;
 
        /* Allocate and initialise context */
        png = zalloc ( sizeof ( *png ) );
        if ( ! png ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
        png->offset = sizeof ( struct png_signature );
        deflate_init ( &png->deflate, DEFLATE_ZLIB );
 
        /* Process chunks */
        do {
 
                /* Extract chunk header */
                remaining = ( image->len - png->offset );
                if ( remaining < ( sizeof ( *header ) + sizeof ( *footer ) ) ){
                        DBGC ( image, "PNG %s truncated chunk header/footer "
                               "at offset %zd\n", image->name, png->offset );
                        rc = -EINVAL;
                        goto err_truncated;
                }
                header = ( image->data + png->offset );
                png->offset += sizeof ( *header );
 
                /* Validate chunk length */
                chunk_len = ntohl ( header->len );
                if ( chunk_len > ( remaining - sizeof ( *header ) -
                                   sizeof ( *footer ) ) ) {
                        DBGC ( image, "PNG %s truncated chunk data at offset "
                               "%zd\n", image->name, png->offset );
                        rc = -EINVAL;
                        goto err_truncated;
                }
 
                /* Handle chunk */
                if ( ( rc = png_chunk ( image, png, header->type,
                                        chunk_len ) ) != 0 )
                        goto err_chunk;
 
                /* Move to next chunk */
                png->offset += ( chunk_len + sizeof ( *footer ) );
 
        } while ( png->offset < image->len );
 
        /* Check that we finished with an IEND chunk */
        if ( header->type != htonl ( PNG_TYPE_IEND ) ) {
                DBGC ( image, "PNG %s did not finish with IEND\n",
                       image->name );
                rc = -EINVAL;
                goto err_iend;
        }
 
        /* Return pixel buffer */
        *pixbuf = pixbuf_get ( png->pixbuf );
 
        /* Success */
        rc = 0;
 
 err_iend:
 err_chunk:
 err_truncated:
        pixbuf_put ( png->pixbuf );
        ufree ( png->raw.data );
        free ( png );
 err_alloc:
        return rc;
}

References deflate_chunk::data, image::data, DBGC, png_context::deflate, deflate_init(), DEFLATE_ZLIB, EINVAL, ENOMEM, free, header, htonl, image::len, image::name, ntohl, png_context::offset, png_context::pixbuf, png_chunk(), PNG_TYPE_IEND, png_context::raw, rc, ufree(), and zalloc().

Referenced by __image_type().

png_probe()

int png_probe ( struct image * image )

static

Probe PNG image.

Parameters

image

PNG image

Return values

rc	Return status code

Definition at line 983 of file png.c.

                                             {
        const struct png_signature *signature;
 
        /* Sanity check */
        if ( image->len < sizeof ( *signature ) ) {
                DBGC ( image, "PNG %s is too short\n", image->name );
                return -ENOEXEC;
        }
 
        /* Check signature */
        signature = image->data;
        if ( memcmp ( signature, &png_signature, sizeof ( *signature ) ) != 0 ){
                DBGC ( image, "PNG %s has invalid signature\n", image->name );
                return -ENOEXEC;
        }
 
        return 0;
}

References image::data, DBGC, ENOEXEC, image::len, memcmp(), image::name, and signature.

Referenced by __image_type().

__image_type()

struct image_type png_image_type __image_type

(

PROBE_NORMAL

)

PNG image type.

References __image_type, png_pixbuf(), png_probe(), and PROBE_NORMAL.

Variable Documentation

png_signature

struct png_signature png_signature = PNG_SIGNATURE

static

PNG file signature.

Definition at line 88 of file png.c.

png_interlace_passes

uint8_t png_interlace_passes[]

static

Initial value:

                                    = {
        [PNG_INTERLACE_NONE] = 1,
        [PNG_INTERLACE_ADAM7] = 7,
}

Number of interlacing passes.

Definition at line 91 of file png.c.

                                      {
        [PNG_INTERLACE_NONE] = 1,
        [PNG_INTERLACE_ADAM7] = 7,
};

Referenced by png_image_header().

png_filters

struct png_filter png_filters[]

static

Initial value:

                        = {
        [PNG_FILTER_BASIC_NONE] = { png_unfilter_none },
        [PNG_FILTER_BASIC_SUB] = { png_unfilter_sub },
        [PNG_FILTER_BASIC_UP] = { png_unfilter_up },
        [PNG_FILTER_BASIC_AVERAGE] = { png_unfilter_average },
        [PNG_FILTER_BASIC_PAETH] = { png_unfilter_paeth },
}

PNG filter types.

Definition at line 501 of file png.c.

                                       {
        [PNG_FILTER_BASIC_NONE] = { png_unfilter_none },
        [PNG_FILTER_BASIC_SUB] = { png_unfilter_sub },
        [PNG_FILTER_BASIC_UP] = { png_unfilter_up },
        [PNG_FILTER_BASIC_AVERAGE] = { png_unfilter_average },
        [PNG_FILTER_BASIC_PAETH] = { png_unfilter_paeth },
};

Referenced by png_unfilter_pass().

png_chunk_handlers

struct png_chunk_handler png_chunk_handlers[]

static

Initial value:

                               = {
        { htonl ( PNG_TYPE_IHDR ), png_image_header },
        { htonl ( PNG_TYPE_PLTE ), png_palette },
        { htonl ( PNG_TYPE_IDAT ), png_image_data },
        { htonl ( PNG_TYPE_IEND ), png_image_end },
}

PNG chunk handlers.

Definition at line 852 of file png.c.

                                                     {
        { htonl ( PNG_TYPE_IHDR ), png_image_header },
        { htonl ( PNG_TYPE_PLTE ), png_palette },
        { htonl ( PNG_TYPE_IDAT ), png_image_data },
        { htonl ( PNG_TYPE_IEND ), png_image_end },
};

Referenced by png_chunk().