/* -*- mode: C; c-file-style: "linux" -*- */

/* GdkPixbuf library - Windows Icon/Cursor image loader

 *

 * Copyright (C) 1999 The Free Software Foundation

 *

 * Authors: Arjan van de Ven <arjan@fenrus.demon.nl>

 *          Federico Mena-Quintero <federico@gimp.org>

 *

 * Based on io-bmp.c

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, see <http://www.gnu.org/licenses/>.

 */

#undef DUMPBIH

#define DEBUG(s)

#define INFOHEADER_SIZE 40

/*

Icons are just like BMP's, except for the header.

Known bugs:

	* bi-tonal files aren't tested 

*/

#include "config.h"

#include <stdio.h>

#include <stdlib.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <string.h>

#include <errno.h>

#include "gdk-pixbuf-private.h"

/* 

These structures are actually dummies. These are according to

the "Windows API reference guide volume II" as written by 

Borland International, but GCC fiddles with the alignment of

the internal members.

*/

struct BitmapFileHeader {

	gushort bfType;

	guint bfSize;

	guint reserverd;

	guint bfOffbits;

};

struct BitmapInfoHeader {

	guint biSize;

	guint biWidth;

	guint biHeight;

	gushort biPlanes;

	gushort biBitCount;

	guint biCompression;

	guint biSizeImage;

	guint biXPelsPerMeter;

	guint biYPelsPerMeter;

	guint biClrUsed;

	guint biClrImportant;

};

#ifdef DUMPBIH

/*

DumpBIH printf's the values in a BitmapInfoHeader to the screen, for 

debugging purposes.

*/

static void DumpBIH(unsigned char *BIH)

{

	printf("biSize      = %i \n",

	       (int)(BIH[3] << 24) + (BIH[2] << 16) + (BIH[1] << 8) + (BIH[0]));

	printf("biWidth     = %i \n",

	       (int)(BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) + (BIH[4]));

	printf("biHeight    = %i \n",

	       (int)(BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) +

	       (BIH[8]));

	printf("biPlanes    = %i \n", (int)(BIH[13] << 8) + (BIH[12]));

	printf("biBitCount  = %i \n", (int)(BIH[15] << 8) + (BIH[14]));

	printf("biCompress  = %i \n",

	       (int)(BIH[19] << 24) + (BIH[18] << 16) + (BIH[17] << 8) +

	       (BIH[16]));

	printf("biSizeImage = %i \n",

	       (int)(BIH[23] << 24) + (BIH[22] << 16) + (BIH[21] << 8) +

	       (BIH[20]));

	printf("biXPels     = %i \n",

	       (int)(BIH[27] << 24) + (BIH[26] << 16) + (BIH[25] << 8) +

	       (BIH[24]));

	printf("biYPels     = %i \n",

	       (int)(BIH[31] << 24) + (BIH[30] << 16) + (BIH[29] << 8) +

	       (BIH[28]));

	printf("biClrUsed   = %i \n",

	       (int)(BIH[35] << 24) + (BIH[34] << 16) + (BIH[33] << 8) +

	       (BIH[32]));

	printf("biClrImprtnt= %i \n",

	       (int)(BIH[39] << 24) + (BIH[38] << 16) + (BIH[37] << 8) +

	       (BIH[36]));

}

#endif

/* Progressive loading */

struct headerpair {

	gint width;

	gint height;

	guint depth;

	guint Negative;		/* Negative = 1 -> top down BMP,  

				   Negative = 0 -> bottom up BMP */

};

/* Score the various parts of the icon */

struct ico_direntry_data {

	gint ImageScore;

        gint width;

        gint height;

	guint DIBoffset;

	gint x_hot;

	gint y_hot;

};

struct ico_progressive_state {

	GdkPixbufModuleSizeFunc size_func;

	GdkPixbufModulePreparedFunc prepared_func;

	GdkPixbufModuleUpdatedFunc updated_func;

	gpointer user_data;

	gint HeaderSize;	/* The size of the header-part (incl colormap) */

	guchar *HeaderBuf;	/* The buffer for the header (incl colormap) */

	gint BytesInHeaderBuf;  /* The size of the allocated HeaderBuf */

	gint HeaderDone;	/* The nr of bytes actually in HeaderBuf */

	gint LineWidth;		/* The width of a line in bytes */

	guchar *LineBuf;	/* Buffer for 1 line */

	gint LineDone;		/* # of bytes in LineBuf */

	gint Lines;		/* # of finished lines */

