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>

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)

static const char *	png_type_name (uint32_t type)
	Transcribe PNG chunk type name (for debugging) More...

static void	png_interlace (struct png_context png, unsigned int pass, struct png_interlace interlace)
	Calculate PNG interlace pass parameters. More...

static unsigned int	png_pixel_len (struct png_context *png)
	Calculate PNG pixel length. More...

static size_t	png_scanline_len (struct png_context png, struct png_interlace interlace)
	Calculate PNG scanline length. More...

static int	png_image_header (struct image image, struct png_context png, size_t len)
	Handle PNG image header chunk. More...

static int	png_palette (struct image image, struct png_context png, size_t len)
	Handle PNG palette chunk. More...

static int	png_image_data (struct image image, struct png_context png, size_t len)
	Handle PNG image data chunk. More...

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. More...

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. More...

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. More...

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. More...

static unsigned int	png_paeth_predictor (unsigned int a, unsigned int b, unsigned int c)
	Paeth predictor function (defined in RFC 2083) More...

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. More...

static int	png_unfilter_pass (struct image image, struct png_context png, struct png_interlace *interlace)
	Unfilter one interlace pass of PNG raw data. More...

static int	png_unfilter (struct image image, struct png_context png)
	Unfilter PNG raw data. More...

static unsigned int	png_pixel (unsigned int raw, unsigned int alpha, unsigned int max)
	Calculate PNG pixel component value. More...

static void	png_pixels_pass (struct image image, struct png_context png, struct png_interlace *interlace)
	Fill one interlace pass of PNG pixels. More...

static void	png_pixels (struct image image, struct png_context png)
	Fill PNG pixels. More...

static int	png_image_end (struct image image, struct png_context png, size_t len)
	Handle PNG image end chunk. More...

static int	png_chunk (struct image image, struct png_context png, uint32_t type, size_t len)
	Handle PNG chunk. More...

static int	png_pixbuf (struct image image, struct pixel_buffer *pixbuf)
	Convert PNG image to pixel buffer. More...

static int	png_probe (struct image *image)
	Probe PNG image. More...

struct image_type png_image_type	__image_type (PROBE_NORMAL)
	PNG image type. More...

Variables
static struct png_signature	png_signature = PNG_SIGNATURE
	PNG file signature. More...

static uint8_t	png_interlace_passes []
	Number of interlacing passes. More...

static struct png_filter	png_filters []
	PNG filter types. More...

static struct png_chunk_handler	png_chunk_handlers []
	PNG chunk handlers. More...

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 )

◆ png_type_name()

static 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 101 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()

static 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 118 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()

static 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 171 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()

static 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)

Definition at line 183 of file png.c.

                                                                    {
 
         return ( 1 /* Filter byte */ +
                  ( ( interlace->width * png->channels * png->depth ) + 7 ) / 8);
 }

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

Referenced by png_image_header(), and png_unfilter_pass().

◆ png_image_header()

static 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 198 of file png.c.

                                            {
         struct png_image_header ihdr;
         struct png_interlace interlace;
         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 */
         copy_from_user ( &ihdr, image->data, png->offset, len );
         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;
                 png->raw.len += ( interlace.height *
                                   png_scanline_len ( png, &interlace ) );
         }
 
         /* 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, copy_from_user(), image::data, deflate_chunk::data, DBGC, png_context::depth, png_image_header::depth, EINVAL, ENOMEM, ENOTSUP, png_image_header::filter, png_interlace::height, png_image_header::height, png_image_header::interlace, len, deflate_chunk::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()

static 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 298 of file png.c.

                                       {
         size_t offset = png->offset;
         struct png_palette_entry palette;
         unsigned int i;
 
         /* Populate palette */
         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 */
                 copy_from_user ( &palette, image->data, offset,
                                  sizeof ( palette ) );
                 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 */
                 offset += sizeof ( palette );
                 len -= sizeof ( palette );
         }
 
         return 0;
 }

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

◆ png_image_data()

