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

/* GdkPixbuf library - Windows Bitmap 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-ras.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/>.

 */

#include "config.h"

#include <stdio.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <string.h>

#include "gdk-pixbuf-private.h"

#define DUMPBIH 0

#if 0

/* If these structures were unpacked, they would define the two headers of the

 * BMP file.  After them comes the palette, and then the image data.

 *

 * We do not use these structures; we just keep them here for reference.

 */

struct BitmapFileHeader {

	guint16 magic;

	guint32 file_size;

	guint32 reserved;

	guint32 data_offset;

};

struct BitmapInfoHeader {

	guint32 header_size;

	guint32 width;

	guint32 height;

	guint16 planes;

	guint16 bpp;

	guint32 compression;

	guint32 data_size;

	guint32 x_ppm;

	guint32 y_ppm;

	guint32 n_colors;

	guint32 n_important_colors;

};

#endif

/* Compression values */

#define BI_RGB 0

#define BI_RLE8 1

#define BI_RLE4 2

#define BI_BITFIELDS 3

/* State machine */

typedef enum {

	READ_STATE_HEADERS,	/* Reading the bitmap file header and bitmap info header */

	READ_STATE_PALETTE,	/* Reading the palette */

	READ_STATE_BITMASKS,	/* Reading the bitmasks for BI_BITFIELDS */

	READ_STATE_DATA,	/* Reading the actual image data */

	READ_STATE_ERROR,	/* An error occurred; further data will be ignored */

	READ_STATE_DONE		/* Done reading the image; further data will be ignored */

} ReadState;

/*

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

debugging purposes.

*/

#if DUMPBIH

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

/* struct headerpair contains the decoded width/height/depth info for

   the current bitmap */

struct headerpair {

	guint32 size;

	gint32 width;

	gint32 height;

	guint depth;

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

				   Negative = 0 -> bottom up BMP */

	guint  n_colors;

};

/* Data needed for the "state" during decompression */

struct bmp_compression_state {

	gint phase;

	gint run;

	gint count;

	gint x, y;

	guchar *p;

};

/* Progressive loading */

struct bmp_progressive_state {

	GdkPixbufModuleSizeFunc size_func;

	GdkPixbufModulePreparedFunc prepared_func;

	GdkPixbufModuleUpdatedFunc updated_func;

	gpointer user_data;

	ReadState read_state;

	guint LineWidth;

	guint Lines;		/* # of finished lines */

	guchar *buff;

	guint BufferSize;

	guint BufferPadding;

	guint BufferDone;

	guchar (*Colormap)[3];

	gint Type;		/*

				   32 = RGB + alpha

				   24 = RGB

				   16 = RGB

				   4  = 4 bpp colormapped

				   8  = 8 bpp colormapped

				   1  = 1 bit bitonal

				 */

	guint Compressed;

	struct bmp_compression_state compr;

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

	/* Bit masks, shift amounts, and significant bits for BI_BITFIELDS coding */

	int r_mask, r_shift, r_bits;

	int g_mask, g_shift, g_bits;

	int b_mask, b_shift, b_bits;

	int a_mask, a_shift, a_bits;

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

};

static gpointer

gdk_pixbuf__bmp_image_begin_load(GdkPixbufModuleSizeFunc size_func,

                                 GdkPixbufModulePreparedFunc prepared_func,

				 GdkPixbufModuleUpdatedFunc updated_func,

                                 gpointer user_data,

                                 GError **error);

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

static gboolean gdk_pixbuf__bmp_image_load_increment(gpointer data,

                                                     const guchar * buf,

                                                     guint size,

                                                     GError **error);

/* Picks up a 32-bit little-endian integer starting at the specified location.

 * Does it by hand instead of dereferencing a simple (gint *) cast due to

 * alignment constraints many platforms.

 */

static int

lsb_32 (guchar *src)

{

	return src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);

}

/* Same as above, but for 16-bit little-endian integers. */

static short

lsb_16 (guchar *src)

{

	return src[0] | (src[1] << 8);

}

