#include <stdio.h></stdio.h>

#include <string.h></string.h>

#include <stdlib.h></stdlib.h>

#include <math.h></math.h>

#include "../compatibility/tnz4.h"

#include "../compatibility/inforegion.h"

#include "filebmp.h"

/*

typedef unsigned long  ULONG;

typedef unsigned short USHORT;

typedef unsigned char  UCHAR;

typedef unsigned int   UINT;

typedef void IMAGERGB;

typedef struct {USHORT m,b,g,r;} SPIXEL;

#define CASE break; case

#define __OR      ; case

#define DEFAULT break; default

#define TRUE 1

#define FALSE 0

#define NIL (void*)0

*/

typedef enum {

	BMP_NONE,

	BMP_BW,

	BMP_GREY16,

	BMP_GREY16C,

	BMP_GREY256,

	BMP_GREY256C,

	BMP_CMAPPED16,

	BMP_CMAPPED16C,

	BMP_CMAPPED256,

	BMP_CMAPPED256C,

	BMP_RGB

} BMP_SUBTYPE;

/*

typedef struct bmpimage {

	int xsize,ysize;

	LPIXEL *buffer;

  BMP_SUBTYPE type;

	} IMAGE;

*/

#define UNUSED_REDUCE_COLORS

/*---------------------------------------------------------------------------*/

/*-- Defines ----------------------------------------------------------------*/

#define BMP_BI_RGB 0

#define BMP_BI_RLE8 1

#define BMP_BI_RLE4 2

#define BMP_WIN_OS2_OLD 12

#define BMP_WIN_NEW 40

#define BMP_OS2_NEW 64

#define BMP_READ_INFO 1

#define BMP_READ_IMAGE 2

#define BMP_FERROR(fp) (ferror(fp) || feof(fp))

#define BMP_RMAP(x) (x & 0xe0) | ((x & 0xe0) >> 3) | ((x & 0xc0) >> 6)

#define BMP_GMAP(x) ((x & 0x1c) << 3) | (x & 0x1c) | ((x & 0x18) >> 3)

#define BMP_BMAP(x) ((x & 0x03) << 6) | ((x & 0x03) << 4) | ((x & 0x03) << 2) | (x & 0x03)

#define BMP_RMAP16(x) ((x & 0xc0) << 0) | ((x & 0xc0) >> 2) | ((x & 0xc0) >> 4) | ((x & 0xc0) >> 6)

#define BMP_GMAP16(x) ((x & 0x60) << 1) | ((x & 0x60) >> 1) | ((x & 0x60) >> 3) | ((x & 0x60) >> 5)

#define BMP_BMAP16(x) ((x & 0x30) << 2) | ((x & 0x30) << 0) | ((x & 0x30) >> 2) | ((x & 0x30) >> 4)

#define BMP_CUT(a, b, c) \

	{                    \

		if (a < b)       \

			a = b;       \

		else if (a > c)  \

			a = c;       \

	}

#define BMP_REDUCE_COLORS(r, g, b) ((r & 0xe0) | ((g & 0xe0) >> 3) | ((b & 0xc0) >> 6))

#define BMP_ADD_ERROR(pix, weight)            \

	{                                         \

		tmp = (pix).r + ((r1 * weight) >> 4); \

		BMP_CUT(tmp, 0, 255);                 \

		(pix).r = tmp;                        \

		tmp = (pix).g + ((g1 * weight) >> 4); \

		BMP_CUT(tmp, 0, 255);                 \

		(pix).g = tmp;                        \

		tmp = (pix).b + ((b1 * weight) >> 4); \

		BMP_CUT(tmp, 0, 255);                 \

		(pix).b = tmp;                        \

	}

#define BMP_ADD_ERROR_BW(pix, error) \

	{                                \

		tmp = (pix).r + (error);     \

		BMP_CUT(tmp, 0, 255);        \

		(pix).r = tmp;               \

		tmp = (pix).g + (error);     \

		BMP_CUT(tmp, 0, 255);        \

		(pix).g = tmp;               \

		tmp = (pix).b + (error);     \

		BMP_CUT(tmp, 0, 255);        \

		(pix).b = tmp;               \

	}

