--- ray/src/common/bmpfile.c	2004/03/27 16:33:31	2.6
+++ ray/src/common/bmpfile.c	2005/05/10 01:08:43	2.15
@@ -1,5 +1,5 @@
 #ifndef lint
-static const char RCSid[] = "$Id: bmpfile.c,v 2.6 2004/03/27 16:33:31 greg Exp $";
+static const char RCSid[] = "$Id: bmpfile.c,v 2.15 2005/05/10 01:08:43 greg Exp $";
 #endif
 /*
  *  Windows and OS/2 BMP file support
@@ -10,6 +10,13 @@ static const char RCSid[] = "$Id: bmpfile.c,v 2.6 2004
 #include <string.h>
 #include "bmpfile.h"
 
+#ifdef getc_unlocked		/* avoid horrendous overhead of flockfile */
+#undef getc
+#undef putc
+#define getc    getc_unlocked
+#define putc    putc_unlocked
+#endif
+
 /* get corresponding error message */
 const char *
 BMPerrorMessage(int ec)
@@ -64,12 +71,15 @@ BMPheaderOK(const BMPHeader *hdr)
 	if (hdr->compr == BI_BITFIELDS && (BMPbitField(hdr)[0] &
 				BMPbitField(hdr)[1] & BMPbitField(hdr)[2]))
 		return 0;
-	if ((hdr->nColors < 0) | (hdr->impColors < 0))
-		return 0;
-	if (hdr->impColors > hdr->nColors)
-		return 0;
-	if (hdr->nColors > BMPpalLen(hdr))
-		return 0;
+	if (hdr->bpp > 8) {
+		if (hdr->nColors != 0)
+			return 0;
+	} else {
+		if ((hdr->nColors < 0) | (hdr->nColors > 1<<hdr->bpp))
+			return 0;
+		if ((hdr->impColors < 0) | (hdr->impColors > hdr->nColors))
+			return 0;
+	}
 	return 1;
 }
 
@@ -136,12 +146,11 @@ BMPReader *
 BMPopenReader(int (*cget)(void *), int (*seek)(uint32, void *), void *c_data)
 {
 	BMPReader       *br;
-	uint32		bmPos, hdrSiz;
-	int		palLen;
+	uint32		bmPos, hdrSiz, palSiz;
+	int		magic[2];		/* check magic number */
 
 	if (cget == NULL)
 		return NULL;
-	int     magic[2];		/* check magic number */
 	magic[0] = (*cget)(c_data);
 	if (magic[0] != 'B')
 		return NULL;
@@ -179,27 +188,24 @@ BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
 	br->hdr->hRes = rdint32(br);		/* horizontal resolution */
 	br->hdr->vRes = rdint32(br);		/* vertical resolution */
 	br->hdr->nColors = rdint32(br);		/* # colors used */
+	if (!br->hdr->nColors && br->hdr->bpp <= 8)
+		br->hdr->nColors = 1<<br->hdr->bpp;
 	br->hdr->impColors = rdint32(br);       /* # important colors */
 	if (br->hdr->impColors < 0)
 		goto err;			/* catch premature EOF */
 	if (!BMPheaderOK(br->hdr))
 		goto err;
-	palLen = BMPpalLen(br->hdr);
-	if (br->hdr->bpp <= 8) {		/* normalize color counts */
-		if (br->hdr->nColors <= 0)
-			br->hdr->nColors = palLen;
-		if (br->hdr->impColors <= 0)
-			br->hdr->impColors = br->hdr->nColors;
-	}
+	palSiz = sizeof(RGBquad)*br->hdr->nColors;
+	if (br->hdr->impColors <= 0)
+		br->hdr->impColors = br->hdr->nColors;
 						/* extend header */
-	if (bmPos < hdrSiz + sizeof(RGBquad)*palLen)
+	if (bmPos < hdrSiz + palSiz)
 		goto err;
-	br->hdr->infoSiz = bmPos - (hdrSiz + sizeof(RGBquad)*palLen);
-	if (palLen > 0 || br->hdr->infoSiz > 0) {
+	br->hdr->infoSiz = bmPos - (hdrSiz + palSiz);
+	if (br->hdr->nColors > 0 || br->hdr->infoSiz > 0) {
 		br->hdr = (BMPHeader *)realloc((void *)br->hdr,
 					sizeof(BMPHeader) +
-					sizeof(RGBquad)*palLen +
-					br->hdr->infoSiz);
+					palSiz + br->hdr->infoSiz);
 		if (br->hdr == NULL)
 			goto err;
 	}
@@ -208,8 +214,7 @@ BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
 		BMPbitField(br->hdr)[0] = (uint32)rdint32(br);
 		BMPbitField(br->hdr)[1] = (uint32)rdint32(br);
 		BMPbitField(br->hdr)[2] = (uint32)rdint32(br);
-	} else if (rdbytes((char *)br->hdr->palette,
-			sizeof(RGBquad)*palLen, br) != BIR_OK)
+	} else if (rdbytes((char *)br->hdr->palette, palSiz, br) != BIR_OK)
 		goto err;
 						/* read add'l information */
 	if (rdbytes(BMPinfo(br->hdr), br->hdr->infoSiz, br) != BIR_OK)
@@ -232,9 +237,8 @@ BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
 				sizeof(br->scanpos[0])*br->hdr->height);
 	}
 	br->scanpos[0] = br->fpos;
-	if (BMPreadScanline(br) != BIR_OK)
-		goto err;
-	return br;
+	if (BMPreadScanline(br) == BIR_OK)
+		return br;
 err:
 	if (br->hdr != NULL)
 		free((void *)br->hdr);