static gboolean grow_buffer (struct bmp_progressive_state *State,

                             GError **error)

{

  guchar *tmp;

  if (State->BufferSize == 0) {

    g_set_error_literal (error,

                         GDK_PIXBUF_ERROR,

                         GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                         _("BMP image has bogus header data"));

    State->read_state = READ_STATE_ERROR;

    return FALSE;

  }

  tmp = g_try_realloc (State->buff, State->BufferSize);

  if (!tmp) {

    g_set_error_literal (error,

                         GDK_PIXBUF_ERROR,

                         GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,

                         _("Not enough memory to load bitmap image"));

    State->read_state = READ_STATE_ERROR;

    return FALSE;

  }

  State->buff = tmp;

  return TRUE;

}

static gboolean

decode_bitmasks (guchar *buf,

		 struct bmp_progressive_state *State, 

		 GError **error);

static gboolean DecodeHeader(unsigned char *BFH, unsigned char *BIH,

                             struct bmp_progressive_state *State,

                             GError **error)

{

	gint clrUsed;

	guint bytesPerPixel;

	/* First check for the two first bytes content. A sane

	   BMP file must start with bytes 0x42 0x4D.  */

	if (*BFH != 0x42 || *(BFH + 1) != 0x4D) {

		g_set_error_literal (error,

                                     GDK_PIXBUF_ERROR,

                                     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                     _("BMP image has bogus header data"));

		State->read_state = READ_STATE_ERROR;

		return FALSE;

	}

        /* FIXME this is totally unrobust against bogus image data. */

	if (State->BufferSize < lsb_32 (&BIH[0]) + 14) {

		State->BufferSize = lsb_32 (&BIH[0]) + 14;

		if (!grow_buffer (State, error))

			return FALSE;

		return TRUE;

	}

#if DUMPBIH

	DumpBIH(BIH);

#endif    

	State->Header.size = lsb_32 (&BIH[0]);

	if (State->Header.size == 124) {

                /* BMP v5 */

		State->Header.width = lsb_32 (&BIH[4]);

		State->Header.height = lsb_32 (&BIH[8]);

		State->Header.depth = lsb_16 (&BIH[14]);

		State->Compressed = lsb_32 (&BIH[16]);

	} else if (State->Header.size == 108) {

                /* BMP v4 */

		State->Header.width = lsb_32 (&BIH[4]);

		State->Header.height = lsb_32 (&BIH[8]);

		State->Header.depth = lsb_16 (&BIH[14]);

		State->Compressed = lsb_32 (&BIH[16]);

	} else if (State->Header.size == 64) {

                /* BMP OS/2 v2 */

		State->Header.width = lsb_32 (&BIH[4]);

		State->Header.height = lsb_32 (&BIH[8]);

		State->Header.depth = lsb_16 (&BIH[14]);

		State->Compressed = lsb_32 (&BIH[16]);

	} else if (State->Header.size == 56) {

                /* BMP v3 with RGBA bitmasks */

		State->Header.width = lsb_32 (&BIH[4]);

		State->Header.height = lsb_32 (&BIH[8]);

		State->Header.depth = lsb_16 (&BIH[14]);

		State->Compressed = lsb_32 (&BIH[16]);

	} else if (State->Header.size == 52) {

                /* BMP v3 with RGB bitmasks */

		State->Header.width = lsb_32 (&BIH[4]);

		State->Header.height = lsb_32 (&BIH[8]);

		State->Header.depth = lsb_16 (&BIH[14]);

		State->Compressed = lsb_32 (&BIH[16]);

	} else if (State->Header.size == 40) {

                /* BMP v3 */ 

		State->Header.width = lsb_32 (&BIH[4]);

		State->Header.height = lsb_32 (&BIH[8]);

		State->Header.depth = lsb_16 (&BIH[14]);

		State->Compressed = lsb_32 (&BIH[16]);

	} else if (State->Header.size == 12) {

                /* BMP OS/2 */

		State->Header.width = lsb_16 (&BIH[4]);

		State->Header.height = lsb_16 (&BIH[6]);

		State->Header.depth = lsb_16 (&BIH[10]);

		State->Compressed = BI_RGB;

	} else {

		g_set_error_literal (error,

                                     GDK_PIXBUF_ERROR,

                                     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                     _("BMP image has unsupported header size"));

		State->read_state = READ_STATE_ERROR;

		return FALSE;

	}

        if (State->Header.depth > 32)

          {

		g_set_error_literal (error,

                                     GDK_PIXBUF_ERROR,

                                     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                     _("BMP image has unsupported depth"));

		State->read_state = READ_STATE_ERROR;

		return FALSE;

          }

	if (State->Header.size == 12)

		clrUsed = 1 << State->Header.depth;

	else

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

        if (clrUsed > (1 << State->Header.depth))

          {

		g_set_error_literal (error,

                                     GDK_PIXBUF_ERROR,

                                     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                     _("BMP image has oversize palette"));

		State->read_state = READ_STATE_ERROR;

		return FALSE;

          }

	if (clrUsed != 0)

		State->Header.n_colors = clrUsed;

	else

            State->Header.n_colors = (1 << State->Header.depth);

	State->Type = State->Header.depth;	/* This may be less trivial someday */

	/* Negative heights indicates bottom-down pixelorder */

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

		if (State->Header.height == INT_MIN) {

			g_set_error_literal (error,

					     GDK_PIXBUF_ERROR,

					     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

					     _("BMP image has bogus header data"));

			State->read_state = READ_STATE_ERROR;

			return FALSE;

		}

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

		State->Header.Negative = 1;

	}

	if (State->Header.Negative && 

	    (State->Compressed != BI_RGB && State->Compressed != BI_BITFIELDS))

	{

		g_set_error_literal (error,

                                     GDK_PIXBUF_ERROR,

                                     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                     _("Topdown BMP images cannot be compressed"));

		State->read_state = READ_STATE_ERROR;

		return FALSE;

	}

	if (State->Header.width <= 0 || State->Header.height == 0 ||

	    (State->Compressed == BI_RLE4 && State->Type != 4)    ||

	    (State->Compressed == BI_RLE8 && State->Type != 8)	  ||

	    (State->Compressed == BI_BITFIELDS && !(State->Type == 16 || State->Type == 32)) ||

	    (State->Compressed > BI_BITFIELDS)) {

		g_set_error_literal (error,

                                     GDK_PIXBUF_ERROR,

                                     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                     _("BMP image has bogus header data"));

		State->read_state = READ_STATE_ERROR;

		return FALSE;

	}

	if ((State->Type >= 8) && (State->Type <= 32) && (State->Type % 8 == 0)) {

		bytesPerPixel = State->Type / 8;

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

		if (State->Header.width != State->LineWidth / bytesPerPixel) {

			g_set_error_literal (error,

					     GDK_PIXBUF_ERROR,

					     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

					     _("BMP image width too large"));

			return FALSE;

		}

	} 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,

                                     _("BMP image has bogus header data"));

		State->read_state = READ_STATE_ERROR;

		return FALSE;

	}

	/* Pad to a 32 bit boundary */

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

	    && (State->Compressed == BI_RGB || State->Compressed == BI_BITFIELDS))

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

	if (State->pixbuf == NULL) {

		guint64 len;

		int rowstride;

		gboolean has_alpha;

		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->read_state = READ_STATE_DONE;

				State->BufferSize = 0;

				return TRUE;

			}

		}

		/* rowstride is always >= width, so do an early check for bogus header */

		if (State->Header.width <= 0 ||

		    State->Header.height <= 0 ||

		    !g_uint64_checked_mul (&len, State->Header.width, State->Header.height) ||

		    len > G_MAXINT) {

			g_set_error_literal (error,

                                             GDK_PIXBUF_ERROR,

                                             GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                             _("BMP image has bogus header data"));

			State->read_state = READ_STATE_ERROR;

			return FALSE;

		}

		if (State->Type == 32 ||

		    State->Compressed == BI_RLE4 ||

		    State->Compressed == BI_RLE8)

			has_alpha = TRUE;

		else

			has_alpha = FALSE;

		rowstride = gdk_pixbuf_calculate_rowstride (GDK_COLORSPACE_RGB, has_alpha, 8,

							    (gint) State->Header.width,

							    (gint) State->Header.height);

		if (rowstride <= 0 ||

		    !g_uint64_checked_mul (&len, rowstride, State->Header.height) ||

		    len > G_MAXINT) {

			g_set_error_literal (error,

                                             GDK_PIXBUF_ERROR,

                                             GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                             _("BMP image has bogus header data"));

			State->read_state = READ_STATE_ERROR;

			return FALSE;

		}

		State->pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, has_alpha, 8,

						(gint) State->Header.width,

						(gint) State->Header.height);

		if (State->pixbuf == NULL) {

			g_set_error_literal (error,

                                             GDK_PIXBUF_ERROR,

                                             GDK_PIXBUF_ERROR_INSUFFICIENT_MEMORY,

                                             _("Not enough memory to load bitmap image"));

			State->read_state = READ_STATE_ERROR;

			return FALSE;

		}

		if (State->prepared_func != NULL)

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

			(*State->prepared_func) (State->pixbuf, NULL, State->user_data);

		/* make all pixels initially transparent */

		if (State->Compressed == BI_RLE4 || State->Compressed == BI_RLE8) {

			memset (State->pixbuf->pixels, 0, State->pixbuf->rowstride * State->Header.height);

			State->compr.p = State->pixbuf->pixels 

				+ State->pixbuf->rowstride * (State->Header.height- 1);

		}

	}

	State->BufferDone = 0;

	if (State->Type <= 8) {

                gint samples;

		State->read_state = READ_STATE_PALETTE;

		/* Allocate enough to hold the palette */

	        samples = (State->Header.size == 12 ? 3 : 4);

		State->BufferSize = State->Header.n_colors * samples;

		/* Skip over everything between the palette and the data.

		   This protects us against a malicious BFH[10] value.

                */

		State->BufferPadding = (lsb_32 (&BFH[10]) - 14 - State->Header.size) - State->BufferSize;

	} else if (State->Compressed == BI_RGB) {

		if (State->BufferSize < lsb_32 (&BFH[10]))

		{

			/* skip over padding between headers and image data */

			State->read_state = READ_STATE_HEADERS;

			State->BufferDone = State->BufferSize;

			State->BufferSize = lsb_32 (&BFH[10]);

		}

		else

		{

			State->read_state = READ_STATE_DATA;

			State->BufferSize = State->LineWidth;

		}

	} else if (State->Compressed == BI_BITFIELDS) {

               if (State->Header.size == 52  || State->Header.size == 56 ||

                   State->Header.size == 108 || State->Header.size == 124)

               {

			/* extended v3, v4 and v5 have the bitmasks in the header */

			if (!decode_bitmasks (&BIH[40], State, error)) {

			       State->read_state = READ_STATE_ERROR;

			       return FALSE;

                        }

               }

               else 

               {

		       State->read_state = READ_STATE_BITMASKS;

		       State->BufferSize = 12;

               }

	} else {

		g_set_error_literal (error,

                                     GDK_PIXBUF_ERROR,

                                     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                     _("BMP image has bogus header data"));

		State->read_state = READ_STATE_ERROR;

		return FALSE;

	}

	if (!grow_buffer (State, error)) 

		return FALSE;

        return TRUE;

}

