src/common/color.c

#ifndef lint
static const char       RCSid[] = "$Id: color.c,v 2.16 2005/02/09 00:00:17 greg Exp $";
#endif
/*
 *  color.c - routines for color calculations.
 *
 *  Externals declared in color.h
 */

#include "copyright.h"

#include  <stdio.h>
#include  <stdlib.h>
#include  <math.h>
#include  "color.h"

#ifdef getc_unlocked            /* avoid horrendous overhead of flockfile */
#undef getc
#undef putc
#define getc    getc_unlocked
#define putc    putc_unlocked
#endif

#define  MINELEN        8       /* minimum scanline length for encoding */
#define  MAXELEN        0x7fff  /* maximum scanline length for encoding */
#define  MINRUN         4       /* minimum run length */


char *
tempbuffer(                     /* get a temporary buffer */
        unsigned int  len
)
{
        static char  *tempbuf = NULL;
        static unsigned  tempbuflen = 0;

        if (len > tempbuflen) {
                if (tempbuflen > 0)
                        tempbuf = (char *)realloc((void *)tempbuf, len);
                else
                        tempbuf = (char *)malloc(len);
                tempbuflen = tempbuf==NULL ? 0 : len;
        }
        return(tempbuf);
}


int
fwritecolrs(                    /* write out a colr scanline */
        COLR  *scanline,
        int  len,
        FILE  *fp
)
{
        int  i, j, beg, cnt = 1;
        int  c2;
        
        if ((len < MINELEN) | (len > MAXELEN))  /* OOBs, write out flat */
                return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
                                        /* put magic header */
        putc(2, fp);
        putc(2, fp);
        putc(len>>8, fp);
        putc(len&255, fp);
                                        /* put components seperately */
        for (i = 0; i < 4; i++) {
            for (j = 0; j < len; j += cnt) {    /* find next run */
                for (beg = j; beg < len; beg += cnt) {
                    for (cnt = 1; cnt < 127 && beg+cnt < len &&
                            scanline[beg+cnt][i] == scanline[beg][i]; cnt++)
                        ;
                    if (cnt >= MINRUN)
                        break;                  /* long enough */
                }
                if (beg-j > 1 && beg-j < MINRUN) {
                    c2 = j+1;
                    while (scanline[c2++][i] == scanline[j][i])
                        if (c2 == beg) {        /* short run */
                            putc(128+beg-j, fp);
                            putc(scanline[j][i], fp);
                            j = beg;
                            break;
                        }
                }
                while (j < beg) {               /* write out non-run */
                    if ((c2 = beg-j) > 128) c2 = 128;
                    putc(c2, fp);
                    while (c2--)
                        putc(scanline[j++][i], fp);
                }
                if (cnt >= MINRUN) {            /* write out run */
                    putc(128+cnt, fp);
                    putc(scanline[beg][i], fp);
                } else
                    cnt = 0;
            }
        }
        return(ferror(fp) ? -1 : 0);
}


static int
oldreadcolrs(                   /* read in an old colr scanline */
        COLR  *scanline,
        int  len,
        FILE  *fp
)
{
        int  rshift;
        int  i;
        
        rshift = 0;
        
        while (len > 0) {
                scanline[0][RED] = getc(fp);
                scanline[0][GRN] = getc(fp);
                scanline[0][BLU] = getc(fp);
                scanline[0][EXP] = getc(fp);
                if (feof(fp) || ferror(fp))
                        return(-1);
                if (scanline[0][RED] == 1 &&
                                scanline[0][GRN] == 1 &&
                                scanline[0][BLU] == 1) {
                        for (i = scanline[0][EXP] << rshift; i > 0; i--) {
                                copycolr(scanline[0], scanline[-1]);
                                scanline++;
                                len--;
                        }
                        rshift += 8;
                } else {
                        scanline++;
                        len--;
                        rshift = 0;
                }
        }
        return(0);
}


