pnm.c

Go to the documentation of this file.

/*
 * Copyright (C) 2013 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
 *
 * Portable anymap format (PNM)
 *
 */
 
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <ipxe/image.h>
#include <ipxe/pixbuf.h>
#include <ipxe/pnm.h>
 
/**
 * Extract PNM ASCII value
 *
 * @v image             PNM image
 * @v pnm               PNM context
 * @ret value           Value, or negative error
 */
static int pnm_ascii ( struct image *image, struct pnm_context *pnm ) {
        char buf[ pnm->ascii_len + 1 /* NUL */ ];
        char *endp;
        char ch;
        size_t len;
        int value;
        int in_comment = 0;
 
        /* Skip any leading whitespace and comments */
        for ( ; pnm->offset < image->len ; pnm->offset++ ) {
                ch = *( ( ( const uint8_t * ) image->data ) + pnm->offset );
                if ( in_comment ) {
                        if ( ch == '\n' )
                                in_comment = 0;
                } else {
                        if ( ch == '#' ) {
                                in_comment = 1;
                        } else if ( ! isspace ( ch ) ) {
                                break;
                        }
                }
        }
 
        /* Fail if no value is present */
        len = ( image->len - pnm->offset );
        if ( len == 0 ) {
                DBGC ( image, "PNM %s ran out of ASCII data\n", image->name );
                return -EINVAL;
        }
 
        /* Copy ASCII value to buffer and ensure string is NUL-terminated */
        if ( len > ( sizeof ( buf ) - 1 /* NUL */ ) )
                len = ( sizeof ( buf ) - 1 /* NUL */ );
        memcpy ( buf, ( image->data + pnm->offset ), len );
        buf[len] = '\0';
 
        /* Parse value and update offset */
        value = strtoul ( buf, &endp, 0 );
        pnm->offset += ( endp - buf );
 
        /* Check and skip terminating whitespace character, if present */
        if ( ( pnm->offset != image->len ) && ( *endp != '\0' ) ) {
                if ( ! isspace ( *endp ) ) {
                        DBGC ( image, "PNM %s invalid ASCII integer\n",
                               image->name );
                        return -EINVAL;
                }
                pnm->offset++;
        }
 
        return value;
}
 
/**
 * Extract PNM binary value
 *
 * @v image             PNM image
 * @v pnm               PNM context
 * @ret value           Value, or negative error
 */
static int pnm_binary ( struct image *image, struct pnm_context *pnm ) {
        const uint8_t *value;
 
        /* Sanity check */
        if ( pnm->offset == image->len ) {
                DBGC ( image, "PNM %s ran out of binary data\n",
                       image->name );
                return -EINVAL;
        }
 
        /* Extract value */
        value = ( image->data + pnm->offset++ );
        return *value;
}
 
/**
 * Scale PNM scalar value
 *
 * @v image             PNM image
 * @v pnm               PNM context
 * @v value             Raw value
 * @ret value           Scaled value (in range 0-255)
 */
static int pnm_scale ( struct image *image, struct pnm_context *pnm,
                       unsigned int value ) {
 
        if ( value > pnm->max ) {
                DBGC ( image, "PNM %s has out-of-range value %d (max %d)\n",
                       image->name, value, pnm->max );
                return -EINVAL;
        }
        return ( ( 255 * value ) / pnm->max );
}
 
/**
 * Convert PNM bitmap composite value to RGB
 *
 * @v composite         Composite value
 * @v index             Pixel index within this composite value
 * @ret rgb             24-bit RGB value
 */
static uint32_t pnm_bitmap ( uint32_t composite, unsigned int index ) {
 
        /* Composite value is an 8-bit bitmask */
        return ( ( ( composite << index ) & 0x80 ) ? 0x000000 : 0xffffff );
}
 
/**
 * Convert PNM greymap composite value to RGB
 *
 * @v composite         Composite value
 * @v index             Pixel index within this composite value
 * @ret rgb             24-bit RGB value
 */
static uint32_t pnm_greymap ( uint32_t composite, unsigned int index __unused ){
 
        /* Composite value is an 8-bit greyscale value */
        return ( ( composite << 16 ) | ( composite << 8 ) | composite );
}
 
/**
 * Convert PNM pixmap composite value to RGB
 *
 * @v composite         Composite value
 * @v index             Pixel index within this composite value
 * @ret rgb             24-bit RGB value
 */
static uint32_t pnm_pixmap ( uint32_t composite, unsigned int index __unused ) {
 
        /* Composite value is already an RGB value */
        return composite;
}
 
/**
 * Extract PNM pixel data
 *
 * @v image             PNM image
 * @v pnm               PNM context
 * @v pixbuf            Pixel buffer
 * @ret rc              Return status code
 */
static int pnm_data ( struct image *image, struct pnm_context *pnm,
                      struct pixel_buffer *pixbuf ) {
        struct pnm_type *type = pnm->type;
        unsigned int pixels = pixbuf->pixels;
        unsigned int index = 0;
        unsigned int xpos = 0;
        int scalar;
        uint32_t composite;
        unsigned int i;
 
        /* Fill pixel buffer */
        while ( index < pixels ) {
 
                /* Extract a scaled composite scalar value from the file */
                composite = 0;
                for ( i = 0 ; i < type->depth ; i++ ) {
                        scalar = type->scalar ( image, pnm );
                        if ( scalar < 0 )
                                return scalar;
                        scalar = pnm_scale ( image, pnm, scalar );
                        if ( scalar < 0 )
                                return scalar;
                        composite = ( ( composite << 8 ) | scalar );
                }
 
                /* Extract 24-bit RGB values from composite value */
                for ( i = 0 ; i < type->packing ; i++ ) {
                        if ( index >= pixels ) {
                                DBGC ( image, "PNM %s has too many pixels\n",
                                       image->name );
                                return -EINVAL;
                        }
                        pixbuf->data[index++] = type->rgb ( composite, i );
                        if ( ++xpos == pixbuf->width ) {
                                xpos = 0;
                                break;
                        }
                }
        }
 
        return 0;
}
 
