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.12 by greg, Sat Sep 22 10:45:42 1990 UTC vs.
Revision 2.2 by greg, Tue Jun 23 10:59:34 1992 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 14 | Line 14 | static char SCCSid[] = "$SunId$ LBL";
14  
15   #include  "color.h"
16  
17 + #define  MINELEN        8       /* minimum scanline length for encoding */
18 + #define  MINRUN         4       /* minimum run length */
19  
20 +
21 + char *
22 + tempbuffer(len)                 /* get a temporary buffer */
23 + unsigned  len;
24 + {
25 +        extern char  *malloc(), *realloc();
26 +        static char  *tempbuf = NULL;
27 +        static int  tempbuflen = 0;
28 +
29 +        if (len > tempbuflen) {
30 +                if (tempbuflen > 0)
31 +                        tempbuf = realloc(tempbuf, len);
32 +                else
33 +                        tempbuf = malloc(len);
34 +                tempbuflen = tempbuf==NULL ? 0 : len;
35 +        }
36 +        return(tempbuf);
37 + }
38 +
39 +
40   fwritecolrs(scanline, len, fp)          /* write out a colr scanline */
41   register COLR  *scanline;
42 < int  len;
42 > unsigned  len;
43   register FILE  *fp;
44   {
45 <        COLR  lastcolr;
46 <        int  rept;
45 >        register int  i, j, beg, cnt;
46 >        int  c2;
47          
48 <        lastcolr[RED] = lastcolr[GRN] = lastcolr[BLU] = 1;
49 <        lastcolr[EXP] = 0;
50 <        rept = 0;
51 <        
52 <        while (len > 0) {
53 <                if (scanline[0][EXP] == lastcolr[EXP] &&
54 <                                scanline[0][RED] == lastcolr[RED] &&
55 <                                scanline[0][GRN] == lastcolr[GRN] &&
56 <                                scanline[0][BLU] == lastcolr[BLU])
57 <                        rept++;
58 <                else {
59 <                        while (rept) {          /* write out count */
60 <                                putc(1, fp);
61 <                                putc(1, fp);
62 <                                putc(1, fp);
63 <                                putc(rept & 255, fp);
64 <                                rept >>= 8;
48 >        if (len < MINELEN | len > 0x7fff)       /* OOBs, write out flat */
49 >                return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
50 >                                        /* put magic header */
51 >        putc(2, fp);
52 >        putc(2, fp);
53 >        putc(len>>8, fp);
54 >        putc(len&255, fp);
55 >                                        /* put components seperately */
56 >        for (i = 0; i < 4; i++) {
57 >            for (j = 0; j < len; j += cnt) {    /* find next run */
58 >                for (beg = j; beg < len; beg += cnt) {
59 >                    for (cnt = 1; cnt < 127 && beg+cnt < len &&
60 >                            scanline[beg+cnt][i] == scanline[beg][i]; cnt++)
61 >                        ;
62 >                    if (cnt >= MINRUN)
63 >                        break;                  /* long enough */
64 >                }
65 >                if (beg-j > 1 && beg-j < MINRUN) {
66 >                    c2 = j+1;
67 >                    while (scanline[c2++][i] == scanline[j][i])
68 >                        if (c2 == beg) {        /* short run */
69 >                            putc(128+beg-j, fp);
70 >                            putc(scanline[j][i], fp);
71 >                            j = beg;
72 >                            break;
73                          }
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;
74                  }
75 <                scanline++;
76 <                len--;
75 >                while (j < beg) {               /* write out non-run */
76 >                    if ((c2 = beg-j) > 128) c2 = 128;
77 >                    putc(c2, fp);
78 >                    while (c2--)
79 >                        putc(scanline[j++][i], fp);
80 >                }
81 >                if (cnt >= MINRUN) {            /* write out run */
82 >                    putc(128+cnt, fp);
83 >                    putc(scanline[beg][i], fp);
84 >                } else
85 >                    cnt = 0;
86 >            }
87          }
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 –        }
88          return(ferror(fp) ? -1 : 0);
89   }
90  
91  
92 < freadcolrs(scanline, len, fp)           /* read in a colr scanline */
92 > freadcolrs(scanline, len, fp)           /* read in an encoded colr scanline */
93   register COLR  *scanline;
94   int  len;
95   register FILE  *fp;
96   {
97 +        register int  i, j;
98 +        int  code;
99 +                                        /* determine scanline type */
100 +        if (len < MINELEN)
101 +                return(oldreadcolrs(scanline, len, fp));
102 +        if ((i = getc(fp)) == EOF)
103 +                return(-1);
104 +        if (i != 2) {
105 +                ungetc(i, fp);
106 +                return(oldreadcolrs(scanline, len, fp));
107 +        }
108 +        scanline[0][GRN] = getc(fp);
109 +        scanline[0][BLU] = getc(fp);
110 +        if ((i = getc(fp)) == EOF)
111 +                return(-1);
112 +        if (scanline[0][GRN] != 2 || scanline[0][BLU] & 128) {
113 +                scanline[0][RED] = 2;
114 +                scanline[0][EXP] = i;
115 +                return(oldreadcolrs(scanline+1, len-1, fp));
116 +        }
117 +        if ((scanline[0][BLU]<<8 | i) != len)
118 +                return(-1);             /* length mismatch! */
119 +                                        /* read each component */
120 +        for (i = 0; i < 4; i++)
121 +            for (j = 0; j < len; ) {
122 +                if ((code = getc(fp)) == EOF)
123 +                    return(-1);
124 +                if (code > 128) {       /* run */
125 +                    scanline[j++][i] = getc(fp);
126 +                    for (code &= 127; --code; j++)
127 +                        scanline[j][i] = scanline[j-1][i];
128 +                } else                  /* non-run */
129 +                    while (code--)
130 +                        scanline[j++][i] = getc(fp);
131 +            }
132 +        return(feof(fp) ? -1 : 0);
133 + }
134 +
135 +
136 + oldreadcolrs(scanline, len, fp)         /* read in an old colr scanline */
137 + register COLR  *scanline;
138 + int  len;
139 + register FILE  *fp;
140 + {
141          int  rshift;
142          register int  i;
143          
# Line 101 | Line 172 | register FILE  *fp;
172   fwritescan(scanline, len, fp)           /* write out a scanline */
173   register COLOR  *scanline;
174   int  len;
175 < register FILE  *fp;
175 > FILE  *fp;
176   {
177 <        COLR  lastcolr, thiscolr;
178 <        int  rept;
179 <        
180 <        lastcolr[RED] = lastcolr[GRN] = lastcolr[BLU] = 1;
181 <        lastcolr[EXP] = 0;
182 <        rept = 0;
183 <        
184 <        while (len > 0) {
185 <                setcolr(thiscolr, scanline[0][RED],
177 >        COLR  *clrscan;
178 >        int  n;
179 >        register COLR  *sp;
180 >                                        /* get scanline buffer */
181 >        if ((sp = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
182 >                return(-1);
183 >        clrscan = sp;
184 >                                        /* convert scanline */
185 >        n = len;
186 >        while (n-- > 0) {
187 >                setcolr(sp[0], scanline[0][RED],
188                                    scanline[0][GRN],
189                                    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 –                }
190                  scanline++;
191 <                len--;
191 >                sp++;
192          }
193 <        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);
193 >        return(fwritecolrs(clrscan, len, fp));
194   }
195  
196  
197   freadscan(scanline, len, fp)            /* read in a scanline */
198   register COLOR  *scanline;
199   int  len;
200 < register FILE  *fp;
200 > FILE  *fp;
201   {
202 <        COLR  thiscolr;
203 <        int  rshift;
204 <        register int  i;
205 <        
206 <        rshift = 0;
207 <        
208 <        while (len > 0) {
209 <                thiscolr[RED] = getc(fp);
210 <                thiscolr[GRN] = getc(fp);
211 <                thiscolr[BLU] = getc(fp);
212 <                thiscolr[EXP] = getc(fp);
213 <                if (feof(fp) || ferror(fp))
214 <                        return(-1);
215 <                if (thiscolr[RED] == 1 &&
216 <                                thiscolr[GRN] == 1 &&
217 <                                thiscolr[BLU] == 1) {
218 <                        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 <                }
202 >        register COLR  *clrscan;
203 >
204 >        if ((clrscan = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
205 >                return(-1);
206 >        if (freadcolrs(clrscan, len, fp) < 0)
207 >                return(-1);
208 >                                        /* convert scanline */
209 >        colr_color(scanline[0], clrscan[0]);
210 >        while (--len > 0) {
211 >                scanline++; clrscan++;
212 >                if (clrscan[0][RED] == clrscan[-1][RED] &&
213 >                            clrscan[0][GRN] == clrscan[-1][GRN] &&
214 >                            clrscan[0][BLU] == clrscan[-1][BLU] &&
215 >                            clrscan[0][EXP] == clrscan[-1][EXP])
216 >                        copycolor(scanline[0], scanline[-1]);
217 >                else
218 >                        colr_color(scanline[0], clrscan[0]);
219          }
220          return(0);
221   }
# Line 225 | Line 260 | register COLR  clr;
260                  col[RED] = (clr[RED] + 0.5)*f;
261                  col[GRN] = (clr[GRN] + 0.5)*f;
262                  col[BLU] = (clr[BLU] + 0.5)*f;
228 –        }
229 – }
230 –
231 –
232 – normcolrs(scan, len, adjust)    /* normalize a scanline of colrs */
233 – register COLR  *scan;
234 – int  len;
235 – int  adjust;
236 – {
237 –        register int  c;
238 –        register int  shift;
239 –
240 –        while (len-- > 0) {
241 –                shift = scan[0][EXP] + adjust - COLXS;
242 –                if (shift > 0) {
243 –                        if (shift > 8) {
244 –                                scan[0][RED] =
245 –                                scan[0][GRN] =
246 –                                scan[0][BLU] = 255;
247 –                        } else {
248 –                                shift--;
249 –                                c = (scan[0][RED]<<1 | 1) << shift;
250 –                                scan[0][RED] = c > 255 ? 255 : c;
251 –                                c = (scan[0][GRN]<<1 | 1) << shift;
252 –                                scan[0][GRN] = c > 255 ? 255 : c;
253 –                                c = (scan[0][BLU]<<1 | 1) << shift;
254 –                                scan[0][BLU] = c > 255 ? 255 : c;
255 –                        }
256 –                } else if (shift < 0) {
257 –                        if (shift < -8) {
258 –                                scan[0][RED] =
259 –                                scan[0][GRN] =
260 –                                scan[0][BLU] = 0;
261 –                        } else {
262 –                                shift = -1-shift;
263 –                                scan[0][RED] = ((scan[0][RED]>>shift)+1)>>1;
264 –                                scan[0][GRN] = ((scan[0][GRN]>>shift)+1)>>1;
265 –                                scan[0][BLU] = ((scan[0][BLU]>>shift)+1)>>1;
266 –                        }
267 –                }
268 –                scan[0][EXP] = COLXS - adjust;
269 –                scan++;
263          }
264   }
265  

Diff Legend

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