diff options
Diffstat (limited to 'src/libnsbmp.c')
| -rw-r--r-- | src/libnsbmp.c | 1126 |
1 files changed, 1126 insertions, 0 deletions
diff --git a/src/libnsbmp.c b/src/libnsbmp.c new file mode 100644 index 0000000..7d1a81c --- /dev/null +++ b/src/libnsbmp.c @@ -0,0 +1,1126 @@ +/* + * Copyright 2006 Richard Wilson <richard.wilson@netsurf-browser.org> + * Copyright 2008 Sean Fox <dyntryx@gmail.com> + * + * This file is part of NetSurf's libnsbmp, http://www.netsurf-browser.org/ + * Licenced under the MIT License, + * http://www.opensource.org/licenses/mit-license.php + */ + +#include <assert.h> +#include <stdbool.h> +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <stdint.h> + +#include <libnsbmp.h> + +#include "utils/log.h" + +/* The functions provided by this file allow for the decoding of + Microsoft's BMP and ICO image file formats. + + READING BMP FILES + ================= + + To begin decoding a BMP, the caller should initialise a + 'bmp_bitmap_callback_vt' structure with the appropriate values necessary + to handle bitmap images. Next, a 'bmp_image' structure should be + initialised by calling bmp_create(). This structure should then be + passed to bmp_analyse() along with the BMP data to process and the size + of this data. + + Once the analysis has begun, the decoder completes the width and height + variables. + + To decode the image, the caller must use bmp_decode() which selects the + proper decoding method based on the BMP info header and assigns the + decoded bitmap image to the 'bitmap' member of the 'bmp_image' + structure. The bitmap image is stored with 4 bytes-per-pixel in RGBA + format. + + It should be noted that bmp_finalise() should always be called, even if + the image was never decoded. It is also the responsibility of the + caller to free 'bmp_data'. + + READING ICO FILES + ================= + + To begin decoding an ICO, the caller should initialise a + 'bmp_bitmap_callback_vt' structure with the appropriate values necessary + to handle bitmap images. Next, an 'ico_collection' structure should be + initialised by calling ico_create(). This structure should then be + passed to ico_analyse() along with the ICO data to process and the size + of this data. + + Once the analysis has begun, the decoder completes the width and height + variables. Because ICO collections contain multiple bitmap images, the + width and height will contain the values of the largest available image. + + The caller then obtains a BMP from the ICO collection by calling + ico_find() with the requested width and height. + + To decode the image, the caller must use bmp_decode() which selects the + proper decoding method based on the BMP info header and assigns the + decoded bitmap image to the 'bitmap' member of the 'bmp_image' + structure. The bitmap image is stored with 4 bytes-per-pixel in RGBA + format. + + It should be noted that ico_finalise() should always be called, even if + no images were decoded. Because ico_finalise() calls bmp_finalise() for + each bitmap within the collection, the caller is not required to perform + this function. However, it is the responsibility of the caller to free + 'ico_data'. + + [dynis] - Tue 1st July 2008 +*/ + +/* squashes unused variable compiler warnings */ +#define UNUSED(x) ((x)=(x)) + +/* BMP flags */ +#define BMP_FILE_HEADER_SIZE 14 +#define ICO_FILE_HEADER_SIZE 6 +#define ICO_DIR_ENTRY_SIZE 16 + +static inline int8_t read_int8(uint8_t *data, unsigned int o) { + return (int8_t) data[o]; +} + +static inline uint8_t read_uint8(uint8_t *data, unsigned int o) { + return (uint8_t) data[o]; +} + +static inline int16_t read_int16(uint8_t *data, unsigned int o) { + return (int16_t) (data[o] | (data[o+1] << 8)); +} + +static inline uint16_t read_uint16(uint8_t *data, unsigned int o) { + return (uint16_t) (data[o] | (data[o+1] << 8)); +} + +static inline int32_t read_int32(uint8_t *data, unsigned int o) { + return (int32_t) (data[o] | (data[o+1] << 8) | (data[o+2] << 16) | (data[o+3] << 24)); +} + +static inline uint32_t read_uint32(uint8_t *data, unsigned int o) { + return (uint32_t) (data[o] | (data[o+1] << 8) | (data[o+2] << 16) | (data[o+3] << 24)); +} + +static bmp_result next_ico_image(ico_collection *ico, ico_image *image); +static bmp_result bmp_analyse_header(bmp_image *bmp, unsigned char *data); +static bmp_result bmp_decode_rgb24(bmp_image *bmp, uint8_t **start, int bytes); +static bmp_result bmp_decode_rgb16(bmp_image *bmp, uint8_t **start, int bytes); +static bmp_result bmp_decode_rgb(bmp_image *bmp, uint8_t **start, int bytes); +static bmp_result bmp_decode_mask(bmp_image *bmp, uint8_t *data, int bytes); +static bmp_result bmp_decode_rle(bmp_image *bmp, uint8_t *data, int bytes, int size); +static void bmp_invalidate(void *bitmap, void *private_word); + + + +/** Initialises necessary bmp_image members. +*/ +void bmp_create(bmp_image *bmp, bmp_bitmap_callback_vt *bitmap_callbacks) { + memset(bmp, 0, sizeof(bmp_image)); + bmp->bitmap_callbacks = *bitmap_callbacks; +} + + +/** Initialises necessary ico_collection members. +*/ +void ico_collection_create(ico_collection *ico, bmp_bitmap_callback_vt *bitmap_callbacks) { + memset(ico, 0, sizeof(ico_collection)); + ico->bitmap_callbacks = *bitmap_callbacks; +} + + +/** + * Analyse a BMP prior to decoding. + * + * This function will scan the data provided and perform simple checks to + * ensure the data is a valid BMP. + * + * This function must be called before bmp_decode() and sets up all the + * relevant values in the bmp structure. + * + * \param bmp the BMP image to analyse + * \return BMP_OK on success + */ +bmp_result bmp_analyse(bmp_image *bmp, size_t size, unsigned char *cdata) { + uint8_t *data = (uint8_t *)cdata; + + /* ensure we aren't already initialised */ + if (bmp->bitmap) + return BMP_OK; + + /* initialize values */ + bmp->buffer_size = size; + bmp->bmp_data = data; + + /* standard 14-byte BMP file header is: + * + * +0 UINT16 File Type ('BM') + * +2 UINT32 Size of File (in bytes) + * +6 INT16 Reserved Field (1) + * +8 INT16 Reserved Field (2) + * +10 UINT32 Starting Position of Image Data (offset in bytes) + */ + if (bmp->buffer_size < BMP_FILE_HEADER_SIZE) + return BMP_INSUFFICIENT_DATA; + if ((data[0] != (uint8_t)'B') || (data[1] != (uint8_t)'M')) + return BMP_DATA_ERROR; + bmp->bitmap_offset = read_uint32(data, 10); + data += BMP_FILE_HEADER_SIZE; + + /* boundary checking */ + if (bmp->bitmap_offset >= size) + return BMP_INSUFFICIENT_DATA; + + /* decode the BMP header */ + return bmp_analyse_header(bmp, data); +} + + +/** + * Analyse an ICO prior to decoding. + * + * This function will scan the data provided and perform simple checks to + * ensure the data is a valid ICO. + * + * This function must be called before ico_find(). + * + * \param ico the ICO image to analyse + * \return BMP_OK on success + */ +bmp_result ico_analyse(ico_collection *ico, size_t size, uint8_t *data) { + uint16_t count, i; + bmp_result result; + int area, max_area = 0; + + /* ensure we aren't already initialised */ + if (ico->first) + return BMP_OK; + + /* initialize values */ + ico->buffer_size = size; + ico->ico_data = data; + + /* 6-byte ICO file header is: + * + * +0 INT16 Reserved (should be 0) + * +2 UINT16 Type (1 for ICO, 2 for CUR) + * +4 UINT16 Number of BMPs to follow + */ + if (ico->buffer_size < ICO_FILE_HEADER_SIZE) + return BMP_INSUFFICIENT_DATA; +// if (read_int16(data, 2) != 0x0000) +// return BMP_DATA_ERROR; + if (read_uint16(data, 2) != 0x0001) + return BMP_DATA_ERROR; + count = read_uint16(data, 4); + if (count == 0) + return BMP_DATA_ERROR; + data += ICO_FILE_HEADER_SIZE; + + /* check if we have enough data for the directory */ + if (ico->buffer_size < (uint32_t)(ICO_FILE_HEADER_SIZE + (ICO_DIR_ENTRY_SIZE * count))) + return BMP_INSUFFICIENT_DATA; + + /* Decode the BMP files. + * + * 16-byte ICO directory entry is: + * + * +0 UINT8 Width (0 for 256 pixels) + * +1 UINT8 Height (0 for 256 pixels) + * +2 UINT8 Colour count (0 if more than 256 colours) + * +3 INT8 Reserved (should be 0, but may not be) + * +4 UINT16 Colour Planes (should be 0 or 1) + * +6 UINT16 Bits Per Pixel + * +8 UINT32 Size of BMP info header + bitmap data in bytes + * +12 UINT32 Offset (points to the BMP info header, not the bitmap data) + */ + for (i = 0; i < count; i++) { + ico_image *image; + image = calloc(1, sizeof(ico_image)); + if (!image) + return BMP_INSUFFICIENT_MEMORY; + result = next_ico_image(ico, image); + if (result != BMP_OK) + return result; + image->bmp.width = read_uint8(data, 0); + if (image->bmp.width == 0) + image->bmp.width = 256; + image->bmp.height = read_uint8(data, 1); + if (image->bmp.height == 0) + image->bmp.height = 256; + image->bmp.buffer_size = read_uint32(data, 8); + image->bmp.bmp_data = ico->ico_data + read_uint32(data, 12); + image->bmp.ico = true; + data += ICO_DIR_ENTRY_SIZE; + result = bmp_analyse_header(&image->bmp, image->bmp.bmp_data); + if (result != BMP_OK) + return result; + /* adjust the size based on the images available */ + area = image->bmp.width * image->bmp.height; + if (area > max_area) { + ico->width = image->bmp.width; + ico->height = image->bmp.height; + max_area = area; + } + } + return BMP_OK; +} + + +/** + * Allocates memory for the next BMP in an ICO collection + * + * Sets proper structure values + * + * \param ico the ICO collection to add the image to + * \param image a pointer to the ICO image to be initialised + */ +static bmp_result next_ico_image(ico_collection *ico, ico_image *image) { + bmp_create(&image->bmp, &ico->bitmap_callbacks); + image->next = ico->first; + ico->first = image; + return BMP_OK; +} + + +static bmp_result bmp_analyse_header(bmp_image *bmp, uint8_t *data) { + uint32_t header_size; + uint32_t i; + uint8_t j; + int32_t width, height; + uint32_t uheight; + uint8_t palette_size; + unsigned int flags; + + /* a variety of different bitmap headers can follow, depending + * on the BMP variant. A full description of the various headers + * can be found at + * http://msdn.microsoft.com/en-us/library/ms532301(VS.85).aspx + */ + header_size = read_uint32(data, 0); + if (bmp->buffer_size < (14 + header_size)) + return BMP_INSUFFICIENT_DATA; + if (header_size == 12) { + /* the following header is for os/2 and windows 2.x and consists of: + * + * +0 UINT32 size of this header (in bytes) + * +4 INT16 image width (in pixels) + * +6 INT16 image height (in pixels) + * +8 UINT16 number of colour planes (always 1) + * +10 UINT16 number of bits per pixel + */ + width = read_int16(data, 4); + height = read_int16(data, 6); + if ((width <= 0) || (height == 0)) + return BMP_DATA_ERROR; + if (height < 0) { + bmp->reversed = true; + height = -height; + } + /* ICOs only support 256*256 resolutions + * In the case of the ICO header, the height is actually the added + * height of XOR-Bitmap and AND-Bitmap (double the visible height) + * Technically we could remove this check and ICOs with bitmaps + * of any size could be processed; this is to conform to the spec. + */ + if (bmp->ico) { + if ((width > 256) || (height > 512)) { + return BMP_DATA_ERROR; + } else { + bmp->width = width; + bmp->height = height / 2; + } + } else { + bmp->width = width; + bmp->height = height; + } + if (read_uint16(data, 8) != 1) + return BMP_DATA_ERROR; + bmp->bpp = read_uint16(data, 10); + /** + * The bpp value should be in the range 1-32, but the only + * values considered legal are: + * RGB ENCODING: 1, 4, 8, 16, 24 and 32 + */ + if ((bmp->bpp != 1) && (bmp->bpp != 4) && + (bmp->bpp != 8) && + (bmp->bpp != 16) && + (bmp->bpp != 24) && + (bmp->bpp != 32)) + return BMP_DATA_ERROR; + bmp->colours = (1 << bmp->bpp); + palette_size = 3; + } else if (header_size < 40) { + return BMP_DATA_ERROR; + } else { + /* the following header is for windows 3.x and onwards. it is a + * minimum of 40 bytes and (as of Windows 95) a maximum of 108 bytes. + * + * +0 UINT32 size of this header (in bytes) + * +4 INT32 image width (in pixels) + * +8 INT32 image height (in pixels) + * +12 UINT16 number of colour planes (always 1) + * +14 UINT16 number of bits per pixel + * +16 UINT32 compression methods used + * +20 UINT32 size of bitmap (in bytes) + * +24 UINT32 horizontal resolution (in pixels per meter) + * +28 UINT32 vertical resolution (in pixels per meter) + * +32 UINT32 number of colours in the image + * +36 UINT32 number of important colours + * +40 UINT32 mask identifying bits of red component + * +44 UINT32 mask identifying bits of green component + * +48 UINT32 mask identifying bits of blue component + * +52 UINT32 mask identifying bits of alpha component + * +56 UINT32 color space type + * +60 UINT32 x coordinate of red endpoint + * +64 UINT32 y coordinate of red endpoint + * +68 UINT32 z coordinate of red endpoint + * +72 UINT32 x coordinate of green endpoint + * +76 UINT32 y coordinate of green endpoint + * +80 UINT32 z coordinate of green endpoint + * +84 UINT32 x coordinate of blue endpoint + * +88 UINT32 y coordinate of blue endpoint + * +92 UINT32 z coordinate of blue endpoint + * +96 UINT32 gamma red coordinate scale value + * +100 UINT32 gamma green coordinate scale value + * +104 UINT32 gamma blue coordinate scale value + */ + width = read_int32(data, 4); + height = read_int32(data, 8); + if ((width <= 0) || (height == 0)) + return BMP_DATA_ERROR; + if (height < 0) { + bmp->reversed = true; + uheight = -height; + } + /* ICOs only support 256*256 resolutions + * In the case of the ICO header, the height is actually the added + * height of XOR-Bitmap and AND-Bitmap (double the visible height) + * Technically we could remove this check and ICOs with bitmaps + * of any size could be processed; this is to conform to the spec. + */ + if (bmp->ico) { + if ((width > 256) || (height > 512)) { + return BMP_DATA_ERROR; + } else { + bmp->width = width; + bmp->height = height / 2; + } + } else { + bmp->width = width; + bmp->height = height; + } + if (read_uint16(data, 12) != 1) + return BMP_DATA_ERROR; + bmp->bpp = read_uint16(data, 14); + if (bmp->bpp == 0) + bmp->bpp = 8; + bmp->encoding = read_uint32(data, 16); + /** + * The bpp value should be in the range 1-32, but the only + * values considered legal are: + * RGB ENCODING: 1, 4, 8, 16, 24 and 32 + * RLE4 ENCODING: 4 + * RLE8 ENCODING: 8 + * BITFIELD ENCODING: 16 and 32 + */ + switch (bmp->encoding) { + case BMP_ENCODING_RGB: + if ((bmp->bpp != 1) && (bmp->bpp != 4) && + (bmp->bpp != 8) && + (bmp->bpp != 16) && + (bmp->bpp != 24) && + (bmp->bpp != 32)) + return BMP_DATA_ERROR; + break; + case BMP_ENCODING_RLE8: + if (bmp->bpp != 8) + return BMP_DATA_ERROR; + break; + case BMP_ENCODING_RLE4: + if (bmp->bpp != 4) + return BMP_DATA_ERROR; + break; + case BMP_ENCODING_BITFIELDS: + if ((bmp->bpp != 16) && (bmp->bpp != 32)) + return BMP_DATA_ERROR; + break; + /* invalid encoding */ + default: + return BMP_DATA_ERROR; + break; + } + /* Bitfield encoding means we have red, green, blue, and alpha masks. + * Here we aquire the masks and determine the required bit shift to + * align them in our 24-bit color 8-bit alpha format. + */ + if (bmp->encoding == BMP_ENCODING_BITFIELDS) { + if (header_size == 40) { + header_size += 12; + if (bmp->buffer_size < (14 + header_size)) + return BMP_INSUFFICIENT_DATA; + for (i = 0; i < 3; i++) + bmp->mask[i] = read_uint32(data, 40 + (i << 2)); + } else { + for (i = 0; i < 4; i++) + bmp->mask[i] = read_uint32(data, 40 + (i << 2)); + } + for (i = 0; i < 4; i++) { + if (bmp->mask[i] == 0) + break; + for (j = 31; j > 0; j--) + if (bmp->mask[i] & (1 << j)) { + if ((j - 7) > 0) + bmp->mask[i] &= 0xff << (j - 7); + else + bmp->mask[i] &= 0xff >> (-(j - 7)); + bmp->shift[i] = (i << 3) - (j - 7); + break; + } + } + } + bmp->colours = read_uint32(data, 32); + if (bmp->colours == 0) + bmp->colours = (1 << bmp->bpp); + palette_size = 4; + } + data += header_size; + + /* if there's no alpha mask, flag the bmp opaque */ + if ((!bmp->ico) && (bmp->mask[3] == 0)) { + flags |= BMP_OPAQUE; + bmp->opaque = true; + } + + /* we only have a palette for <16bpp */ + if (bmp->bpp < 16) { + /* we now have a series of palette entries of the format: + * + * +0 BYTE blue + * +1 BYTE green + * +2 BYTE red + * + * if the palette is from an OS/2 or Win2.x file then the entries + * are padded with an extra byte. + */ + + /* boundary checking */ + if (bmp->buffer_size < (14 + header_size + ((uint64_t)4 * bmp->colours))) + return BMP_INSUFFICIENT_DATA; + + /* create the colour table */ + bmp->colour_table = (uint32_t *)malloc(bmp->colours * 4); + if (!bmp->colour_table) + return BMP_INSUFFICIENT_MEMORY; + for (i = 0; i < bmp->colours; i++) { + bmp->colour_table[i] = data[2] | (data[1] << 8) | (data[0] << 16); + if (bmp->opaque) + bmp->colour_table[i] |= (0xff << 24); + data += palette_size; + } + } + + /* create our bitmap */ + flags |= BMP_NEW | BMP_CLEAR_MEMORY; + bmp->bitmap = bmp->bitmap_callbacks.bitmap_create(bmp->width, bmp->height, flags); + if (!bmp->bitmap) { + if (bmp->colour_table) + free(bmp->colour_table); + bmp->colour_table = NULL; + return BMP_INSUFFICIENT_MEMORY; + } + /* BMPs within ICOs don't have BMP file headers, so the image data should + * always be right after the colour table. + */ + if (bmp->ico) + bmp->bitmap_offset = (intptr_t)data - (intptr_t)bmp->bmp_data; + bmp->bitmap_callbacks.bitmap_set_suspendable(bmp->bitmap, bmp, bmp_invalidate); + return BMP_OK; +} + + +/** + * Finds the closest BMP within an ICO collection + * + * This function finds the BMP with dimensions as close to a specified set + * as possible from the images in the collection. + * + * \param ico the ICO collection to examine + * \param width the preferred width (0 to use ICO header width) + * \param height the preferred height (0 to use ICO header height) + */ +bmp_image *ico_find(ico_collection *ico, uint16_t width, uint16_t height) { + bmp_image *bmp = NULL; + ico_image *image; + int x, y, cur, distance = (1 << 24); + + if (width == 0) + width = ico->width; + if (height == 0) + height = ico->height; + for (image = ico->first; image; image = image->next) { + if ((image->bmp.width == width) && (image->bmp.height == height)) + return &image->bmp; + x = image->bmp.width - width; + y = image->bmp.height - height; + cur = (x * x) + (y * y); + if (cur < distance) { + distance = cur; + bmp = &image->bmp; + } + } + return bmp; +} + + +/** + * Invalidates a BMP + * + * This function sets the BMP into a state such that the bitmap image data + * can be released from memory. + * + * \param bmp the BMP image to invalidate + */ +static void bmp_invalidate(void *bitmap, void *private_word) { + bmp_image *bmp = (bmp_image *)private_word; + UNUSED(bitmap); + + bmp->decoded = false; +} + + +/** + * Decode a BMP + * + * This function decodes the BMP data such that bmp->bitmap is a valid + * image. The state of bmp->decoded is set to TRUE on exit such that it + * can easily be identified which BMPs are in a fully decoded state. + * + * \param bmp the BMP image to decode + * \return BMP_OK on success + */ +bmp_result bmp_decode(bmp_image *bmp) { + uint8_t *data; + uint32_t bytes; + bmp_result result = BMP_OK; + + assert(bmp->bitmap); + + data = bmp->bmp_data + bmp->bitmap_offset; + bytes = bmp->buffer_size - bmp->bitmap_offset; + + switch (bmp->encoding) { + case BMP_ENCODING_RGB: + if ((bmp->bpp == 24) || (bmp->bpp == 32)) + result = bmp_decode_rgb24(bmp, &data, bytes); + else if (bmp->bpp == 16) + result = bmp_decode_rgb16(bmp, &data, bytes); + else + result = bmp_decode_rgb(bmp, &data, bytes); + break; + case BMP_ENCODING_RLE8: + result = bmp_decode_rle(bmp, data, bytes, 8); + break; + case BMP_ENCODING_RLE4: + result = bmp_decode_rle(bmp, data, bytes, 4); + break; + case BMP_ENCODING_BITFIELDS: + if (bmp->bpp == 32) + result = bmp_decode_rgb24(bmp, &data, bytes); + else if (bmp->bpp == 16) + result = bmp_decode_rgb16(bmp, &data, bytes); + else + return BMP_DATA_ERROR; + } + + if ((!bmp->ico) || (result != BMP_OK)) + return result; + + bytes = (uintptr_t)bmp->bmp_data + bmp->buffer_size - (uintptr_t)data; + return bmp_decode_mask(bmp, data, bytes); +} + +/** + * Decode a BMP using "limited transparency" + * + * Bitmaps do not have native transparency support. However, there is a + * "trick" that is used in some instances in which the first pixel of the + * bitmap becomes the "transparency index". The decoding application can + * replace this index with whatever background colour it chooses to + * create the illusion of transparency. + * + * When to use transparency is at the discretion of the decoding + * application. + * + * \param bmp the BMP image to decode + * \param colour the colour to use as "transparent" + * \return BMP_OK on success + */ +bmp_result bmp_decode_trans(bmp_image *bmp, uint32_t colour) { + bmp->limited_trans = true; + bmp->trans_colour = colour; + return bmp_decode(bmp); +} + + +/** + * Decode BMP data stored in 24bpp colour. + * + * \param bmp the BMP image to decode + * \param start the data to decode, updated to last byte read on success + * \param bytes the number of bytes of data available + * \return BMP_OK on success + * BMP_INSUFFICIENT_DATA if the bitmap data ends unexpectedly; + * in this case, the image may be partially viewable + */ +static bmp_result bmp_decode_rgb24(bmp_image *bmp, uint8_t **start, int bytes) { + uint8_t *top, *bottom, *end, *data; + uint32_t *scanline; + uint32_t x, y; + uint32_t swidth, skip; + intptr_t addr; + uint8_t i; + uint32_t word; + + data = *start; + swidth = bmp->bitmap_callbacks.bitmap_get_bpp(bmp->bitmap) * bmp->width; + top = bmp->bitmap_callbacks.bitmap_get_buffer(bmp->bitmap); + if (!top) + return BMP_INSUFFICIENT_MEMORY; + bottom = top + (uint64_t)swidth * (bmp->height - 1); + end = data + bytes; + addr = ((intptr_t)data) & 3; + skip = bmp->bpp >> 3; + bmp->decoded = true; + + /* Determine transparent index */ + if (bmp->limited_trans) { + if ((data + skip) > end) + return BMP_INSUFFICIENT_DATA; + if (bmp->encoding == BMP_ENCODING_BITFIELDS) + bmp->transparent_index = read_uint32(data, 0); + else + bmp->transparent_index = data[2] | (data[1] << 8) | (data[0] << 16); + } + + for (y = 0; y < bmp->height; y++) { + while (addr != (((intptr_t)data) & 3)) + data++; + if ((data + (skip * bmp->width)) > end) + return BMP_INSUFFICIENT_DATA; + if (bmp->reversed) + scanline = (uint32_t *)(top + (y * swidth)); + else + scanline = (uint32_t *)(bottom - (y * swidth)); + if (bmp->encoding == BMP_ENCODING_BITFIELDS) { + for (x = 0; x < bmp->width; x++) { + word = read_uint32(data, 0); + for (i = 0; i < 4; i++) + if (bmp->shift[i] > 0) + scanline[x] |= ((word & bmp->mask[i]) << bmp->shift[i]); + else + scanline[x] |= ((word & bmp->mask[i]) >> (-bmp->shift[i])); + /* 32-bit BMPs have alpha masks, but sometimes they're not utilized */ + if (bmp->opaque) + scanline[x] |= (0xff << 24); + data += skip; + } + } else { + for (x = 0; x < bmp->width; x++) { + scanline[x] = data[2] | (data[1] << 8) | (data[0] << 16); + if ((bmp->limited_trans) && (scanline[x] == bmp->transparent_index)) + scanline[x] = bmp->trans_colour; + if (bmp->opaque) + scanline[x] |= (0xff << 24); + data += skip; + } + } + } + *start = data; + return BMP_OK; +} + + +/** + * Decode BMP data stored in 16bpp colour. + * + * \param bmp the BMP image to decode + * \param start the data to decode, updated to last byte read on success + * \param bytes the number of bytes of data available + * \return BMP_OK on success + * BMP_INSUFFICIENT_DATA if the bitmap data ends unexpectedly; + * in this case, the image may be partially viewable + */ +static bmp_result bmp_decode_rgb16(bmp_image *bmp, uint8_t **start, int bytes) { + uint8_t *top, *bottom, *end, *data; + uint32_t *scanline; + uint32_t x, y, swidth; + intptr_t addr; + uint8_t i; + uint16_t word; + + data = *start; + swidth = bmp->bitmap_callbacks.bitmap_get_bpp(bmp->bitmap) * bmp->width; + top = bmp->bitmap_callbacks.bitmap_get_buffer(bmp->bitmap); + if (!top) + return BMP_INSUFFICIENT_MEMORY; + bottom = top + (uint64_t)swidth * (bmp->height - 1); + end = data + bytes; + addr = ((intptr_t)data) & 3; + bmp->decoded = true; + + /* Determine transparent index */ + if (bmp->limited_trans) { + if ((data + 2) > end) + return BMP_INSUFFICIENT_DATA; + bmp->transparent_index = read_uint16(data, 0); + } + + for (y = 0; y < bmp->height; y++) { + while (addr != (((intptr_t)data) & 3)) + data += 2; + if ((data + (2 * bmp->width)) > end) + return BMP_INSUFFICIENT_DATA; + if (bmp->reversed) + scanline = (uint32_t *)(top + (y * swidth)); + else + scanline = (uint32_t *)(bottom - (y * swidth)); + if (bmp->encoding == BMP_ENCODING_BITFIELDS) { + for (x = 0; x < bmp->width; x++) { + word = read_uint16(data, 0); + if ((bmp->limited_trans) && (word == bmp->transparent_index)) + scanline[x] = bmp->trans_colour; + else { + scanline[x] = 0; + for (i = 0; i < 4; i++) + if (bmp->shift[i] > 0) + scanline[x] |= ((word & bmp->mask[i]) << bmp->shift[i]); + else + scanline[x] |= ((word & bmp->mask[i]) >> (-bmp->shift[i])); + if (bmp->opaque) + scanline[x] |= (0xff << 24); + } + data += 2; + } + } else { + for (x = 0; x < bmp->width; x++) { + word = read_uint16(data, 0); + if ((bmp->limited_trans) && (word == bmp->transparent_index)) + scanline[x] = bmp->trans_colour; + else { + /* 16-bit RGB defaults to RGB555 */ + scanline[x] = ((word & (31 << 0)) << 19) | + ((word & (31 << 5)) << 6) | + ((word & (31 << 10)) >> 7); + } + if (bmp->opaque) + scanline[x] |= (0xff << 24); + data += 2; + } + } + } + *start = data; + return BMP_OK; +} + + +/** + * Decode BMP data stored with a palette and in 8bpp colour or less. + * + * \param bmp the BMP image to decode + * \param start the data to decode, updated to last byte read on success + * \param bytes the number of bytes of data available + * \return BMP_OK on success + * BMP_INSUFFICIENT_DATA if the bitmap data ends unexpectedly; + * in this case, the image may be partially viewable + */ +static bmp_result bmp_decode_rgb(bmp_image *bmp, uint8_t **start, int bytes) { + uint8_t *top, *bottom, *end, *data; + uint32_t *scanline; + intptr_t addr; + uint32_t x, y, swidth; + uint8_t bit_shifts[8]; + uint8_t ppb = 8 / bmp->bpp; + uint8_t bit_mask = (1 << bmp->bpp) - 1; + uint8_t cur_byte = 0, bit, i; + + for (i = 0; i < ppb; i++) + bit_shifts[i] = 8 - ((i + 1) * bmp->bpp); + + data = *start; + swidth = bmp->bitmap_callbacks.bitmap_get_bpp(bmp->bitmap) * bmp->width; + top = bmp->bitmap_callbacks.bitmap_get_buffer(bmp->bitmap); + if (!top) + return BMP_INSUFFICIENT_MEMORY; + bottom = top + (uint64_t)swidth * (bmp->height - 1); + end = data + bytes; + addr = ((intptr_t)data) & 3; + bmp->decoded = true; + + /* Determine transparent index */ + if (bmp->limited_trans) + bmp->transparent_index = bmp->colour_table[(*data >> bit_shifts[0]) & bit_mask]; + + for (y = 0; y < bmp->height; y++) { + while (addr != (((intptr_t)data) & 3)) + data++; + bit = 8; + if ((data + (bmp->width / ppb)) > end) + return BMP_INSUFFICIENT_DATA; + if (bmp->reversed) + scanline = (unsigned int *)(top + (y * swidth)); + else + scanline = (unsigned int *)(bottom - (y * swidth)); + for (x = 0; x < bmp->width; x++) { + if (bit >= ppb) { + bit = 0; + cur_byte = *data++; + } + scanline[x] = bmp->colour_table[(cur_byte >> bit_shifts[bit++]) & bit_mask]; + if ((bmp->limited_trans) && (scanline[x] == bmp->transparent_index)) + scanline[x] = bmp->trans_colour; + } + } + *start = data; + return BMP_OK; +} + + +/** + * Decode a 1bpp mask for an ICO + * + * \param bmp the BMP image to decode + * \param data the data to decode + * \param bytes the number of bytes of data available + * \return BMP_OK on success + */ +static bmp_result bmp_decode_mask(bmp_image *bmp, uint8_t *data, int bytes) { + uint8_t *top, *bottom, *end; + uint32_t *scanline; + intptr_t addr; + uint32_t x, y, swidth; + uint32_t cur_byte = 0; + + swidth = bmp->bitmap_callbacks.bitmap_get_bpp(bmp->bitmap) * bmp->width; + top = bmp->bitmap_callbacks.bitmap_get_buffer(bmp->bitmap); + if (!top) + return BMP_INSUFFICIENT_MEMORY; + bottom = top + (uint64_t)swidth * (bmp->height - 1); + end = data + bytes; + addr = ((intptr_t)data) & 3; + + for (y = 0; y < bmp->height; y++) { + while (addr != (((intptr_t)data) & 3)) + data++; + if ((data + (bmp->width >> 3)) > end) + return BMP_INSUFFICIENT_DATA; + scanline = (uint32_t *)(bottom - (y * swidth)); + for (x = 0; x < bmp->width; x++) { + if ((x & 7) == 0) + cur_byte = *data++; + if ((cur_byte & 128) == 0) + scanline[x] |= (0xff << 24); + cur_byte = cur_byte << 1; + } + } + return BMP_OK; +} + + +/** + * Decode BMP data stored encoded in either RLE4 or RLE8. + * + * \param bmp the BMP image to decode + * \param data the data to decode + * \param bytes the number of bytes of data available + * \param size the size of the RLE tokens (4 or 8) + * \return BMP_OK on success + * BMP_INSUFFICIENT_DATA if the bitmap data ends unexpectedly; + * in this case, the image may be partially viewable + */ +static bmp_result bmp_decode_rle(bmp_image *bmp, uint8_t *data, int bytes, int size) { + uint8_t *top, *bottom, *end; + uint32_t *scanline; + uint32_t swidth; + uint32_t i, length, pixels_left; + uint32_t x = 0, y = 0, last_y = 0; + uint32_t pixel = 0, pixel2; + + if (bmp->ico) + return BMP_DATA_ERROR; + + swidth = bmp->bitmap_callbacks.bitmap_get_bpp(bmp->bitmap) * bmp->width; + top = bmp->bitmap_callbacks.bitmap_get_buffer(bmp->bitmap); + if (!top) + return BMP_INSUFFICIENT_MEMORY; + bottom = top + (uint64_t)swidth * (bmp->height - 1); + end = data + bytes; + bmp->decoded = true; + + do { + if (data + 2 > end) + return BMP_INSUFFICIENT_DATA; + length = *data++; + if (length == 0) { + length = *data++; + if (length == 0) { + /* 00 - 00 means end of scanline */ + x = 0; + if (last_y == y) { + if (++y > bmp->height) + return BMP_DATA_ERROR; + } + last_y = y; + } else if (length == 1) { + /* 00 - 01 means end of RLE data */ + return BMP_OK; + } else if (length == 2) { + /* 00 - 02 - XX - YY means move cursor */ + if (data + 2 > end) + return BMP_INSUFFICIENT_DATA; + x += *data++; + if (x >= bmp->width) + return BMP_DATA_ERROR; + y += *data++; + if (y >= bmp->height) + return BMP_DATA_ERROR; + } else { + /* 00 - NN means escape NN pixels */ + if (bmp->reversed) { + pixels_left = (y + 1) * bmp->width - x; + scanline = (unsigned int *)(top + (y * swidth)); + } else { + pixels_left = (bmp->height - y + 1) * bmp->width - x; + scanline = (unsigned int *)(bottom - (y * swidth)); + } + if (length > pixels_left) + length = pixels_left; + if (data + length > end) + return BMP_INSUFFICIENT_DATA; + + /* the following code could be easily optimised by simply + * checking the bounds on entry and using some simply copying + * routines if so */ + if (size == 8) { + for (i = 0; i < length; i++) { + if (x >= bmp->width) { + x = 0; + if (++y > bmp->height) + return BMP_DATA_ERROR; + scanline -= bmp->width; + } + scanline[x++] = bmp->colour_table[(int)*data++]; + } + } else { + for (i = 0; i < length; i++) { + if (x >= bmp->width) { + x = 0; + if (++y > bmp->height) + return BMP_DATA_ERROR; + scanline -= bmp->width; + } + if ((i & 1) == 0) { + pixel = *data++; + scanline[x++] = bmp->colour_table + [pixel >> 4]; + } else { + scanline[x++] = bmp->colour_table + [pixel & 0xf]; + } + } + length = (length + 1) >> 1; + } + if ((length & 1) && (*data++ != 0x00)) + return BMP_DATA_ERROR; + + } + } else { + /* NN means perform RLE for NN pixels */ + if (bmp->reversed) { + pixels_left = (y + 1) * bmp->width - x; + scanline = (unsigned int *)(top + (y * swidth)); + } else { + pixels_left = (bmp->height - y + 1) * bmp->width - x; + scanline = (unsigned int *)(bottom - (y * swidth)); + } + if (length > pixels_left) + length = pixels_left; + + /* boundary checking */ + if (data + 1 > end) + return BMP_INSUFFICIENT_DATA; + + /* the following code could be easily optimised by simply + * checking the bounds on entry and using some simply copying + * routines if so */ + if (size == 8) { + pixel = bmp->colour_table[(int)*data++]; + for (i = 0; i < length; i++) { + if (x >= bmp->width) { + x = 0; + if (++y > bmp->height) + return BMP_DATA_ERROR; + scanline -= bmp->width; + } + scanline[x++] = pixel; + } + } else { + pixel2 = *data++; + pixel = bmp->colour_table[pixel2 >> 4]; + pixel2 = bmp->colour_table[pixel2 & 0xf]; + for (i = 0; i < length; i++) { + if (x >= bmp->width) { + x = 0; + if (++y > bmp->height) + return BMP_DATA_ERROR; + scanline -= bmp->width; + } + if ((i & 1) == 0) + scanline[x++] = pixel; + else + scanline[x++] = pixel2; + } + } + } + } while (data < end); + return BMP_OK; +} + + +/** + * Finalise a BMP prior to destruction. + * + * \param bmp the BMP image to finalise + */ +void bmp_finalise(bmp_image *bmp) { + if (bmp->bitmap) + bmp->bitmap_callbacks.bitmap_destroy(bmp->bitmap); + bmp->bitmap = NULL; + if (bmp->colour_table) + free(bmp->colour_table); + bmp->colour_table = NULL; +} + + +/** + * Finalise an ICO prior to destruction. + * + * \param ico the ICO image to finalise + */ +void ico_finalise(ico_collection *ico) { + ico_image *image; + + for (image = ico->first; image; image = image->next) + bmp_finalise(&image->bmp); + while (ico->first) { + image = ico->first; + ico->first = image->next; + free(image); + } +} |