/*---------------------------------------------------------------------------*/

/*-- Structures and Enums ---------------------------------------------------*/

typedef struct

	{

	UINT bfSize;

	UINT bfOffBits;

	UINT biSize;

	UINT biWidth;

	UINT biHeight;

	UINT biPlanes;

	UINT biBitCount;

	UINT biCompression;

	UINT biSizeImage;

	UINT biXPelsPerMeter;

	UINT biYPelsPerMeter;

	UINT biClrUsed;

	UINT biClrImportant;

	UINT biFilesize;

	UINT biPad;

} BMP_HEADER;

/*---------------------------------------------------------------------------*/

/*-- Prototypes -------------------------------------------------------------*/

int load_bmp_header(FILE *fp, BMP_HEADER **pHd);

int write_bmp_header(FILE *fp, BMP_HEADER *hd);

void release_bmp_header(BMP_HEADER *hd);

int write_bmp_palette(FILE *fp, int nc, UCHAR *b, UCHAR *g, UCHAR *r);

int make_bmp_palette(int colors, int grey, UCHAR *r, UCHAR *g, UCHAR *b);

BMP_SUBTYPE bmp_get_colorstyle(IMAGE *img);

int error_checking_bmp(BMP_HEADER *hd);

int read_bmp_line(FILE *fp, void *line,

				  UINT w, UINT h, UCHAR **map, BMP_SUBTYPE type);

int write_bmp_line(FILE *fp, void *line_buffer,

				   UINT w, UINT row, UCHAR *map, BMP_SUBTYPE type);

int skip_bmp_lines(FILE *fp, UINT w, UINT rows, int whence, BMP_SUBTYPE type);

/*---------------------------------------------------------------------------*/

/*-- Local Prototypes -------------------------------------------------------*/

static UINT getshort(FILE *fp);

static UINT getint(FILE *fp);

static void putshort(FILE *fp, int value);

static void putint(FILE *fp, int value);

static int img_read_bmp_generic(const MYSTRING fname, int type, IMAGE **);

#ifndef UNUSED_REDUCE_COLORS

static UCHAR *reduce_colors(UCHAR *buffin, int xsize, int ysize,

							UCHAR *rmap, UCHAR *gmap, UCHAR *bmap, int nc);

#endif

static int loadBMP1(FILE *fp, LPIXEL *pic, UINT w, UINT h, UCHAR *r, UCHAR *g, UCHAR *b);

static int loadBMP4(FILE *fp, LPIXEL *pic, UINT w, UINT h, UINT comp, UCHAR *r, UCHAR *g, UCHAR *b);

static int loadBMP8(FILE *fp, LPIXEL *pic, UINT w, UINT h, UINT comp, UCHAR *r, UCHAR *g, UCHAR *b);

static int loadBMP24(FILE *fp, LPIXEL *pic, UINT w, UINT h);

static int writeBMP1(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *map);

static int writeBMP4(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *map);

static int writeBMPC4(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *map);

static int writeBMP8(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *map);

static int writeBMPC8(FILE *fp, UCHAR *pic8, UINT w, UINT h, UCHAR *map);

static int writeBMP24(FILE *fp, UCHAR *pic24, UINT w, UINT h, UCHAR *map);

static int load_lineBMP1(FILE *fp, LPIXEL *pic, UINT w, UINT padw, UCHAR **map);

static int load_lineBMP4(FILE *fp, LPIXEL *pic, UINT w, UINT padw, UCHAR **map);

static int load_lineBMPC4(FILE *fp, LPIXEL *pic, UINT w, UINT y, UCHAR **map);

static int load_lineBMP8(FILE *fp, LPIXEL *pic, UINT w, UINT padw, UCHAR **map);

static int load_lineBMPC8(FILE *fp, LPIXEL *pic, UINT w, UINT y, UCHAR **map);

static int load_lineBMP24(FILE *fp, LPIXEL *pic, UINT w, UINT padb);

static int line_writeBMP1(FILE *fp, UCHAR *pic8, UINT w, UINT padw, UCHAR *pc2nc);

static int line_writeBMP4(FILE *fp, UCHAR *pic8, UINT w, UINT padw, UCHAR *pc2nc);