static gboolean DecodeColormap (guchar *buff,

				struct bmp_progressive_state *State,

				GError **error)

{

	gint i;

	gint samples;

	guint newbuffersize;

	g_assert (State->read_state == READ_STATE_PALETTE);

	samples = (State->Header.size == 12 ? 3 : 4);

	newbuffersize = State->Header.n_colors * samples;

	if (newbuffersize / samples != State->Header.n_colors) /* Integer overflow check */

		return FALSE;

	if (State->BufferSize < newbuffersize) {

		State->BufferSize = newbuffersize;

		if (!grow_buffer (State, error))

			return FALSE;

		return TRUE;

	}

	State->Colormap = g_malloc0 ((1 << State->Header.depth) * sizeof (*State->Colormap));

	for (i = 0; i < State->Header.n_colors; i++)

	{

		State->Colormap[i][0] = buff[i * samples];

		State->Colormap[i][1] = buff[i * samples + 1];

		State->Colormap[i][2] = buff[i * samples + 2];

#ifdef DUMPCMAP

		g_print ("color %d %x %x %x\n", i,

			 State->Colormap[i][0],

			 State->Colormap[i][1],

			 State->Colormap[i][2]);

#endif

	}

	State->read_state = READ_STATE_DATA;

	State->BufferDone = 0;

	if (!(State->Compressed == BI_RGB || State->Compressed == BI_BITFIELDS))

		State->BufferSize = 2;

	else

		State->BufferSize = State->LineWidth;

	if (!grow_buffer (State, error))

		return FALSE;

	return TRUE;

}