	gint Type;		/*  

				   32 = RGBA

				   24 = RGB

				   16 = 555 RGB

				   8 = 8 bit colormapped

				   4 = 4 bpp colormapped

				   1  = 1 bit bitonal 

				 */

        gboolean cursor;

        gint x_hot;

        gint y_hot;

	struct headerpair Header;	/* Decoded (BE->CPU) header */

	GList *entries;

	guint			DIBoffset;

	GdkPixbuf *pixbuf;	/* Our "target" */

};

static gpointer

gdk_pixbuf__ico_image_begin_load(GdkPixbufModuleSizeFunc size_func,

                                 GdkPixbufModulePreparedFunc prepared_func,

				 GdkPixbufModuleUpdatedFunc updated_func,

				 gpointer user_data,

                                 GError **error);

static gboolean gdk_pixbuf__ico_image_stop_load(gpointer data, GError **error);

static gboolean gdk_pixbuf__ico_image_load_increment(gpointer data,

                                                     const guchar * buf, guint size,

                                                     GError **error);

static void 

context_free (struct ico_progressive_state *context)

{

	g_free (context->LineBuf);

	context->LineBuf = NULL;

	g_free (context->HeaderBuf);

	g_list_free_full (context->entries, g_free);

	if (context->pixbuf)

		g_object_unref (context->pixbuf);

	g_free (context);

}

static gint

compare_direntry_scores (gconstpointer a,

                         gconstpointer b)

{

	const struct ico_direntry_data *ia = a;

	const struct ico_direntry_data *ib = b;

	/* Backwards, so largest first */

	if (ib->ImageScore < ia->ImageScore)

		return -1;

	else if (ib->ImageScore > ia->ImageScore)

		return 1;

	return 0;

}

static void DecodeHeader(guchar *Data, gint Bytes,

			 struct ico_progressive_state *State,

			 GError **error)

