ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/bmpfile.c

Comparing ray/src/common/bmpfile.c (file contents):
Revision 2.2 by schorsch, Fri Mar 26 21:29:19 2004 UTC vs.
Revision 2.5 by greg, Sat Mar 27 05:43:37 2004 UTC

#	Line 5 | Line 5 | static const char RCSid[] = "$Id$";
5		*  Windows and OS/2 BMP file support
6		*/
7
8	–	/* XXX reading and writing of compressed files currently unsupported */
9	–
8		#include <stdio.h>
9		#include <stdlib.h>
10		#include <string.h>
#	Line 25 | Line 23 | BMPerrorMessage(int ec)
23		return "Truncated BMP image";
24		case BIR_UNSUPPORTED:
25		return "Unsupported BMP feature";
26	+	case BIR_RLERROR:
27	+	return "BMP runlength encoding error";
28		case BIR_SEEKERR:
29		return "BMP seek error";
30		}
31		return "Unknown BMP error";
32		}
33
34	<	/* compute uncompressed scanline size */
35	<	static uint32
36	<	getScanSiz(BMPHeader *hdr)
34	>	/* check than header is sensible */
35	>	static int
36	>	BMPheaderOK(const BMPHeader *hdr)
37		{
38	<	uint32  scanSiz;
39	<	/* bytes per scanline */
40	<	scanSiz = (hdr->bpp*hdr->width + 7) >> 3;
41	<	if (scanSiz & 3)                        /* 32-bit word boundary */
42	<	scanSiz += 4 - (scanSiz & 3);
43	<
44	<	return scanSiz;
38	>	if (!hdr)
39	>	return 0;
40	>	if ((hdr->width <= 0) | (hdr->height <= 0))
41	>	return 0;
42	>	switch (hdr->bpp) {             /* check compression */
43	>	case 1:
44	>	case 24:
45	>	if (hdr->compr != BI_UNCOMPR)
46	>	return 0;
47	>	break;
48	>	case 16:
49	>	case 32:
50	>	if ((hdr->compr != BI_UNCOMPR) & (hdr->compr != BI_BITFIELDS))
51	>	return 0;
52	>	break;
53	>	case 4:
54	>	if ((hdr->compr != BI_UNCOMPR) & (hdr->compr != BI_RLE4))
55	>	return 0;
56	>	break;
57	>	case 8:
58	>	if ((hdr->compr != BI_UNCOMPR) & (hdr->compr != BI_RLE8))
59	>	return 0;
60	>	break;
61	>	default:
62	>	return 0;
63	>	}
64	>	if (hdr->compr == BI_BITFIELDS && (BMPbitField(hdr)[0] &
65	>	BMPbitField(hdr)[1] & BMPbitField(hdr)[2]))
66	>	return 0;
67	>	if ((hdr->nColors < 0) | (hdr->impColors < 0))
68	>	return 0;
69	>	if (hdr->impColors > hdr->nColors)
70	>	return 0;
71	>	if (hdr->nColors > BMPpalLen(hdr))
72	>	return 0;
73	>	return 1;
74		}
75
76	+	/* compute uncompressed scan size */
77	+	#define getScanSiz(h)   ( ((((h)->bpp*(h)->width+7) >>3) + 3) & ~03 )
78	+
79		/* get next byte from reader */
80		#define rdbyte(c,br)    ((br)->fpos += (c=(*(br)->cget)((br)->c_data))!=EOF, c)
81
#	Line 130 | Line 162 | BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
162		(void)rdint32(br);                      /* file size */
163		(void)rdint32(br);                      /* reserved word */
164		bmPos = rdint32(br);                    /* offset to bitmap */
165	<	hdrSiz = rdint32(br) + 14;              /* header size */
165	>	hdrSiz = 2 + 3*4 + rdint32(br);         /* header size */
166		if (hdrSiz < 2 + 6*4 + 2*2 + 6*4)
167		goto err;
168		br->hdr->width = rdint32(br);           /* bitmap width */
#	Line 142 | Line 174 | BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
174		if (rduint16(br) != 1)                  /* number of planes */
175		goto err;
176		br->hdr->bpp = rduint16(br);            /* bits per pixel */
145	–	if (br->hdr->bpp != 1 && br->hdr->bpp != 4 &&
146	–	br->hdr->bpp != 8 && br->hdr->bpp != 24 &&
147	–	br->hdr->bpp != 32)
148	–	goto err;
177		br->hdr->compr = rdint32(br);           /* compression mode */
150	–	if (br->hdr->compr != BI_UNCOMPR && br->hdr->compr != BI_RLE8)
151	–	goto err;                       /* don't support the rest */
178		(void)rdint32(br);                      /* bitmap size */
179		br->hdr->hRes = rdint32(br);            /* horizontal resolution */
180		br->hdr->vRes = rdint32(br);            /* vertical resolution */
#	Line 156 | Line 182 | BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
182		br->hdr->impColors = rdint32(br);       /* # important colors */
183		if (br->hdr->impColors < 0)
184		goto err;                       /* catch premature EOF */
185	<	palLen = 0;
186	<	if (br->hdr->bpp <= 8) {
187	<	palLen = 1 << br->hdr->bpp;
185	>	if (!BMPheaderOK(br->hdr))
186	>	goto err;
187	>	palLen = BMPpalLen(br->hdr);
188	>	if (br->hdr->bpp <= 8) {                /* normalize color counts */
189		if (br->hdr->nColors <= 0)
190		br->hdr->nColors = palLen;
164	–	else if (br->hdr->nColors > palLen)
165	–	goto err;
191		if (br->hdr->impColors <= 0)
192		br->hdr->impColors = br->hdr->nColors;
193	<	else if (br->hdr->impColors > br->hdr->nColors)
169	<	goto err;
170	<	} else if (br->hdr->nColors > 0 || br->hdr->compr != BI_UNCOMPR)
171	<	goto err;
193	>	}
194		/* extend header */
195		if (bmPos < hdrSiz + sizeof(RGBquad)*palLen)
196		goto err;
#	Line 176 | Line 198 | BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
198		if (palLen > 0 || br->hdr->infoSiz > 0) {
199		br->hdr = (BMPHeader *)realloc((void *)br->hdr,
200		sizeof(BMPHeader) +
201	<	sizeof(RGBquad)*palLen -
180	<	sizeof(br->hdr->palette) +
201	>	sizeof(RGBquad)*palLen +
202		br->hdr->infoSiz);
203		if (br->hdr == NULL)
204		goto err;
205		}
206	<	/* read color palette */
207	<	if (rdbytes((char *)br->hdr->palette,
206	>	/* read colors or fields */
207	>	if (br->hdr->compr == BI_BITFIELDS) {
208	>	BMPbitField(br->hdr)[0] = (uint32)rdint32(br);
209	>	BMPbitField(br->hdr)[1] = (uint32)rdint32(br);
210	>	BMPbitField(br->hdr)[2] = (uint32)rdint32(br);
211	>	} else if (rdbytes((char *)br->hdr->palette,
212		sizeof(RGBquad)*palLen, br) != BIR_OK)
213		goto err;
214		/* read add'l information */
#	Line 194 | Line 219 | BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
219		if (br->scanline == NULL)
220		goto err;
221		br->yscan = -1;
222	<	if (seek != NULL && br->hdr->compr != BI_UNCOMPR) {
222	>	if (seek != NULL && ((br->hdr->compr == BI_RLE8) |
223	>	(br->hdr->compr == BI_RLE4))) {
224		BMPReader       *newbr = (BMPReader *)realloc((void *)br,
225		sizeof(BMPReader) +
226		sizeof(br->scanpos[0]) *
#	Line 239 | Line 265 | BMPisGrayscale(const BMPHeader *hdr)
265		int
266		BMPreadScanline(BMPReader *br)
267		{
268	+	int     n;
269	+	int8    *sp;
270	+
271		if (br->yscan + 1 >= br->hdr->height)
272		return BIR_EOF;
273		br->yscan++;                    /* prepare to read */
274	<	if (br->hdr->compr == BI_UNCOMPR)
275	<	return rdbytes((char *)br->scanline, getScanSiz(br->hdr), br);
276	<	/* XXX need to perform actual decompression */
277	<	return BIR_UNSUPPORTED;
278	<	if (br->seek != NULL)
274	>	n = getScanSiz(br->hdr);        /* reading uncompressed data? */
275	>	if (br->hdr->compr == BI_UNCOMPR || br->hdr->compr == BI_BITFIELDS)
276	>	return rdbytes((char *)br->scanline, n, br);
277	>	/*
278	>	* RLE/RLE8 Decoding
279	>	*
280	>	* Certain aspects of this scheme are completely insane, so
281	>	* we don't support them.  Fortunately, they rarely appear.
282	>	* One is the mid-file EOD (0x0001) and another is the insane
283	>	* "delta" (0x0002), which is like a "goto" statement for bitmaps.
284	>	* Whoever thought this up should be shot, then told why
285	>	* it's impossible to support in any reasonable way.
286	>	* Also, RLE4 mode allows runs to stop halfway through a byte,
287	>	* which is likewise uncodeable, so we don't even try.
288	>	* Finally, the scanline break is ambiguous -- we assume here that
289	>	* it is required at the end of each scanline, though I haven't
290	>	* found anywhere this is written.  Otherwise, we would read to
291	>	* the end of the scanline, assuming the next bit of data belongs
292	>	* the following scan.  If a break follows the last pixel, as it
293	>	* seems to in the files I've tested out of Photoshop, you end up
294	>	* painting every other line black.  BTW, I assume any skipped
295	>	* pixels are painted with color 0, which is often black.  Nowhere
296	>	* is it specified what we should assume for missing pixels.  This
297	>	* is undoubtedly the most brain-dead format I've ever encountered.
298	>	*/
299	>	sp = br->scanline;
300	>	while (n > 0) {
301	>	int     skipOdd, len, val;
302	>
303	>	if (rdbyte(len, br) == EOF)
304	>	return BIR_TRUNCATED;
305	>	if (len > 0) {          /* got a run */
306	>	if (br->hdr->compr == BI_RLE4) {
307	>	if (len & 1)
308	>	return BIR_UNSUPPORTED;
309	>	len >>= 1;
310	>	}
311	>	if (len > n)
312	>	return BIR_RLERROR;
313	>	if (rdbyte(val, br) == EOF)
314	>	return BIR_TRUNCATED;
315	>	n -= len;
316	>	while (len--)
317	>	*sp++ = val;
318	>	continue;
319	>	}
320	>	switch (rdbyte(len, br)) {
321	>	case EOF:
322	>	return BIR_TRUNCATED;
323	>	case 0:                 /* end of line */
324	>	while (n--)
325	>	*sp++ = 0;
326	>	continue;
327	>	case 1:                 /* end of bitmap */
328	>	case 2:                 /* delta */
329	>	return BIR_UNSUPPORTED;
330	>	}
331	>	/* absolute mode */
332	>	if (br->hdr->compr == BI_RLE4) {
333	>	if (len & 1)
334	>	return BIR_UNSUPPORTED;
335	>	len >>= 1;
336	>	}
337	>	skipOdd = len & 1;
338	>	if (len > n)
339	>	return BIR_RLERROR;
340	>	n -= len;
341	>	while (len--) {
342	>	if (rdbyte(val, br) == EOF)
343	>	return BIR_TRUNCATED;
344	>	*sp++ = val;
345	>	}
346	>	if (skipOdd && rdbyte(val, br) == EOF)
347	>	return BIR_TRUNCATED;
348	>	}
349	>	/* verify break at end of line */
350	>	if (rdbyte(n, br) != 0 || (rdbyte(n, br) != 0 &&
351	>	(n != 1 || br->yscan != br->hdr->height-1)))
352	>	return BIR_RLERROR;
353	>	if (br->seek != NULL)           /* record next scanline position */
354		br->scanpos[br->yscan + 1] = br->fpos;
355		return BIR_OK;
356		}
#	Line 270 | Line 374 | BMPseekScanline(int y, BMPReader *br)
374		if (y != br->yscan + 1 && br->seek != NULL) {
375		int     yseek;
376		uint32  seekp;
377	<	if (br->hdr->compr == BI_UNCOMPR) {
377	>	if (br->hdr->compr == BI_UNCOMPR ||
378	>	br->hdr->compr == BI_BITFIELDS) {
379		yseek = y;
380		seekp = br->scanpos[0] + y*getScanSiz(br->hdr);
381		} else {
#	Line 295 | Line 400 | BMPseekScanline(int y, BMPReader *br)
400
401		/* get ith pixel from last scanline */
402		RGBquad
403	<	BMPdecodePixel(int i, BMPReader *br)
403	>	BMPdecodePixel(int i, const BMPReader *br)
404		{
405	+	static const uint32     std16mask[3] = {0x7c00, 0x3e0, 0x1f};
406		static const RGBquad    black = {0, 0, 0, 0};
407	+	const uint32            *mask;
408	+	const uint8             *pp;
409	+	uint32                  pval, v;
410	+	RGBquad                 cval;
411
412		if (((br == NULL) | (i < 0)) || i >= br->hdr->width)
413		return black;
414
415	+	cval.padding = 0;
416	+
417		switch (br->hdr->bpp) {
418	<	case 24: {
419	<	uint8   *bgr = br->scanline + 3*i;
420	<	RGBquad cval;
421	<	cval.b = bgr[0]; cval.g = bgr[1]; cval.r = bgr[2];
422	<	cval.padding = 0;
418	>	case 24:
419	>	pp = br->scanline + 3*i;
420	>	cval.b = *pp++;
421	>	cval.g = *pp++;
422	>	cval.r = *pp;
423		return cval;
312	–	}
424		case 32:
425	<	return ((RGBquad *)br->scanline)[i];
425	>	if (br->hdr->compr == BI_UNCOMPR)
426	>	return ((RGBquad *)br->scanline)[i];
427	>	/* convert bit fields */
428	>	pp = br->scanline + 4*i;
429	>	pval = *pp++;
430	>	pval |= *pp++ << 8;
431	>	pval |= *pp++ << 16;
432	>	pval |= *pp << 24;
433	>	mask = BMPbitField(br->hdr);
434	>	v = pval & mask[0];
435	>	while (v & ~0xff) v >>= 8;
436	>	cval.r = v;
437	>	v = pval & mask[1];
438	>	while (v & ~0xff) v >>= 8;
439	>	cval.g = v;
440	>	v = pval & mask[2];
441	>	while (v & ~0xff) v >>= 8;
442	>	cval.b = v;
443	>	return cval;
444		case 8:
445		return br->hdr->palette[br->scanline[i]];
446		case 1:
447	<	return br->hdr->palette[br->scanline[i>>3]>>(i&7) & 1];
447	>	return br->hdr->palette[br->scanline[i>>3]>>((7-i)&7) & 1];
448		case 4:
449	<	return br->hdr->palette[br->scanline[i>>1]>>((i&1)<<2) & 0xf];
449	>	return br->hdr->palette[br->scanline[i>>1]>>(i&1?4:0) & 0xf];
450	>	case 16:
451	>	pp = br->scanline + 2*i;
452	>	pval = *pp++;
453	>	pval |= *pp++ << 8;
454	>	mask = std16mask;
455	>	if (br->hdr->compr == BI_BITFIELDS)
456	>	mask = BMPbitField(br->hdr);
457	>	cval.r = ((pval & mask[0]) << 8) / (mask[0] + 1);
458	>	cval.g = ((pval & mask[1]) << 8) / (mask[1] + 1);
459	>	cval.b = ((pval & mask[2]) << 8) / (mask[2] + 1);
460	>	return cval;
461		}
462		return black;                           /* should never happen */
463		}
#	Line 409 | Line 549 | BMPmappedHeader(int xr, int yr, int infolen, int ncolo
549		hdr->height = yr;
550		hdr->yIsDown = 0;                       /* default to upwards order */
551		hdr->bpp = n;
552	<	hdr->compr = BI_UNCOMPR;
552	>	hdr->compr = BI_UNCOMPR;                /* compression needs seek */
553		hdr->hRes = hdr->vRes = 2835;           /* default to 72 ppi */
554		hdr->nColors = ncolors;
555		hdr->impColors = 0;                     /* says all colors important */
#	Line 423 | Line 563 | BMPmappedHeader(int xr, int yr, int infolen, int ncolo
563
564		/* put byte to writer */
565		#define wrbyte(c,bw)    ( (*(bw)->cput)(c,(bw)->c_data), \
566	<	++((bw)->fpos) > (bw)->flen ? \
566	>	++(bw)->fpos > (bw)->flen ? \
567		((bw)->flen = (bw)->fpos) : \
568		(bw)->fpos )
569
#	Line 442 | Line 582 | wrint32(int32 i, BMPWriter *bw)
582		wrbyte(i& 0xff, bw);
583		wrbyte(i>>8 & 0xff, bw);
584		wrbyte(i>>16 & 0xff, bw);
585	<	wrbyte(i>>24  & 0xff, bw);
585	>	wrbyte(i>>24 & 0xff, bw);
586		}
587
588		/* write 16-bit unsigned integer in littlendian order */
#	Line 482 | Line 622 | BMPopenWriter(void (*cput)(int, void *), int (*seek)(u
622		BMPWriter       *bw;
623		uint32          hdrSiz, palSiz, scanSiz, bmSiz;
624		/* check arguments */
625	<	if (cput == NULL || hdr == NULL)
625	>	if (cput == NULL)
626		return NULL;
627	<	if (hdr->width <= 0 || hdr->height <= 0)
627	>	if (!BMPheaderOK(hdr))
628		return NULL;
629	<	if (hdr->compr != BI_UNCOMPR && hdr->compr != BI_RLE8)
629	>	if ((hdr->bpp == 16) | (hdr->compr == BI_RLE4))
630		return NULL;                    /* unsupported */
631	<	if (hdr->bpp > 8 && hdr->compr != BI_UNCOMPR)
631	>	/* no seek means we may have the wrong file length, but most app's don't care
632	>	if (seek == NULL && ((hdr->compr == BI_RLE8) | (hdr->compr == BI_RLE4)))
633		return NULL;
634	<	palSiz = BMPpalLen(hdr);
494	<	if (hdr->nColors > palSiz)
495	<	return NULL;
496	<	if (hdr->compr != BI_UNCOMPR && seek == NULL)
497	<	return NULL;
634	>	*/
635		/* compute sizes */
636		hdrSiz = 2 + 6*4 + 2*2 + 6*4;
637	<	palSiz *= sizeof(RGBquad);
637	>	if (hdr->compr == BI_BITFIELDS)
638	>	hdrSiz += sizeof(uint32)*3;
639	>	palSiz = sizeof(RGBquad)*BMPpalLen(hdr);
640		scanSiz = getScanSiz(hdr);
641		bmSiz = hdr->height*scanSiz;            /* wrong if compressed */
642		/* initialize writer */
#	Line 547 | Line 686 | BMPopenWriter(void (*cput)(int, void *), int (*seek)(u
686		#endif
687		return bw;
688		}
689	+
690	+	/* find position of next run of 5 or more identical bytes, or 255 if none */
691	+	static int
692	+	findNextRun(const int8 *bp, int len)
693	+	{
694	+	int     pos, cnt;
695	+	/* look for run */
696	+	for (pos = 0; (len > 0) & (pos < 255); pos++, bp++, len--) {
697	+	if (len < 5)                    /* no hope left? */
698	+	continue;
699	+	cnt = 1;                        /* else let's try it */
700	+	while (bp[cnt] == bp[0])
701	+	if (++cnt >= 5)
702	+	return pos;     /* long enough */
703	+	}
704	+	return pos;                             /* didn't find any */
705	+	}
706
707		/* write the current scanline */
708		int
709		BMPwriteScanline(BMPWriter *bw)
710		{
711	+	const int8      *sp;
712	+	int             n;
713	+
714		if (bw->yscan >= bw->hdr->height)
715		return BIR_EOF;
716		/* writing uncompressed? */
717	<	if (bw->hdr->compr == BI_UNCOMPR) {
717	>	if (bw->hdr->compr == BI_UNCOMPR || bw->hdr->compr == BI_BITFIELDS) {
718		uint32  scanSiz = getScanSiz(bw->hdr);
719		uint32  slpos = bw->fbmp + bw->yscan*scanSiz;
720		if (wrseek(slpos, bw) != BIR_OK)
#	Line 564 | Line 723 | BMPwriteScanline(BMPWriter *bw)
723		bw->yscan++;
724		return BIR_OK;
725		}
726	<	/* else write compressed */
727	<	/* XXX need to do actual compression */
728	<	return BIR_UNSUPPORTED;
729	<	/* write file length at end */
726	>	/*
727	>	* RLE8 Encoding
728	>	*
729	>	* See the notes in BMPreadScanline() on this encoding.  Needless
730	>	* to say, we avoid the nuttier aspects of this specification.
731	>	* We also assume that every scanline ends in a line break
732	>	* (0x0000) except for the last, which ends in a bitmap break
733	>	* (0x0001).  We don't support RLE4 at all; it's too awkward.
734	>	*/
735	>	sp = bw->scanline;
736	>	n = bw->hdr->width;
737	>	while (n > 0) {
738	>	int     cnt, val;
739	>
740	>	cnt = findNextRun(sp, n);       /* 0-255 < n */
741	>	if (cnt >= 3) {                 /* output non-run */
742	>	int     skipOdd = cnt & 1;
743	>	wrbyte(0, bw);
744	>	wrbyte(cnt, bw);
745	>	n -= cnt;
746	>	while (cnt--)
747	>	wrbyte(*sp++, bw);
748	>	if (skipOdd)
749	>	wrbyte(0, bw);
750	>	}
751	>	if (n <= 0)                     /* was that it? */
752	>	break;
753	>	val = *sp;                      /* output run */
754	>	for (cnt = 1; cnt < 255; cnt++)
755	>	if (!--n | *++sp != val)
756	>	break;
757	>	wrbyte(cnt, bw);
758	>	wrbyte(val, bw);
759	>	}
760	>	bw->yscan++;                            /* write line break or EOD */
761		if (bw->yscan == bw->hdr->height) {
762	+	wrbyte(0, bw); wrbyte(1, bw);   /* end of bitmap marker */
763		if (bw->seek == NULL || (*bw->seek)(2, bw->c_data) != 0)
764	<	return BIR_SEEKERR;
764	>	return BIR_OK;          /* no one may care */
765		bw->fpos = 2;
766	<	wrint32(bw->flen, bw);
766	>	wrint32(bw->flen-bw->fbmp, bw); /* output correct bitmap length */
767	>	} else {
768	>	wrbyte(0, bw); wrbyte(0, bw);   /* end of line marker */
769		}
770		return BIR_OK;
771		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)