/** PNM image types */
static struct pnm_type pnm_types[] = {
        {
                .type = '1',
                .depth = 1,
                .packing = 1,
                .flags = PNM_BITMAP,
                .scalar = pnm_ascii,
                .rgb = pnm_bitmap,
        },
        {
                .type = '2',
                .depth = 1,
                .packing = 1,
                .scalar = pnm_ascii,
                .rgb = pnm_greymap,
        },
        {
                .type = '3',
                .depth = 3,
                .packing = 1,
                .scalar = pnm_ascii,
                .rgb = pnm_pixmap,
        },
        {
                .type = '4',
                .depth = 1,
                .packing = 8,
                .flags = PNM_BITMAP,
                .scalar = pnm_binary,
                .rgb = pnm_bitmap,
        },
        {
                .type = '5',
                .depth = 1,
                .packing = 1,
                .scalar = pnm_binary,
                .rgb = pnm_greymap,
        },
        {
                .type = '6',
                .depth = 3,
                .packing = 1,
                .scalar = pnm_binary,
                .rgb = pnm_pixmap,
        },
};
 
/**
 * Determine PNM image type
 *
 * @v image             PNM image
 * @ret type            PNM image type, or NULL if not found
 */
static struct pnm_type * pnm_type ( struct image *image ) {
        const struct pnm_signature *signature;
        struct pnm_type *type;
        unsigned int i;
 
        /* Extract signature */
        assert ( image->len >= sizeof ( *signature ) );
        signature = image->data;
 
        /* Check for supported types */
        for ( i = 0 ; i < ( sizeof ( pnm_types ) /
                            sizeof ( pnm_types[0] ) ) ; i++ ) {
                type = &pnm_types[i];
                if ( type->type == signature->type )
                        return type;
        }
        return NULL;
}
 
/**
 * Convert PNM image to pixel buffer
 *
 * @v image             PNM image
 * @v pixbuf            Pixel buffer to fill in
 * @ret rc              Return status code
 */
static int pnm_pixbuf ( struct image *image, struct pixel_buffer **pixbuf ) {
        struct pnm_context pnm;
        int width;
        int height;
        int max;
        int rc;
 
        /* Initialise PNM context */
        pnm.type = pnm_type ( image );
        if ( ! pnm.type ) {
                rc = -ENOTSUP;
                goto err_type;
        }
        pnm.offset = sizeof ( struct pnm_signature );
        pnm.ascii_len = PNM_ASCII_LEN;
 
        /* Extract width */
        if ( ( width = pnm_ascii ( image, &pnm ) ) < 0 ) {
                rc = width;
                goto err_width;
        }
 
        /* Extract height */
        if ( ( height = pnm_ascii ( image, &pnm ) ) < 0 ) {
                rc = height;
                goto err_height;
        }
 
        /* Extract maximum scalar value, if not predefined */
        if ( pnm.type->flags & PNM_BITMAP ) {
                pnm.max = ( ( 1 << pnm.type->packing ) - 1 );
                pnm.ascii_len = 1;
        } else {
                if ( ( max = pnm_ascii ( image, &pnm ) ) < 0 ) {
                        rc = max;
                        goto err_max;
                }
                pnm.max = max;
        }
        if ( pnm.max == 0 ) {
                DBGC ( image, "PNM %s has invalid maximum value 0\n",
                       image->name );
                rc = -EINVAL;
                goto err_max;
        }
        DBGC ( image, "PNM %s is type %c width %d height %d max %d\n",
               image->name, pnm.type->type, width, height, pnm.max );
 
        /* Allocate pixel buffer */
        *pixbuf = alloc_pixbuf ( width, height );
        if ( ! *pixbuf ) {
                rc = -ENOMEM;
                goto err_alloc_pixbuf;
        }
 
        /* Extract pixel data */
        if ( ( rc = pnm_data ( image, &pnm, *pixbuf ) ) != 0 )
                goto err_data;
 
        return 0;
 
 err_data:
        pixbuf_put ( *pixbuf );
 err_alloc_pixbuf:
 err_max:
 err_height:
 err_width:
 err_type:
        return rc;
}
 
/**
 * Probe PNM image
 *
 * @v image             PNM image
 * @ret rc              Return status code
 */
static int pnm_probe ( struct image *image ) {
        const struct pnm_signature *signature;
 
        /* Sanity check */
        if ( image->len < sizeof ( *signature ) ) {
                DBGC ( image, "PNM %s is too short\n", image->name );
                return -ENOEXEC;
        }
 
        /* Check signature */
        signature = image->data;
        if ( ! ( ( signature->magic == PNM_MAGIC ) &&
                 ( isdigit ( signature->type ) ) &&
                 ( isspace ( signature->space ) ) ) ) {
                DBGC ( image, "PNM %s has invalid signature\n", image->name );
                return -ENOEXEC;
        }
        DBGC ( image, "PNM %s is type %c\n", image->name, signature->type );
 
        return 0;
}
 
/** PNM image type */
struct image_type pnm_image_type __image_type ( PROBE_NORMAL ) = {
        .name = "PNM",
        .probe = pnm_probe,
        .pixbuf = pnm_pixbuf,
};