{

/* For ICO's we have to be very clever. There are multiple images possible

   in an .ICO. As a simple heuristic, we select the image which is the largest

   in pixels.

 */

	struct ico_direntry_data *entry;

	gint IconCount = 0; /* The number of icon-versions in the file */

	guchar *BIH; /* The DIB for the used icon */

 	guchar *Ptr;

 	gint I;

	guint16 imgtype; /* 1 = icon, 2 = cursor */

	GList *l;

	gboolean got_broken_header = FALSE;

 	/* Step 1: The ICO header */

	/* First word should be 0 according to specs */

	if (((Data[1] << 8) + Data[0]) != 0) {

		g_set_error (error,

			     GDK_PIXBUF_ERROR,

			     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

			     _("Invalid header in icon (%s)"), "first word");

		return;

	}

	imgtype = (Data[3] << 8) + Data[2];

	State->cursor = (imgtype == 2) ? TRUE : FALSE;

	/* If it is not a cursor make sure it is actually an icon */

	if (!State->cursor && imgtype != 1) {

		g_set_error (error,

			     GDK_PIXBUF_ERROR,

			     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

			     _("Invalid header in icon (%s)"), "image type");

		return;

	}

 	IconCount = (Data[5] << 8) + (Data[4]);

 	State->HeaderSize = 6 + IconCount*16;

        DEBUG(g_print ("Image type: %d (%s)\nImage count: %d\n", imgtype, imgtype == 2 ? "cursor" : "icon", IconCount));

 	if (State->HeaderSize>State->BytesInHeaderBuf) {

 		guchar *tmp=g_try_realloc(State->HeaderBuf,State->HeaderSize);

		if (!tmp) {

			g_set_error_literal (error,

                                             GDK_PIXBUF_ERROR,

                                             GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,

                                             _("Not enough memory to load icon"));

			return;

		}

		State->HeaderBuf = tmp;

 		State->BytesInHeaderBuf = State->HeaderSize;

 	}

 	if (Bytes < State->HeaderSize) {

 		return;

	}

	/* Now iterate through the ICONDIRENTRY structures, and sort them by

	 * which one we think is "best" (essentially the largest) */

	g_list_free_full (State->entries, g_free);

	State->entries = 0;

	Ptr = Data + 6;

	for (I=0;I

                int width;

                int height;

                int depth;

                int x_hot;

                int y_hot;

                guint data_size G_GNUC_UNUSED;

                guint data_offset;

                width = Ptr[0];

                height = Ptr[1];

                depth = Ptr[2];

		x_hot = (Ptr[5] << 8) + Ptr[4];

		y_hot = (Ptr[7] << 8) + Ptr[6];

                data_size = ((guint) (Ptr[11]) << 24) + (Ptr[10] << 16) + (Ptr[9] << 8) + (Ptr[8]);

		data_offset = ((guint) (Ptr[15]) << 24) + (Ptr[14] << 16) + (Ptr[13] << 8) + (Ptr[12]);

                DEBUG(g_print ("Image %d: %d x %d\n\tDepth: %d\n", I, width, height, depth);

                if (imgtype == 2)

                  g_print ("\tHotspot: %d x %d\n", x_hot, y_hot);

                else

                  g_print ("\tColor planes: %d\n\tBits per pixel: %d\n", x_hot, y_hot);

                g_print ("\tSize: %d\n\tOffset: %d\n", data_size, data_offset);)

                if (depth == 0)

                        depth = 32;

                else if (depth <= 2)

                        depth = 1;

                else if (depth <= 16)

                        depth = 4;

                else if (depth <= 256)

                        depth = 8;

		/* We check whether the HeaderSize (int) would overflow */

                if (data_offset > INT_MAX - INFOHEADER_SIZE) {

			got_broken_header = TRUE;

			continue;

		}

		entry = g_new0 (struct ico_direntry_data, 1);

                entry->width = width ? width : 256;

                entry->height = height ? height : 256;

                entry->ImageScore = entry->width * entry->height * depth;

		entry->x_hot = x_hot;

		entry->y_hot = y_hot;

		entry->DIBoffset = data_offset;

		State->entries = g_list_insert_sorted (State->entries, entry, compare_direntry_scores);

		Ptr += 16;

	}

	/* Now go through and find one we can parse */

	entry = NULL;

	for (l = State->entries; l != NULL; l = g_list_next (l)) {

		entry = l->data;

		/* We know how many bytes are in the "header" part. */

		State->HeaderSize = entry->DIBoffset + INFOHEADER_SIZE;

		if (State->HeaderSize < 0) {

			g_set_error (error,

			             GDK_PIXBUF_ERROR,

			             GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

			             _("Invalid header in icon (%s)"), "header size");

			return;

		}

		if (State->HeaderSize>State->BytesInHeaderBuf) {

			guchar *tmp=g_try_realloc(State->HeaderBuf,State->HeaderSize);

			if (!tmp) {

				g_set_error_literal (error,

				                     GDK_PIXBUF_ERROR,

				                     GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,

				                     _("Not enough memory to load icon"));

				return;

			}

			State->HeaderBuf = tmp;

			State->BytesInHeaderBuf = State->HeaderSize;

		}

		if (Bytes<State->HeaderSize)

			return;

		BIH = Data+entry->DIBoffset;

		/* A compressed icon, try the next one */

		if ((BIH[16] != 0) || (BIH[17] != 0) || (BIH[18] != 0)

		    || (BIH[19] != 0)) {

			DEBUG(g_print("Skipping icon with score %d, as it is compressed\n", entry->ImageScore));

			continue;

		}

		DEBUG(g_print("Selecting icon with score %d\n", entry->ImageScore));

		/* If we made it to here then we have selected a BIH structure

		 * in a format that we can parse */

		break;

	}

	/* No valid icon found, because all are compressed? */

	if (l == NULL) {

		g_set_error_literal (error,

				     GDK_PIXBUF_ERROR,

				     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

				     got_broken_header ?

					_("Invalid header in icon") :

					_("Compressed icons are not supported"));

		return;

	}

	/* This is the one we're going with */

	State->DIBoffset = entry->DIBoffset;

	State->x_hot = entry->x_hot;

	State->y_hot = entry->y_hot;

#ifdef DUMPBIH

	DumpBIH(BIH);

#endif

	/* Add the palette to the headersize */

	State->Header.width =

	    (int)(BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) + (BIH[4]);

	if (State->Header.width == 0)

		State->Header.width = 256;

	State->Header.height =

	    (int)((BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) + (BIH[8]))/2;

	    /* /2 because the BIH height includes the transparency mask */

	if (State->Header.height == 0)

		State->Header.height = 256;

	/* Negative heights mean top-down pixel-order */

	if (State->Header.height < 0) {

		State->Header.height = -State->Header.height;

		State->Header.Negative = 1;

	}

	if (State->Header.width < 0) {

		State->Header.width = -State->Header.width;

	}

        if (State->Header.width != entry->width ||

            State->Header.height != entry->height) {

		g_set_error (error,

                             GDK_PIXBUF_ERROR,

                             GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                             _("Invalid header in icon (%s)"), "image size");

		return;

        }

	State->Header.depth = (BIH[15] << 8) + (BIH[14]);

	State->Type = State->Header.depth;

	/* Determine the  palette size. If the header indicates 0, it

	   is actually the maximum for the bpp. You have to love the

	   guys who made the spec. */

	I = (int)(BIH[35] << 24) + (BIH[34] << 16) + (BIH[33] << 8) + (BIH[32]);

	I = I*4;

	if ((I==0)&&(State->Type==1))

		I = 2*4;

	if ((I==0)&&(State->Type==4))

		I = 16*4;

	if ((I==0)&&(State->Type==8))

		I = 256*4;

	State->HeaderSize+=I;

	if (State->HeaderSize < 0) {

		g_set_error (error,

                             GDK_PIXBUF_ERROR,

                             GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                             _("Invalid header in icon (%s)"), "palette size");

		return;

	}

 	if (State->HeaderSize>State->BytesInHeaderBuf) {

	        guchar *tmp=g_try_realloc(State->HeaderBuf,State->HeaderSize);

		if (!tmp) {

			g_set_error_literal (error,

                                             GDK_PIXBUF_ERROR,

                                             GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,

                                             _("Not enough memory to load icon"));

			return;

		}

		State->HeaderBuf = tmp;

 		State->BytesInHeaderBuf = State->HeaderSize;

 	}

 	if (Bytes < State->HeaderSize) {

 		return;

	}

        if (State->Type == 32)

                State->LineWidth = State->Header.width * 4;

        else if (State->Type == 24)

		State->LineWidth = State->Header.width * 3;

        else if (State->Type == 16)

                State->LineWidth = State->Header.width * 2;

        else if (State->Type == 8)

		State->LineWidth = State->Header.width * 1;

        else if (State->Type == 4)

		State->LineWidth = (State->Header.width+1)/2;

        else if (State->Type == 1) {

		State->LineWidth = State->Header.width / 8;

		if ((State->Header.width & 7) != 0)

			State->LineWidth++;

        } else {

          g_set_error_literal (error,

                               GDK_PIXBUF_ERROR,

                               GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                               _("Unsupported icon type"));

          return;

	}

	/* Pad to a 32 bit boundary */

	if (((State->LineWidth % 4) > 0))

		State->LineWidth = (State->LineWidth / 4) * 4 + 4;

	if (State->LineBuf == NULL) {

		State->LineBuf = g_try_malloc(State->LineWidth);

		if (!State->LineBuf) {

			g_set_error_literal (error,

                                             GDK_PIXBUF_ERROR,

                                             GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,

                                             _("Not enough memory to load icon"));

			return;

		}

	}

	g_assert(State->LineBuf != NULL);

	if (State->pixbuf == NULL) {

		if (State->size_func) {

			gint width = State->Header.width;

			gint height = State->Header.height;

			(*State->size_func) (&width, &height, State->user_data);

			if (width == 0 || height == 0) {

				State->LineWidth = 0;

				return;

			}

		}

		State->pixbuf =

		    gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE, 8,

				   State->Header.width,

				   State->Header.height);

		if (!State->pixbuf) {

			g_set_error_literal (error,

                                             GDK_PIXBUF_ERROR,

                                             GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,

                                             _("Not enough memory to load icon"));

			return;

		}

		if (State->cursor) {

			gchar hot[10];

			g_snprintf (hot, 10, "%d", State->x_hot);

			gdk_pixbuf_set_option (State->pixbuf, "x_hot", hot);

			g_snprintf (hot, 10, "%d", State->y_hot);

			gdk_pixbuf_set_option (State->pixbuf, "y_hot", hot);

		}

		if (State->prepared_func != NULL)

			/* Notify the client that we are ready to go */

			(*State->prepared_func) (State->pixbuf,

                                                 NULL,

						 State->user_data);

	}

}