static int line_writeBMPC4(FILE *fp, UCHAR *pic8, UINT w, UINT row, UCHAR *pc2nc);

static int line_writeBMP8(FILE *fp, UCHAR *pic8, UINT w, UINT padw, UCHAR *pc2nc);

static int line_writeBMPC8(FILE *fp, UCHAR *pic8, UINT w, UINT row, UCHAR *pc2nc);

static int line_writeBMP24(FILE *fp, LPIXEL *pp, UINT w, UINT padb);

static int skip_rowsBMP1(FILE *fp, UINT w, UINT pad, UINT rows, int whence);

static int skip_rowsBMP4(FILE *fp, UINT w, UINT pad, UINT rows, int whence);

static int skip_rowsBMPC4(FILE *fp, UINT rows);

static int skip_rowsBMP8(FILE *fp, UINT w, UINT pad, UINT rows, int whence);

static int skip_rowsBMPC8(FILE *fp, UINT rows);

static int skip_rowsBMP24(FILE *fp, UINT w, UINT pad, UINT rows, int whence);

#define BMP_DEBUG 0

#define __BMP_WRITE_LINE_BY_LINE

#define __BMP_READ_LINE_BY_LINE

/*---------------------------------------------------------------------------*/

int read_bmp_line(FILE *fp, void *line_buffer,

				  UINT w, UINT row, UCHAR **map, BMP_SUBTYPE type)

/*---------------------------------------------------------------------------*/

{

	LPIXEL *pic = (LPIXEL *)line_buffer;

	unsigned int pad;

	int rv = 0;

	switch (type) {

	case BMP_BW:

		pad = ((w + 31) / 32) * 32;

		rv = load_lineBMP1(fp, pic, w, pad, map);

		CASE BMP_GREY16 : __OR BMP_CMAPPED16 : pad = ((w + 7) / 8) * 8;

		rv = load_lineBMP4(fp, pic, w, pad, map);

		CASE BMP_GREY16C : __OR BMP_CMAPPED16C : rv = load_lineBMPC4(fp, pic, w, row, map);

		if (rv == -1)

			rv = 1;

		else if (rv == -2)

			rv = 0;

		else if (rv == -3)

			rv = 0;

		else

			rv = 0;

		CASE BMP_GREY256 : __OR BMP_CMAPPED256 : pad = ((w + 3) / 4) * 4;

		rv = load_lineBMP8(fp, pic, w, pad, map);

		CASE BMP_GREY256C : __OR BMP_CMAPPED256C : rv = load_lineBMPC8(fp, pic, w, row, map);

		if (rv == -1)

			rv = 1;

		else if (rv == -2)

			rv = 0;

		else if (rv == -3)

			rv = 0;

		else

			rv = 0;

		CASE BMP_RGB : pad = (4 - ((w * 3) % 4)) & 0x03;

		rv = load_lineBMP24(fp, pic, w, pad);

	DEFAULT:

		break;

	}

	return !rv; /* return 0 for unsuccess */

}

/*---------------------------------------------------------------------------*/

int write_bmp_line(FILE *fp, void *line_buffer,

				   UINT w, UINT row, UCHAR *map, BMP_SUBTYPE type)

/*---------------------------------------------------------------------------*/

{

	UCHAR *pic = (UCHAR *)line_buffer;

	LPIXEL *p24 = (LPIXEL *)line_buffer;

	unsigned int pad;

	int rv = 0;

	switch (type) {

	case BMP_BW:

		pad = ((w + 31) / 32) * 32;

		rv = line_writeBMP1(fp, pic, w, pad, map);

		CASE BMP_GREY16 : __OR BMP_CMAPPED16 : pad = ((w + 7) / 8) * 8;

		rv = line_writeBMP4(fp, pic, w, pad, map);

		CASE BMP_GREY16C : __OR BMP_CMAPPED16C : rv = line_writeBMPC4(fp, pic, w, row, map);

		CASE BMP_GREY256 : __OR BMP_CMAPPED256 : pad = ((w + 3) / 4) * 4;

		rv = line_writeBMP8(fp, pic, w, pad, map);

		CASE BMP_GREY256C : __OR BMP_CMAPPED256C : rv = line_writeBMPC8(fp, pic, w, row, map);

		CASE BMP_RGB : pad = (4 - ((w * 3) % 4)) & 0x03;

		rv = line_writeBMP24(fp, p24, w, pad);

	DEFAULT:

		break;

	}

	return rv; /* 0 for unsuccess */

}