/* Finds the lowest set bit and the number of set bits */

static void

find_bits (int n, int *lowest, int *n_set)

{

	int i;

	*n_set = 0;

	for (i = 31; i >= 0; i--)

		if (n & (1 << i)) {

			*lowest = i;

			(*n_set)++;

		}

}

/* Decodes the bitmasks for BI_BITFIELDS coding */

static gboolean

decode_bitmasks (guchar *buf,

		 struct bmp_progressive_state *State, 

		 GError **error)

{

        State->a_mask = State->a_shift = State->a_bits = 0;

	State->r_mask = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);

	buf += 4;

	State->g_mask = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);

	buf += 4;

	State->b_mask = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);

	find_bits (State->r_mask, &State->r_shift, &State->r_bits);

	find_bits (State->g_mask, &State->g_shift, &State->g_bits);

	find_bits (State->b_mask, &State->b_shift, &State->b_bits);

        /* extended v3, v4 and v5 have an alpha mask */

        if (State->Header.size == 56 || State->Header.size == 108 || State->Header.size == 124) {

	      buf += 4;

	      State->a_mask = buf[0] | (buf[1] << 8) | (buf[2] << 16) | (buf[3] << 24);

	      find_bits (State->a_mask, &State->a_shift, &State->a_bits);

        }

	if (State->r_bits == 0 || State->g_bits == 0 || State->b_bits == 0) {

                if (State->Type == 16) {

		       State->r_mask = 0x7c00;

		       State->r_shift = 10;

		       State->g_mask = 0x03e0;

		       State->g_shift = 5;

		       State->b_mask = 0x001f;

		       State->b_shift = 0;

		       State->r_bits = State->g_bits = State->b_bits = 5;

                }

                else {

		       State->r_mask = 0x00ff0000;

		       State->r_shift = 16;

		       State->g_mask = 0x0000ff00;

		       State->g_shift = 8;

		       State->b_mask = 0x000000ff;

		       State->b_shift = 0;

		       State->a_mask = 0xff000000;

		       State->a_shift = 24;

		       State->r_bits = State->g_bits = State->b_bits = State->a_bits = 8;

                }

	}

        if (State->r_bits > 8) {

          State->r_shift += State->r_bits - 8;

          State->r_bits = 8;

        }

        if (State->g_bits > 8) {

          State->g_shift += State->g_bits - 8;

          State->g_bits = 8;

        }

        if (State->b_bits > 8) {

          State->b_shift += State->b_bits - 8;

          State->b_bits = 8;

        }

        if (State->a_bits > 8) {

          State->a_shift += State->a_bits - 8;

          State->a_bits = 8;

        }

	State->read_state = READ_STATE_DATA;

	State->BufferDone = 0;

	State->BufferSize = State->LineWidth;

	if (!grow_buffer (State, error)) 

		return FALSE;

	return TRUE;

}