int
freadcolrs(                     /* read in an encoded colr scanline */
        COLR  *scanline,
        int  len,
        FILE  *fp
)
{
        int  i, j;
        int  code, val;
                                        /* determine scanline type */
        if ((len < MINELEN) | (len > MAXELEN))
                return(oldreadcolrs(scanline, len, fp));
        if ((i = getc(fp)) == EOF)
                return(-1);
        if (i != 2) {
                ungetc(i, fp);
                return(oldreadcolrs(scanline, len, fp));
        }
        scanline[0][GRN] = getc(fp);
        scanline[0][BLU] = getc(fp);
        if ((i = getc(fp)) == EOF)
                return(-1);
        if (scanline[0][GRN] != 2 || scanline[0][BLU] & 128) {
                scanline[0][RED] = 2;
                scanline[0][EXP] = i;
                return(oldreadcolrs(scanline+1, len-1, fp));
        }
        if ((scanline[0][BLU]<<8 | i) != len)
                return(-1);             /* length mismatch! */
                                        /* read each component */
        for (i = 0; i < 4; i++)
            for (j = 0; j < len; ) {
                if ((code = getc(fp)) == EOF)
                    return(-1);
                if (code > 128) {       /* run */
                    code &= 127;
                    if ((val = getc(fp)) == EOF)
                        return -1;
                    if (j + code > len)
                        return -1;      /* overrun */
                    while (code--)
                        scanline[j++][i] = val;
                } else {                /* non-run */
                    if (j + code > len)
                        return -1;      /* overrun */
                    while (code--) {
                        if ((val = getc(fp)) == EOF)
                            return -1;
                        scanline[j++][i] = val;
                    }
                }
            }
        return(0);
}