/* 

 * func - called when we have pixmap created (but no image data)

 * user_data - passed as arg 1 to func

 * return context (opaque to user)

 */

static gpointer

gdk_pixbuf__ico_image_begin_load(GdkPixbufModuleSizeFunc size_func,

                                 GdkPixbufModulePreparedFunc prepared_func,

				 GdkPixbufModuleUpdatedFunc updated_func,

				 gpointer user_data,

                                 GError **error)

{

	struct ico_progressive_state *context;

	context = g_new0(struct ico_progressive_state, 1);

	context->size_func = size_func;

	context->prepared_func = prepared_func;

	context->updated_func = updated_func;

	context->user_data = user_data;

	context->HeaderSize = 54;

	context->HeaderBuf = g_try_malloc(14 + INFOHEADER_SIZE + 4*256 + 512);

	if (!context->HeaderBuf) {

		g_free (context);

		g_set_error_literal (error,

                                     GDK_PIXBUF_ERROR,

                                     GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,

                                     _("Not enough memory to load ICO file"));

		return NULL;

	}

	/* 4*256 for the colormap */

	context->BytesInHeaderBuf = 14 + INFOHEADER_SIZE + 4*256 + 512 ;

	context->HeaderDone = 0;

	context->LineWidth = 0;

	context->LineBuf = NULL;

	context->LineDone = 0;

	context->Lines = 0;

	context->Type = 0;

	memset(&context->Header, 0, sizeof(struct headerpair));

	context->pixbuf = NULL;

	return (gpointer) context;

}