/*

 * 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__bmp_image_begin_load(GdkPixbufModuleSizeFunc size_func,

                                 GdkPixbufModulePreparedFunc prepared_func,

				 GdkPixbufModuleUpdatedFunc updated_func,

                                 gpointer user_data,

                                 GError **error)

{

	struct bmp_progressive_state *context;

	context = g_new0(struct bmp_progressive_state, 1);

	context->size_func = size_func;

	context->prepared_func = prepared_func;

	context->updated_func = updated_func;

	context->user_data = user_data;

	context->read_state = READ_STATE_HEADERS;

	context->BufferSize = 26;

	context->BufferPadding = 0;

	context->buff = g_malloc(26);

	context->BufferDone = 0;

	/* 14 for the BitmapFileHeader, 12 for the BitmapImageHeader */

	context->Colormap = NULL;

	context->Lines = 0;

	context->Type = 0;

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

	memset(&context->compr, 0, sizeof(struct bmp_compression_state));

	context->pixbuf = NULL;

	return (gpointer) context;

}

/*

 * context - returned from image_begin_load

 *

 * free context, unref gdk_pixbuf

 */

static gboolean gdk_pixbuf__bmp_image_stop_load(gpointer data, GError **error)

{

	gboolean retval = TRUE;

	struct bmp_progressive_state *context =

	    (struct bmp_progressive_state *) data;

        /* FIXME this thing needs to report errors if

         * we have unused image data

         */

	g_return_val_if_fail(context != NULL, TRUE);

	g_free(context->Colormap);

	if (context->pixbuf)

		g_object_unref(context->pixbuf);

	if (context->read_state == READ_STATE_HEADERS) {

                g_set_error_literal (error,

                                     GDK_PIXBUF_ERROR,

                                     GDK_PIXBUF_ERROR_CORRUPT_IMAGE,

                                     _("Premature end-of-file encountered"));

		retval = FALSE;

	}

	g_free(context->buff);

	g_free(context);

        return retval;

}

