ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/bmpfile.c
(Generate patch)

Comparing ray/src/common/bmpfile.c (file contents):
Revision 2.8 by greg, Sat Apr 10 02:54:44 2004 UTC vs.
Revision 2.21 by greg, Mon Oct 4 23:04:59 2021 UTC

# Line 10 | Line 10 | static const char RCSid[] = "$Id$";
10   #include <string.h>
11   #include "bmpfile.h"
12  
13 < /* get corresponding error message */
13 > #ifdef getc_unlocked            /* avoid horrendous overhead of flockfile */
14 > #undef getc
15 > #undef putc
16 > #define getc    getc_unlocked
17 > #define putc    putc_unlocked
18 > #endif
19 >
20 > /* Get corresponding error message */
21   const char *
22   BMPerrorMessage(int ec)
23   {
# Line 31 | Line 38 | BMPerrorMessage(int ec)
38          return "Unknown BMP error";
39   }
40  
41 < /* check than header is sensible */
41 > /* Check that header is sensible */
42   static int
43   BMPheaderOK(const BMPHeader *hdr)
44   {
# Line 64 | Line 71 | BMPheaderOK(const BMPHeader *hdr)
71          if (hdr->compr == BI_BITFIELDS && (BMPbitField(hdr)[0] &
72                                  BMPbitField(hdr)[1] & BMPbitField(hdr)[2]))
73                  return 0;
74 <        if ((hdr->nColors < 0) | (hdr->impColors < 0))
75 <                return 0;
76 <        if (hdr->impColors > hdr->nColors)
77 <                return 0;
78 <        if (hdr->nColors > BMPpalLen(hdr))
79 <                return 0;
74 >        if (hdr->bpp > 8) {
75 >                if (hdr->nColors != 0)
76 >                        return 0;
77 >        } else {
78 >                if ((hdr->nColors < 0) | (hdr->nColors > 1<<hdr->bpp))
79 >                        return 0;
80 >                if ((hdr->impColors < 0) | (hdr->impColors > hdr->nColors))
81 >                        return 0;
82 >        }
83          return 1;
84   }
85  
# Line 79 | Line 89 | BMPheaderOK(const BMPHeader *hdr)
89                                          /* get next byte from reader */
90   #define rdbyte(c,br)    ((br)->fpos += (c=(*(br)->cget)((br)->c_data))!=EOF, c)
91  
92 < /* read n bytes */
92 > /* Read n bytes */
93   static int
94   rdbytes(char *bp, uint32 n, BMPReader *br)
95   {
# Line 93 | Line 103 | rdbytes(char *bp, uint32 n, BMPReader *br)
103          return BIR_OK;
104   }
105  
106 < /* read 32-bit integer in littlendian order */
106 > /* Read 32-bit integer in littlendian order */
107   static int32
108   rdint32(BMPReader *br)
109   {
# Line 107 | Line 117 | rdint32(BMPReader *br)
117          return i;                       /* -1 on EOF */
118   }
119  
120 < /* read 16-bit unsigned integer in littlendian order */
120 > /* Read 16-bit unsigned integer in littlendian order */
121   static int
122   rduint16(BMPReader *br)
123   {
# Line 119 | Line 129 | rduint16(BMPReader *br)
129          return i;                       /* -1 on EOF */
130   }
131  
132 < /* seek on reader or return 0 (BIR_OK) on success */
132 > /* Seek on reader or return 0 (BIR_OK) on success */
133   static int
134   rdseek(uint32 pos, BMPReader *br)
135   {
# Line 131 | Line 141 | rdseek(uint32 pos, BMPReader *br)
141          return BIR_OK;
142   }
143  
144 < /* open BMP stream for reading and get first scanline */
144 > /* Open BMP stream for reading and get first scanline */
145   BMPReader *
146   BMPopenReader(int (*cget)(void *), int (*seek)(uint32, void *), void *c_data)
147   {
148          BMPReader       *br;
149 <        uint32          bmPos, hdrSiz;
150 <        int             palLen;
149 >        uint32          bmPos, hdrSiz, palSiz;
150 >        int             magic[2];               /* check magic number */
151  
152          if (cget == NULL)
153                  return NULL;
154 <        int     magic[2];               /* check magic number */
154 >        if (cget == &stdio_getc && c_data == NULL)
155 >                return NULL;                    /* stdio error condition */
156          magic[0] = (*cget)(c_data);
157          if (magic[0] != 'B')
158                  return NULL;
# Line 179 | Line 190 | BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
190          br->hdr->hRes = rdint32(br);            /* horizontal resolution */
191          br->hdr->vRes = rdint32(br);            /* vertical resolution */
192          br->hdr->nColors = rdint32(br);         /* # colors used */
193 +        if (!br->hdr->nColors && br->hdr->bpp <= 8)
194 +                br->hdr->nColors = 1<<br->hdr->bpp;
195          br->hdr->impColors = rdint32(br);       /* # important colors */
196          if (br->hdr->impColors < 0)
197                  goto err;                       /* catch premature EOF */
198          if (!BMPheaderOK(br->hdr))
199                  goto err;
200 <        palLen = BMPpalLen(br->hdr);
201 <        if (br->hdr->bpp <= 8) {                /* normalize color counts */
202 <                if (br->hdr->nColors <= 0)
190 <                        br->hdr->nColors = palLen;
191 <                if (br->hdr->impColors <= 0)
192 <                        br->hdr->impColors = br->hdr->nColors;
193 <        }
200 >        palSiz = sizeof(RGBquad)*br->hdr->nColors;
201 >        if (br->hdr->impColors <= 0)
202 >                br->hdr->impColors = br->hdr->nColors;
203                                                  /* extend header */
204 <        if (bmPos < hdrSiz + sizeof(RGBquad)*palLen)
204 >        if (bmPos < hdrSiz + palSiz)
205                  goto err;
206 <        br->hdr->infoSiz = bmPos - (hdrSiz + sizeof(RGBquad)*palLen);
207 <        if (palLen > 0 || br->hdr->infoSiz > 0) {
206 >        br->hdr->infoSiz = bmPos - (hdrSiz + palSiz);
207 >        if (br->hdr->nColors > 0 || br->hdr->infoSiz > 0) {
208                  br->hdr = (BMPHeader *)realloc((void *)br->hdr,
209                                          sizeof(BMPHeader) +
210 <                                        sizeof(RGBquad)*palLen +
202 <                                        br->hdr->infoSiz);
210 >                                        palSiz + br->hdr->infoSiz);
211                  if (br->hdr == NULL)
212                          goto err;
213          }
# Line 208 | Line 216 | BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
216                  BMPbitField(br->hdr)[0] = (uint32)rdint32(br);
217                  BMPbitField(br->hdr)[1] = (uint32)rdint32(br);
218                  BMPbitField(br->hdr)[2] = (uint32)rdint32(br);
219 <        } else if (rdbytes((char *)br->hdr->palette,
212 <                        sizeof(RGBquad)*palLen, br) != BIR_OK)
219 >        } else if (rdbytes((char *)br->hdr->palette, palSiz, br) != BIR_OK)
220                  goto err;
221                                                  /* read add'l information */
222          if (rdbytes(BMPinfo(br->hdr), br->hdr->infoSiz, br) != BIR_OK)
# Line 232 | Line 239 | BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
239                                  sizeof(br->scanpos[0])*br->hdr->height);
240          }
241          br->scanpos[0] = br->fpos;
242 <        if (BMPreadScanline(br) != BIR_OK)
243 <                goto err;
237 <        return br;
242 >        if (BMPreadScanline(br) == BIR_OK)
243 >                return br;
244   err:
245          if (br->hdr != NULL)
246                  free((void *)br->hdr);
# Line 244 | Line 250 | err:
250          return NULL;
251   }
252  
253 < /* determine if image is grayscale */
253 > /* Determine if image is grayscale */
254   int
255   BMPisGrayscale(const BMPHeader *hdr)
256   {
# Line 255 | Line 261 | BMPisGrayscale(const BMPHeader *hdr)
261                  return -1;
262          if (hdr->bpp > 8)               /* assume they had a reason for it */
263                  return 0;
264 <        for (rgbp = hdr->palette, n = hdr->nColors; n-- > 0; rgbp++)
265 <                if (((rgbp->r != rgbp->g) | (rgbp->g != rgbp->b)))
264 >        for (rgbp = hdr->palette, n = hdr->impColors; n-- > 0; rgbp++)
265 >                if ((rgbp->r != rgbp->g) | (rgbp->g != rgbp->b))
266                          return 0;
267          return 1;                       /* all colors neutral in map */
268   }
269  
270 < /* read and decode next BMP scanline */
270 > /* Read and decode next BMP scanline */
271   int
272   BMPreadScanline(BMPReader *br)
273   {
# Line 275 | Line 281 | BMPreadScanline(BMPReader *br)
281          if (br->hdr->compr == BI_UNCOMPR || br->hdr->compr == BI_BITFIELDS)
282                  return rdbytes((char *)br->scanline, n, br);
283          /*
284 <         * RLE/RLE8 Decoding
284 >         * RLE4/RLE8 Decoding
285           *
286           * Certain aspects of this scheme are completely insane, so
287           * we don't support them.  Fortunately, they rarely appear.
288           * One is the mid-file EOD (0x0001) and another is the ill-conceived
289           * "delta" (0x0002), which is like a "goto" statement for bitmaps.
290 <         * Whoever thought this up should be shot, then told why
291 <         * it's impossible to support such a scheme in any reasonable way.
290 >         * Whoever thought this up should be wrestled to the ground and told
291 >         * why it's impossible to support such a scheme in any reasonable way.
292           * Also, RLE4 mode allows runs to stop halfway through a byte,
293           * which is likewise uncodeable, so we don't even try.
294           * Finally, the scanline break is ambiguous -- we assume here that
# Line 296 | Line 302 | BMPreadScanline(BMPReader *br)
302           * is it specified what we should assume for missing pixels.  This
303           * is undoubtedly the most brain-dead format I've ever encountered.
304           */
305 <        sp = br->scanline;
305 >        sp = (int8 *)br->scanline;
306 >        n = br->hdr->width;
307 >        if (br->hdr->compr == BI_RLE4)
308 >                n = (n + 1) >> 1;
309          while (n > 0) {
310                  int     skipOdd, len, val;
311  
# Line 317 | Line 326 | BMPreadScanline(BMPReader *br)
326                                  *sp++ = val;
327                          continue;
328                  }
329 +                                        /* check for escape */
330                  switch (rdbyte(len, br)) {
331                  case EOF:
332                          return BIR_TRUNCATED;
# Line 356 | Line 366 | BMPreadScanline(BMPReader *br)
366          return BIR_OK;
367   }
368  
369 < /* read a specific scanline */
369 > /* Read a specific scanline */
370   int
371   BMPseekScanline(int y, BMPReader *br)
372   {
# Line 399 | Line 409 | BMPseekScanline(int y, BMPReader *br)
409          return BIR_OK;
410   }
411  
412 < /* get ith pixel from last scanline */
412 > /* Get ith pixel from last scanline */
413   RGBquad
414   BMPdecodePixel(int i, const BMPReader *br)
415   {
# Line 445 | Line 455 | BMPdecodePixel(int i, const BMPReader *br)
455          case 8:
456                  return br->hdr->palette[br->scanline[i]];
457          case 1:
458 <                return br->hdr->palette[br->scanline[i>>3]>>((7-i)&7) & 1];
458 >                return br->hdr->palette[br->scanline[i>>3]>>(7-(i&7)) & 1];
459          case 4:
460                  return br->hdr->palette[br->scanline[i>>1]>>(i&1?4:0) & 0xf];
461          case 16:
# Line 463 | Line 473 | BMPdecodePixel(int i, const BMPReader *br)
473          return black;                           /* should never happen */
474   }
475  
476 < /* free BMP reader resources */
476 > /* Free BMP reader resources */
477   void
478   BMPfreeReader(BMPReader *br)
479   {
# Line 500 | Line 510 | stdio_fseek(uint32 pos, void *p)
510          return fseek((FILE *)p, (long)pos, 0);
511   }
512  
513 < /* allocate uncompressed (24-bit) RGB header */
513 > /* Allocate uncompressed (24-bit) RGB header */
514   BMPHeader *
515   BMPtruecolorHeader(int xr, int yr, int infolen)
516   {
# Line 523 | Line 533 | BMPtruecolorHeader(int xr, int yr, int infolen)
533          return hdr;
534   }
535  
536 < /* allocate color-mapped header (defaults to minimal grayscale) */
536 > /* Allocate color-mapped header (defaults to minimal grayscale) */
537   BMPHeader *
538   BMPmappedHeader(int xr, int yr, int infolen, int ncolors)
539   {
# Line 541 | Line 551 | BMPmappedHeader(int xr, int yr, int infolen, int ncolo
551          else
552                  return NULL;
553          hdr = (BMPHeader *)malloc(sizeof(BMPHeader) +
554 <                                        sizeof(RGBquad)*(1<<n) -
554 >                                        sizeof(RGBquad)*((size_t)1<<n) -
555                                          sizeof(hdr->palette) +
556                                          infolen);
557          if (hdr == NULL)
# Line 555 | Line 565 | BMPmappedHeader(int xr, int yr, int infolen, int ncolo
565          hdr->nColors = ncolors;
566          hdr->impColors = 0;                     /* says all colors important */
567          hdr->infoSiz = infolen;
568 <        memset((void *)hdr->palette, 0, sizeof(RGBquad)*(1<<n) + infolen);
568 >        memset((void *)hdr->palette, 0, sizeof(RGBquad)*((size_t)1<<n) + infolen);
569          for (n = ncolors; n--; )
570                  hdr->palette[n].r = hdr->palette[n].g =
571                          hdr->palette[n].b = n*255/(ncolors-1);
# Line 568 | Line 578 | BMPmappedHeader(int xr, int yr, int infolen, int ncolo
578                                          ((bw)->flen = (bw)->fpos) : \
579                                          (bw)->fpos )
580  
581 < /* write out a string of bytes */
581 > /* Write out a string of bytes */
582   static void
583   wrbytes(char *bp, uint32 n, BMPWriter *bw)
584   {
# Line 576 | Line 586 | wrbytes(char *bp, uint32 n, BMPWriter *bw)
586                  wrbyte(*bp++, bw);
587   }
588  
589 < /* write 32-bit integer in littlendian order */
589 > /* Write 32-bit integer in littlendian order */
590   static void
591   wrint32(int32 i, BMPWriter *bw)
592   {
# Line 586 | Line 596 | wrint32(int32 i, BMPWriter *bw)
596          wrbyte(i>>24 & 0xff, bw);
597   }
598  
599 < /* write 16-bit unsigned integer in littlendian order */
599 > /* Write 16-bit unsigned integer in littlendian order */
600   static void
601   wruint16(uint16 ui, BMPWriter *bw)
602   {
# Line 594 | Line 604 | wruint16(uint16 ui, BMPWriter *bw)
604          wrbyte(ui>>8 & 0xff, bw);
605   }
606  
607 < /* seek to the specified file position, returning 0 (BIR_OK) on success */
607 > /* Seek to the specified file position, returning 0 (BIR_OK) on success */
608   static int
609   wrseek(uint32 pos, BMPWriter *bw)
610   {
# Line 610 | Line 620 | wrseek(uint32 pos, BMPWriter *bw)
620          return BIR_OK;
621   }
622  
623 < /* open BMP stream for writing */
623 > /* Open BMP stream for writing */
624   BMPWriter *
625   BMPopenWriter(void (*cput)(int, void *), int (*seek)(uint32, void *),
626                          void *c_data, BMPHeader *hdr)
# Line 620 | Line 630 | BMPopenWriter(void (*cput)(int, void *), int (*seek)(u
630                                                  /* check arguments */
631          if (cput == NULL)
632                  return NULL;
633 +        if (cput == &stdio_putc && c_data == NULL)
634 +                return NULL;                    /* stdio error condition */
635          if (!BMPheaderOK(hdr))
636                  return NULL;
637          if ((hdr->bpp == 16) | (hdr->compr == BI_RLE4))
# Line 632 | Line 644 | BMPopenWriter(void (*cput)(int, void *), int (*seek)(u
644          hdrSiz = 2 + 6*4 + 2*2 + 6*4;
645          if (hdr->compr == BI_BITFIELDS)
646                  hdrSiz += sizeof(uint32)*3;
647 <        palSiz = sizeof(RGBquad)*BMPpalLen(hdr);
647 >        palSiz = sizeof(RGBquad)*hdr->nColors;
648          scanSiz = getScanSiz(hdr);
649          bmSiz = hdr->height*scanSiz;            /* wrong if compressed */
650                                                  /* initialize writer */
# Line 683 | Line 695 | BMPopenWriter(void (*cput)(int, void *), int (*seek)(u
695          return bw;
696   }
697  
698 < /* find position of next run of 5 or more identical bytes, or 255 if none */
698 > /* Find position of next run of 5 or more identical bytes, or 255 if none */
699   static int
700   findNextRun(const int8 *bp, int len)
701   {
# Line 700 | Line 712 | findNextRun(const int8 *bp, int len)
712          return pos;                             /* didn't find any */
713   }
714                                  
715 < /* write the current scanline */
715 > /* Write the current scanline */
716   int
717   BMPwriteScanline(BMPWriter *bw)
718   {
# Line 728 | Line 740 | BMPwriteScanline(BMPWriter *bw)
740           * (0x0000) except for the last, which ends in a bitmap break
741           * (0x0001).  We don't support RLE4 at all; it's too awkward.
742           */
743 <        sp = bw->scanline;
743 >        sp = (const int8 *)bw->scanline;
744          n = bw->hdr->width;
745          while (n > 0) {
746                  int     cnt, val;
735 –
747                  cnt = findNextRun(sp, n);       /* 0-255 < n */
748 <                if (cnt >= 3) {                 /* output non-run */
748 >                if (cnt >= 3) {                 /* output absolute */
749                          int     skipOdd = cnt & 1;
750                          wrbyte(0, bw);
751                          wrbyte(cnt, bw);
# Line 746 | Line 757 | BMPwriteScanline(BMPWriter *bw)
757                  }
758                  if (n <= 0)                     /* was that it? */
759                          break;
760 <                val = *sp;                      /* output run */
761 <                for (cnt = 1; cnt < 255; cnt++)
762 <                        if ((!--n) | (*++sp != val))
760 >                val = *sp++;                    /* output run */
761 >                for (cnt = 1; --n && cnt < 255; cnt++, sp++)
762 >                        if (*sp != val)
763                                  break;
764                  wrbyte(cnt, bw);
765                  wrbyte(val, bw);
# Line 768 | Line 779 | BMPwriteScanline(BMPWriter *bw)
779          return BIR_OK;
780   }
781  
782 < /* free BMP writer resources */
782 > /* Free BMP writer resources */
783   void
784   BMPfreeWriter(BMPWriter *bw)
785   {

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines