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.2 by greg, Tue Jun 23 10:59:34 1992 UTC vs.
Revision 2.18 by greg, Tue Apr 10 23:38:40 2018 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 + #define getc    getc_unlocked
21 + #define putc    putc_unlocked
22 + #define ferror  ferror_unlocked
23 + #endif
24 +
25   #define  MINELEN        8       /* minimum scanline length for encoding */
26 + #define  MAXELEN        0x7fff  /* maximum scanline length for encoding */
27   #define  MINRUN         4       /* minimum run length */
28  
29  
30   char *
31 < tempbuffer(len)                 /* get a temporary buffer */
32 < unsigned  len;
31 > tempbuffer(                     /* get a temporary buffer */
32 >        unsigned int  len
33 > )
34   {
25 –        extern char  *malloc(), *realloc();
35          static char  *tempbuf = NULL;
36 <        static int  tempbuflen = 0;
36 >        static unsigned  tempbuflen = 0;
37  
38          if (len > tempbuflen) {
39                  if (tempbuflen > 0)
40 <                        tempbuf = realloc(tempbuf, len);
40 >                        tempbuf = (char *)realloc((void *)tempbuf, len);
41                  else
42 <                        tempbuf = malloc(len);
42 >                        tempbuf = (char *)malloc(len);
43                  tempbuflen = tempbuf==NULL ? 0 : len;
44          }
45          return(tempbuf);
46   }
47  
48  
49 < fwritecolrs(scanline, len, fp)          /* write out a colr scanline */
50 < register COLR  *scanline;
51 < unsigned  len;
52 < register FILE  *fp;
49 > int
50 > fwritecolrs(                    /* write out a colr scanline */
51 >        COLR  *scanline,
52 >        int  len,
53 >        FILE  *fp
54 > )
55   {
56 <        register int  i, j, beg, cnt;
56 >        int  i, j, beg, cnt = 1;
57          int  c2;
58          
59 <        if (len < MINELEN | len > 0x7fff)       /* OOBs, write out flat */
59 >        if ((len < MINELEN) | (len > MAXELEN))  /* OOBs, write out flat */
60                  return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
61                                          /* put magic header */
62          putc(2, fp);
# Line 89 | Line 100 | register FILE  *fp;
100   }
101  
102  
103 < freadcolrs(scanline, len, fp)           /* read in an encoded colr scanline */
104 < register COLR  *scanline;
105 < int  len;
106 < register FILE  *fp;
103 > static int
104 > oldreadcolrs(                   /* read in an old colr scanline */
105 >        COLR  *scanline,
106 >        int  len,
107 >        FILE  *fp
108 > )
109   {
110 <        register int  i, j;
111 <        int  code;
110 >        int  rshift = 0;
111 >        int  i;
112 >        
113 >        while (len > 0) {
114 >                scanline[0][RED] = getc(fp);
115 >                scanline[0][GRN] = getc(fp);
116 >                scanline[0][BLU] = getc(fp);
117 >                scanline[0][EXP] = i = getc(fp);
118 >                if (i == EOF)
119 >                        return(-1);
120 >                if (scanline[0][RED] == 1 &&
121 >                                scanline[0][GRN] == 1 &&
122 >                                scanline[0][BLU] == 1) {
123 >                        for (i = scanline[0][EXP] << rshift; i > 0; i--) {
124 >                                copycolr(scanline[0], scanline[-1]);
125 >                                scanline++;
126 >                                len--;
127 >                        }
128 >                        rshift += 8;
129 >                } else {
130 >                        scanline++;
131 >                        len--;
132 >                        rshift = 0;
133 >                }
134 >        }
135 >        return(0);
136 > }
137 >
138 >
139 > int
140 > freadcolrs(                     /* read in an encoded colr scanline */
141 >        COLR  *scanline,
142 >        int  len,
143 >        FILE  *fp
144 > )
145 > {
146 >        int  i, j;
147 >        int  code, val;
148                                          /* determine scanline type */
149 <        if (len < MINELEN)
149 >        if ((len < MINELEN) | (len > MAXELEN))
150                  return(oldreadcolrs(scanline, len, fp));
151          if ((i = getc(fp)) == EOF)
152                  return(-1);
# Line 122 | Line 171 | register FILE  *fp;
171                  if ((code = getc(fp)) == EOF)
172                      return(-1);
173                  if (code > 128) {       /* run */
174 <                    scanline[j++][i] = getc(fp);
175 <                    for (code &= 127; --code; j++)
176 <                        scanline[j][i] = scanline[j-1][i];
177 <                } else                  /* non-run */
174 >                    code &= 127;
175 >                    if ((val = getc(fp)) == EOF)
176 >                        return -1;
177 >                    if (j + code > len)
178 >                        return -1;      /* overrun */
179                      while (code--)
180 <                        scanline[j++][i] = getc(fp);
181 <            }
182 <        return(feof(fp) ? -1 : 0);
183 < }
184 <
185 <
186 < oldreadcolrs(scanline, len, fp)         /* read in an old colr scanline */
187 < register COLR  *scanline;
188 < int  len;
139 < register FILE  *fp;
140 < {
141 <        int  rshift;
142 <        register int  i;
143 <        
144 <        rshift = 0;
145 <        
146 <        while (len > 0) {
147 <                scanline[0][RED] = getc(fp);
148 <                scanline[0][GRN] = getc(fp);
149 <                scanline[0][BLU] = getc(fp);
150 <                scanline[0][EXP] = getc(fp);
151 <                if (feof(fp) || ferror(fp))
152 <                        return(-1);
153 <                if (scanline[0][RED] == 1 &&
154 <                                scanline[0][GRN] == 1 &&
155 <                                scanline[0][BLU] == 1) {
156 <                        for (i = scanline[0][EXP] << rshift; i > 0; i--) {
157 <                                copycolr(scanline[0], scanline[-1]);
158 <                                scanline++;
159 <                                len--;
160 <                        }
161 <                        rshift += 8;
162 <                } else {
163 <                        scanline++;
164 <                        len--;
165 <                        rshift = 0;
180 >                        scanline[j++][i] = val;
181 >                } else {                /* non-run */
182 >                    if (j + code > len)
183 >                        return -1;      /* overrun */
184 >                    while (code--) {
185 >                        if ((val = getc(fp)) == EOF)
186 >                            return -1;
187 >                        scanline[j++][i] = val;
188 >                    }
189                  }
190 <        }
190 >            }
191          return(0);
192   }
193  
194  
195 < fwritescan(scanline, len, fp)           /* write out a scanline */
196 < register COLOR  *scanline;
197 < int  len;
198 < FILE  *fp;
195 > int
196 > fwritescan(                     /* write out a scanline */
197 >        COLOR  *scanline,
198 >        int  len,
199 >        FILE  *fp
200 > )
201   {
202          COLR  *clrscan;
203          int  n;
204 <        register COLR  *sp;
204 >        COLR  *sp;
205                                          /* get scanline buffer */
206          if ((sp = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
207                  return(-1);
# Line 194 | Line 219 | FILE  *fp;
219   }
220  
221  
222 < freadscan(scanline, len, fp)            /* read in a scanline */
223 < register COLOR  *scanline;
224 < int  len;
225 < FILE  *fp;
222 > int
223 > freadscan(                      /* read in a scanline */
224 >        COLOR  *scanline,
225 >        int  len,
226 >        FILE  *fp
227 > )
228   {
229 <        register COLR  *clrscan;
229 >        COLR  *clrscan;
230  
231          if ((clrscan = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
232                  return(-1);
# Line 221 | Line 248 | FILE  *fp;
248   }
249  
250  
251 < setcolr(clr, r, g, b)           /* assign a short color value */
252 < register COLR  clr;
253 < double  r, g, b;
251 > void
252 > setcolr(                        /* assign a short color value */
253 >        COLR  clr,
254 >        double  r,
255 >        double  g,
256 >        double  b
257 > )
258   {
228 –        double  frexp();
259          double  d;
260          int  e;
261          
# Line 238 | Line 268 | double  r, g, b;
268                  return;
269          }
270  
271 <        d = frexp(d, &e) * 256.0 / d;
271 >        d = frexp(d, &e) * 255.9999 / d;
272  
273 <        clr[RED] = r * d;
274 <        clr[GRN] = g * d;
275 <        clr[BLU] = b * d;
273 >        if (r > 0.0)
274 >                clr[RED] = r * d;
275 >        else
276 >                clr[RED] = 0;
277 >        if (g > 0.0)
278 >                clr[GRN] = g * d;
279 >        else
280 >                clr[GRN] = 0;
281 >        if (b > 0.0)
282 >                clr[BLU] = b * d;
283 >        else
284 >                clr[BLU] = 0;
285 >
286          clr[EXP] = e + COLXS;
287   }
288  
289  
290 < colr_color(col, clr)            /* convert short to float color */
291 < register COLOR  col;
292 < register COLR  clr;
290 > void
291 > colr_color(                     /* convert short to float color */
292 >        COLOR  col,
293 >        COLR  clr
294 > )
295   {
296          double  f;
297          
# Line 264 | Line 306 | register COLR  clr;
306   }
307  
308  
309 < bigdiff(c1, c2, md)                     /* c1 delta c2 > md? */
310 < register COLOR  c1, c2;
311 < double  md;
309 > int
310 > bigdiff(                                /* c1 delta c2 > md? */
311 >        COLOR  c1,
312 >        COLOR  c2,
313 >        double  md
314 > )
315   {
316 <        register int  i;
316 >        int  i;
317  
318          for (i = 0; i < 3; i++)
319                  if (colval(c1,i)-colval(c2,i) > md*colval(c2,i) ||

Diff Legend

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