/*

The OneLineXX functions are called when 1 line worth of data is present.

OneLine24 is the 24 bpp-version.

*/

static void OneLine32(struct bmp_progressive_state *context)

{

	int i;

	guchar *pixels;

	guchar *src;

	if (!context->Header.Negative)

		pixels = (context->pixbuf->pixels +

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

	else

		pixels = (context->pixbuf->pixels +

			  context->pixbuf->rowstride * context->Lines);

	src = context->buff;

	if (context->Compressed == BI_BITFIELDS) {

		int r_lshift, r_rshift;

		int g_lshift, g_rshift;

		int b_lshift, b_rshift;

		int a_lshift, a_rshift;

		r_lshift = 8 - context->r_bits;

		g_lshift = 8 - context->g_bits;

		b_lshift = 8 - context->b_bits;

		a_lshift = 8 - context->a_bits;

		r_rshift = context->r_bits - r_lshift;

		g_rshift = context->g_bits - g_lshift;

		b_rshift = context->b_bits - b_lshift;

		a_rshift = context->a_bits - a_lshift;

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

			unsigned int v, r, g, b, a;

			v = src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);

			r = (v & context->r_mask) >> context->r_shift;

			g = (v & context->g_mask) >> context->g_shift;

			b = (v & context->b_mask) >> context->b_shift;

			a = (v & context->a_mask) >> context->a_shift;

			*pixels++ = (r << r_lshift) | (r >> r_rshift);

			*pixels++ = (g << g_lshift) | (g >> g_rshift);

			*pixels++ = (b << b_lshift) | (b >> b_rshift);

                        if (context->a_bits)

			  *pixels++ = (a << a_lshift) | (a >> a_rshift);

                        else

                          *pixels++ = 0xff;

			src += 4;

		}

	} else

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

			*pixels++ = src[2];

			*pixels++ = src[1];

			*pixels++ = src[0];

			*pixels++ = 0xff;

			src += 4;

		}

}

static void OneLine24(struct bmp_progressive_state *context)

{

	gint X;

	guchar *Pixels;

	X = 0;

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

		Pixels = (context->pixbuf->pixels +

			  context->pixbuf->rowstride *

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

	else

		Pixels = (context->pixbuf->pixels +

			  context->pixbuf->rowstride *

			  context->Lines);

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

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

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

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

		X++;

	}

}