| /* | |
| * Copyright (C) 2014 Michael Brown <mbrown@fensystems.co.uk>. | |
| * | |
| * This program is free software; you can redistribute it and/or | |
| * modify it under the terms of the GNU General Public License as | |
| * published by the Free Software Foundation; either version 2 of the | |
| * License, or any later version. | |
| * | |
| * This program is distributed in the hope that it will be useful, but | |
| * WITHOUT ANY WARRANTY; without even the implied warranty of | |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| * General Public License for more details. | |
| * | |
| * You should have received a copy of the GNU General Public License | |
| * along with this program; if not, write to the Free Software | |
| * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
| * 02110-1301, USA. | |
| * | |
| * You can also choose to distribute this program under the terms of | |
| * the Unmodified Binary Distribution Licence (as given in the file | |
| * COPYING.UBDL), provided that you have satisfied its requirements. | |
| */ | |
| FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL ); | |
| FILE_SECBOOT ( PERMITTED ); | |
| #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> | |
| /** @file | |
| * | |
| * Portable Network Graphics (PNG) format | |
| * | |
| * The PNG format is defined in RFC 2083. | |
| */ | |
| /** PNG context */ | |
| struct png_context { | |
| /** Offset within image */ | |
| size_t offset; | |
| /** Pixel buffer */ | |
| struct pixel_buffer *pixbuf; | |
| /** Bit depth */ | |
| unsigned int depth; | |
| /** Colour type */ | |
| unsigned int colour_type; | |
| /** Number of channels */ | |
| unsigned int channels; | |
| /** Number of interlace passes */ | |
| unsigned int passes; | |
| /** Palette, in iPXE's pixel buffer format */ | |
| uint32_t palette[PNG_PALETTE_COUNT]; | |
| /** Decompression buffer for raw PNG data */ | |
| struct deflate_chunk raw; | |
| /** Decompressor */ | |
| struct deflate deflate; | |
| }; | |
| /** A PNG interlace pass */ | |
| struct png_interlace { | |
| /** Pass number */ | |
| unsigned int pass; | |
| /** X starting indent */ | |
| unsigned int x_indent; | |
| /** Y starting indent */ | |
| unsigned int y_indent; | |
| /** X stride */ | |
| unsigned int x_stride; | |
| /** Y stride */ | |
| unsigned int y_stride; | |
| /** Width */ | |
| unsigned int width; | |
| /** Height */ | |
| unsigned int height; | |
| }; | |
| /** PNG file signature */ | |
| static struct png_signature png_signature = PNG_SIGNATURE; | |
| /** Number of interlacing passes */ | |
| static uint8_t png_interlace_passes[] = { | |
| [PNG_INTERLACE_NONE] = 1, | |
| [PNG_INTERLACE_ADAM7] = 7, | |
| }; | |
| /** | |
| * Transcribe PNG chunk type name (for debugging) | |
| * | |
| * @v type Chunk type | |
| * @ret name Chunk type name | |
| */ | |
| static const char * png_type_name ( uint32_t type ) { | |
| static union { | |
| uint32_t type; | |
| char name[ sizeof ( uint32_t ) + 1 /* NUL */ ]; | |
| } u; | |
| u.type = type; | |
| return u.name; | |
| } | |
| /** | |
| * Calculate PNG interlace pass parameters | |
| * | |
| * @v png PNG context | |
| * @v pass Pass number (0=first pass) | |
| * @v interlace Interlace pass to fill in | |
| */ | |
| static void png_interlace ( struct png_context *png, unsigned int pass, | |
| struct png_interlace *interlace ) { | |
| 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 ); | |
| } | |
| /** | |
| * Calculate PNG pixel length | |
| * | |
| * @v png PNG context | |
| * @ret pixel_len Pixel length | |
| */ | |
| static unsigned int png_pixel_len ( struct png_context *png ) { | |
| return ( ( ( png->channels * png->depth ) + 7 ) / 8 ); | |
| } | |
| /** | |
| * Calculate PNG scanline length | |
| * | |
| * @v png PNG context | |
| * @v interlace Interlace pass | |
| * @ret scanline_len Scanline length (including filter byte), or 0 on error | |
| */ | |
| static size_t png_scanline_len ( struct png_context *png, | |
| struct png_interlace *interlace ) { | |
| 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 ) ) ); | |
| } | |
| /** | |
| * Handle PNG image header chunk | |
| * | |
| * @v image PNG image | |
| * @v png PNG context | |
| * @v len Chunk length | |
| * @ret rc Return status code | |
| */ | |
| static int png_image_header ( struct image *image, struct png_context *png, | |
| size_t len ) { | |
| 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; | |
| } | |
| /** | |
| * Handle PNG palette chunk | |
| * | |
| * @v image PNG image | |
| * @v png PNG context | |
| * @v len Chunk length | |
| * @ret rc Return status code | |
| */ | |
| static int png_palette ( struct image *image, struct png_context *png, | |
| size_t len ) { | |
| 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; | |
| } | |
| /** | |
| * Handle PNG image data chunk | |
| * | |
| * @v image PNG image | |
| * @v png PNG context | |
| * @v len Chunk length | |
| * @ret rc Return status code | |
| */ | |
| static int png_image_data ( struct image *image, struct png_context *png, | |
| size_t len ) { | |
| 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; | |
| } | |
| /** | |
| * Unfilter byte using the "None" filter | |
| * | |
| * @v current Filtered current byte | |
| * @v left Unfiltered left byte | |
| * @v above Unfiltered above byte | |
| * @v above_left Unfiltered above-left byte | |
| * @ret current Unfiltered current byte | |
| */ | |
| static unsigned int png_unfilter_none ( unsigned int current, | |
| unsigned int left __unused, | |
| unsigned int above __unused, | |
| unsigned int above_left __unused ) { | |
| return current; | |
| } | |
| /** | |
| * Unfilter byte using the "Sub" filter | |
| * | |
| * @v current Filtered current byte | |
| * @v left Unfiltered left byte | |
| * @v above Unfiltered above byte | |
| * @v above_left Unfiltered above-left byte | |
| * @ret current Unfiltered current byte | |
| */ | |
| static unsigned int png_unfilter_sub ( unsigned int current, | |
| unsigned int left, | |
| unsigned int above __unused, | |
| unsigned int above_left __unused ) { | |
| return ( current + left ); | |
| } | |
| /** | |
| * Unfilter byte using the "Up" filter | |
| * | |
| * @v current Filtered current byte | |
| * @v left Unfiltered left byte | |
| * @v above Unfiltered above byte | |
| * @v above_left Unfiltered above-left byte | |
| * @ret current Unfiltered current byte | |
| */ | |
| static unsigned int png_unfilter_up ( unsigned int current, | |
| unsigned int left __unused, | |
| unsigned int above, | |
| unsigned int above_left __unused ) { | |
| return ( current + above ); | |
| } | |
| /** | |
| * Unfilter byte using the "Average" filter | |
| * | |
| * @v current Filtered current byte | |
| * @v left Unfiltered left byte | |
| * @v above Unfiltered above byte | |
| * @v above_left Unfiltered above-left byte | |
| * @ret current Unfiltered current byte | |
| */ | |
| static unsigned int png_unfilter_average ( unsigned int current, | |
| unsigned int left, | |
| unsigned int above, | |
| unsigned int above_left __unused ) { | |
| return ( current + ( ( above + left ) >> 1 ) ); | |
| } | |
| /** | |
| * Paeth predictor function (defined in RFC 2083) | |
| * | |
| * @v a Pixel A | |
| * @v b Pixel B | |
| * @v c Pixel C | |
| * @ret predictor Predictor pixel | |
| */ | |
| static unsigned int png_paeth_predictor ( unsigned int a, unsigned int b, | |
| unsigned int 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; | |
| } | |
| } | |
| /** | |
| * Unfilter byte using the "Paeth" filter | |
| * | |
| * @v current Filtered current byte | |
| * @v above_left Unfiltered above-left byte | |
| * @v above Unfiltered above byte | |
| * @v left Unfiltered left byte | |
| * @ret current Unfiltered current byte | |
| */ | |
| static unsigned int png_unfilter_paeth ( unsigned int current, | |
| unsigned int left, | |
| unsigned int above, | |
| unsigned int above_left ) { | |
| return ( current + png_paeth_predictor ( left, above, above_left ) ); | |
| } | |
| /** A PNG filter */ | |
| struct png_filter { | |
| /** | |
| * Unfilter byte | |
| * | |
| * @v current Filtered current byte | |
| * @v left Unfiltered left byte | |
| * @v above Unfiltered above byte | |
| * @v above_left Unfiltered above-left byte | |
| * @ret current Unfiltered current byte | |
| */ | |
| unsigned int ( * unfilter ) ( unsigned int current, | |
| unsigned int left, | |
| unsigned int above, | |
| unsigned int above_left ); | |
| }; | |
| /** PNG filter types */ | |
| static struct png_filter png_filters[] = { | |
| [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 }, | |
| }; | |
| /** | |
| * Unfilter one interlace pass of PNG raw data | |
| * | |
| * @v image PNG image | |
| * @v png PNG context | |
| * @v interlace Interlace pass | |
| * @ret 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. | |
| */ | |
| static int png_unfilter_pass ( struct image *image, struct png_context *png, | |
| struct png_interlace *interlace ) { | |
| 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; | |
| } | |
| /** | |
| * Unfilter PNG raw data | |
| * | |
| * @v image PNG image | |
| * @v png PNG context | |
| * @ret 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. | |
| */ | |
| static int png_unfilter ( struct image *image, struct png_context *png ) { | |
| 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; | |
| } | |
| /** | |
| * Calculate PNG pixel component value | |
| * | |
| * @v raw Raw component value | |
| * @v alpha Alpha value | |
| * @v max Maximum raw/alpha value | |
| * @ret value Component value in range 0-255 | |
| */ | |
| static inline unsigned int png_pixel ( unsigned int raw, unsigned int alpha, | |
| unsigned int max ) { | |
| /* 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 ); | |
| } | |
| /** | |
| * Fill one interlace pass of PNG pixels | |
| * | |
| * @v image PNG image | |
| * @v png PNG context | |
| * @v 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. | |
| */ | |
| static void png_pixels_pass ( struct image *image, | |
| struct png_context *png, | |
| struct png_interlace *interlace ) { | |
| 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 ); | |
| } | |
| /** | |
| * Fill PNG pixels | |
| * | |
| * @v image PNG image | |
| * @v 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. | |
| */ | |
| static void png_pixels ( struct image *image, struct png_context *png ) { | |
| 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 ); | |
| } | |
| /** | |
| * Handle PNG image end chunk | |
| * | |
| * @v image PNG image | |
| * @v png PNG context | |
| * @v len Chunk length | |
| * @ret rc Return status code | |
| */ | |
| static int png_image_end ( struct image *image, struct png_context *png, | |
| size_t len ) { | |
| 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; | |
| } | |
| /** A PNG chunk handler */ | |
| struct png_chunk_handler { | |
| /** Chunk type */ | |
| uint32_t type; | |
| /** | |
| * Handle chunk | |
| * | |
| * @v image PNG image | |
| * @v png PNG context | |
| * @v len Chunk length | |
| * @ret rc Return status code | |
| */ | |
| int ( * handle ) ( struct image *image, struct png_context *png, | |
| size_t len ); | |
| }; | |
| /** PNG chunk handlers */ | |
| static struct png_chunk_handler png_chunk_handlers[] = { | |
| { 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 }, | |
| }; | |
| /** | |
| * Handle PNG chunk | |
| * | |
| * @v image PNG image | |
| * @v png PNG context | |
| * @v type Chunk type | |
| * @v len Chunk length | |
| * @ret rc Return status code | |
| */ | |
| static int png_chunk ( struct image *image, struct png_context *png, | |
| uint32_t type, size_t len ) { | |
| 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; | |
| } | |
| /** | |
| * Convert PNG image to pixel buffer | |
| * | |
| * @v image PNG image | |
| * @v pixbuf Pixel buffer to fill in | |
| * @ret rc Return status code | |
| */ | |
| static int png_pixbuf ( struct image *image, struct pixel_buffer **pixbuf ) { | |
| 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; | |
| } | |
| /** | |
| * Probe PNG image | |
| * | |
| * @v image PNG image | |
| * @ret rc Return status code | |
| */ | |
| static int png_probe ( struct image *image ) { | |
| 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; | |
| } | |
| /** PNG image type */ | |
| struct image_type png_image_type __image_type ( PROBE_NORMAL ) = { | |
| .name = "PNG", | |
| .probe = png_probe, | |
| .pixbuf = png_pixbuf, | |
| }; |