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.13 by greg, Fri Oct 19 11:13:02 1990 UTC vs.
Revision 2.8 by greg, Sat Mar 26 13:44:38 1994 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1986 Regents of the University of California */
1 > /* Copyright (c) 1991 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 12 | Line 12 | static char SCCSid[] = "$SunId$ LBL";
12  
13   #include  <stdio.h>
14  
15 + #include  <math.h>
16 +
17   #include  "color.h"
18  
19 + #define  MINELEN        8       /* minimum scanline length for encoding */
20 + #define  MAXELEN        0x7fff  /* maximum scanline length for encoding */
21 + #define  MINRUN         4       /* minimum run length */
22  
23 +
24 + char *
25 + tempbuffer(len)                 /* get a temporary buffer */
26 + unsigned  len;
27 + {
28 +        extern char  *malloc(), *realloc();
29 +        static char  *tempbuf = NULL;
30 +        static unsigned  tempbuflen = 0;
31 +
32 +        if (len > tempbuflen) {
33 +                if (tempbuflen > 0)
34 +                        tempbuf = realloc(tempbuf, len);
35 +                else
36 +                        tempbuf = malloc(len);
37 +                tempbuflen = tempbuf==NULL ? 0 : len;
38 +        }
39 +        return(tempbuf);
40 + }
41 +
42 +
43   fwritecolrs(scanline, len, fp)          /* write out a colr scanline */
44   register COLR  *scanline;
45 < int  len;
45 > unsigned  len;
46   register FILE  *fp;
47   {
48 <        COLR  lastcolr;
49 <        int  rept;
48 >        register int  i, j, beg, cnt;
49 >        int  c2;
50          
51 <        lastcolr[RED] = lastcolr[GRN] = lastcolr[BLU] = 1;
52 <        lastcolr[EXP] = 0;
53 <        rept = 0;
54 <        
55 <        while (len > 0) {
56 <                if (scanline[0][EXP] == lastcolr[EXP] &&
57 <                                scanline[0][RED] == lastcolr[RED] &&
58 <                                scanline[0][GRN] == lastcolr[GRN] &&
59 <                                scanline[0][BLU] == lastcolr[BLU])
60 <                        rept++;
61 <                else {
62 <                        while (rept) {          /* write out count */
63 <                                putc(1, fp);
64 <                                putc(1, fp);
65 <                                putc(1, fp);
66 <                                putc(rept & 255, fp);
67 <                                rept >>= 8;
51 >        if (len < MINELEN | len > MAXELEN)      /* OOBs, write out flat */
52 >                return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
53 >                                        /* put magic header */
54 >        putc(2, fp);
55 >        putc(2, fp);
56 >        putc(len>>8, fp);
57 >        putc(len&255, fp);
58 >                                        /* put components seperately */
59 >        for (i = 0; i < 4; i++) {
60 >            for (j = 0; j < len; j += cnt) {    /* find next run */
61 >                for (beg = j; beg < len; beg += cnt) {
62 >                    for (cnt = 1; cnt < 127 && beg+cnt < len &&
63 >                            scanline[beg+cnt][i] == scanline[beg][i]; cnt++)
64 >                        ;
65 >                    if (cnt >= MINRUN)
66 >                        break;                  /* long enough */
67 >                }
68 >                if (beg-j > 1 && beg-j < MINRUN) {
69 >                    c2 = j+1;
70 >                    while (scanline[c2++][i] == scanline[j][i])
71 >                        if (c2 == beg) {        /* short run */
72 >                            putc(128+beg-j, fp);
73 >                            putc(scanline[j][i], fp);
74 >                            j = beg;
75 >                            break;
76                          }
44 –                        putc(scanline[0][RED], fp);     /* new color */
45 –                        putc(scanline[0][GRN], fp);
46 –                        putc(scanline[0][BLU], fp);
47 –                        putc(scanline[0][EXP], fp);
48 –                        copycolr(lastcolr, scanline[0]);
49 –                        rept = 0;
77                  }
78 <                scanline++;
79 <                len--;
78 >                while (j < beg) {               /* write out non-run */
79 >                    if ((c2 = beg-j) > 128) c2 = 128;
80 >                    putc(c2, fp);
81 >                    while (c2--)
82 >                        putc(scanline[j++][i], fp);
83 >                }
84 >                if (cnt >= MINRUN) {            /* write out run */
85 >                    putc(128+cnt, fp);
86 >                    putc(scanline[beg][i], fp);
87 >                } else
88 >                    cnt = 0;
89 >            }
90          }
54 –        while (rept) {          /* write out count */
55 –                putc(1, fp);
56 –                putc(1, fp);
57 –                putc(1, fp);
58 –                putc(rept & 255, fp);
59 –                rept >>= 8;
60 –        }
91          return(ferror(fp) ? -1 : 0);
92   }
93  
94  
95 < freadcolrs(scanline, len, fp)           /* read in a colr scanline */
95 > freadcolrs(scanline, len, fp)           /* read in an encoded colr scanline */
96   register COLR  *scanline;
97   int  len;
98   register FILE  *fp;
99   {
100 +        register int  i, j;
101 +        int  code, val;
102 +                                        /* determine scanline type */
103 +        if (len < MINELEN | len > MAXELEN)
104 +                return(oldreadcolrs(scanline, len, fp));
105 +        if ((i = getc(fp)) == EOF)
106 +                return(-1);
107 +        if (i != 2) {
108 +                ungetc(i, fp);
109 +                return(oldreadcolrs(scanline, len, fp));
110 +        }
111 +        scanline[0][GRN] = getc(fp);
112 +        scanline[0][BLU] = getc(fp);
113 +        if ((i = getc(fp)) == EOF)
114 +                return(-1);
115 +        if (scanline[0][GRN] != 2 || scanline[0][BLU] & 128) {
116 +                scanline[0][RED] = 2;
117 +                scanline[0][EXP] = i;
118 +                return(oldreadcolrs(scanline+1, len-1, fp));
119 +        }
120 +        if ((scanline[0][BLU]<<8 | i) != len)
121 +                return(-1);             /* length mismatch! */
122 +                                        /* read each component */
123 +        for (i = 0; i < 4; i++)
124 +            for (j = 0; j < len; ) {
125 +                if ((code = getc(fp)) == EOF)
126 +                    return(-1);
127 +                if (code > 128) {       /* run */
128 +                    code &= 127;
129 +                    val = getc(fp);
130 +                    while (code--)
131 +                        scanline[j++][i] = val;
132 +                } else                  /* non-run */
133 +                    while (code--)
134 +                        scanline[j++][i] = getc(fp);
135 +            }
136 +        return(feof(fp) ? -1 : 0);
137 + }
138 +
139 +
140 + oldreadcolrs(scanline, len, fp)         /* read in an old colr scanline */
141 + register COLR  *scanline;
142 + int  len;
143 + register FILE  *fp;
144 + {
145          int  rshift;
146          register int  i;
147          
# Line 101 | Line 176 | register FILE  *fp;
176   fwritescan(scanline, len, fp)           /* write out a scanline */
177   register COLOR  *scanline;
178   int  len;
179 < register FILE  *fp;
179 > FILE  *fp;
180   {
181 <        COLR  lastcolr, thiscolr;
182 <        int  rept;
183 <        
184 <        lastcolr[RED] = lastcolr[GRN] = lastcolr[BLU] = 1;
185 <        lastcolr[EXP] = 0;
186 <        rept = 0;
187 <        
188 <        while (len > 0) {
189 <                setcolr(thiscolr, scanline[0][RED],
181 >        COLR  *clrscan;
182 >        int  n;
183 >        register COLR  *sp;
184 >                                        /* get scanline buffer */
185 >        if ((sp = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
186 >                return(-1);
187 >        clrscan = sp;
188 >                                        /* convert scanline */
189 >        n = len;
190 >        while (n-- > 0) {
191 >                setcolr(sp[0], scanline[0][RED],
192                                    scanline[0][GRN],
193                                    scanline[0][BLU]);
117 –                if (thiscolr[EXP] == lastcolr[EXP] &&
118 –                                thiscolr[RED] == lastcolr[RED] &&
119 –                                thiscolr[GRN] == lastcolr[GRN] &&
120 –                                thiscolr[BLU] == lastcolr[BLU])
121 –                        rept++;
122 –                else {
123 –                        while (rept) {          /* write out count */
124 –                                putc(1, fp);
125 –                                putc(1, fp);
126 –                                putc(1, fp);
127 –                                putc(rept & 255, fp);
128 –                                rept >>= 8;
129 –                        }
130 –                        putc(thiscolr[RED], fp);        /* new color */
131 –                        putc(thiscolr[GRN], fp);
132 –                        putc(thiscolr[BLU], fp);
133 –                        putc(thiscolr[EXP], fp);
134 –                        copycolr(lastcolr, thiscolr);
135 –                        rept = 0;
136 –                }
194                  scanline++;
195 <                len--;
195 >                sp++;
196          }
197 <        while (rept) {          /* write out count */
141 <                putc(1, fp);
142 <                putc(1, fp);
143 <                putc(1, fp);
144 <                putc(rept & 255, fp);
145 <                rept >>= 8;
146 <        }
147 <        return(ferror(fp) ? -1 : 0);
197 >        return(fwritecolrs(clrscan, len, fp));
198   }
199  
200  
201   freadscan(scanline, len, fp)            /* read in a scanline */
202   register COLOR  *scanline;
203   int  len;
204 < register FILE  *fp;
204 > FILE  *fp;
205   {
206 <        COLR  thiscolr;
207 <        int  rshift;
208 <        register int  i;
209 <        
210 <        rshift = 0;
211 <        
212 <        while (len > 0) {
213 <                thiscolr[RED] = getc(fp);
214 <                thiscolr[GRN] = getc(fp);
215 <                thiscolr[BLU] = getc(fp);
216 <                thiscolr[EXP] = getc(fp);
217 <                if (feof(fp) || ferror(fp))
218 <                        return(-1);
219 <                if (thiscolr[RED] == 1 &&
220 <                                thiscolr[GRN] == 1 &&
221 <                                thiscolr[BLU] == 1) {
222 <                        for (i = thiscolr[EXP] << rshift; i > 0; i--) {
173 <                                copycolor(scanline[0], scanline[-1]);
174 <                                scanline++;
175 <                                len--;
176 <                        }
177 <                        rshift += 8;
178 <                } else {
179 <                        colr_color(scanline[0], thiscolr);
180 <                        scanline++;
181 <                        len--;
182 <                        rshift = 0;
183 <                }
206 >        register COLR  *clrscan;
207 >
208 >        if ((clrscan = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
209 >                return(-1);
210 >        if (freadcolrs(clrscan, len, fp) < 0)
211 >                return(-1);
212 >                                        /* convert scanline */
213 >        colr_color(scanline[0], clrscan[0]);
214 >        while (--len > 0) {
215 >                scanline++; clrscan++;
216 >                if (clrscan[0][RED] == clrscan[-1][RED] &&
217 >                            clrscan[0][GRN] == clrscan[-1][GRN] &&
218 >                            clrscan[0][BLU] == clrscan[-1][BLU] &&
219 >                            clrscan[0][EXP] == clrscan[-1][EXP])
220 >                        copycolor(scanline[0], scanline[-1]);
221 >                else
222 >                        colr_color(scanline[0], clrscan[0]);
223          }
224          return(0);
225   }
# Line 190 | Line 229 | setcolr(clr, r, g, b)          /* assign a short color value *
229   register COLR  clr;
230   double  r, g, b;
231   {
193 –        double  frexp();
232          double  d;
233          int  e;
234          
# Line 203 | Line 241 | double  r, g, b;
241                  return;
242          }
243  
244 <        d = frexp(d, &e) * 256.0 / d;
244 >        d = frexp(d, &e) * 255.9999 / d;
245  
246          clr[RED] = r * d;
247          clr[GRN] = g * d;

Diff Legend

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