/*---------------------------------------------------------------------------*/

int skip_bmp_lines(FILE *fp, UINT w, UINT rows, int whence, BMP_SUBTYPE type)

/*---------------------------------------------------------------------------*/

{

	unsigned int pad;

	int rv = 0;

	switch (type) {

	case BMP_BW:

		pad = ((w + 31) / 32) * 32;

		rv = skip_rowsBMP1(fp, w, pad, rows, whence);

		CASE BMP_GREY16 : __OR BMP_CMAPPED16 : pad = ((w + 7) / 8) * 8;

		rv = skip_rowsBMP4(fp, w, pad, rows, whence);

		CASE BMP_GREY16C : __OR BMP_CMAPPED16C : rv = skip_rowsBMPC4(fp, rows);

		CASE BMP_GREY256 : __OR BMP_CMAPPED256 : pad = ((w + 3) / 4) * 4;

		rv = skip_rowsBMP8(fp, w, pad, rows, whence);

		CASE BMP_GREY256C : __OR BMP_CMAPPED256C : rv = skip_rowsBMPC8(fp, rows);

		CASE BMP_RGB : pad = (4 - ((w * 3) % 4)) & 0x03;

		rv = skip_rowsBMP24(fp, w, pad, rows, whence);

	DEFAULT:

		break;

	}

	return !rv;

}

/*---------------------------------------------------------------------------*/

int error_checking_bmp(BMP_HEADER *hd)

/*---------------------------------------------------------------------------*/

{

	/* error checking */

	if ((hd->biBitCount != 1 &&

		 hd->biBitCount != 4 &&

		 hd->biBitCount != 8 &&

		 hd->biBitCount != 24) ||

		hd->biPlanes != 1 || hd->biCompression > BMP_BI_RLE4) {

		return UNSUPPORTED_BMP_FORMAT;

	}

	/* error checking */

	if (((hd->biBitCount == 1 || hd->biBitCount == 24) &&

		 hd->biCompression != BMP_BI_RGB) ||

		(hd->biBitCount == 4 && hd->biCompression == BMP_BI_RLE8) ||

		(hd->biBitCount == 8 && hd->biCompression == BMP_BI_RLE4)) {

		return UNSUPPORTED_BMP_FORMAT;

	}

	return OK;

}

/*---------------------------------------------------------------------------*/

int load_bmp_header(FILE *fp, BMP_HEADER **header)

/*---------------------------------------------------------------------------*/

