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

Comparing ray/src/common/bmpfile.c (file contents):
Revision 2.12 by greg, Tue Sep 14 02:53:50 2004 UTC vs.
Revision 2.22 by greg, Fri Sep 12 19:31:15 2025 UTC

# Line 17 | Line 17 | static const char RCSid[] = "$Id$";
17   #define putc    putc_unlocked
18   #endif
19  
20 < /* get corresponding error message */
20 > /* Get corresponding error message */
21   const char *
22   BMPerrorMessage(int ec)
23   {
# Line 38 | 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 71 | 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 86 | 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 100 | 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 114 | 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 126 | 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 138 | 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;
148 <        int     magic[2];               /* check magic number */
149 >        uint32          bmPos, hdrSiz, palSiz;
150 >        int             magic[2];               /* check magic number */
151  
152          if (cget == NULL)
153                  return NULL;
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 186 | 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)
197 <                        br->hdr->nColors = palLen;
198 <                if (br->hdr->impColors <= 0)
199 <                        br->hdr->impColors = br->hdr->nColors;
200 <        }
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) {
208 <                br->hdr = (BMPHeader *)realloc((void *)br->hdr,
206 >        br->hdr->infoSiz = bmPos - (hdrSiz + palSiz);
207 >        if (br->hdr->nColors > 0 || br->hdr->infoSiz > 0) {
208 >                br->hdr = (BMPHeader *)realloc(br->hdr,
209                                          sizeof(BMPHeader) +
210 <                                        sizeof(RGBquad)*palLen +
209 <                                        br->hdr->infoSiz);
210 >                                        palSiz + br->hdr->infoSiz);
211                  if (br->hdr == NULL)
212                          goto err;
213          }
# Line 215 | 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,
219 <                        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 228 | Line 228 | BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
228          br->yscan = -1;
229          if (seek != NULL && ((br->hdr->compr == BI_RLE8) |
230                                          (br->hdr->compr == BI_RLE4))) {
231 <                BMPReader       *newbr = (BMPReader *)realloc((void *)br,
231 >                BMPReader       *newbr = (BMPReader *)realloc(br,
232                                                  sizeof(BMPReader) +
233                                                  sizeof(br->scanpos[0]) *
234                                                          br->hdr->height);
235                  if (newbr == NULL)
236                          goto err;
237                  br = newbr;
238 <                memset((void *)(br->scanpos + 1), 0,
238 >                memset(br->scanpos+1, 0,
239                                  sizeof(br->scanpos[0])*br->hdr->height);
240          }
241          br->scanpos[0] = br->fpos;
# Line 243 | Line 243 | BMPopenReader(int (*cget)(void *), int (*seek)(uint32,
243                  return br;
244   err:
245          if (br->hdr != NULL)
246 <                free((void *)br->hdr);
246 >                free(br->hdr);
247          if (br->scanline != NULL)
248 <                free((void *)br->scanline);
249 <        free((void *)br);
248 >                free(br->scanline);
249 >        free(br);
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 261 | 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 302 | 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;
# Line 366 | 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 409 | 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 455 | 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 473 | 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   {
480          if (br == NULL)
481                  return;
482 <        free((void *)br->hdr);
483 <        free((void *)br->scanline);
484 <        free((void *)br);
482 >        free(br->hdr);
483 >        free(br->scanline);
484 >        free(br);
485   }
486  
487   /* stdio getc() callback */
# Line 510 | 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 529 | Line 529 | BMPtruecolorHeader(int xr, int yr, int infolen)
529          hdr->compr = BI_UNCOMPR;
530          hdr->hRes = hdr->vRes = 2835;           /* default to 72 ppi */
531          hdr->nColors = hdr->impColors = 0;
532 <        hdr->infoSiz = infolen;
532 >        if ((hdr->infoSiz = infolen) > 0)
533 >                memset(BMPinfo(hdr), 0, hdr->infoSiz);
534          return hdr;
535   }
536  
537 < /* allocate color-mapped header (defaults to minimal grayscale) */
537 > /* Allocate color-mapped header (defaults to minimal grayscale) */
538   BMPHeader *
539   BMPmappedHeader(int xr, int yr, int infolen, int ncolors)
540   {
# Line 551 | Line 552 | BMPmappedHeader(int xr, int yr, int infolen, int ncolo
552          else
553                  return NULL;
554          hdr = (BMPHeader *)malloc(sizeof(BMPHeader) +
555 <                                        sizeof(RGBquad)*(1<<n) -
555 >                                        sizeof(RGBquad)*((size_t)1<<n) -
556                                          sizeof(hdr->palette) +
557                                          infolen);
558          if (hdr == NULL)
# Line 565 | Line 566 | BMPmappedHeader(int xr, int yr, int infolen, int ncolo
566          hdr->nColors = ncolors;
567          hdr->impColors = 0;                     /* says all colors important */
568          hdr->infoSiz = infolen;
569 <        memset((void *)hdr->palette, 0, sizeof(RGBquad)*(1<<n) + infolen);
569 >        memset(hdr->palette, 0, sizeof(RGBquad)*((size_t)1<<n) + infolen);
570          for (n = ncolors; n--; )
571                  hdr->palette[n].r = hdr->palette[n].g =
572                          hdr->palette[n].b = n*255/(ncolors-1);
# Line 578 | Line 579 | BMPmappedHeader(int xr, int yr, int infolen, int ncolo
579                                          ((bw)->flen = (bw)->fpos) : \
580                                          (bw)->fpos )
581  
582 < /* write out a string of bytes */
582 > /* Write out a string of bytes */
583   static void
584   wrbytes(char *bp, uint32 n, BMPWriter *bw)
585   {
# Line 586 | Line 587 | wrbytes(char *bp, uint32 n, BMPWriter *bw)
587                  wrbyte(*bp++, bw);
588   }
589  
590 < /* write 32-bit integer in littlendian order */
590 > /* Write 32-bit integer in littlendian order */
591   static void
592   wrint32(int32 i, BMPWriter *bw)
593   {
# Line 596 | Line 597 | wrint32(int32 i, BMPWriter *bw)
597          wrbyte(i>>24 & 0xff, bw);
598   }
599  
600 < /* write 16-bit unsigned integer in littlendian order */
600 > /* Write 16-bit unsigned integer in littlendian order */
601   static void
602   wruint16(uint16 ui, BMPWriter *bw)
603   {
# Line 604 | Line 605 | wruint16(uint16 ui, BMPWriter *bw)
605          wrbyte(ui>>8 & 0xff, bw);
606   }
607  
608 < /* seek to the specified file position, returning 0 (BIR_OK) on success */
608 > /* Seek to the specified file position, returning 0 (BIR_OK) on success */
609   static int
610   wrseek(uint32 pos, BMPWriter *bw)
611   {
# Line 620 | Line 621 | wrseek(uint32 pos, BMPWriter *bw)
621          return BIR_OK;
622   }
623  
624 < /* open BMP stream for writing */
624 > /* Open BMP stream for writing */
625   BMPWriter *
626   BMPopenWriter(void (*cput)(int, void *), int (*seek)(uint32, void *),
627                          void *c_data, BMPHeader *hdr)
# Line 630 | Line 631 | BMPopenWriter(void (*cput)(int, void *), int (*seek)(u
631                                                  /* check arguments */
632          if (cput == NULL)
633                  return NULL;
634 +        if (cput == &stdio_putc && c_data == NULL)
635 +                return NULL;                    /* stdio error condition */
636          if (!BMPheaderOK(hdr))
637                  return NULL;
638          if ((hdr->bpp == 16) | (hdr->compr == BI_RLE4))
# Line 642 | Line 645 | BMPopenWriter(void (*cput)(int, void *), int (*seek)(u
645          hdrSiz = 2 + 6*4 + 2*2 + 6*4;
646          if (hdr->compr == BI_BITFIELDS)
647                  hdrSiz += sizeof(uint32)*3;
648 <        palSiz = sizeof(RGBquad)*BMPpalLen(hdr);
648 >        palSiz = sizeof(RGBquad)*hdr->nColors;
649          scanSiz = getScanSiz(hdr);
650          bmSiz = hdr->height*scanSiz;            /* wrong if compressed */
651                                                  /* initialize writer */
# Line 653 | Line 656 | BMPopenWriter(void (*cput)(int, void *), int (*seek)(u
656          bw->yscan = 0;
657          bw->scanline = (uint8 *)calloc(scanSiz, sizeof(uint8));
658          if (bw->scanline == NULL) {
659 <                free((void *)bw);
659 >                free(bw);
660                  return NULL;
661          }
662          bw->fbmp = hdrSiz + palSiz + hdr->infoSiz;
# Line 693 | Line 696 | BMPopenWriter(void (*cput)(int, void *), int (*seek)(u
696          return bw;
697   }
698  
699 < /* find position of next run of 5 or more identical bytes, or 255 if none */
699 > /* Find position of next run of 5 or more identical bytes, or 255 if none */
700   static int
701   findNextRun(const int8 *bp, int len)
702   {
# Line 710 | Line 713 | findNextRun(const int8 *bp, int len)
713          return pos;                             /* didn't find any */
714   }
715                                  
716 < /* write the current scanline */
716 > /* Write the current scanline */
717   int
718   BMPwriteScanline(BMPWriter *bw)
719   {
# Line 738 | Line 741 | BMPwriteScanline(BMPWriter *bw)
741           * (0x0000) except for the last, which ends in a bitmap break
742           * (0x0001).  We don't support RLE4 at all; it's too awkward.
743           */
744 <        sp = bw->scanline;
744 >        sp = (const int8 *)bw->scanline;
745          n = bw->hdr->width;
746          while (n > 0) {
747                  int     cnt, val;
# Line 755 | Line 758 | BMPwriteScanline(BMPWriter *bw)
758                  }
759                  if (n <= 0)                     /* was that it? */
760                          break;
761 <                val = *sp;                      /* output run */
762 <                for (cnt = 1; --n && cnt < 255; cnt++)
763 <                        if (*++sp != val)
761 >                val = *sp++;                    /* output run */
762 >                for (cnt = 1; --n && cnt < 255; cnt++, sp++)
763 >                        if (*sp != val)
764                                  break;
765                  wrbyte(cnt, bw);
766                  wrbyte(val, bw);
# Line 777 | Line 780 | BMPwriteScanline(BMPWriter *bw)
780          return BIR_OK;
781   }
782  
783 < /* free BMP writer resources */
783 > /* Free BMP writer resources */
784   void
785   BMPfreeWriter(BMPWriter *bw)
786   {
787          if (bw == NULL)
788                  return;
789 <        free((void *)bw->hdr);
790 <        free((void *)bw->scanline);
791 <        free((void *)bw);
789 >        free(bw->hdr);
790 >        free(bw->scanline);
791 >        free(bw);
792   }

Diff Legend

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