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

Comparing ray/src/common/color.c (file contents):
Revision 2.4 by greg, Fri Oct 2 15:59:58 1992 UTC vs.
Revision 2.22 by greg, Sat Mar 5 17:18:02 2022 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1991 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  color.c - routines for color calculations.
6   *
7 < *     10/10/85
7 > *  Externals declared in color.h
8   */
9  
10 < #include  <stdio.h>
10 > #include "copyright.h"
11  
12 + #include  <stdio.h>
13 + #include  <stdlib.h>
14 + #include  <math.h>
15   #include  "color.h"
16  
17 + #ifdef getc_unlocked            /* avoid horrendous overhead of flockfile */
18 + #undef getc
19 + #undef putc
20 + #undef ferror
21 + #define getc    getc_unlocked
22 + #define putc    putc_unlocked
23 + #define ferror  ferror_unlocked
24 + #endif
25 +
26   #define  MINELEN        8       /* minimum scanline length for encoding */
27 + #define  MAXELEN        0x7fff  /* maximum scanline length for encoding */
28   #define  MINRUN         4       /* minimum run length */
29  
20 – #ifndef frexp
21 – extern double  frexp();
22 – #endif
30  
31 <
32 < char *
33 < tempbuffer(len)                 /* get a temporary buffer */
34 < unsigned  len;
31 > void *
32 > tempbuffer(                     /* get a temporary buffer */
33 >        unsigned int  len
34 > )
35   {
36 <        extern char  *malloc(), *realloc();
37 <        static char  *tempbuf = NULL;
31 <        static int  tempbuflen = 0;
36 >        static void             *tempbuf = NULL;
37 >        static unsigned int     tempbuflen = 0;
38  
39 <        if (len > tempbuflen) {
40 <                if (tempbuflen > 0)
41 <                        tempbuf = realloc(tempbuf, len);
42 <                else
43 <                        tempbuf = malloc(len);
44 <                tempbuflen = tempbuf==NULL ? 0 : len;
39 >        if (!len) {             /* call to free */
40 >                if (tempbuflen) {
41 >                        free(tempbuf);
42 >                        tempbuf = NULL;
43 >                        tempbuflen = 0;
44 >                }
45 >                return(NULL);
46          }
47 +        if (len <= tempbuflen)  /* big enough already? */
48 +                return(tempbuf);
49 +                                /* else free & reallocate */
50 +        if (tempbuflen)
51 +                free(tempbuf);
52 +        tempbuf = malloc(len);
53 +        tempbuflen = len*(tempbuf != NULL);
54          return(tempbuf);
55   }
56  
57  
58 < fwritecolrs(scanline, len, fp)          /* write out a colr scanline */
59 < register COLR  *scanline;
60 < unsigned  len;
61 < register FILE  *fp;
58 > int
59 > fwritecolrs(                    /* write out a colr scanline */
60 >        COLR  *scanline,
61 >        int  len,
62 >        FILE  *fp
63 > )
64   {
65 <        register int  i, j, beg, cnt;
65 >        int  i, j, beg, cnt = 1;
66          int  c2;
67          
68 <        if (len < MINELEN | len > 0x7fff)       /* OOBs, write out flat */
68 >        if ((len < MINELEN) | (len > MAXELEN))  /* OOBs, write out flat */
69                  return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
70                                          /* put magic header */
71          putc(2, fp);
72          putc(2, fp);
73          putc(len>>8, fp);
74 <        putc(len&255, fp);
74 >        putc(len&0xff, fp);
75                                          /* put components seperately */
76          for (i = 0; i < 4; i++) {
77              for (j = 0; j < len; j += cnt) {    /* find next run */
78                  for (beg = j; beg < len; beg += cnt) {
79 <                    for (cnt = 1; cnt < 127 && beg+cnt < len &&
79 >                    for (cnt = 1; (cnt < 127) & (beg+cnt < len) &&
80                              scanline[beg+cnt][i] == scanline[beg][i]; cnt++)
81                          ;
82                      if (cnt >= MINRUN)
83                          break;                  /* long enough */
84                  }
85 <                if (beg-j > 1 && beg-j < MINRUN) {
85 >                if ((beg-j > 1) & (beg-j < MINRUN)) {
86                      c2 = j+1;
87                      while (scanline[c2++][i] == scanline[j][i])
88                          if (c2 == beg) {        /* short run */
# Line 93 | Line 109 | register FILE  *fp;
109   }
110  
111  
112 < freadcolrs(scanline, len, fp)           /* read in an encoded colr scanline */
113 < register COLR  *scanline;
114 < int  len;
115 < register FILE  *fp;
112 > static int
113 > oldreadcolrs(                   /* read in an old-style colr scanline */
114 >        COLR  *scanline,
115 >        int  len,
116 >        FILE  *fp
117 > )
118   {
119 <        register int  i, j;
120 <        int  code;
119 >        int  rshift = 0;
120 >        int  i;
121 >        
122 >        while (len > 0) {
123 >                scanline[0][RED] = getc(fp);
124 >                scanline[0][GRN] = getc(fp);
125 >                scanline[0][BLU] = getc(fp);
126 >                scanline[0][EXP] = i = getc(fp);
127 >                if (i == EOF)
128 >                        return(-1);
129 >                if (scanline[0][GRN] == 1 &&
130 >                                (scanline[0][RED] == 1) &
131 >                                (scanline[0][BLU] == 1)) {
132 >                        i = scanline[0][EXP] << rshift;
133 >                        while (i--) {
134 >                                copycolr(scanline[0], scanline[-1]);
135 >                                if (--len <= 0)
136 >                                        return(0);
137 >                                scanline++;
138 >                        }
139 >                        rshift += 8;
140 >                } else {
141 >                        scanline++;
142 >                        len--;
143 >                        rshift = 0;
144 >                }
145 >        }
146 >        return(0);
147 > }
148 >
149 >
150 > int
151 > freadcolrs(                     /* read in an encoded colr scanline */
152 >        COLR  *scanline,
153 >        int  len,
154 >        FILE  *fp
155 > )
156 > {
157 >        int  i, j;
158 >        int  code, val;
159                                          /* determine scanline type */
160 <        if (len < MINELEN | len > 0x7fff)
160 >        if ((len < MINELEN) | (len > MAXELEN))
161                  return(oldreadcolrs(scanline, len, fp));
162          if ((i = getc(fp)) == EOF)
163                  return(-1);
# Line 113 | Line 169 | register FILE  *fp;
169          scanline[0][BLU] = getc(fp);
170          if ((i = getc(fp)) == EOF)
171                  return(-1);
172 <        if (scanline[0][GRN] != 2 || scanline[0][BLU] & 128) {
172 >        if ((scanline[0][GRN] != 2) | ((scanline[0][BLU] & 0x80) != 0)) {
173                  scanline[0][RED] = 2;
174                  scanline[0][EXP] = i;
175                  return(oldreadcolrs(scanline+1, len-1, fp));
# Line 126 | Line 182 | register FILE  *fp;
182                  if ((code = getc(fp)) == EOF)
183                      return(-1);
184                  if (code > 128) {       /* run */
185 <                    scanline[j++][i] = getc(fp);
186 <                    for (code &= 127; --code; j++)
187 <                        scanline[j][i] = scanline[j-1][i];
188 <                } else                  /* non-run */
185 >                    code &= 127;
186 >                    if ((val = getc(fp)) == EOF)
187 >                        return -1;
188 >                    if (j + code > len)
189 >                        return -1;      /* overrun */
190                      while (code--)
191 <                        scanline[j++][i] = getc(fp);
192 <            }
193 <        return(feof(fp) ? -1 : 0);
194 < }
195 <
196 <
197 < oldreadcolrs(scanline, len, fp)         /* read in an old colr scanline */
198 < register COLR  *scanline;
199 < int  len;
143 < register FILE  *fp;
144 < {
145 <        int  rshift;
146 <        register int  i;
147 <        
148 <        rshift = 0;
149 <        
150 <        while (len > 0) {
151 <                scanline[0][RED] = getc(fp);
152 <                scanline[0][GRN] = getc(fp);
153 <                scanline[0][BLU] = getc(fp);
154 <                scanline[0][EXP] = getc(fp);
155 <                if (feof(fp) || ferror(fp))
156 <                        return(-1);
157 <                if (scanline[0][RED] == 1 &&
158 <                                scanline[0][GRN] == 1 &&
159 <                                scanline[0][BLU] == 1) {
160 <                        for (i = scanline[0][EXP] << rshift; i > 0; i--) {
161 <                                copycolr(scanline[0], scanline[-1]);
162 <                                scanline++;
163 <                                len--;
164 <                        }
165 <                        rshift += 8;
166 <                } else {
167 <                        scanline++;
168 <                        len--;
169 <                        rshift = 0;
191 >                        scanline[j++][i] = val;
192 >                } else {                /* non-run */
193 >                    if (j + code > len)
194 >                        return -1;      /* overrun */
195 >                    while (code--) {
196 >                        if ((val = getc(fp)) == EOF)
197 >                            return -1;
198 >                        scanline[j++][i] = val;
199 >                    }
200                  }
201 <        }
201 >            }
202          return(0);
203   }
204  
205  
206 < fwritescan(scanline, len, fp)           /* write out a scanline */
207 < register COLOR  *scanline;
208 < int  len;
209 < FILE  *fp;
206 > int
207 > fwritescan(                     /* write out a scanline */
208 >        COLOR  *scanline,
209 >        int  len,
210 >        FILE  *fp
211 > )
212   {
213          COLR  *clrscan;
214          int  n;
215 <        register COLR  *sp;
215 >        COLR  *sp;
216                                          /* get scanline buffer */
217          if ((sp = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
218                  return(-1);
# Line 198 | Line 230 | FILE  *fp;
230   }
231  
232  
233 < freadscan(scanline, len, fp)            /* read in a scanline */
234 < register COLOR  *scanline;
235 < int  len;
236 < FILE  *fp;
233 > int
234 > freadscan(                      /* read in a scanline */
235 >        COLOR  *scanline,
236 >        int  len,
237 >        FILE  *fp
238 > )
239   {
240 <        register COLR  *clrscan;
240 >        COLR  *clrscan;
241  
242          if ((clrscan = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
243                  return(-1);
# Line 213 | Line 247 | FILE  *fp;
247          colr_color(scanline[0], clrscan[0]);
248          while (--len > 0) {
249                  scanline++; clrscan++;
250 <                if (clrscan[0][RED] == clrscan[-1][RED] &&
251 <                            clrscan[0][GRN] == clrscan[-1][GRN] &&
252 <                            clrscan[0][BLU] == clrscan[-1][BLU] &&
253 <                            clrscan[0][EXP] == clrscan[-1][EXP])
250 >                if (clrscan[0][GRN] == clrscan[-1][GRN] &&
251 >                            (clrscan[0][RED] == clrscan[-1][RED]) &
252 >                            (clrscan[0][BLU] == clrscan[-1][BLU]) &
253 >                            (clrscan[0][EXP] == clrscan[-1][EXP]))
254                          copycolor(scanline[0], scanline[-1]);
255                  else
256                          colr_color(scanline[0], clrscan[0]);
# Line 225 | Line 259 | FILE  *fp;
259   }
260  
261  
262 < setcolr(clr, r, g, b)           /* assign a short color value */
263 < register COLR  clr;
264 < double  r, g, b;
262 > void
263 > setcolr(                        /* assign a short color value */
264 >        COLR  clr,
265 >        double  r,
266 >        double  g,
267 >        double  b
268 > )
269   {
270          double  d;
271          int  e;
# Line 243 | Line 281 | double  r, g, b;
281  
282          d = frexp(d, &e) * 256.0 / d;
283  
284 <        clr[RED] = r * d;
285 <        clr[GRN] = g * d;
286 <        clr[BLU] = b * d;
284 >        if (r > 0.0)
285 >                clr[RED] = r * d;
286 >        else
287 >                clr[RED] = 0;
288 >        if (g > 0.0)
289 >                clr[GRN] = g * d;
290 >        else
291 >                clr[GRN] = 0;
292 >        if (b > 0.0)
293 >                clr[BLU] = b * d;
294 >        else
295 >                clr[BLU] = 0;
296 >
297          clr[EXP] = e + COLXS;
298   }
299  
300  
301 < colr_color(col, clr)            /* convert short to float color */
302 < register COLOR  col;
303 < register COLR  clr;
301 > void
302 > colr_color(                     /* convert short to float color */
303 >        COLOR  col,
304 >        COLR  clr
305 > )
306   {
307          double  f;
308          
# Line 267 | Line 317 | register COLR  clr;
317   }
318  
319  
320 < bigdiff(c1, c2, md)                     /* c1 delta c2 > md? */
321 < register COLOR  c1, c2;
322 < double  md;
320 > int
321 > bigdiff(                                /* c1 delta c2 > md? */
322 >        COLOR  c1,
323 >        COLOR  c2,
324 >        double  md
325 > )
326   {
327 <        register int  i;
327 >        int  i;
328  
329          for (i = 0; i < 3; i++)
330                  if (colval(c1,i)-colval(c2,i) > md*colval(c2,i) ||
331 <                        colval(c2,i)-colval(c1,i) > md*colval(c1,i))
331 >                                colval(c2,i)-colval(c1,i) > md*colval(c1,i))
332                          return(1);
333          return(0);
334   }

Diff Legend

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