{

	BMP_HEADER *hd = NULL;

	int c, c1;

	*header = NULL;

	hd = (BMP_HEADER *)calloc((size_t)1, sizeof(BMP_HEADER));

	if (!hd)

		return OUT_OF_MEMORY;

	/* figure out the file size */

	fseek(fp, 0L, SEEK_END);

	hd->biFilesize = ftell(fp);

	fseek(fp, 0L, 0);

	/* read the file type (first two bytes) */

	c = getc(fp);

	c1 = getc(fp);

	if (c != 'B' || c1 != 'M') {

		free(hd);

		return UNSUPPORTED_BMP_FORMAT;

	}

	hd->bfSize = getint(fp);

	/* reserved and ignored */

	getshort(fp);

	getshort(fp);

	hd->bfOffBits = getint(fp);

	hd->biSize = getint(fp);

	if (hd->biSize == BMP_WIN_NEW || hd->biSize == BMP_OS2_NEW) {

		hd->biWidth = getint(fp);

		hd->biHeight = getint(fp);

		hd->biPlanes = getshort(fp);

		hd->biBitCount = getshort(fp);

		hd->biCompression = getint(fp);

		hd->biSizeImage = getint(fp);

		hd->biXPelsPerMeter = getint(fp);

		hd->biYPelsPerMeter = getint(fp);

		hd->biClrUsed = getint(fp);

		hd->biClrImportant = getint(fp);

	} else /* old bitmap format */

	{

		hd->biWidth = getshort(fp);

		hd->biHeight = getshort(fp);

		hd->biPlanes = getshort(fp);

		hd->biBitCount = getshort(fp);

		/* Not in old versions so have to compute them */

		hd->biSizeImage = (((hd->biPlanes *

							 hd->biBitCount *

							 hd->biWidth) +

							31) /

						   32) *

						  4 * hd->biHeight;

		hd->biCompression = BMP_BI_RGB;

		hd->biXPelsPerMeter = 0;

		hd->biYPelsPerMeter = 0;

		hd->biClrUsed = 0;

		hd->biClrImportant = 0;

	}

	if (BMP_DEBUG) {

		printf("\nLoadBMP:\tbfSize=%u, bfOffBits=%u\n", hd->bfSize,

			   hd->bfOffBits);

		printf("\t\tbiSize=%u, biWidth=%u, biHeight=%u, biPlanes=%u\n",

			   hd->biSize,

			   hd->biWidth,

			   hd->biHeight,

			   hd->biPlanes);

		printf("\t\tbiBitCount=%u, biCompression=%u, biSizeImage=%u\n",

			   hd->biBitCount,

			   hd->biCompression,

			   hd->biSizeImage);

		printf("\t\tbiX,YPelsPerMeter=%u,%u  biClrUsed=%u, biClrImp=%u\n",

			   hd->biXPelsPerMeter,

			   hd->biYPelsPerMeter,

			   hd->biClrUsed,

			   hd->biClrImportant);

	}

	if (BMP_FERROR(fp)) {

		free(hd);

		return UNEXPECTED_EOF;

	}

	*header = hd;

	return OK;

}

/*---------------------------------------------------------------------------*/

void release_bmp_header(BMP_HEADER *hd)

/*---------------------------------------------------------------------------*/

{

	if (hd)

		free(hd);

}

#ifndef __LIBSIMAGE__

/*---------------------------------------------------------------------------*/

int img_read_bmp(const MYSTRING fname, IMAGE **pimg)

/*---------------------------------------------------------------------------*/

{

	return img_read_bmp_generic(fname, BMP_READ_IMAGE, pimg);

}

/*---------------------------------------------------------------------------*/

static int img_read_bmp_generic(const MYSTRING fname, int type, IMAGE **pimg)

/*---------------------------------------------------------------------------*/