@@ -255,8 +259,8 @@ BMPisGrayscale(const BMPHeader *hdr)
 		return -1;
 	if (hdr->bpp > 8)		/* assume they had a reason for it */
 		return 0;
-	for (rgbp = hdr->palette, n = hdr->nColors; n-- > 0; rgbp++)
-		if (((rgbp->r != rgbp->g) | (rgbp->g != rgbp->b)))
+	for (rgbp = hdr->palette, n = hdr->impColors; n-- > 0; rgbp++)
+		if ((rgbp->r != rgbp->g) | (rgbp->g != rgbp->b))
 			return 0;
 	return 1;			/* all colors neutral in map */
 }
@@ -275,14 +279,14 @@ BMPreadScanline(BMPReader *br)
 	if (br->hdr->compr == BI_UNCOMPR || br->hdr->compr == BI_BITFIELDS)
 		return rdbytes((char *)br->scanline, n, br);
 	/*
-	 * RLE/RLE8 Decoding
+	 * RLE4/RLE8 Decoding
 	 *
 	 * Certain aspects of this scheme are completely insane, so
 	 * we don't support them.  Fortunately, they rarely appear.
 	 * One is the mid-file EOD (0x0001) and another is the ill-conceived
 	 * "delta" (0x0002), which is like a "goto" statement for bitmaps.
-	 * Whoever thought this up should be shot, then told why
-	 * it's impossible to support such a scheme in any reasonable way.
+	 * Whoever thought this up should be wrestled to the ground and told
+	 * why it's impossible to support such a scheme in any reasonable way.
 	 * Also, RLE4 mode allows runs to stop halfway through a byte,
 	 * which is likewise uncodeable, so we don't even try.
 	 * Finally, the scanline break is ambiguous -- we assume here that
@@ -296,7 +300,10 @@ BMPreadScanline(BMPReader *br)
 	 * is it specified what we should assume for missing pixels.  This
 	 * is undoubtedly the most brain-dead format I've ever encountered.
 	 */
-	sp = br->scanline;
+	sp = (int8 *)br->scanline;
+	n = br->hdr->width;
+	if (br->hdr->compr == BI_RLE4)
+		n = (n + 1) >> 1;
 	while (n > 0) {
 		int     skipOdd, len, val;
 
@@ -317,6 +324,7 @@ BMPreadScanline(BMPReader *br)
 				*sp++ = val;
 			continue;
 		}
+					/* check for escape */
 		switch (rdbyte(len, br)) {
 		case EOF:
 			return BIR_TRUNCATED;
@@ -600,13 +608,8 @@ wrseek(uint32 pos, BMPWriter *bw)
 {
 	if (pos == bw->fpos)
 		return BIR_OK;
-	if (bw->seek == NULL) {
-		if (pos < bw->fpos)
-			return BIR_SEEKERR;
-		while (bw->fpos < pos)
-			wrbyte(0, bw);
-		return BIR_OK;
-	}
+	if (bw->seek == NULL)
+		return BIR_SEEKERR;
 	if ((*bw->seek)(pos, bw->c_data) != 0)
 		return BIR_SEEKERR;
 	bw->fpos = pos;
@@ -637,7 +640,7 @@ BMPopenWriter(void (*cput)(int, void *), int (*seek)(u
 	hdrSiz = 2 + 6*4 + 2*2 + 6*4;
 	if (hdr->compr == BI_BITFIELDS)
 		hdrSiz += sizeof(uint32)*3;
-	palSiz = sizeof(RGBquad)*BMPpalLen(hdr);
+	palSiz = sizeof(RGBquad)*hdr->nColors;
 	scanSiz = getScanSiz(hdr);
 	bmSiz = hdr->height*scanSiz;		/* wrong if compressed */
 						/* initialize writer */
@@ -733,13 +736,12 @@ BMPwriteScanline(BMPWriter *bw)
 	 * (0x0000) except for the last, which ends in a bitmap break
 	 * (0x0001).  We don't support RLE4 at all; it's too awkward.
 	 */
-	sp = bw->scanline;
+	sp = (const int8 *)bw->scanline;
 	n = bw->hdr->width;
 	while (n > 0) {
 		int     cnt, val;
-
 		cnt = findNextRun(sp, n);       /* 0-255 < n */
-		if (cnt >= 3) {			/* output non-run */
+		if (cnt >= 3) {			/* output absolute */
 			int     skipOdd = cnt & 1;
 			wrbyte(0, bw);
 			wrbyte(cnt, bw);
@@ -752,8 +754,8 @@ BMPwriteScanline(BMPWriter *bw)
 		if (n <= 0)			/* was that it? */
 			break;
 		val = *sp;			/* output run */
-		for (cnt = 1; cnt < 255; cnt++)
-			if (!--n | *++sp != val)
+		for (cnt = 1; --n && cnt < 255; cnt++)
+			if (*++sp != val)
 				break;
 		wrbyte(cnt, bw);
 		wrbyte(val, bw);
@@ -761,9 +763,11 @@ BMPwriteScanline(BMPWriter *bw)
 	bw->yscan++;				/* write line break or EOD */
 	if (bw->yscan == bw->hdr->height) {
 		wrbyte(0, bw); wrbyte(1, bw);   /* end of bitmap marker */
-		if (bw->seek == NULL || (*bw->seek)(2, bw->c_data) != 0)
+		if (wrseek(2, bw) != BIR_OK)
 			return BIR_OK;		/* no one may care */
-		bw->fpos = 2;
+		wrint32(bw->flen, bw);		/* correct file length */
+		if (wrseek(34, bw) != BIR_OK)
+			return BIR_OK;
 		wrint32(bw->flen-bw->fbmp, bw); /* correct bitmap length */
 	} else {
 		wrbyte(0, bw); wrbyte(0, bw);   /* end of line marker */