ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/bmpfile.c
Revision: 2.4
Committed: Fri Mar 26 23:30:05 2004 UTC (20 years, 1 month ago) by schorsch
Content type: text/plain
Branch: MAIN
Changes since 2.3: +14 -14 lines
Log Message: 
Reduced compiler warnings.

File Contents

# User Rev Content
1 greg 2.1 #ifndef lint
2 schorsch 2.4 static const char RCSid[] = "$Id: bmpfile.c,v 2.3 2004/03/26 22:58:21 greg Exp $";
3 greg 2.1 #endif
4     /*
5     * Windows and OS/2 BMP file support
6     */
7    
8     #include <stdio.h>
9     #include <stdlib.h>
10     #include <string.h>
11     #include "bmpfile.h"
12    
13     /* get corresponding error message */
14     const char *
15     BMPerrorMessage(int ec)
16     {
17     switch (ec) {
18     case BIR_OK:
19     return "No error";
20     case BIR_EOF:
21     return "End of BMP image";
22     case BIR_TRUNCATED:
23     return "Truncated BMP image";
24     case BIR_UNSUPPORTED:
25     return "Unsupported BMP feature";
26 greg 2.3 case BIR_RLERROR:
27     return "BMP runlength encoding error";
28 greg 2.1 case BIR_SEEKERR:
29     return "BMP seek error";
30     }
31     return "Unknown BMP error";
32     }
33    
34 greg 2.3 /* check than header is sensible */
35     static int
36     BMPheaderOK(const BMPHeader *hdr)
37     {
38     if (!hdr)
39     return 0;
40 schorsch 2.4 if ((hdr->width <= 0) | (hdr->height <= 0))
41 greg 2.3 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 schorsch 2.4 if ((hdr->compr != BI_UNCOMPR) & (hdr->compr != BI_BITFIELDS))
51 greg 2.3 return 0;
52     break;
53     case 4:
54 schorsch 2.4 if ((hdr->compr != BI_UNCOMPR) & (hdr->compr != BI_RLE4))
55 greg 2.3 return 0;
56     break;
57     case 8:
58 schorsch 2.4 if ((hdr->compr != BI_UNCOMPR) & (hdr->compr != BI_RLE8))
59 greg 2.3 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 schorsch 2.4 if ((hdr->nColors < 0) | (hdr->impColors < 0))
68 greg 2.3 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 greg 2.1
76 greg 2.3 /* compute uncompressed scan size */
77 schorsch 2.4 #define getScanSiz(h) ( ((((h)->bpp*(h)->width+7) >>3) + 3) & ~03 )
78 greg 2.1
79     /* get next byte from reader */
80     #define rdbyte(c,br) ((br)->fpos += (c=(*(br)->cget)((br)->c_data))!=EOF, c)
81    
82     /* read n bytes */
83     static int
84     rdbytes(char *bp, uint32 n, BMPReader *br)
85     {
86     int c;
87    
88     while (n--) {
89     if (rdbyte(c, br) == EOF)
90     return BIR_TRUNCATED;
91     *bp++ = c;
92     }
93     return BIR_OK;
94     }
95    
96     /* read 32-bit integer in littlendian order */
97     static int32
98     rdint32(BMPReader *br)
99     {
100     int32 i;
101     int c;
102    
103     i = rdbyte(c, br);
104     i |= rdbyte(c, br) << 8;
105     i |= rdbyte(c, br) << 16;
106     i |= rdbyte(c, br) << 24;
107     return i; /* -1 on EOF */
108     }
109    
110     /* read 16-bit unsigned integer in littlendian order */
111     static int
112     rduint16(BMPReader *br)
113     {
114     int i;
115     int c;
116    
117     i = rdbyte(c, br);
118     i |= rdbyte(c, br) << 8;
119     return i; /* -1 on EOF */
120     }
121    
122     /* seek on reader or return 0 (BIR_OK) on success */
123     static int
124     rdseek(uint32 pos, BMPReader *br)
125     {
126     if (pos == br->fpos)
127     return BIR_OK;
128     if (br->seek == NULL || (*br->seek)(pos, br->c_data) != 0)
129     return BIR_SEEKERR;
130     br->fpos = pos;
131     return BIR_OK;
132     }
133    
134     /* open BMP stream for reading and get first scanline */
135     BMPReader *
136     BMPopenReader(int (*cget)(void *), int (*seek)(uint32, void *), void *c_data)
137     {
138     BMPReader *br;
139     uint32 bmPos, hdrSiz;
140     int palLen;
141    
142     if (cget == NULL)
143     return NULL;
144     int magic[2]; /* check magic number */
145     magic[0] = (*cget)(c_data);
146     if (magic[0] != 'B')
147     return NULL;
148     magic[1] = (*cget)(c_data);
149     if (magic[1] != 'M' && magic[1] != 'A')
150     return NULL;
151     br = (BMPReader *)calloc(1, sizeof(BMPReader));
152     if (br == NULL)
153     return NULL;
154     br->cget = cget;
155     br->seek = seek;
156     br->c_data = c_data;
157     br->hdr = (BMPHeader *)malloc(sizeof(BMPHeader));
158     if (br->hdr == NULL)
159     goto err;
160     br->fpos = 2;
161     /* read & verify file header */
162     (void)rdint32(br); /* file size */
163     (void)rdint32(br); /* reserved word */
164     bmPos = rdint32(br); /* offset to bitmap */
165 greg 2.3 hdrSiz = 2 + 3*4 + rdint32(br); /* header size */
166 greg 2.1 if (hdrSiz < 2 + 6*4 + 2*2 + 6*4)
167     goto err;
168     br->hdr->width = rdint32(br); /* bitmap width */
169     br->hdr->height = rdint32(br); /* bitmap height */
170 schorsch 2.2 if (((br->hdr->width <= 0) | (br->hdr->height == 0)))
171 greg 2.1 goto err;
172     if ((br->hdr->yIsDown = br->hdr->height < 0))
173     br->hdr->height = -br->hdr->height;
174     if (rduint16(br) != 1) /* number of planes */
175     goto err;
176     br->hdr->bpp = rduint16(br); /* bits per pixel */
177     br->hdr->compr = rdint32(br); /* compression mode */
178     (void)rdint32(br); /* bitmap size */
179     br->hdr->hRes = rdint32(br); /* horizontal resolution */
180     br->hdr->vRes = rdint32(br); /* vertical resolution */
181     br->hdr->nColors = rdint32(br); /* # colors used */
182     br->hdr->impColors = rdint32(br); /* # important colors */
183     if (br->hdr->impColors < 0)
184     goto err; /* catch premature EOF */
185 greg 2.3 if (!BMPheaderOK(br->hdr))
186     goto err;
187     palLen = BMPpalLen(br->hdr);
188     if (br->hdr->bpp <= 8) { /* normalize color counts */
189 greg 2.1 if (br->hdr->nColors <= 0)
190     br->hdr->nColors = palLen;
191     if (br->hdr->impColors <= 0)
192     br->hdr->impColors = br->hdr->nColors;
193 greg 2.3 }
194 greg 2.1 /* extend header */
195     if (bmPos < hdrSiz + sizeof(RGBquad)*palLen)
196     goto err;
197     br->hdr->infoSiz = bmPos - (hdrSiz + sizeof(RGBquad)*palLen);
198     if (palLen > 0 || br->hdr->infoSiz > 0) {
199     br->hdr = (BMPHeader *)realloc((void *)br->hdr,
200     sizeof(BMPHeader) +
201 greg 2.3 sizeof(RGBquad)*palLen +
202 greg 2.1 br->hdr->infoSiz);
203     if (br->hdr == NULL)
204     goto err;
205     }
206 greg 2.3 /* 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 greg 2.1 sizeof(RGBquad)*palLen, br) != BIR_OK)
213     goto err;
214     /* read add'l information */
215     if (rdbytes(BMPinfo(br->hdr), br->hdr->infoSiz, br) != BIR_OK)
216     goto err;
217     /* read first scanline */
218     br->scanline = (uint8 *)calloc(getScanSiz(br->hdr), sizeof(uint8));
219     if (br->scanline == NULL)
220     goto err;
221     br->yscan = -1;
222 schorsch 2.4 if (seek != NULL && ((br->hdr->compr == BI_RLE8) |
223     (br->hdr->compr == BI_RLE4))) {
224 greg 2.1 BMPReader *newbr = (BMPReader *)realloc((void *)br,
225     sizeof(BMPReader) +
226     sizeof(br->scanpos[0]) *
227     br->hdr->height);
228     if (newbr == NULL)
229     goto err;
230     br = newbr;
231     memset((void *)(br->scanpos + 1), 0,
232     sizeof(br->scanpos[0])*br->hdr->height);
233     }
234     br->scanpos[0] = br->fpos;
235     if (BMPreadScanline(br) != BIR_OK)
236     goto err;
237     return br;
238     err:
239     if (br->hdr != NULL)
240     free((void *)br->hdr);
241     if (br->scanline != NULL)
242     free((void *)br->scanline);
243     free((void *)br);
244     return NULL;
245     }
246    
247     /* determine if image is grayscale */
248     int
249     BMPisGrayscale(const BMPHeader *hdr)
250     {
251     const RGBquad *rgbp;
252     int n;
253    
254     if (hdr == NULL)
255     return -1;
256     if (hdr->bpp > 8) /* assume they had a reason for it */
257     return 0;
258     for (rgbp = hdr->palette, n = hdr->impColors; n-- > 0; rgbp++)
259 schorsch 2.2 if (((rgbp->r != rgbp->g) | (rgbp->g != rgbp->b)))
260 greg 2.1 return 0;
261     return 1; /* all colors neutral in map */
262     }
263    
264     /* read and decode next BMP scanline */
265     int
266     BMPreadScanline(BMPReader *br)
267     {
268 greg 2.3 int n;
269     int8 *sp;
270    
271 greg 2.1 if (br->yscan + 1 >= br->hdr->height)
272     return BIR_EOF;
273     br->yscan++; /* prepare to read */
274 greg 2.3 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 greg 2.1 br->scanpos[br->yscan + 1] = br->fpos;
355     return BIR_OK;
356     }
357    
358     /* read a specific scanline */
359     int
360     BMPseekScanline(int y, BMPReader *br)
361     {
362     int rv;
363     /* check arguments */
364     if (br == NULL)
365     return BIR_EOF;
366     if (y < 0)
367     return BIR_SEEKERR;
368     if (y >= br->hdr->height)
369     return BIR_EOF;
370     /* already read? */
371     if (y == br->yscan)
372     return BIR_OK;
373     /* shall we seek? */
374     if (y != br->yscan + 1 && br->seek != NULL) {
375     int yseek;
376     uint32 seekp;
377 greg 2.3 if (br->hdr->compr == BI_UNCOMPR ||
378     br->hdr->compr == BI_BITFIELDS) {
379 greg 2.1 yseek = y;
380     seekp = br->scanpos[0] + y*getScanSiz(br->hdr);
381     } else {
382     yseek = br->yscan + 1;
383     while (yseek < y && br->scanpos[yseek+1] != 0)
384     ++yseek;
385     if (y < yseek && br->scanpos[yseek=y] == 0)
386     return BIR_SEEKERR;
387     seekp = br->scanpos[yseek];
388     }
389     if ((rv = rdseek(seekp, br)) != BIR_OK)
390     return rv;
391     br->yscan = yseek - 1;
392     } else if (y < br->yscan) /* else we can't back up */
393     return BIR_SEEKERR;
394     /* read until we get there */
395     while (br->yscan < y)
396     if ((rv = BMPreadScanline(br)) != BIR_OK)
397     return rv;
398     return BIR_OK;
399     }
400    
401     /* get ith pixel from last scanline */
402     RGBquad
403 greg 2.3 BMPdecodePixel(int i, const BMPReader *br)
404 greg 2.1 {
405 greg 2.3 static const uint32 std16mask[3] = {0x7c00, 0x3e0, 0x1f};
406 greg 2.1 static const RGBquad black = {0, 0, 0, 0};
407 greg 2.3 const uint32 *mask;
408     const uint8 *pp;
409     uint32 pval, v;
410     RGBquad cval;
411 greg 2.1
412 schorsch 2.2 if (((br == NULL) | (i < 0)) || i >= br->hdr->width)
413 greg 2.1 return black;
414    
415 greg 2.3 cval.padding = 0;
416    
417 greg 2.1 switch (br->hdr->bpp) {
418 greg 2.3 case 24:
419     pp = br->scanline + 3*i;
420     cval.b = *pp++;
421     cval.g = *pp++;
422     cval.r = *pp;
423 greg 2.1 return cval;
424     case 32:
425 greg 2.3 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 greg 2.1 case 8:
445     return br->hdr->palette[br->scanline[i]];
446     case 1:
447 schorsch 2.4 return br->hdr->palette[br->scanline[i>>3]>>((7-i)&7) & 1];
448 greg 2.1 case 4:
449 greg 2.3 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 greg 2.1 }
462     return black; /* should never happen */
463     }
464    
465     /* free BMP reader resources */
466     void
467     BMPfreeReader(BMPReader *br)
468     {
469     if (br == NULL)
470     return;
471     free((void *)br->hdr);
472     free((void *)br->scanline);
473     free((void *)br);
474     }
475    
476     /* stdio getc() callback */
477     int
478     stdio_getc(void *p)
479     {
480     if (!p)
481     return EOF;
482     return getc((FILE *)p);
483     }
484    
485     /* stdio putc() callback */
486     void
487     stdio_putc(int c, void *p)
488     {
489     if (p)
490     putc(c, (FILE *)p);
491     }
492    
493     /* stdio fseek() callback */
494     int
495     stdio_fseek(uint32 pos, void *p)
496     {
497     if (!p)
498     return -1;
499     return fseek((FILE *)p, (long)pos, 0);
500     }
501    
502     /* allocate uncompressed (24-bit) RGB header */
503     BMPHeader *
504     BMPtruecolorHeader(int xr, int yr, int infolen)
505     {
506     BMPHeader *hdr;
507    
508     if (xr <= 0 || yr <= 0 || infolen < 0)
509     return NULL;
510     hdr = (BMPHeader *)malloc(sizeof(BMPHeader) - sizeof(hdr->palette) +
511     infolen);
512     if (hdr == NULL)
513     return NULL;
514     hdr->width = xr;
515     hdr->height = yr;
516     hdr->yIsDown = 0; /* default to upwards order */
517     hdr->bpp = 24;
518     hdr->compr = BI_UNCOMPR;
519     hdr->hRes = hdr->vRes = 2835; /* default to 72 ppi */
520     hdr->nColors = hdr->impColors = 0;
521     hdr->infoSiz = infolen;
522     return hdr;
523     }
524    
525 greg 2.3 /* allocate color-mapped header (defaults minimal grayscale) */
526 greg 2.1 BMPHeader *
527     BMPmappedHeader(int xr, int yr, int infolen, int ncolors)
528     {
529     int n;
530     BMPHeader *hdr;
531    
532     if (xr <= 0 || yr <= 0 || infolen < 0 || ncolors < 2)
533     return NULL;
534     if (ncolors <= 2)
535     n = 1;
536     else if (ncolors <= 16)
537     n = 4;
538     else if (ncolors <= 256)
539     n = 8;
540     else
541     return NULL;
542     hdr = (BMPHeader *)malloc(sizeof(BMPHeader) +
543     sizeof(RGBquad)*(1<<n) -
544     sizeof(hdr->palette) +
545     infolen);
546     if (hdr == NULL)
547     return NULL;
548     hdr->width = xr;
549     hdr->height = yr;
550     hdr->yIsDown = 0; /* default to upwards order */
551     hdr->bpp = n;
552     hdr->compr = BI_UNCOMPR;
553     hdr->hRes = hdr->vRes = 2835; /* default to 72 ppi */
554     hdr->nColors = ncolors;
555     hdr->impColors = 0; /* says all colors important */
556     hdr->infoSiz = infolen;
557     memset((void *)hdr->palette, 0, sizeof(RGBquad)*(1<<n) + infolen);
558     for (n = ncolors; n--; )
559     hdr->palette[n].r = hdr->palette[n].g =
560     hdr->palette[n].b = n*255/(ncolors-1);
561     return hdr;
562     }
563    
564     /* put byte to writer */
565     #define wrbyte(c,bw) ( (*(bw)->cput)(c,(bw)->c_data), \
566 greg 2.3 ++(bw)->fpos > (bw)->flen ? \
567 greg 2.1 ((bw)->flen = (bw)->fpos) : \
568     (bw)->fpos )
569    
570     /* write out a string of bytes */
571     static void
572     wrbytes(char *bp, uint32 n, BMPWriter *bw)
573     {
574     while (n--)
575     wrbyte(*bp++, bw);
576     }
577    
578     /* write 32-bit integer in littlendian order */
579     static void
580     wrint32(int32 i, BMPWriter *bw)
581     {
582     wrbyte(i& 0xff, bw);
583     wrbyte(i>>8 & 0xff, bw);
584     wrbyte(i>>16 & 0xff, bw);
585 greg 2.3 wrbyte(i>>24 & 0xff, bw);
586 greg 2.1 }
587    
588     /* write 16-bit unsigned integer in littlendian order */
589     static void
590     wruint16(uint16 ui, BMPWriter *bw)
591     {
592     wrbyte(ui & 0xff, bw);
593     wrbyte(ui>>8 & 0xff, bw);
594     }
595    
596     /* seek to the specified file position, returning 0 (BIR_OK) on success */
597     static int
598     wrseek(uint32 pos, BMPWriter *bw)
599     {
600     if (pos == bw->fpos)
601     return BIR_OK;
602     if (bw->seek == NULL) {
603     if (pos < bw->fpos)
604     return BIR_SEEKERR;
605     while (bw->fpos < pos)
606     wrbyte(0, bw);
607     return BIR_OK;
608     }
609     if ((*bw->seek)(pos, bw->c_data) != 0)
610     return BIR_SEEKERR;
611     bw->fpos = pos;
612     if (pos > bw->flen)
613     bw->flen = pos;
614     return BIR_OK;
615     }
616    
617     /* open BMP stream for writing */
618     BMPWriter *
619     BMPopenWriter(void (*cput)(int, void *), int (*seek)(uint32, void *),
620     void *c_data, BMPHeader *hdr)
621     {
622     BMPWriter *bw;
623     uint32 hdrSiz, palSiz, scanSiz, bmSiz;
624     /* check arguments */
625 greg 2.3 if (cput == NULL)
626 greg 2.1 return NULL;
627 greg 2.3 if (!BMPheaderOK(hdr))
628 greg 2.1 return NULL;
629 schorsch 2.4 if ((hdr->bpp == 16) | (hdr->compr == BI_RLE4))
630 greg 2.1 return NULL; /* unsupported */
631 schorsch 2.4 if (seek == NULL && ((hdr->compr == BI_RLE8) | (hdr->compr == BI_RLE4)))
632 greg 2.1 return NULL;
633     /* compute sizes */
634     hdrSiz = 2 + 6*4 + 2*2 + 6*4;
635 greg 2.3 if (hdr->compr == BI_BITFIELDS)
636     hdrSiz += sizeof(uint32)*3;
637     palSiz = sizeof(RGBquad)*BMPpalLen(hdr);
638 greg 2.1 scanSiz = getScanSiz(hdr);
639     bmSiz = hdr->height*scanSiz; /* wrong if compressed */
640     /* initialize writer */
641     bw = (BMPWriter *)malloc(sizeof(BMPWriter));
642     if (bw == NULL)
643     return NULL;
644     bw->hdr = hdr;
645     bw->yscan = 0;
646     bw->scanline = (uint8 *)calloc(scanSiz, sizeof(uint8));
647     if (bw->scanline == NULL) {
648     free((void *)bw);
649     return NULL;
650     }
651     bw->fbmp = hdrSiz + palSiz + hdr->infoSiz;
652     bw->fpos = bw->flen = 0;
653     bw->cput = cput;
654     bw->seek = seek;
655     bw->c_data = c_data;
656     /* write out header */
657     wrbyte('B', bw); wrbyte('M', bw); /* magic number */
658     wrint32(bw->fbmp + bmSiz, bw); /* file size */
659     wrint32(0, bw); /* reserved word */
660     wrint32(bw->fbmp, bw); /* offset to bitmap */
661     wrint32(hdrSiz - bw->fpos, bw); /* info header size */
662     wrint32(hdr->width, bw); /* bitmap width */
663     if (hdr->yIsDown) /* bitmap height */
664     wrint32(-hdr->height, bw);
665     else
666     wrint32(hdr->height, bw);
667     wruint16(1, bw); /* number of planes */
668     wruint16(hdr->bpp, bw); /* bits per pixel */
669     wrint32(hdr->compr, bw); /* compression mode */
670     wrint32(bmSiz, bw); /* bitmap size */
671     wrint32(hdr->hRes, bw); /* horizontal resolution */
672     wrint32(hdr->vRes, bw); /* vertical resolution */
673     wrint32(hdr->nColors, bw); /* # colors used */
674     wrint32(hdr->impColors, bw); /* # important colors */
675     /* write out color palette */
676     wrbytes((char *)hdr->palette, palSiz, bw);
677     /* write add'l information */
678     wrbytes(BMPinfo(hdr), hdr->infoSiz, bw);
679     #ifndef NDEBUG
680     if (bw->fpos != bw->fbmp) {
681     fputs("Coding error 1 in BMPopenWriter\n", stderr);
682     exit(1);
683     }
684     #endif
685     return bw;
686     }
687 greg 2.3
688     /* find position of next run of 5 or more identical bytes, or 255 if none */
689     static int
690     findNextRun(const int8 *bp, int len)
691     {
692     int pos, cnt;
693     /* look for run */
694 schorsch 2.4 for (pos = 0; (len > 0) & (pos < 255); pos++, bp++, len--) {
695 greg 2.3 if (len < 5) /* no hope left? */
696     continue;
697     cnt = 1; /* else let's try it */
698     while (bp[cnt] == bp[0])
699     if (++cnt >= 5) /* long enough */
700     return pos;
701     }
702     return pos; /* didn't find any */
703     }
704 greg 2.1
705     /* write the current scanline */
706     int
707     BMPwriteScanline(BMPWriter *bw)
708     {
709 greg 2.3 const int8 *sp;
710     int n;
711    
712 greg 2.1 if (bw->yscan >= bw->hdr->height)
713     return BIR_EOF;
714     /* writing uncompressed? */
715 greg 2.3 if (bw->hdr->compr == BI_UNCOMPR || bw->hdr->compr == BI_BITFIELDS) {
716 greg 2.1 uint32 scanSiz = getScanSiz(bw->hdr);
717     uint32 slpos = bw->fbmp + bw->yscan*scanSiz;
718     if (wrseek(slpos, bw) != BIR_OK)
719     return BIR_SEEKERR;
720     wrbytes((char *)bw->scanline, scanSiz, bw);
721     bw->yscan++;
722     return BIR_OK;
723     }
724 greg 2.3 /*
725     * RLE8 Encoding
726     *
727     * See the notes in BMPreadScanline() on this encoding. Needless
728     * to say, we avoid the nuttier aspects of this specification.
729     * We also assume that every scanline ends in a line break
730     * (0x0000) except for the last, which ends in a bitmap break
731     * (0x0001). We don't support RLE4 at all; it's too awkward.
732     */
733     sp = bw->scanline;
734     n = bw->hdr->width;
735     while (n > 0) {
736     int cnt, val;
737    
738     cnt = findNextRun(sp, n); /* 0-255 < n */
739     if (cnt >= 3) { /* output non-run */
740     int skipOdd = cnt & 1;
741     wrbyte(0, bw);
742     wrbyte(cnt, bw);
743     n -= cnt;
744     while (cnt--)
745     wrbyte(*sp++, bw);
746     if (skipOdd)
747     wrbyte(0, bw);
748     }
749     if (n <= 0) /* was that it? */
750     break;
751     val = *sp; /* output run */
752 schorsch 2.4 for (cnt = 1; (--n > 0) & (*++sp == val); cnt++)
753 greg 2.3 ;
754     wrbyte(cnt, bw);
755     wrbyte(val, bw);
756     }
757     bw->yscan++; /* write file length at end */
758 greg 2.1 if (bw->yscan == bw->hdr->height) {
759 greg 2.3 wrbyte(0, bw); wrbyte(1, bw); /* end of bitmap marker */
760 greg 2.1 if (bw->seek == NULL || (*bw->seek)(2, bw->c_data) != 0)
761     return BIR_SEEKERR;
762     bw->fpos = 2;
763 greg 2.3 wrint32(bw->flen, bw); /* corrected file length */
764     } else {
765     wrbyte(0, bw); wrbyte(0, bw); /* end of line marker */
766 greg 2.1 }
767     return BIR_OK;
768     }
769    
770     /* free BMP writer resources */
771     void
772     BMPfreeWriter(BMPWriter *bw)
773     {
774     if (bw == NULL)
775     return;
776     free((void *)bw->hdr);
777     free((void *)bw->scanline);
778     free((void *)bw);
779     }