{

	int retCode = OK;

	UCHAR r[256], g[256], b[256];

	BMP_HEADER *hd = NULL;

	IMAGE *img = NULL;

	int rv, c, i;

	LPIXEL *pic;

	FILE *fp;

	*pimg = 0;

	/* returns  'NULL' on unsuccess */

	pic = (LPIXEL *)NULL;

	/* open image file */

	fp = _wfopen(fname, L"rb");

	if (!fp)

		return CANT_OPEN_FILE;

	/* load up the image header */

	retCode = load_bmp_header(fp, &hd);

	if (retCode != OK)

		goto ERROR;

	/* error checking */

	if ((hd->biBitCount != 1 &&

		 hd->biBitCount != 4 &&

		 hd->biBitCount != 8 &&

		 hd->biBitCount != 24) ||

		hd->biPlanes != 1 || hd->biCompression > BMP_BI_RLE4) {

		retCode = UNSUPPORTED_BMP_FORMAT;

		goto ERROR;

	}

	/* error checking */

	if (((hd->biBitCount == 1 || hd->biBitCount == 24) &&

		 hd->biCompression != BMP_BI_RGB) ||

		(hd->biBitCount == 4 && hd->biCompression == BMP_BI_RLE8) ||

		(hd->biBitCount == 8 && hd->biCompression == BMP_BI_RLE4)) {

		retCode = UNSUPPORTED_BMP_FORMAT;

		goto ERROR;

	}

	img = new_img();

	img->type = TOONZRGB;

	if (type == BMP_READ_INFO) {

		fclose(fp);

		img->xSBsize = img->xsize = hd->biWidth;

		img->ySBsize = img->ysize = hd->biHeight;

		release_bmp_header(hd);

		*pimg = img;

		return OK;

	}

	allocate_pixmap(img, (int)hd->biWidth, (int)hd->biHeight);

	/* hd->biPad; */

	if (hd->biSize != BMP_WIN_OS2_OLD) {

		/* skip ahead to colormap, using biSize */

		c = hd->biSize - 40; /* 40 bytes read from biSize to biClrImportant */

		for (i = 0; i < c; i++)

			getc(fp);

		hd->biPad = hd->bfOffBits - (hd->biSize + 14);

	}

	/* load up colormap, if any */

	if (hd->biBitCount != 24) {

		int i, cmaplen;

		/*cmaplen = (hd->biClrUsed) ? hd->biClrUsed : 1 << hd->biBitCount;*/

		if (hd->biClrUsed)

			cmaplen = hd->biClrUsed;

		else

			cmaplen = 1 << hd->biBitCount;

		for (i = 0; i < cmaplen; i++) {

			b[i] = getc(fp);

			g[i] = getc(fp);

			r[i] = getc(fp);

			if (hd->biSize != BMP_WIN_OS2_OLD) {

				getc(fp);

				hd->biPad -= 4;

			}

		}

		if (BMP_FERROR(fp)) {

			retCode = UNEXPECTED_EOF;

			goto ERROR;

		}

		if (BMP_DEBUG) {

			printf("LoadBMP:  BMP colormap:  (RGB order)\n");

			for (i = 0; i < cmaplen; i++)

				printf("%02x%02x%02x  ", r[i], g[i], b[i]);

			printf("\n\n");

		}

	}

	if (hd->biSize != BMP_WIN_OS2_OLD) {

		/* Waste any unused bytes between the colour map (if present)

         and the start of the actual bitmap data. 

     */

		while (hd->biPad > 0) {

			(void)getc(fp);

			hd->biPad--;

		}

	}

	/* create 32 bit image buffer */

	pic = (LPIXEL *)img->buffer;

	/* load up the image */

	switch (hd->biBitCount) {

	case 1:

		rv = loadBMP1(fp, pic, hd->biWidth, hd->biHeight, r, g, b);

		CASE 4 : rv = loadBMP4(fp, pic, hd->biWidth, hd->biHeight, hd->biCompression, r, g, b);

		CASE 8 : rv = loadBMP8(fp, pic, hd->biWidth, hd->biHeight, hd->biCompression, r, g, b);

		CASE 24 : rv = loadBMP24(fp, pic, hd->biWidth, hd->biHeight);

	DEFAULT:

		retCode = UNSUPPORTED_BMP_FORMAT;

		goto ERROR;

	}

	if (rv) {

		retCode = UNEXPECTED_EOF;

		goto ERROR;

	}

	fclose(fp);

	release_bmp_header(hd);

	*pimg = img;

	return OK;

ERROR:

	fclose(fp);

	release_bmp_header(hd);

	if (img) {

		TFREE(img->buffer)

		TFREE(img)

	}

	return retCode;

}

#endif /* __LIBSIMAGE__ */

static int img_read_bmp_region(const MYSTRING fname, IMAGE **pimg, int x1, int y1, int x2, int y2, int scale)

