Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

1548 lines (1255 sloc) 30.747 kb
#include "imext.h"
#include "msicon.h"
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <assert.h>
static
int read_packed(io_glue *ig, const char *format, ...);
static int
read_palette(ico_reader_t *file, ico_image_t *image, int *error);
static int
read_24bit_data(ico_reader_t *file, ico_image_t *image, int *error);
static int
read_32bit_data(ico_reader_t *file, ico_image_t *image, int *error);
static int
read_8bit_data(ico_reader_t *file, ico_image_t *image, int *error);
static int
read_4bit_data(ico_reader_t *file, ico_image_t *image, int *error);
static int
read_1bit_data(ico_reader_t *file, ico_image_t *image, int *error);
static int
read_mask(ico_reader_t *file, ico_image_t *image, int *error);
static int
ico_write_validate(ico_image_t const *images, int image_count, int *error);
static int
ico_image_size(ico_image_t const *image, int *bits, int *colors);
static int
write_packed(i_io_glue_t *ig, char const *format, ...);
static int
write_palette(i_io_glue_t *ig, ico_image_t const *image, int *error);
static int
write_32_bit(i_io_glue_t *ig, ico_image_t const *image, int *error);
static int
write_8_bit(i_io_glue_t *ig, ico_image_t const *image, int *error);
static int
write_4_bit(i_io_glue_t *ig, ico_image_t const *image, int *error);
static int
write_1_bit(i_io_glue_t *ig, ico_image_t const *image, int *error);
static int
write_mask(i_io_glue_t *ig, ico_image_t const *image, int *error);
typedef struct {
int width;
int height;
long offset;
long size;
int hotspot_x, hotspot_y;
} ico_reader_image_entry;
/* this was previously declared, now define it */
struct ico_reader_tag {
/* the file we're dealing with */
i_io_glue_t *ig;
/* number of images in the file */
int count;
/* type of resource - 1=icon, 2=cursor */
int type;
/* image information from the header */
ico_reader_image_entry *images;
};
/*
=head1 NAME
msicon.c - functions for working with .ICO files.
=head1 SYNOPSIS
// reading
int error;
ico_reader_t *file = ico_reader_open(ig, &error);
if (!file) {
char buffer[100];
ico_error_message(error, buffer, sizeof(buffer));
fputs(buffer, stderr);
exit(1);
}
int count = ico_image_count(file);
for (i = 0; i < count; ++i) {
ico_image_t *im = ico_image_read(file, index);
printf("%d x %d image %d\n", im->width, im->height,
im->direct ? "direct" : "paletted");
ico_image_release(im);
}
ico_reader_close(file);
=head1 DESCRIPTION
This is intended as a general interface to reading MS Icon files, and
is written to be independent of Imager, even though it is part of
Imager. You just need to supply something that acts like Imager's
io_glue.
It relies on icon images being generally small, and reads the entire
image into memory when reading.
=head1 READING ICON FILES
=over
=item ico_reader_open(ig, &error)
Parameters:
=over
=item *
io_glue *ig - an Imager IO object. This must be seekable.
=item *
int *error - pointer to an integer which an error code will be
returned in on failure.
=back
=cut
*/
ico_reader_t *
ico_reader_open(i_io_glue_t *ig, int *error) {
long res1, type, count;
ico_reader_t *file = NULL;
int i;
if (!read_packed(ig, "www", &res1, &type, &count)) {
*error = ICOERR_Short_File;
return NULL;
}
if (res1 != 0 || (type != 1 && type != 2) || count == 0) {
*error = ICOERR_Invalid_File;
return NULL;
}
file = malloc(sizeof(ico_reader_t));
if (!file) {
*error = ICOERR_Out_Of_Memory;
return NULL;
}
file->count = count;
file->type = type;
file->ig = ig;
file->images = malloc(sizeof(ico_reader_image_entry) * count);
if (file->images == NULL) {
*error = ICOERR_Out_Of_Memory;
free(file);
return NULL;
}
for (i = 0; i < count; ++i) {
long width, height, bytes_in_res, image_offset;
ico_reader_image_entry *image = file->images + i;
if (type == ICON_ICON) {
if (!read_packed(ig, "bb xxxxxx dd", &width, &height, &bytes_in_res,
&image_offset)) {
free(file->images);
free(file);
*error = ICOERR_Short_File;
return NULL;
}
image->hotspot_x = image->hotspot_y = 0;
}
else {
long hotspot_x, hotspot_y;
if (!read_packed(ig, "bb xx ww dd", &width, &height,
&hotspot_x, &hotspot_y, &bytes_in_res,
&image_offset)) {
free(file->images);
free(file);
*error = ICOERR_Short_File;
return NULL;
}
image->hotspot_x = hotspot_x;
image->hotspot_y = hotspot_y;
}
/* a width or height of zero here indicates a width/height of 256 */
image->width = width ? width : 256;
image->height = height ? height : 256;
image->offset = image_offset;
image->size = bytes_in_res;
}
return file;
}
/*
=item ico_image_count
// number of images in the file
count = ico_image_count(file);
=cut
*/
int
ico_image_count(ico_reader_t *file) {
return file->count;
}
/*
=item ico_type
// type of file - ICON_ICON for icon, ICON_CURSOR for cursor
type = ico_type(file);
=cut
*/
int
ico_type(ico_reader_t *file) {
return file->type;
}
/*
=item ico_image_read
Read an image from the file given it's index.
=cut
*/
ico_image_t *
ico_image_read(ico_reader_t *file, int index, int *error) {
io_glue *ig = file->ig;
ico_reader_image_entry *im;
long bi_size, width, height, planes, bit_count;
ico_image_t *result;
if (index < 0 || index >= file->count) {
*error = ICOERR_Bad_Image_Index;
return NULL;
}
im = file->images + index;
if (i_io_seek(ig, im->offset, SEEK_SET) != im->offset) {
*error = ICOERR_File_Error;
return NULL;
}
if (!read_packed(ig, "dddww xxxx xxxx xxxx xxxx xxxx xxxx", &bi_size,
&width, &height, &planes, &bit_count)) {
*error = ICOERR_Short_File;
return NULL;
}
/* the bitmapinfoheader height includes the height of
the and and xor masks */
if (bi_size != 40 || width != im->width || height != im->height * 2
|| planes != 1) { /* don't know how to handle planes != 1 */
*error = ICOERR_Invalid_File;
return NULL;
}
if (bit_count != 1 && bit_count != 4 && bit_count != 8
&& bit_count != 24 && bit_count != 32) {
*error = ICOERR_Unknown_Bits;
return 0;
}
result = malloc(sizeof(ico_image_t));
if (!result) {
*error = ICOERR_Out_Of_Memory;
return NULL;
}
result->width = width;
result->height = im->height;
result->direct = bit_count > 8;
result->bit_count = bit_count;
result->palette = NULL;
result->image_data = NULL;
result->mask_data = NULL;
result->hotspot_x = im->hotspot_x;
result->hotspot_y = im->hotspot_y;
if (bit_count == 32) {
result->palette_size = 0;
result->image_data = malloc(result->width * result->height * sizeof(ico_color_t));
if (!result->image_data) {
free(result);
*error = ICOERR_Out_Of_Memory;
return NULL;
}
if (!read_32bit_data(file, result, error)) {
free(result->image_data);
free(result);
return NULL;
}
}
else if (bit_count == 24) {
result->palette_size = 0;
result->image_data = malloc(result->width * result->height * sizeof(ico_color_t));
if (!result->image_data) {
free(result);
*error = ICOERR_Out_Of_Memory;
return NULL;
}
if (!read_24bit_data(file, result, error)) {
free(result->image_data);
free(result);
return NULL;
}
}
else {
int read_result;
result->palette_size = 1 << bit_count;
result->palette = malloc(sizeof(ico_color_t) * result->palette_size);
if (!result->palette) {
free(result);
*error = ICOERR_Out_Of_Memory;
return NULL;
}
result->image_data = malloc(result->width * result->height);
if (!result->image_data) {
*error = ICOERR_Out_Of_Memory;
free(result->palette);
free(result);
return 0;
}
if (!read_palette(file, result, error)) {
free(result->palette);
free(result->image_data);
free(result);
return 0;
}
switch (bit_count) {
case 1:
read_result = read_1bit_data(file, result, error);
break;
case 4:
read_result = read_4bit_data(file, result, error);
break;
case 8:
read_result = read_8bit_data(file, result, error);
break;
default:
assert(0); /* this can't happen in theory */
read_result = 0;
break;
}
if (!read_result) {
free(result->palette);
free(result->image_data);
free(result);
return 0;
}
}
result->mask_data = malloc(result->width * result->height);
if (!result->mask_data) {
*error = ICOERR_Out_Of_Memory;
free(result->palette);
free(result->image_data);
free(result);
return 0;
}
if (!read_mask(file, result, error)) {
free(result->mask_data);
free(result->palette);
free(result->image_data);
free(result);
return 0;
}
return result;
}
/*
=item ico_image_release
Release an image structure returned by ico_image_read.
=cut
*/
void
ico_image_release(ico_image_t *image) {
free(image->mask_data);
free(image->palette);
free(image->image_data);
free(image);
}
/*
=item ico_reader_close
Releases the read file structure.
=cut
*/
void
ico_reader_close(ico_reader_t *file) {
i_io_close(file->ig);
free(file->images);
free(file);
}
/*
=back
=head1 WRITING ICON FILES
=over
=item ico_write(ig, images, image_count, type, &error)
Parameters:
=over
=item *
io_glue *ig - an Imager IO object. This only needs to implement
writing for ico_write()
=item *
ico_image_t *images - array of images to be written.
=item *
int image_count - number of images
=item *
int type - must be ICON_ICON or ICON_CURSOR
=item *
int *error - set to an error code on failure.
=back
Returns non-zero on success.
=cut
*/
int
ico_write(i_io_glue_t *ig, ico_image_t const *images, int image_count,
int type, int *error) {
int i;
int start_offset = 6 + 16 * image_count;
int current_offset = start_offset;
if (type != ICON_ICON && type != ICON_CURSOR) {
*error = ICOERR_Bad_File_Type;
return 0;
}
/* validate the images */
if (!ico_write_validate(images, image_count, error))
return 0;
/* write the header */
if (!write_packed(ig, "www", 0, type, image_count)) {
*error = ICOERR_Write_Failure;
return 0;
}
/* work out the offsets of each image */
for (i = 0; i < image_count; ++i) {
ico_image_t const *image = images + i;
int bits, colors;
int size = ico_image_size(image, &bits, &colors);
int width_byte = image->width == 256 ? 0 : image->width;
int height_byte = image->height == 256 ? 0 : image->height;
if (type == ICON_ICON) {
if (!write_packed(ig, "bbbbwwdd", width_byte, height_byte,
colors, 0, 1, bits, (unsigned long)size,
(unsigned long)current_offset)) {
*error = ICOERR_Write_Failure;
return 0;
}
}
else {
int hotspot_x = image->hotspot_x;
int hotspot_y = image->hotspot_y;
if (hotspot_x < 0)
hotspot_x = 0;
else if (hotspot_x >= image->width)
hotspot_x = image->width - 1;
if (hotspot_y < 0)
hotspot_y = 0;
else if (hotspot_y >= image->height)
hotspot_y = image->height - 1;
if (!write_packed(ig, "bbbbwwdd", width_byte, height_byte,
colors, 0, hotspot_x, hotspot_y, (unsigned long)size,
(unsigned long)current_offset)) {
*error = ICOERR_Write_Failure;
return 0;
}
}
current_offset += size;
}
/* write out each image */
for (i = 0; i < image_count; ++i) {
ico_image_t const *image = images + i;
if (image->direct) {
if (!write_32_bit(ig, image, error))
return 0;
}
else {
if (image->palette_size <= 2) {
if (!write_1_bit(ig, image, error))
return 0;
}
else if (image->palette_size <= 16) {
if (!write_4_bit(ig, image, error))
return 0;
}
else {
if (!write_8_bit(ig, image, error))
return 0;
}
}
if (!write_mask(ig, image, error))
return 0;
}
return 1;
}
/*
=back
=head1 ERROR MESSAGES
=over
=item ico_error_message
Converts an error code into an error message.
=cut
*/
size_t
ico_error_message(int error, char *buffer, size_t buffer_size) {
char const *msg;
size_t size;
switch (error) {
case ICOERR_Short_File:
msg = "Short read";
break;
case ICOERR_File_Error:
msg = "I/O error";
break;
case ICOERR_Write_Failure:
msg = "Write failure";
break;
case ICOERR_Invalid_File:
msg = "Not an icon file";
break;
case ICOERR_Unknown_Bits:
msg = "Unknown value for bits/pixel";
break;
case ICOERR_Bad_Image_Index:
msg = "Image index out of range";
break;
case ICOERR_Bad_File_Type:
msg = "Bad file type parameter";
break;
case ICOERR_Invalid_Width:
msg = "Invalid image width";
break;
case ICOERR_Invalid_Height:
msg = "Invalid image height";
break;
case ICOERR_Invalid_Palette:
msg = "Invalid Palette";
break;
case ICOERR_No_Data:
msg = "No image data in image supplied to ico_write";
break;
case ICOERR_Out_Of_Memory:
msg = "Out of memory";
break;
default:
msg = "Unknown error code";
break;
}
size = strlen(msg) + 1;
if (size > buffer_size)
size = buffer_size;
memcpy(buffer, msg, size);
buffer[size-1] = '\0';
return size;
}
/*
=back
=head1 PRIVATE FUNCTIONS
=over
=item read_packed
Reads packed data from a stream, unpacking it.
=cut
*/
static
int read_packed(io_glue *ig, const char *format, ...) {
unsigned char buffer[100];
va_list ap;
long *p;
int size;
const char *formatp;
unsigned char *bufp;
/* read efficiently, work out the size of the buffer */
size = 0;
formatp = format;
while (*formatp) {
switch (*formatp++) {
case 'b':
case 'x': size += 1; break;
case 'w': size += 2; break;
case 'd': size += 4; break;
case ' ': break; /* space to separate components */
default:
fprintf(stderr, "invalid unpack char in %s\n", format);
exit(1);
}
}
if (size > sizeof(buffer)) {
/* catch if we need a bigger buffer, but 100 is plenty */
fprintf(stderr, "format %s too long for buffer\n", format);
exit(1);
}
if (i_io_read(ig, buffer, size) != size) {
return 0;
}
va_start(ap, format);
bufp = buffer;
while (*format) {
switch (*format) {
case 'b':
p = va_arg(ap, long *);
*p = *bufp++;
break;
case 'w':
p = va_arg(ap, long *);
*p = bufp[0] + (bufp[1] << 8);
bufp += 2;
break;
case 'd':
p = va_arg(ap, long *);
*p = bufp[0] + (bufp[1] << 8) + (bufp[2] << 16) + (bufp[3] << 24);
bufp += 4;
break;
case 'x':
++bufp; /* skip a byte */
break;
case ' ':
/* nothing to do */
break;
}
++format;
}
return 1;
}
/*
=item read_palette
Reads the palette data for an icon image.
=cut
*/
static
int
read_palette(ico_reader_t *file, ico_image_t *image, int *error) {
int palette_bytes = image->palette_size * 4;
unsigned char *read_buffer = malloc(palette_bytes);
unsigned char *inp;
ico_color_t *outp;
int i;
if (!read_buffer) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
if (i_io_read(file->ig, read_buffer, palette_bytes) != palette_bytes) {
*error = ICOERR_Short_File;
free(read_buffer);
return 0;
}
inp = read_buffer;
outp = image->palette;
for (i = 0; i < image->palette_size; ++i) {
outp->b = *inp++;
outp->g = *inp++;
outp->r = *inp++;
outp->a = 255;
++inp;
++outp;
}
free(read_buffer);
return 1;
}
/*
=item read_32bit_data
Reads 32 bit image data.
=cut
*/
static
int
read_32bit_data(ico_reader_t *file, ico_image_t *image, int *error) {
int line_bytes = image->width * 4;
unsigned char *buffer = malloc(line_bytes);
int y;
int x;
unsigned char *inp;
ico_color_t *outp;
if (!buffer) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
for (y = image->height - 1; y >= 0; --y) {
if (i_io_read(file->ig, buffer, line_bytes) != line_bytes) {
free(buffer);
*error = ICOERR_Short_File;
return 0;
}
outp = image->image_data;
outp += y * image->width;
inp = buffer;
for (x = 0; x < image->width; ++x) {
outp->b = inp[0];
outp->g = inp[1];
outp->r = inp[2];
outp->a = inp[3];
++outp;
inp += 4;
}
}
free(buffer);
return 1;
}
/*
=item read_24bit_data
Reads 24 bit image data.
=cut
*/
static
int
read_24bit_data(ico_reader_t *file, ico_image_t *image, int *error) {
int line_bytes = image->width * 3;
unsigned char *buffer;
int y;
int x;
unsigned char *inp;
ico_color_t *outp;
line_bytes = (line_bytes + 3) / 4 * 4;
buffer = malloc(line_bytes);
if (!buffer) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
for (y = image->height - 1; y >= 0; --y) {
if (i_io_read(file->ig, buffer, line_bytes) != line_bytes) {
free(buffer);
*error = ICOERR_Short_File;
return 0;
}
outp = image->image_data;
outp += y * image->width;
inp = buffer;
for (x = 0; x < image->width; ++x) {
outp->b = inp[0];
outp->g = inp[1];
outp->r = inp[2];
outp->a = 255;
++outp;
inp += 3;
}
}
free(buffer);
return 1;
}
/*
=item read_8bit_data
Reads 8 bit image data.
=cut
*/
static
int
read_8bit_data(ico_reader_t *file, ico_image_t *image, int *error) {
int line_bytes = (image->width + 3) / 4 * 4;
unsigned char *buffer = malloc(line_bytes);
int y;
int x;
unsigned char *inp, *outp;
if (!buffer) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
for (y = image->height - 1; y >= 0; --y) {
outp = image->image_data;
outp += y * image->width;
if (i_io_read(file->ig, buffer, line_bytes) != line_bytes) {
free(buffer);
*error = ICOERR_Short_File;
return 0;
}
for (x = 0, inp = buffer; x < image->width; ++x) {
*outp++ = *inp++;
}
}
free(buffer);
return 1;
}
/*
=item read_4bit_data
Reads 4 bit image data.
=cut
*/
static
int
read_4bit_data(ico_reader_t *file, ico_image_t *image, int *error) {
/* 2 pixels per byte, rounded up to the nearest dword */
int line_bytes = ((image->width + 1) / 2 + 3) / 4 * 4;
unsigned char *read_buffer = malloc(line_bytes);
int y;
int x;
unsigned char *inp, *outp;
if (!read_buffer) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
for (y = image->height - 1; y >= 0; --y) {
if (i_io_read(file->ig, read_buffer, line_bytes) != line_bytes) {
free(read_buffer);
*error = ICOERR_Short_File;
return 0;
}
outp = image->image_data;
outp += y * image->width;
inp = read_buffer;
for (x = 0; x < image->width; ++x) {
/* yes, this is kind of ugly */
if (x & 1) {
*outp++ = *inp++ & 0x0F;
}
else {
*outp++ = *inp >> 4;
}
}
}
free(read_buffer);
return 1;
}
/*
=item read_1bit_data
Reads 1 bit image data.
=cut
*/
static
int
read_1bit_data(ico_reader_t *file, ico_image_t *image, int *error) {
/* 8 pixels per byte, rounded up to the nearest dword */
int line_bytes = ((image->width + 7) / 8 + 3) / 4 * 4;
unsigned char *read_buffer = malloc(line_bytes);
int y;
int x;
unsigned char *inp, *outp;
if (!read_buffer) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
for (y = image->height - 1; y >= 0; --y) {
if (i_io_read(file->ig, read_buffer, line_bytes) != line_bytes) {
free(read_buffer);
*error = ICOERR_Short_File;
return 0;
}
outp = image->image_data;
outp += y * image->width;
inp = read_buffer;
for (x = 0; x < image->width; ++x) {
*outp++ = (*inp >> (7 - (x & 7))) & 1;
if ((x & 7) == 7)
++inp;
}
}
free(read_buffer);
return 1;
}
/* this is very similar to the 1 bit reader <sigh> */
/*
=item read_mask
Reads the AND mask from an icon image.
=cut
*/
static
int
read_mask(ico_reader_t *file, ico_image_t *image, int *error) {
/* 8 pixels per byte, rounded up to the nearest dword */
int line_bytes = ((image->width + 7) / 8 + 3) / 4 * 4;
unsigned char *read_buffer = malloc(line_bytes);
int y;
int x;
int mask;
unsigned char *inp, *outp;
if (!read_buffer) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
for (y = image->height - 1; y >= 0; --y) {
if (i_io_read(file->ig, read_buffer, line_bytes) != line_bytes) {
free(read_buffer);
*error = ICOERR_Short_File;
return 0;
}
outp = image->mask_data + y * image->width;
inp = read_buffer;
mask = 0x80;
for (x = 0; x < image->width; ++x) {
*outp++ = (*inp & mask) ? 1 : 0;
mask >>= 1;
if (!mask) {
mask = 0x80;
++inp;
}
}
}
free(read_buffer);
return 1;
}
/*
=item ico_write_validate
Check each image to make sure it can go into an icon file.
=cut
*/
static int
ico_write_validate(ico_image_t const *images, int image_count, int *error) {
int i;
for (i = 0; i < image_count; ++i) {
ico_image_t const *image = images + i;
if (image->width < 1 || image->width > 256) {
*error = ICOERR_Invalid_Width;
return 0;
}
if (image->height < 1 || image->height > 256) {
*error = ICOERR_Invalid_Height;
return 0;
}
if (!image->image_data) {
*error = ICOERR_No_Data;
return 0;
}
if (!image->direct) {
if (image->palette_size < 0 || image->palette_size > 256
|| !image->palette) {
*error = ICOERR_Invalid_Palette;
return 0;
}
}
}
return 1;
}
/*
=item ico_image_size
Calculate how much space the icon takes up in the file.
=cut
*/
static int
ico_image_size(ico_image_t const *image, int *bits, int *colors) {
int size = 40; /* start with the BITMAPINFOHEADER */
/* add in the image area */
if (image->direct) {
*bits = 32;
*colors = 0;
size += image->width * 4 * image->height;
}
else {
if (image->palette_size <= 2) {
*bits = 1;
*colors = 2;
}
else if (image->palette_size <= 16) {
*bits = 4;
*colors = 16;
}
else {
*bits = 8;
*colors = 0;
}
/* palette size */
size += *colors * 4;
/* image data size */
size += (image->width * *bits + 31) / 32 * 4 * image->height;
}
/* add in the mask */
size += (image->width + 31) / 32 * 4 * image->height;
return size;
}
/*
=item write_packed
Pack numbers given a format to a stream.
=cut
*/
static int
write_packed(i_io_glue_t *ig, char const *format, ...) {
unsigned char buffer[100];
va_list ap;
unsigned long p;
int size;
const char *formatp;
unsigned char *bufp;
/* write efficiently, work out the size of the buffer */
size = 0;
formatp = format;
while (*formatp) {
switch (*formatp++) {
case 'b': size++; break;
case 'w': size += 2; break;
case 'd': size += 4; break;
case ' ': break; /* space to separate components */
default:
fprintf(stderr, "invalid unpack char in %s\n", format);
exit(1);
}
}
if (size > sizeof(buffer)) {
/* catch if we need a bigger buffer, but 100 is plenty */
fprintf(stderr, "format %s too long for buffer\n", format);
exit(1);
}
va_start(ap, format);
bufp = buffer;
while (*format) {
switch (*format) {
case 'b':
p = va_arg(ap, int);
*bufp++ = p;
break;
case 'w':
p = va_arg(ap, int);
*bufp++ = p & 0xFF;
*bufp++ = (p >> 8) & 0xFF;
break;
case 'd':
p = va_arg(ap, unsigned long);
*bufp++ = p & 0xFF;
*bufp++ = (p >> 8) & 0xFF;
*bufp++ = (p >> 16) & 0xFF;
*bufp++ = (p >> 24) & 0xFF;
break;
case ' ':
/* nothing to do */
break;
}
++format;
}
if (i_io_write(ig, buffer, size) != size)
return 0;
return 1;
}
/*
=item write_palette
Write the palette for an icon.
=cut
*/
static int
write_palette(i_io_glue_t *ig, ico_image_t const *image, int *error) {
int full_size = image->palette_size;
unsigned char *writebuf, *outp;
ico_color_t *colorp;
int i;
if (image->palette_size <= 2)
full_size = 2;
else if (image->palette_size <= 16)
full_size = 16;
else
full_size = 256;
writebuf = calloc(full_size, 4);
if (!writebuf) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
outp = writebuf;
colorp = image->palette;
for (i = 0; i < image->palette_size; ++i) {
*outp++ = colorp->b;
*outp++ = colorp->g;
*outp++ = colorp->r;
*outp++ = 0xFF;
++colorp;
}
for (; i < full_size; ++i) {
*outp++ = 0;
*outp++ = 0;
*outp++ = 0;
*outp++ = 0;
}
if (i_io_write(ig, writebuf, full_size * 4) != full_size * 4) {
*error = ICOERR_Write_Failure;
free(writebuf);
return 0;
}
free(writebuf);
return 1;
}
/*
=item write_bitmapinfoheader
Write the BITMAPINFOHEADER for an icon image.
=cut
*/
static int
write_bitmapinfoheader(i_io_glue_t *ig, ico_image_t const *image, int *error,
int bit_count, int clr_used) {
if (!write_packed(ig, "d dd w w d d dd dd",
40UL, /* biSize */
(unsigned long)image->width,
(unsigned long)2 * image->height, /* biWidth/biHeight */
1, bit_count, /* biPlanes, biBitCount */
0UL, 0UL, /* biCompression, biSizeImage */
0UL, 0UL, /* bi(X|Y)PetsPerMeter */
(unsigned long)clr_used, /* biClrUsed */
0UL)) { /* biClrImportant */
*error = ICOERR_Write_Failure;
return 0;
}
return 1;
}
/*
=item write_32_bit
Write 32-bit image data to the icon.
=cut
*/
static int
write_32_bit(i_io_glue_t *ig, ico_image_t const *image, int *error) {
unsigned char *writebuf;
ico_color_t *data = image->image_data, *colorp;
unsigned char *writep;
int x, y;
if (!write_bitmapinfoheader(ig, image, error, 32, 0)) {
return 0;
}
writebuf = malloc(image->width * 4);
if (!writebuf) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
for (y = image->height-1; y >= 0; --y) {
writep = writebuf;
colorp = data + y * image->width;
for (x = 0; x < image->width; ++x) {
*writep++ = colorp->b;
*writep++ = colorp->g;
*writep++ = colorp->r;
*writep++ = colorp->a;
++colorp;
}
if (i_io_write(ig, writebuf, image->width * 4) != image->width * 4) {
*error = ICOERR_Write_Failure;
free(writebuf);
return 0;
}
}
free(writebuf);
return 1;
}
/*
=item write_8_bit
Write 8 bit image data.
=cut
*/
static int
write_8_bit(i_io_glue_t *ig, ico_image_t const *image, int *error) {
static const unsigned char zeros[3] = { '\0' };
int y;
const unsigned char *data = image->image_data;
int zero_count = (0U - (unsigned)image->width) & 3;
if (!write_bitmapinfoheader(ig, image, error, 8, 256)) {
return 0;
}
if (!write_palette(ig, image, error))
return 0;
for (y = image->height-1; y >= 0; --y) {
if (i_io_write(ig, data + y * image->width,
image->width) != image->width) {
*error = ICOERR_Write_Failure;
return 0;
}
if (zero_count) {
if (i_io_write(ig, zeros, zero_count) != zero_count) {
*error = ICOERR_Write_Failure;
return 0;
}
}
}
return 1;
}
/*
=item write_4_bit
Write 4 bit image data.
=cut
*/
static int
write_4_bit(i_io_glue_t *ig, ico_image_t const *image, int *error) {
int line_size = ((image->width + 1) / 2 + 3) / 4 * 4;
unsigned char *writebuf, *outp;
int x, y;
unsigned char const *data = image->image_data;
unsigned char const *pixelp;
if (!write_bitmapinfoheader(ig, image, error, 4, 16)) {
return 0;
}
if (!write_palette(ig, image, error))
return 0;
writebuf = malloc(line_size);
if (!writebuf) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
for (y = image->height-1; y >= 0; --y) {
pixelp = data + y * image->width;
outp = writebuf;
memset(writebuf, 0, line_size);
for (x = 0; x < image->width; ++x) {
if (x & 1) {
*outp |= *pixelp++ & 0x0F;
++outp;
}
else {
*outp |= *pixelp++ << 4;
}
}
if (i_io_write(ig, writebuf, line_size) != line_size) {
*error = ICOERR_Write_Failure;
free(writebuf);
return 0;
}
}
free(writebuf);
return 1;
}
/*
=item write_1_bit
Write 1 bit image data.
=cut
*/
static int
write_1_bit(i_io_glue_t *ig, ico_image_t const *image, int *error) {
int line_size = (image->width + 31) / 32 * 4;
unsigned char *writebuf = malloc(line_size);
unsigned char *outp;
unsigned char const *data, *pixelp;
int x,y;
unsigned mask;
if (!write_bitmapinfoheader(ig, image, error, 1, 2)) {
return 0;
}
if (!write_palette(ig, image, error))
return 0;
if (!writebuf) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
data = image->image_data;
for (y = image->height-1; y >= 0; --y) {
memset(writebuf, 0, line_size);
pixelp = data + y * image->width;
outp = writebuf;
mask = 0x80;
for (x = 0; x < image->width; ++x) {
if (*pixelp)
*outp |= mask;
mask >>= 1;
if (!mask) {
mask = 0x80;
outp++;
}
}
if (i_io_write(ig, writebuf, line_size) != line_size) {
*error = ICOERR_Write_Failure;
free(writebuf);
return 0;
}
}
free(writebuf);
return 1;
}
/*
=item write_mask
Write the AND mask.
=cut
*/
static int
write_mask(i_io_glue_t *ig, ico_image_t const *image, int *error) {
int line_size = (image->width + 31) / 32 * 4;
unsigned char *writebuf = malloc(line_size);
unsigned char *outp;
unsigned char const *data, *pixelp;
int x,y;
unsigned mask;
if (!writebuf) {
*error = ICOERR_Out_Of_Memory;
return 0;
}
data = image->mask_data;
if (data) {
for (y = image->height-1; y >= 0; --y) {
memset(writebuf, 0, line_size);
pixelp = data + y * image->width;
outp = writebuf;
mask = 0x80;
for (x = 0; x < image->width; ++x) {
if (*pixelp)
*outp |= mask;
mask >>= 1;
if (!mask) {
mask = 0x80;
outp++;
}
++pixelp;
}
if (i_io_write(ig, writebuf, line_size) != line_size) {
*error = ICOERR_Write_Failure;
free(writebuf);
return 0;
}
}
}
else {
memset(writebuf, 0, line_size);
for (y = image->height-1; y >= 0; --y) {
if (i_io_write(ig, writebuf, line_size) != line_size) {
*error = ICOERR_Write_Failure;
free(writebuf);
return 0;
}
}
}
free(writebuf);
return 1;
}
/*
=back
=head1 AUTHOR
Tony Cook <tonyc@cpan.org>
=head1 REVISION
$Revision$
=cut
*/
Jump to Line
Something went wrong with that request. Please try again.