/*

 * context - returned from image_begin_load

 *

 * free context, unref gdk_pixbuf

 */

static gboolean 

gdk_pixbuf__ico_image_stop_load(gpointer data,

				GError **error)

{

	struct ico_progressive_state *context =

	    (struct ico_progressive_state *) data;

	gboolean ret = TRUE;

        /* FIXME this thing needs to report errors if

         * we have unused image data

         */

	g_return_val_if_fail(context != NULL, TRUE);

	if (context->HeaderDone < context->HeaderSize) {

		g_set_error_literal (error,

				     GDK_PIXBUF_ERROR,

				     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

				     _("ICO image was truncated or incomplete."));

		ret = FALSE;

	}

	context_free (context);

        return ret;

}

static void

OneLine32 (struct ico_progressive_state *context)

{

        gint X;

        guchar *Pixels;

        X = 0;

        if (context->Header.Negative == 0)

                Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

                          (context->Header.height - context->Lines - 1));

        else

                Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

                          context->Lines);

        while (X < context->Header.width) {

                /* BGRA */

                Pixels[X * 4 + 0] = context->LineBuf[X * 4 + 2];

                Pixels[X * 4 + 1] = context->LineBuf[X * 4 + 1];

                Pixels[X * 4 + 2] = context->LineBuf[X * 4 + 0];

                Pixels[X * 4 + 3] = context->LineBuf[X * 4 + 3];

                X++;

        }

}

static void OneLine24(struct ico_progressive_state *context)

{

	gint X;

	guchar *Pixels;

	X = 0;

	if (context->Header.Negative == 0)

		Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

			  (context->Header.height - context->Lines - 1));

	else

		Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

			  context->Lines);

	while (X < context->Header.width) {

		Pixels[X * 4 + 0] = context->LineBuf[X * 3 + 2];

		Pixels[X * 4 + 1] = context->LineBuf[X * 3 + 1];

		Pixels[X * 4 + 2] = context->LineBuf[X * 3 + 0];

		Pixels[X * 4 + 3] = 0xff;

		X++;

	}

}

static void

OneLine16 (struct ico_progressive_state *context)

{

        int i;

        guchar *pixels;

        guchar *src;

        if (context->Header.Negative == 0)

                pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

                          (context->Header.height - context->Lines - 1));

        else

                pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

                          context->Lines);

        src = context->LineBuf;

        for (i = 0; i < context->Header.width; i++) {

                int v, r, g, b;

                v = (int) src[0] | ((int) src[1] << 8);

                src += 2;

                /* Extract 5-bit RGB values */

                r = (v >> 10) & 0x1f;

                g = (v >> 5) & 0x1f;

                b = v & 0x1f;

                /* Fill the rightmost bits to form 8-bit values */

                *pixels++ = (r << 3) | (r >> 2);

                *pixels++ = (g << 3) | (g >> 2);

                *pixels++ = (b << 3) | (b >> 2);

                *pixels++ = 0xff;

        }

}

static void OneLine8(struct ico_progressive_state *context)