{

	UCHAR r[256], g[256], b[256] /*  ,*map[3]  */;

	LPIXEL *line = NULL;

	UINT line_size = 0;

	BMP_HEADER *hd = NULL;

	EXT_INFO_REGION info;

	BMP_SUBTYPE subtype;

	LPIXEL *pic, *appo;

	IMAGE *img = NULL;

	UINT start_offset;

	UINT c, i, j;

	char buf[512];

	FILE *fp;

	UINT pad;

	enum BMP_ERROR_CODE bmp_error = OK;

	/* initialize some variables */

	i = pad = 0;

	/* returns  'NULL' on unsuccess */

	pic = (LPIXEL *)NULL;

	/* open image file */

	fp = _wfopen(fname, L"rb");

	if (!fp) {

		return CANT_OPEN_FILE;

	}

	/* load up the image header */

	load_bmp_header(fp, &hd);

	if (!hd)

		goto ERROR;

	/* error checking */

	if ((hd->biBitCount != 1 &&

		 hd->biBitCount != 4 &&

		 hd->biBitCount != 8 &&

		 hd->biBitCount != 24) ||

		hd->biPlanes != 1 || hd->biCompression > BMP_BI_RLE4) {

		sprintf(buf, "Bogus BMP File! (bitCount=%d, Planes=%d, Compression=%d)",

				hd->biBitCount, hd->biPlanes, hd->biCompression);

		bmp_error = UNSUPPORTED_BMP_FORMAT;

		goto ERROR;

	}

	/* error checking */

	if (((hd->biBitCount == 1 || hd->biBitCount == 24) &&

		 hd->biCompression != BMP_BI_RGB) ||

		(hd->biBitCount == 4 && hd->biCompression == BMP_BI_RLE8) ||

		(hd->biBitCount == 8 && hd->biCompression == BMP_BI_RLE4)) {

		sprintf(buf, "Bogus BMP File!  (bitCount=%d, Compression=%d)",

				hd->biBitCount, hd->biCompression);

		bmp_error = UNSUPPORTED_BMP_FORMAT;

		goto ERROR;

	}

	img = new_img();

	img->type = TOONZRGB;

	img->xsize = hd->biWidth;

	img->ysize = hd->biHeight;

	img->xSBsize = hd->biWidth;

	img->ySBsize = hd->biHeight;

	img->x_dpi = (double)(hd->biXPelsPerMeter / 39);

	img->y_dpi = (double)(hd->biYPelsPerMeter / 39);

	hd->biPad = 0;

	if (hd->biSize != BMP_WIN_OS2_OLD) {

		/* skip ahead to colormap, using biSize */

		c = hd->biSize - 40; /* 40 bytes read from biSize to biClrImportant */

		for (i = 0; i < c; i++)

			getc(fp);

		hd->biPad = hd->bfOffBits - (hd->biSize + 14);

	}

	/* load up colormap, if any */

	if (hd->biBitCount != 24) {

		int i, cmaplen;

		/*cmaplen = (hd->biClrUsed) ? hd->biClrUsed : 1 << hd->biBitCount;*/

		if (hd->biClrUsed)

			cmaplen = hd->biClrUsed;

		else

			cmaplen = hd->biBitCount;

		for (i = 0; i < cmaplen; i++) {

			b[i] = getc(fp);

			g[i] = getc(fp);

			r[i] = getc(fp);

			if (hd->biSize != BMP_WIN_OS2_OLD) {

				getc(fp);

				hd->biPad -= 4;

			}

		}

		if (BMP_FERROR(fp)) {

			bmp_error = UNEXPECTED_EOF;

			goto ERROR;

		}

		if (BMP_DEBUG) {

			printf("LoadBMP:  BMP colormap:  (RGB order)\n");

			for (i = 0; i < cmaplen; i++)

				printf("%02x%02x%02x  ", r[i], g[i], b[i]);

			printf("\n\n");

		}

	}

	if (hd->biSize != BMP_WIN_OS2_OLD) {

		/* Waste any unused bytes between the colour map (if present)

         and the start of the actual bitmap data. 

     */

		while (hd->biPad > 0) {

			(void)getc(fp);

			hd->biPad--;

		}

	}

	/* get information about the portion of the image to load */

	get_info_region(&info, x1, y1, x2, y2, scale,

					(int)hd->biWidth, (int)hd->biHeight, TNZ_BOTLEFT);

	/* create 32 bit image buffer */

	if (!allocate_pixmap(img, info.xsize, info.ysize)) {

		bmp_error = OUT_OF_MEMORY;

		goto ERROR;

	}

	start_offset = info.y_offset * info.xsize + info.x_offset;

	pic = ((LPIXEL *)img->buffer) + start_offset;

	if (line_size < hd->biWidth + 32) {

		line_size = hd->biWidth + 32;

		if (!line)

			TCALLOC((LPIXEL *)line, (size_t)line_size)

		else

			TREALLOC(line, line_size)

	}

	if (!line) {

		bmp_error = OUT_OF_MEMORY;

		goto ERROR;

	}

	switch (hd->biBitCount) {

	case 1:

		pad = ((hd->biWidth + 31) / 32) * 32;

		CASE 4 : pad = ((hd->biWidth + 7) / 8) * 8;

		CASE 8 : pad = ((hd->biWidth + 3) / 4) * 4;

		CASE 24 : pad = (4 - ((hd->biWidth * 3) % 4)) & 0x03;

	DEFAULT:

		/* segnala errore ed esci */

		break;

	}

	subtype = bmp_get_colorstyle(img);

	if (subtype == BMP_NONE)

		goto ERROR;

	if (info.y_offset > 0)

		info.scanNrow++;

	if (info.x_offset > 0)

		info.scanNcol++;

	/*  print_info_region(&info);      */

	if (info.startScanRow > 0)

		skip_bmp_lines(fp, hd->biWidth, (unsigned int)(info.startScanRow - 1), (unsigned int)SEEK_CUR, subtype);

	for (i = 0; i < (UINT)info.scanNrow; i++) {

		if (load_lineBMP24(fp, line, hd->biWidth, pad))

			goto ERROR;

		/*  QUESTO SWITCH VA AGGIUSTATO!

      switch (subtype)

       {

	 CASE BMP_BW:

	     if (load_lineBMP1(fp, line, hd->biWidth, pad, map))

	        goto ERROR;

	 CASE BMP_GREY16:

	 __OR BMP_CMAPPED16:

	     if (load_lineBMP4(fp, line, hd->biWidth, pad, map))

	        goto ERROR;

	 CASE BMP_GREY16C:

	 __OR BMP_CMAPPED16C:

	     if (load_lineBMPC4(fp, line, hd->biWidth, i, map)==-1)

	        goto ERROR;

	 CASE BMP_GREY256:

	 __OR BMP_CMAPPED256:

	     if (load_lineBMP8(fp, line, hd->biWidth, pad, map))

	        goto ERROR;

	 CASE BMP_GREY256C:

	 __OR BMP_CMAPPED256C:

	     if (load_lineBMPC8(fp, line, hd->biWidth, i, map)==-1)

	        goto ERROR;

	 CASE BMP_RGB:

	     if (load_lineBMP24(fp, line, hd->biWidth, pad))

	        goto ERROR;

}

*/

		for (appo = pic, j = c = 0; j < (UINT)info.scanNcol; j++, c += info.step)

			*appo++ = *(line + info.startScanCol + c);

		pic += info.xsize;

		skip_bmp_lines(fp, hd->biWidth, (unsigned int)(info.step - 1), (unsigned int)SEEK_CUR, subtype);

	}

	/*

  if (BMP_FERROR(fp)) 

   {

     bmp_error(fname, "File appears truncated.  Winging it.\n");

     goto ERROR;

   }

*/

	fclose(fp);

	release_bmp_header(hd);

	TFREE(line);

	*pimg = img;

	return OK;

ERROR:

	printf("error: (row=%d)\n", i);

	fclose(fp);

	release_bmp_header(hd);

	if (img)

		free_img(img);

	TFREE(line);

	return bmp_error;

}