int
fwritescan(                     /* write out a scanline */
        COLOR  *scanline,
        int  len,
        FILE  *fp
)
{
        COLR  *clrscan;
        int  n;
        COLR  *sp;
                                        /* get scanline buffer */
        if ((sp = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
                return(-1);
        clrscan = sp;
                                        /* convert scanline */
        n = len;
        while (n-- > 0) {
                setcolr(sp[0], scanline[0][RED],
                                  scanline[0][GRN],
                                  scanline[0][BLU]);
                scanline++;
                sp++;
        }
        return(fwritecolrs(clrscan, len, fp));
}


int
freadscan(                      /* read in a scanline */
        COLOR  *scanline,
        int  len,
        FILE  *fp
)
{
        COLR  *clrscan;

        if ((clrscan = (COLR *)tempbuffer(len*sizeof(COLR))) == NULL)
                return(-1);
        if (freadcolrs(clrscan, len, fp) < 0)
                return(-1);
                                        /* convert scanline */
        colr_color(scanline[0], clrscan[0]);
        while (--len > 0) {
                scanline++; clrscan++;
                if (clrscan[0][RED] == clrscan[-1][RED] &&
                            clrscan[0][GRN] == clrscan[-1][GRN] &&
                            clrscan[0][BLU] == clrscan[-1][BLU] &&
                            clrscan[0][EXP] == clrscan[-1][EXP])
                        copycolor(scanline[0], scanline[-1]);
                else
                        colr_color(scanline[0], clrscan[0]);
        }
        return(0);
}


void
setcolr(                        /* assign a short color value */
        COLR  clr,
        double  r,
        double  g,
        double  b
)
{
        double  d;
        int  e;
        
        d = r > g ? r : g;
        if (b > d) d = b;

        if (d <= 1e-32) {
                clr[RED] = clr[GRN] = clr[BLU] = 0;
                clr[EXP] = 0;
                return;
        }

        d = frexp(d, &e) * 255.9999 / d;

        if (r > 0.0)
                clr[RED] = r * d;
        else
                clr[RED] = 0;
        if (g > 0.0)
                clr[GRN] = g * d;
        else
                clr[GRN] = 0;
        if (b > 0.0)
                clr[BLU] = b * d;
        else
                clr[BLU] = 0;

        clr[EXP] = e + COLXS;
}


void
colr_color(                     /* convert short to float color */
        COLOR  col,
        COLR  clr
)
{
        double  f;
        
        if (clr[EXP] == 0)
                col[RED] = col[GRN] = col[BLU] = 0.0;
        else {
                f = ldexp(1.0, (int)clr[EXP]-(COLXS+8));
                col[RED] = (clr[RED] + 0.5)*f;
                col[GRN] = (clr[GRN] + 0.5)*f;
                col[BLU] = (clr[BLU] + 0.5)*f;
        }
}


int
bigdiff(                                /* c1 delta c2 > md? */
        COLOR  c1,
        COLOR  c2,
        double  md
)
{
        int  i;

        for (i = 0; i < 3; i++)
                if (colval(c1,i)-colval(c2,i) > md*colval(c2,i) ||
                        colval(c2,i)-colval(c1,i) > md*colval(c1,i))
                        return(1);
        return(0);
}
Revision:	2.17
Committed:	Sat May 31 20:13:31 2014 UTC (9 years, 11 months ago) by greg
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rad4R2P2, rad5R0, rad5R1, rad4R2, rad4R2P1
Changes since 2.16:	+50 -41 lines
Log Message:	Long overdue ANSIfication
#	User	Rev	Content
1	greg	1.1	#ifndef lint
2	greg	2.17	static const char RCSid[] = "$Id: color.c,v 2.16 2005/02/09 00:00:17 greg Exp $";
3	greg	1.1	#endif
4			/*
5			* color.c - routines for color calculations.
6			*
7	greg	2.9	* Externals declared in color.h
8			*/
9
10	greg	2.10	#include "copyright.h"
11	greg	1.1
12			#include <stdio.h>
13	greg	2.9	#include <stdlib.h>
14	greg	2.7	#include <math.h>
15	greg	1.1	#include "color.h"
16	greg	2.14
17			#ifdef getc_unlocked /* avoid horrendous overhead of flockfile */
18	greg	2.15	#undef getc
19			#undef putc
20	greg	2.14	#define getc getc_unlocked
21			#define putc putc_unlocked
22			#endif
23	greg	1.1
24	greg	1.14	#define MINELEN 8 /* minimum scanline length for encoding */
25	greg	2.6	#define MAXELEN 0x7fff /* maximum scanline length for encoding */
26	greg	1.14	#define MINRUN 4 /* minimum run length */
27
28	greg	2.4
29	greg	1.14	char *
30	greg	2.17	tempbuffer( /* get a temporary buffer */
31			unsigned int len
32			)
33	greg	1.14	{
34			static char *tempbuf = NULL;
35	greg	2.5	static unsigned tempbuflen = 0;
36	greg	1.14
37			if (len > tempbuflen) {
38			if (tempbuflen > 0)
39	greg	2.12	tempbuf = (char )realloc((void )tempbuf, len);
40	greg	1.14	else
41	greg	2.9	tempbuf = (char *)malloc(len);
42	greg	1.14	tempbuflen = tempbuf==NULL ? 0 : len;
43			}
44			return(tempbuf);
45			}
46
47
48	greg	2.9	int
49	greg	2.17	fwritecolrs( /* write out a colr scanline */
50			COLR *scanline,
51			int len,
52			FILE *fp
53			)
54	greg	1.1	{
55	greg	2.17	int i, j, beg, cnt = 1;
56	greg	1.14	int c2;
57	greg	1.1
58	schorsch	2.13	if ((len < MINELEN) \| (len > MAXELEN)) /* OOBs, write out flat */
59	greg	1.14	return(fwrite((char *)scanline,sizeof(COLR),len,fp) - len);
60	greg	2.2	/* put magic header */
61			putc(2, fp);
62	greg	1.14	putc(2, fp);
63			putc(len>>8, fp);
64			putc(len&255, fp);
65			/* put components seperately */
66			for (i = 0; i < 4; i++) {
67			for (j = 0; j < len; j += cnt) { /* find next run */
68			for (beg = j; beg < len; beg += cnt) {
69			for (cnt = 1; cnt < 127 && beg+cnt < len &&
70			scanline[beg+cnt][i] == scanline[beg][i]; cnt++)
71			;
72			if (cnt >= MINRUN)
73			break; /* long enough */
74	greg	1.1	}
75	greg	1.15	if (beg-j > 1 && beg-j < MINRUN) {
76			c2 = j+1;
77			while (scanline[c2++][i] == scanline[j][i])
78			if (c2 == beg) { /* short run */
79			putc(128+beg-j, fp);
80			putc(scanline[j][i], fp);
81			j = beg;
82			break;
83			}
84			}
85			while (j < beg) { /* write out non-run */
86	greg	1.14	if ((c2 = beg-j) > 128) c2 = 128;
87			putc(c2, fp);
88			while (c2--)
89			putc(scanline[j++][i], fp);
90			}
91			if (cnt >= MINRUN) { /* write out run */
92			putc(128+cnt, fp);
93			putc(scanline[beg][i], fp);
94			} else
95			cnt = 0;
96			}
97	greg	1.1	}
98			return(ferror(fp) ? -1 : 0);
99			}
100
101
102	greg	2.9	static int
103	greg	2.17	oldreadcolrs( /* read in an old colr scanline */
104			COLR *scanline,
105			int len,
106			FILE *fp
107			)
108	greg	2.9	{
109			int rshift;
110	greg	2.17	int i;
111	greg	2.9
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	greg	2.17	freadcolrs( /* read in an encoded colr scanline */
142			COLR *scanline,
143			int len,
144			FILE *fp
145			)
146	greg	1.1	{
147	greg	2.17	int i, j;
148	greg	2.6	int code, val;
149	greg	1.14	/* determine scanline type */
150	schorsch	2.13	if ((len < MINELEN) \| (len > MAXELEN))
151	greg	1.14	return(oldreadcolrs(scanline, len, fp));
152			if ((i = getc(fp)) == EOF)
153			return(-1);
154			if (i != 2) {
155			ungetc(i, fp);
156			return(oldreadcolrs(scanline, len, fp));
157			}
158			scanline[0][GRN] = getc(fp);
159			scanline[0][BLU] = getc(fp);
160			if ((i = getc(fp)) == EOF)
161			return(-1);
162			if (scanline[0][GRN] != 2 \|\| scanline[0][BLU] & 128) {
163			scanline[0][RED] = 2;
164			scanline[0][EXP] = i;
165			return(oldreadcolrs(scanline+1, len-1, fp));
166			}
167			if ((scanline[0][BLU]<<8 \| i) != len)
168			return(-1); /* length mismatch! */
169			/* read each component */
170			for (i = 0; i < 4; i++)
171			for (j = 0; j < len; ) {
172			if ((code = getc(fp)) == EOF)
173			return(-1);
174			if (code > 128) { /* run */
175	greg	2.6	code &= 127;
176	greg	2.9	if ((val = getc(fp)) == EOF)
177			return -1;
178	greg	2.16	if (j + code > len)
179			return -1; /* overrun */
180	greg	2.6	while (code--)
181			scanline[j++][i] = val;
182	greg	2.16	} else { /* non-run */
183			if (j + code > len)
184			return -1; /* overrun */
185	greg	2.9	while (code--) {
186			if ((val = getc(fp)) == EOF)
187			return -1;
188			scanline[j++][i] = val;
189			}
190	greg	2.16	}
191	greg	1.14	}
192	greg	1.1	return(0);
193			}
194
195
196	greg	2.9	int
197	greg	2.17	fwritescan( /* write out a scanline */
198			COLOR *scanline,
199			int len,
200			FILE *fp
201			)
202	greg	1.1	{
203	greg	1.14	COLR *clrscan;
204			int n;
205	greg	2.17	COLR *sp;
206	greg	1.14	/* get scanline buffer */
207			if ((sp = (COLR )tempbuffer(lensizeof(COLR))) == NULL)
208			return(-1);
209			clrscan = sp;
210			/* convert scanline */
211			n = len;
212			while (n-- > 0) {
213			setcolr(sp[0], scanline[0][RED],
214	greg	1.1	scanline[0][GRN],
215			scanline[0][BLU]);
216			scanline++;
217	greg	1.14	sp++;
218	greg	1.1	}
219	greg	1.14	return(fwritecolrs(clrscan, len, fp));
220	greg	1.1	}
221
222
223	greg	2.9	int
224	greg	2.17	freadscan( /* read in a scanline */
225			COLOR *scanline,
226			int len,
227			FILE *fp
228			)
229	greg	1.1	{
230	greg	2.17	COLR *clrscan;
231	greg	1.14
232			if ((clrscan = (COLR )tempbuffer(lensizeof(COLR))) == NULL)
233			return(-1);
234			if (freadcolrs(clrscan, len, fp) < 0)
235			return(-1);
236			/* convert scanline */
237			colr_color(scanline[0], clrscan[0]);
238			while (--len > 0) {
239			scanline++; clrscan++;
240			if (clrscan[0][RED] == clrscan[-1][RED] &&
241			clrscan[0][GRN] == clrscan[-1][GRN] &&
242			clrscan[0][BLU] == clrscan[-1][BLU] &&
243			clrscan[0][EXP] == clrscan[-1][EXP])
244			copycolor(scanline[0], scanline[-1]);
245			else
246			colr_color(scanline[0], clrscan[0]);
247	greg	1.1	}
248			return(0);
249			}
250
251
252	greg	2.9	void
253	greg	2.17	setcolr( /* assign a short color value */
254			COLR clr,
255			double r,
256			double g,
257			double b
258			)
259	greg	1.1	{
260			double d;
261			int e;
262
263			d = r > g ? r : g;
264			if (b > d) d = b;
265
266	greg	1.4	if (d <= 1e-32) {
267	greg	1.1	clr[RED] = clr[GRN] = clr[BLU] = 0;
268			clr[EXP] = 0;
269			return;
270			}
271
272	greg	2.8	d = frexp(d, &e) * 255.9999 / d;
273	greg	1.1
274	greg	2.11	if (r > 0.0)
275			clr[RED] = r * d;
276			else
277			clr[RED] = 0;
278			if (g > 0.0)
279			clr[GRN] = g * d;
280			else
281			clr[GRN] = 0;
282			if (b > 0.0)
283			clr[BLU] = b * d;
284			else
285			clr[BLU] = 0;
286
287	greg	1.1	clr[EXP] = e + COLXS;
288			}
289
290
291	greg	2.9	void
292	greg	2.17	colr_color( /* convert short to float color */
293			COLOR col,
294			COLR clr
295			)
296	greg	1.1	{
297	greg	1.6	double f;
298	greg	1.1
299			if (clr[EXP] == 0)
300			col[RED] = col[GRN] = col[BLU] = 0.0;
301			else {
302	greg	1.2	f = ldexp(1.0, (int)clr[EXP]-(COLXS+8));
303	greg	1.1	col[RED] = (clr[RED] + 0.5)*f;
304			col[GRN] = (clr[GRN] + 0.5)*f;
305			col[BLU] = (clr[BLU] + 0.5)*f;
306			}
307	greg	1.6	}
308
309
310	greg	2.9	int
311	greg	2.17	bigdiff( /* c1 delta c2 > md? */
312			COLOR c1,
313			COLOR c2,
314			double md
315			)
316	greg	1.7	{
317	greg	2.17	int i;
318	greg	1.7
319			for (i = 0; i < 3; i++)
320			if (colval(c1,i)-colval(c2,i) > md*colval(c2,i) \|\|
321			colval(c2,i)-colval(c1,i) > md*colval(c1,i))
322			return(1);
323			return(0);
324			}