{

	gint X;

	guchar *Pixels;

	X = 0;

	if (context->Header.Negative == 0)

		Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

			  (context->Header.height - context->Lines - 1));

	else

		Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

			  context->Lines);

	while (X < context->Header.width) {

		/* The joys of having a BGR byteorder */

		Pixels[X * 4 + 0] =

		    context->HeaderBuf[4 * context->LineBuf[X] + INFOHEADER_SIZE + 2 + context->DIBoffset];

		Pixels[X * 4 + 1] =

		    context->HeaderBuf[4 * context->LineBuf[X] + INFOHEADER_SIZE + 1 +context->DIBoffset];

		Pixels[X * 4 + 2] =

		    context->HeaderBuf[4 * context->LineBuf[X] + INFOHEADER_SIZE +context->DIBoffset];

		Pixels[X * 4 + 3] = 0xff;

		X++;

	}

}

static void OneLine4(struct ico_progressive_state *context)

{

	gint X;

	guchar *Pixels;

	X = 0;

	if (context->Header.Negative == 0)

		Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

			  (context->Header.height - context->Lines - 1));

	else

		Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

			  context->Lines);

	while (X < context->Header.width) {

		guchar Pix;

		Pix = context->LineBuf[X/2];

		Pixels[X * 4 + 0] =

		    context->HeaderBuf[4 * (Pix>>4) + INFOHEADER_SIZE + 2 + context->DIBoffset];

		Pixels[X * 4 + 1] =

		    context->HeaderBuf[4 * (Pix>>4) + INFOHEADER_SIZE + 1 +context->DIBoffset];

		Pixels[X * 4 + 2] =

		    context->HeaderBuf[4 * (Pix>>4) + INFOHEADER_SIZE + context->DIBoffset];

		Pixels[X * 4 + 3] = 0xff;

		X++;

		if (X<context->Header.width) { 

			/* Handle the other 4 bit pixel only when there is one */

			Pixels[X * 4 + 0] =

			    context->HeaderBuf[4 * (Pix&15) + INFOHEADER_SIZE + 2 + context->DIBoffset];

			Pixels[X * 4 + 1] =

			    context->HeaderBuf[4 * (Pix&15) + INFOHEADER_SIZE + 1 + context->DIBoffset];

			Pixels[X * 4 + 2] =

			    context->HeaderBuf[4 * (Pix&15) + INFOHEADER_SIZE + context->DIBoffset];

			Pixels[X * 4 + 3] = 0xff;

			X++;

		}

	}

}

static void OneLine1(struct ico_progressive_state *context)

{

	gint X;

	guchar *Pixels;

	X = 0;

	if (context->Header.Negative == 0)

		Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

			  (context->Header.height - context->Lines - 1));

	else

		Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

			  context->Lines);

	while (X < context->Header.width) {

		int Bit;

		Bit = (context->LineBuf[X / 8]) >> (7 - (X & 7));

		Bit = Bit & 1;

		/* The joys of having a BGR byteorder */

		Pixels[X * 4 + 0] = Bit*255;

		Pixels[X * 4 + 1] = Bit*255;

		Pixels[X * 4 + 2] = Bit*255;

		Pixels[X * 4 + 3] = 0xff;

		X++;

	}

}

static void OneLineTransp(struct ico_progressive_state *context)

{

	gint X;

	guchar *Pixels;

	/* Ignore the XOR mask for XP style 32-bpp icons with alpha */ 

	if (context->Header.depth == 32)

		return;

	X = 0;

	if (context->Header.Negative == 0)

		Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

			  (2*context->Header.height - context->Lines - 1));

	else

		Pixels = (context->pixbuf->pixels +

			  (gsize) context->pixbuf->rowstride *

			  (context->Lines-context->Header.height));

	while (X < context->Header.width) {

		int Bit;

		Bit = (context->LineBuf[X / 8]) >> (7 - (X & 7));

		Bit = Bit & 1;

		/* The joys of having a BGR byteorder */

		Pixels[X * 4 + 3] = 255-Bit*255;

#if 0

		if (Bit){

		  Pixels[X*4+0] = 255;

		  Pixels[X*4+1] = 255;

		} else {

		  Pixels[X*4+0] = 0;

		  Pixels[X*4+1] = 0;

		}

#endif		

		X++;

	}

}

static void OneLine(struct ico_progressive_state *context)

{

	context->LineDone = 0;

	if (context->Lines >= context->Header.height*2) {

		return;

	}

	if (context->Lines <context->Header.height) {		

                if (context->Type == 32)

                        OneLine32 (context);

		else if (context->Type == 24)

			OneLine24(context);

                else if (context->Type == 16)

                        OneLine16 (context);

		else if (context->Type == 8)

			OneLine8(context);

		else if (context->Type == 4)

			OneLine4(context);

		else if (context->Type == 1)

			OneLine1(context);

		else 

			g_assert_not_reached ();