/*---------------------------------------------------------------------------*/

static int loadBMP1(FILE *fp, LPIXEL *pic, UINT w, UINT h, UCHAR *r, UCHAR *g, UCHAR *b)

/*---------------------------------------------------------------------------*/

{

	UINT i, j, c, bitnum, padw, rv;

	UCHAR byte;

	LPIXEL *pp;

#ifdef BMP_READ_LINE_BY_LINE

	UCHAR *map[3];

	map[0] = r;

	map[1] = g;

	map[2] = b;

#endif

	rv = c = 0;

	padw = ((w + 31) / 32) * 32; /* 'w', padded to be a multiple of 32 */

	for (i = 0; i < h; i++) {

#ifdef BMP_READ_LINE_BY_LINE

		pp = pic + (i * w);

		rv = load_lineBMP1(fp, pp, w, padw, map);

		if (rv)

			break;

#else

		pp = pic + (i * w);

		for (j = bitnum = 0; j < padw; j++, bitnum++) {

			if ((bitnum & 7) == 0) /* read the next byte */

			{

				c = getc(fp);

				bitnum = 0;

			}

			if (j < w) {

				byte = (c & 0x80) ? 1 : 0;

				c <<= 1;

				pp->r = r[byte];

				pp->g = g[byte];

				pp->b = b[byte];