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 1.14 by greg, Fri Aug 23 12:33:49 1991 UTC vs.
Revision 2.16 by greg, Wed Feb 9 00:00:17 2005 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 "copyright.h"
11 +
12   #include  <stdio.h>
13  
14 + #include  <stdlib.h>
15 +
16 + #include  <math.h>
17 +
18   #include  "color.h"
19  
20 + #ifdef getc_unlocked            /* avoid horrendous overhead of flockfile */
21 + #undef getc
22 + #undef putc
23 + #define getc    getc_unlocked
24 + #define putc    putc_unlocked
25 + #endif
26 +
27   #define  MINELEN        8       /* minimum scanline length for encoding */
28 + #define  MAXELEN        0x7fff  /* maximum scanline length for encoding */
29   #define  MINRUN         4       /* minimum run length */
30  
31  
32   char *
33   tempbuffer(len)                 /* get a temporary buffer */
34 < unsigned  len;
34 > unsigned int  len;
35   {
25 –        extern char  *malloc(), *realloc();
36          static char  *tempbuf = NULL;
37 <        static int  tempbuflen = 0;
37 >        static unsigned  tempbuflen = 0;
38  
39          if (len > tempbuflen) {
40                  if (tempbuflen > 0)
41 <                        tempbuf = realloc(tempbuf, len);
41 >                        tempbuf = (char *)realloc((void *)tempbuf, len);
42                  else
43 <                        tempbuf = malloc(len);
43 >                        tempbuf = (char *)malloc(len);
44                  tempbuflen = tempbuf==NULL ? 0 : len;
45          }
46          return(tempbuf);
47   }
48  
49  
50 + int
51   fwritecolrs(scanline, len, fp)          /* write out a colr scanline */
52   register COLR  *scanline;
53   int  len;
54   register FILE  *fp;
55   {
56 <        register int  i, j, beg, cnt;
56 >        register int  i, j, beg, cnt = 1;
57          int  c2;
58          
59 <        if (len < MINELEN)              /* too small to encode */
59 >        if ((len < MINELEN) | (len > MAXELEN))  /* OOBs, write out flat */
60                  return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
61 <        if (len > 32767)                /* too big! */
51 <                return(-1);
52 <        putc(2, fp);                    /* put magic header */
61 >                                        /* put magic header */
62          putc(2, fp);
63 +        putc(2, fp);
64          putc(len>>8, fp);
65          putc(len&255, fp);
66                                          /* put components seperately */
# Line 63 | Line 73 | register FILE  *fp;
73                      if (cnt >= MINRUN)
74                          break;                  /* long enough */
75                  }
76 <                while (j < beg) {               /* write out non-run(s) */
76 >                if (beg-j > 1 && beg-j < MINRUN) {
77 >                    c2 = j+1;
78 >                    while (scanline[c2++][i] == scanline[j][i])
79 >                        if (c2 == beg) {        /* short run */
80 >                            putc(128+beg-j, fp);
81 >                            putc(scanline[j][i], fp);
82 >                            j = beg;
83 >                            break;
84 >                        }
85 >                }
86 >                while (j < beg) {               /* write out non-run */
87                      if ((c2 = beg-j) > 128) c2 = 128;
88                      putc(c2, fp);
89                      while (c2--)
# Line 80 | Line 100 | register FILE  *fp;
100   }
101  
102  
103 + static int
104 + oldreadcolrs(scanline, len, fp)         /* read in an old colr scanline */
105 + register COLR  *scanline;
106 + int  len;
107 + register FILE  *fp;
108 + {
109 +        int  rshift;
110 +        register int  i;
111 +        
112 +        rshift = 0;
113 +        
114 +        while (len > 0) {
115 +                scanline[0][RED] = getc(fp);
116 +                scanline[0][GRN] = getc(fp);
117 +                scanline[0][BLU] = getc(fp);
118 +                scanline[0][EXP] = getc(fp);
119 +                if (feof(fp) || ferror(fp))
120 +                        return(-1);
121 +                if (scanline[0][RED] == 1 &&
122 +                                scanline[0][GRN] == 1 &&
123 +                                scanline[0][BLU] == 1) {
124 +                        for (i = scanline[0][EXP] << rshift; i > 0; i--) {
125 +                                copycolr(scanline[0], scanline[-1]);
126 +                                scanline++;
127 +                                len--;
128 +                        }
129 +                        rshift += 8;
130 +                } else {
131 +                        scanline++;
132 +                        len--;
133 +                        rshift = 0;
134 +                }
135 +        }
136 +        return(0);
137 + }
138 +
139 +
140 + int
141   freadcolrs(scanline, len, fp)           /* read in an encoded colr scanline */
142   register COLR  *scanline;
143   int  len;
144   register FILE  *fp;
145   {
146          register int  i, j;
147 <        int  code;
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 113 | 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;
130 < register FILE  *fp;
131 < {
132 <        int  rshift;
133 <        register int  i;
134 <        
135 <        rshift = 0;
136 <        
137 <        while (len > 0) {
138 <                scanline[0][RED] = getc(fp);
139 <                scanline[0][GRN] = getc(fp);
140 <                scanline[0][BLU] = getc(fp);
141 <                scanline[0][EXP] = getc(fp);
142 <                if (feof(fp) || ferror(fp))
143 <                        return(-1);
144 <                if (scanline[0][RED] == 1 &&
145 <                                scanline[0][GRN] == 1 &&
146 <                                scanline[0][BLU] == 1) {
147 <                        for (i = scanline[0][EXP] << rshift; i > 0; i--) {
148 <                                copycolr(scanline[0], scanline[-1]);
149 <                                scanline++;
150 <                                len--;
151 <                        }
152 <                        rshift += 8;
153 <                } else {
154 <                        scanline++;
155 <                        len--;
156 <                        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 + int
196   fwritescan(scanline, len, fp)           /* write out a scanline */
197   register COLOR  *scanline;
198   int  len;
# Line 185 | Line 218 | FILE  *fp;
218   }
219  
220  
221 + int
222   freadscan(scanline, len, fp)            /* read in a scanline */
223   register COLOR  *scanline;
224   int  len;
# Line 212 | Line 246 | FILE  *fp;
246   }
247  
248  
249 + void
250   setcolr(clr, r, g, b)           /* assign a short color value */
251   register COLR  clr;
252   double  r, g, b;
253   {
219 –        double  frexp();
254          double  d;
255          int  e;
256          
# Line 229 | Line 263 | double  r, g, b;
263                  return;
264          }
265  
266 <        d = frexp(d, &e) * 256.0 / d;
266 >        d = frexp(d, &e) * 255.9999 / d;
267  
268 <        clr[RED] = r * d;
269 <        clr[GRN] = g * d;
270 <        clr[BLU] = b * d;
268 >        if (r > 0.0)
269 >                clr[RED] = r * d;
270 >        else
271 >                clr[RED] = 0;
272 >        if (g > 0.0)
273 >                clr[GRN] = g * d;
274 >        else
275 >                clr[GRN] = 0;
276 >        if (b > 0.0)
277 >                clr[BLU] = b * d;
278 >        else
279 >                clr[BLU] = 0;
280 >
281          clr[EXP] = e + COLXS;
282   }
283  
284  
285 + void
286   colr_color(col, clr)            /* convert short to float color */
287   register COLOR  col;
288   register COLR  clr;
# Line 255 | Line 300 | register COLR  clr;
300   }
301  
302  
303 + int
304   bigdiff(c1, c2, md)                     /* c1 delta c2 > md? */
305   register COLOR  c1, c2;
306   double  md;

Diff Legend

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