static 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 337 of file png.c.

                                          {
         struct deflate_chunk in;
         int rc;
 
         /* Deflate this chunk */
         deflate_chunk_init ( &in, image->data, png->offset,
                              ( png->offset + len ) );
         if ( ( rc = deflate_inflate ( &png->deflate, &in, &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(), in, len, image::name, png_context::offset, png_context::raw, rc, and strerror().

◆ png_unfilter_none()

static 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 363 of file png.c.

                                                                            {
 
         return current;
 }

◆ png_unfilter_sub()

static 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 380 of file png.c.

                                                                           {
 
         return ( current + left );
 }

◆ png_unfilter_up()

static 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 397 of file png.c.

                                                                          {
 
         return ( current + above );
 }

◆ png_unfilter_average()

static 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 414 of file png.c.

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

◆ png_paeth_predictor()

static 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 430 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, and c.

Referenced by png_unfilter_paeth().

◆ png_unfilter_paeth()

static 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 460 of file png.c.

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

References png_paeth_predictor().

◆ png_unfilter_pass()

static 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 505 of file png.c.

                                                                  {
         size_t offset = png->raw.offset;
         size_t pixel_len = png_pixel_len ( png );
         size_t scanline_len = png_scanline_len ( png, interlace );
         struct png_filter *filter;
         unsigned int scanline;
         unsigned int byte;
         uint8_t filter_type;
         uint8_t left;
         uint8_t above;
         uint8_t above_left;
         uint8_t current;
 
         /* 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 */
                 copy_from_user ( &filter_type, png->raw.data, offset++,
                                  sizeof ( filter_type ) );
                 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 ) {
                                 copy_from_user ( &left, png->raw.data,
                                                  ( offset - pixel_len ),
                                                  sizeof ( left ) );
                         }
                         if ( scanline > 0 ) {
                                 copy_from_user ( &above, png->raw.data,
                                                  ( offset - scanline_len ),
                                                  sizeof ( above ) );
                         }
                         if ( ( scanline > 0 ) && ( byte >= pixel_len ) ) {
                                 copy_from_user ( &above_left, png->raw.data,
                                                  ( offset - scanline_len -
                                                    pixel_len ),
                                                  sizeof ( above_left ) );
                         }
 
                         /* Unfilter current byte */
                         copy_from_user ( &current, png->raw.data,
                                          offset, sizeof ( current ) );
                         current = filter->unfilter ( current, left, above,
                                                      above_left );
                         copy_to_user ( png->raw.data, offset++,
                                        &current, sizeof ( current ) );
                 }
         }
 
         /* Update offset */
         png->raw.offset = offset;
 
         return 0;
 }

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

Referenced by png_unfilter().

◆ png_unfilter()

static 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 594 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()

static 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 628 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()

static 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 651 of file png.c.

                                                                 {
         size_t raw_offset = png->raw.offset;
         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 );
         size_t pixbuf_y_offset;
         size_t pixbuf_offset;
         size_t pixbuf_x_stride;
         size_t pixbuf_y_stride;
         size_t raw_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;
         raw_stride = ( ( depth + 7 ) / 8 );
         if ( depth > 8 )
                 depth = 8;
         max = ( ( 1 << depth ) - 1 );
 
         /* Calculate pixel buffer offset and strides */
         pixbuf_y_offset = ( ( ( interlace->y_indent * png->pixbuf->width ) +
                               interlace->x_indent ) * sizeof ( pixel ) );
         pixbuf_x_stride = ( interlace->x_stride * sizeof ( pixel ) );
         pixbuf_y_stride = ( interlace->y_stride * png->pixbuf->width *
                             sizeof ( pixel ) );
         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 */
                 raw_offset++;
 
                 /* Iterate over each pixel in turn */
                 bits = depth;
                 pixbuf_offset = pixbuf_y_offset;
                 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 ) {
                                         copy_from_user ( &current,
                                                          png->raw.data,
                                                          raw_offset,
                                                          sizeof ( current ) );
                                         raw_offset += raw_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 */
                         copy_to_user ( png->pixbuf->data, pixbuf_offset,
                                        &pixel, sizeof ( pixel ) );
                         pixbuf_offset += pixbuf_x_stride;
                 }
 
                 /* Move to next output row */
                 pixbuf_y_offset += pixbuf_y_stride;
         }
 
         /* Update offset */
         png->raw.offset = raw_offset;
 }

References assert(), bits, c, channel, png_context::channels, png_context::colour_type, copy_from_user(), copy_to_user(), pixel_buffer::data, deflate_chunk::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(), raw, png_context::raw, value, 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_pixels().

◆ png_pixels()

static 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 772 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()

static 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 801 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, len, deflate_chunk::len, image::name, deflate_chunk::offset, png_context::pixbuf, png_pixels(), png_unfilter(), png_context::raw, and rc.

◆ png_chunk()

static 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 871 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(), type, and png_chunk_handler::type.

Referenced by png_pixbuf().

◆ png_pixbuf()

static 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 905 of file png.c.

                                                                             {
         struct png_context *png;
         struct png_chunk_header header;
         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;
                 }
                 copy_from_user ( &header, image->data, png->offset,
                                  sizeof ( header ) );
                 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 copy_from_user(), image::data, deflate_chunk::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().

◆ png_probe()

static int png_probe ( struct image * image )

static

Probe PNG image.

Parameters

image PNG image

Return values

rc	Return status code

Definition at line 987 of file png.c.

                                              {
         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 */
         copy_from_user ( &signature, image->data, 0, sizeof ( signature ) );
         if ( memcmp ( &signature, &png_signature, sizeof ( signature ) ) != 0 ){
                 DBGC ( image, "PNG %s has invalid signature\n", image->name );
                 return -ENOEXEC;
         }
 
         return 0;
 }

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

◆ __image_type()

struct image_type png_image_type __image_type ( PROBE_NORMAL )

PNG image type.

Variable Documentation

◆ png_signature

struct png_signature png_signature = PNG_SIGNATURE

static

PNG file signature.

Definition at line 87 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 90 of file png.c.

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 486 of file png.c.

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 855 of file png.c.

Referenced by png_chunk().

Data Structures

Functions

Variables

Detailed Description

Function Documentation

◆ FILE_LICENCE()

◆ png_type_name()

◆ png_interlace()

◆ png_pixel_len()

◆ png_scanline_len()

◆ png_image_header()

◆ png_palette()

◆ png_image_data()

◆ png_unfilter_none()

◆ png_unfilter_sub()

◆ png_unfilter_up()

◆ png_unfilter_average()

◆ png_paeth_predictor()

◆ png_unfilter_paeth()

◆ png_unfilter_pass()

◆ png_unfilter()

◆ png_pixel()

◆ png_pixels_pass()

◆ png_pixels()

◆ png_image_end()

◆ png_chunk()

◆ png_pixbuf()

◆ png_probe()

◆ __image_type()

Variable Documentation

◆ png_signature

◆ png_interlace_passes

◆ png_filters

◆ png_chunk_handlers