ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/src/px/pvalue.c
Revision: 2.25
Committed: Fri Jan 2 12:47:01 2004 UTC (21 years, 10 months ago) by schorsch
Content type: text/plain
Branch: MAIN
Changes since 2.24: +9 -5 lines
Log Message: 
Fixed typing/prototype of getheader() and its callback.

File Contents

# User Rev Content
1 greg 1.1 #ifndef lint
2 schorsch 2.25 static const char RCSid[] = "$Id: pvalue.c,v 2.24 2003/10/22 02:06:35 greg Exp $";
3 greg 1.1 #endif
4     /*
5     * pvalue.c - program to print pixel values.
6     *
7     * 4/23/86
8     */
9    
10 greg 2.24 #include "platform.h"
11 greg 1.8 #include "standard.h"
12 greg 1.1 #include "color.h"
13 greg 1.8 #include "resolu.h"
14 greg 2.15
15 greg 2.5 #define min(a,b) ((a)<(b)?(a):(b))
16 greg 1.1
17 greg 2.10 /* what to put out (also RED, GRN, BLU) */
18     #define ALL 3
19     #define BRIGHT 4
20    
21 greg 2.5 RESOLU picres; /* resolution of picture */
22 greg 1.1
23 greg 1.6 int uniq = 0; /* print only unique values? */
24 greg 1.1
25 greg 2.7 int doexposure = 0; /* exposure change? (>100 to print) */
26 greg 1.1
27     int dataonly = 0; /* data only format? */
28    
29 greg 2.10 int putprim = ALL; /* what to put out */
30 greg 1.1
31     int reverse = 0; /* reverse conversion? */
32    
33     int format = 'a'; /* input/output format */
34 greg 1.6 char *fmtid = "ascii"; /* format identifier for header */
35 greg 1.1
36 greg 2.3 int header = 1; /* do header? */
37 greg 1.1
38 greg 2.10 long skipbytes = 0; /* skip bytes in input? */
39    
40 greg 2.23 int swapbytes = 0; /* swap bytes? */
41 greg 2.16
42 greg 2.12 int interleave = 1; /* file is interleaved? */
43    
44 greg 2.3 int resolution = 1; /* put/get resolution string? */
45    
46 greg 2.7 int original = 0; /* convert to original values? */
47    
48 greg 1.6 int wrongformat = 0; /* wrong input format? */
49    
50 greg 2.5 double gamcor = 1.0; /* gamma correction */
51 greg 1.7
52 greg 2.4 int ord[3] = {RED, GRN, BLU}; /* RGB ordering */
53     int rord[4]; /* reverse ordering */
54    
55 greg 1.5 COLOR exposure = WHTCOLOR;
56 greg 1.1
57     char *progname;
58    
59     FILE *fin;
60 greg 2.10 FILE *fin2 = NULL, *fin3 = NULL; /* for other color channels */
61 greg 1.1
62     int (*getval)(), (*putval)();
63    
64 schorsch 2.25 static gethfunc checkhead;
65    
66    
67 greg 2.14 double
68     rgb_bright(clr)
69     COLOR clr;
70     {
71     return(bright(clr));
72     }
73    
74     double
75     xyz_bright(clr)
76     COLOR clr;
77     {
78     return(clr[CIEY]);
79     }
80    
81     double (*mybright)() = &rgb_bright;
82    
83 greg 1.1
84     main(argc, argv)
85     int argc;
86     char **argv;
87     {
88 greg 2.10 extern long atol();
89 greg 2.7 double d, expval = 1.0;
90 greg 1.1 int i;
91    
92     progname = argv[0];
93    
94     for (i = 1; i < argc; i++)
95 greg 1.8 if (argv[i][0] == '-' || argv[i][0] == '+')
96 greg 1.1 switch (argv[i][1]) {
97 greg 1.8 case 'h': /* header */
98     header = argv[i][0] == '+';
99 greg 1.1 break;
100 greg 2.3 case 'H': /* resolution string */
101     resolution = argv[i][0] == '+';
102     break;
103 greg 2.10 case 's': /* skip bytes in header */
104     skipbytes = atol(argv[++i]);
105     break;
106 greg 1.1 case 'u': /* unique values */
107 greg 1.8 uniq = argv[i][0] == '-';
108 greg 1.1 break;
109     case 'o': /* original values */
110 greg 1.8 original = argv[i][0] == '-';
111 greg 1.1 break;
112 greg 1.7 case 'g': /* gamma correction */
113 greg 2.7 gamcor = atof(argv[i+1]);
114 greg 1.8 if (argv[i][0] == '+')
115     gamcor = 1.0/gamcor;
116 greg 2.7 i++;
117 greg 1.7 break;
118 greg 2.7 case 'e': /* exposure correction */
119     d = atof(argv[i+1]);
120     if (argv[i+1][0] == '-' || argv[i+1][0] == '+')
121     d = pow(2.0, d);
122     if (argv[i][0] == '-')
123 greg 2.9 expval *= d;
124 greg 2.7 scalecolor(exposure, d);
125     doexposure++;
126     i++;
127     break;
128 greg 2.4 case 'R': /* reverse byte sequence */
129     if (argv[i][0] == '-') {
130     ord[0]=BLU; ord[1]=GRN; ord[2]=RED;
131     } else {
132     ord[0]=RED; ord[1]=GRN; ord[2]=BLU;
133     }
134     break;
135 greg 1.1 case 'r': /* reverse conversion */
136 greg 1.8 reverse = argv[i][0] == '-';
137 greg 1.1 break;
138 greg 2.12 case 'n': /* non-interleaved RGB */
139     interleave = argv[i][0] == '+';
140     break;
141 greg 1.1 case 'b': /* brightness values */
142 greg 2.10 putprim = argv[i][0] == '-' ? BRIGHT : ALL;
143 greg 1.1 break;
144 greg 2.10 case 'p': /* put primary */
145     switch (argv[i][2]) {
146     case 'r': case 'R': putprim = RED; break;
147     case 'g': case 'G': putprim = GRN; break;
148     case 'b': case 'B': putprim = BLU; break;
149     default: goto unkopt;
150     }
151     break;
152 greg 1.1 case 'd': /* data only (no indices) */
153 greg 1.8 dataonly = argv[i][0] == '-';
154 greg 1.1 switch (argv[i][2]) {
155     case '\0':
156     case 'a': /* ascii */
157     format = 'a';
158 greg 1.6 fmtid = "ascii";
159 greg 1.1 break;
160     case 'i': /* integer */
161 greg 1.6 format = 'i';
162     fmtid = "ascii";
163     break;
164 greg 1.1 case 'b': /* byte */
165 greg 1.8 dataonly = 1;
166 greg 1.6 format = 'b';
167     fmtid = "byte";
168     break;
169 greg 2.16 case 'W': /* 16-bit swapped */
170     swapbytes = 1;
171 greg 2.15 case 'w': /* 16-bit */
172     dataonly = 1;
173     format = 'w';
174     fmtid = "16-bit";
175     break;
176 greg 2.23 case 'F': /* swapped floats */
177     swapbytes = 1;
178 greg 1.1 case 'f': /* float */
179 greg 1.8 dataonly = 1;
180 greg 1.6 format = 'f';
181     fmtid = "float";
182     break;
183 greg 2.23 case 'D': /* swapped doubles */
184     swapbytes = 1;
185 greg 1.1 case 'd': /* double */
186 greg 1.8 dataonly = 1;
187 greg 1.6 format = 'd';
188     fmtid = "double";
189 greg 1.1 break;
190     default:
191     goto unkopt;
192     }
193     break;
194     case 'x': /* x resolution */
195 greg 2.6 case 'X': /* x resolution */
196 greg 2.3 resolution = 0;
197 greg 1.8 if (argv[i][0] == '-')
198 greg 2.14 picres.rt |= XDECR;
199 greg 1.8 picres.xr = atoi(argv[++i]);
200 greg 1.1 break;
201     case 'y': /* y resolution */
202 greg 2.6 case 'Y': /* y resolution */
203 greg 2.3 resolution = 0;
204 greg 1.8 if (argv[i][0] == '-')
205 greg 2.14 picres.rt |= YDECR;
206 greg 1.8 if (picres.xr == 0)
207 greg 2.14 picres.rt |= YMAJOR;
208 greg 1.8 picres.yr = atoi(argv[++i]);
209 greg 1.1 break;
210     default:
211     unkopt:
212     fprintf(stderr, "%s: unknown option: %s\n",
213     progname, argv[i]);
214     quit(1);
215     break;
216     }
217     else
218     break;
219 greg 1.6 /* recognize special formats */
220 schorsch 2.22 if (dataonly && format == 'b') {
221 greg 2.17 if (putprim == ALL)
222     fmtid = "24-bit_rgb";
223     else
224 greg 1.6 fmtid = "8-bit_grey";
225 schorsch 2.22 }
226     if (dataonly && format == 'w') {
227 greg 2.17 if (putprim == ALL)
228     fmtid = "48-bit_rgb";
229 greg 1.6 else
230 greg 2.15 fmtid = "16-bit_grey";
231 schorsch 2.22 }
232 greg 2.4 /* assign reverse ordering */
233     rord[ord[0]] = 0;
234     rord[ord[1]] = 1;
235     rord[ord[2]] = 2;
236     /* get input */
237 greg 1.1 if (i == argc) {
238     fin = stdin;
239 greg 2.10 } else if (i < argc) {
240 greg 1.1 if ((fin = fopen(argv[i], "r")) == NULL) {
241     fprintf(stderr, "%s: can't open file \"%s\"\n",
242     progname, argv[i]);
243     quit(1);
244     }
245 greg 2.17 if (reverse && putprim != BRIGHT && i == argc-3) {
246 greg 2.10 if ((fin2 = fopen(argv[i+1], "r")) == NULL) {
247     fprintf(stderr, "%s: can't open file \"%s\"\n",
248     progname, argv[i+1]);
249     quit(1);
250     }
251     if ((fin3 = fopen(argv[i+2], "r")) == NULL) {
252     fprintf(stderr, "%s: can't open file \"%s\"\n",
253     progname, argv[i+2]);
254     quit(1);
255     }
256 greg 2.12 interleave = -1;
257 greg 2.10 } else if (i != argc-1)
258     fin = NULL;
259 greg 2.17 if (reverse && putprim != BRIGHT && !interleave) {
260 greg 2.12 fin2 = fopen(argv[i], "r");
261     fin3 = fopen(argv[i], "r");
262     }
263     if (skipbytes && (fseek(fin, skipbytes, 0) || (fin2 != NULL &&
264     (fseek(fin2, skipbytes, 0) ||
265     fseek(fin3, skipbytes, 0))))) {
266     fprintf(stderr, "%s: cannot skip %ld bytes on input\n",
267     progname, skipbytes);
268     quit(1);
269     }
270 greg 2.10 }
271     if (fin == NULL) {
272 greg 1.1 fprintf(stderr, "%s: bad # file arguments\n", progname);
273     quit(1);
274     }
275    
276     if (reverse) {
277 schorsch 2.18 #ifdef _WIN32
278     SET_FILE_BINARY(stdout);
279 greg 2.5 if (format != 'a' && format != 'i')
280 schorsch 2.18 SET_FILE_BINARY(fin);
281 greg 2.5 #endif
282 greg 1.6 /* get header */
283 greg 2.8 if (header) {
284     if (checkheader(fin, fmtid, stdout) < 0) {
285     fprintf(stderr, "%s: wrong input format\n",
286     progname);
287     quit(1);
288     }
289 greg 2.10 if (fin2 != NULL) {
290     getheader(fin2, NULL, NULL);
291     getheader(fin3, NULL, NULL);
292     }
293 greg 2.8 } else
294     newheader("RADIANCE", stdout);
295 greg 2.3 /* get resolution */
296     if ((resolution && !fgetsresolu(&picres, fin)) ||
297     picres.xr <= 0 || picres.yr <= 0) {
298     fprintf(stderr, "%s: missing resolution\n", progname);
299     quit(1);
300     }
301 greg 2.10 if (resolution && fin2 != NULL) {
302     RESOLU pres2;
303     if (!fgetsresolu(&pres2, fin2) ||
304 greg 2.14 pres2.rt != picres.rt ||
305 greg 2.10 pres2.xr != picres.xr ||
306     pres2.yr != picres.yr ||
307     !fgetsresolu(&pres2, fin3) ||
308 greg 2.14 pres2.rt != picres.rt ||
309 greg 2.10 pres2.xr != picres.xr ||
310     pres2.yr != picres.yr) {
311     fprintf(stderr, "%s: resolution mismatch\n",
312     progname);
313     quit(1);
314     }
315     }
316 greg 1.6 /* add to header */
317     printargs(i, argv, stdout);
318 greg 2.9 if (expval < .99 || expval > 1.01)
319 greg 2.7 fputexpos(expval, stdout);
320 greg 1.6 fputformat(COLRFMT, stdout);
321 greg 1.8 putchar('\n');
322 greg 2.3 fputsresolu(&picres, stdout); /* always put resolution */
323 greg 1.1 valtopix();
324     } else {
325 schorsch 2.18 #ifdef _WIN32
326     SET_FILE_BINARY(fin);
327 greg 2.5 if (format != 'a' && format != 'i')
328 schorsch 2.18 SET_FILE_BINARY(stdout);
329 greg 2.5 #endif
330 greg 1.1 /* get header */
331 greg 1.6 getheader(fin, checkhead, NULL);
332     if (wrongformat) {
333 greg 2.14 fprintf(stderr,
334     "%s: input not a Radiance RGBE picture\n",
335 greg 1.6 progname);
336     quit(1);
337     }
338 greg 2.3 if (!fgetsresolu(&picres, fin)) {
339     fprintf(stderr, "%s: missing resolution\n", progname);
340     quit(1);
341     }
342 greg 1.1 if (header) {
343     printargs(i, argv, stdout);
344 greg 2.9 if (expval < .99 || expval > 1.01)
345 greg 2.7 fputexpos(expval, stdout);
346 greg 1.6 fputformat(fmtid, stdout);
347 greg 1.8 putchar('\n');
348 greg 1.1 }
349 greg 2.3 if (resolution) /* put resolution */
350     fputsresolu(&picres, stdout);
351 greg 1.1 pixtoval();
352     }
353    
354     quit(0);
355     }
356    
357    
358 schorsch 2.25 static int
359     checkhead( /* deal with line from header */
360     char *line,
361     void *p
362     )
363 greg 1.1 {
364 greg 1.6 char fmt[32];
365 greg 1.5 double d;
366     COLOR ctmp;
367    
368 greg 2.14 if (formatval(fmt, line)) {
369     if (!strcmp(fmt, CIEFMT)) {
370     mybright = &xyz_bright;
371     if (original) {
372     scalecolor(exposure, 1./WHTEFFICACY);
373     doexposure++;
374     }
375     } else if (!strcmp(fmt, COLRFMT))
376     mybright = &rgb_bright;
377     else
378     wrongformat++;
379     } else if (original && isexpos(line)) {
380 greg 1.5 d = 1.0/exposval(line);
381     scalecolor(exposure, d);
382 greg 2.7 doexposure++;
383 greg 1.6 } else if (original && iscolcor(line)) {
384 greg 1.5 colcorval(ctmp, line);
385 greg 1.7 setcolor(exposure, colval(exposure,RED)/colval(ctmp,RED),
386     colval(exposure,GRN)/colval(ctmp,GRN),
387     colval(exposure,BLU)/colval(ctmp,BLU));
388 greg 2.7 doexposure++;
389 greg 1.6 } else if (header)
390     fputs(line, stdout);
391 gwlarson 2.13 return(0);
392 greg 1.1 }
393    
394    
395     pixtoval() /* convert picture to values */
396     {
397 greg 2.5 register COLOR *scanln;
398 greg 1.7 int dogamma;
399 greg 1.1 COLOR lastc;
400 schorsch 2.21 RREAL hv[2];
401 greg 2.12 int startprim, endprim;
402     long startpos;
403 greg 1.1 int y;
404     register int x;
405    
406 greg 1.8 scanln = (COLOR *)malloc(scanlen(&picres)*sizeof(COLOR));
407 greg 1.1 if (scanln == NULL) {
408     fprintf(stderr, "%s: out of memory\n", progname);
409     quit(1);
410     }
411 greg 1.8 dogamma = gamcor < .95 || gamcor > 1.05;
412 greg 2.12 if (putprim == ALL && !interleave) {
413     startprim = RED; endprim = BLU;
414     startpos = ftell(fin);
415     } else {
416     startprim = putprim; endprim = putprim;
417     }
418     for (putprim = startprim; putprim <= endprim; putprim++) {
419     if (putprim != startprim && fseek(fin, startpos, 0)) {
420     fprintf(stderr, "%s: seek error on input file\n",
421     progname);
422 greg 1.1 quit(1);
423     }
424 greg 2.12 set_io();
425     setcolor(lastc, 0.0, 0.0, 0.0);
426     for (y = 0; y < numscans(&picres); y++) {
427     if (freadscan(scanln, scanlen(&picres), fin) < 0) {
428     fprintf(stderr, "%s: read error\n", progname);
429 greg 1.1 quit(1);
430     }
431 greg 2.12 for (x = 0; x < scanlen(&picres); x++) {
432 schorsch 2.22 if (uniq) {
433 greg 2.12 if ( colval(scanln[x],RED) ==
434     colval(lastc,RED) &&
435     colval(scanln[x],GRN) ==
436     colval(lastc,GRN) &&
437     colval(scanln[x],BLU) ==
438     colval(lastc,BLU) )
439     continue;
440     else
441     copycolor(lastc, scanln[x]);
442 schorsch 2.22 }
443 greg 2.12 if (doexposure)
444     multcolor(scanln[x], exposure);
445     if (dogamma)
446     setcolor(scanln[x],
447     pow(colval(scanln[x],RED), 1.0/gamcor),
448     pow(colval(scanln[x],GRN), 1.0/gamcor),
449     pow(colval(scanln[x],BLU), 1.0/gamcor));
450     if (!dataonly) {
451     pix2loc(hv, &picres, x, y);
452     printf("%7d %7d ",
453     (int)(hv[0]*picres.xr),
454     (int)(hv[1]*picres.yr));
455     }
456     if ((*putval)(scanln[x]) < 0) {
457     fprintf(stderr, "%s: write error\n",
458     progname);
459     quit(1);
460     }
461     }
462 greg 1.1 }
463     }
464 greg 2.14 free((void *)scanln);
465 greg 1.1 }
466    
467    
468     valtopix() /* convert values to a pixel file */
469     {
470 greg 1.7 int dogamma;
471 greg 2.5 register COLOR *scanln;
472 greg 1.1 int y;
473     register int x;
474    
475 greg 1.8 scanln = (COLOR *)malloc(scanlen(&picres)*sizeof(COLOR));
476 greg 1.1 if (scanln == NULL) {
477     fprintf(stderr, "%s: out of memory\n", progname);
478     quit(1);
479     }
480 greg 1.8 dogamma = gamcor < .95 || gamcor > 1.05;
481 greg 2.12 set_io();
482 greg 1.8 for (y = 0; y < numscans(&picres); y++) {
483     for (x = 0; x < scanlen(&picres); x++) {
484 greg 2.10 if (!dataonly) {
485 greg 1.1 fscanf(fin, "%*d %*d");
486 greg 2.10 if (fin2 != NULL) {
487     fscanf(fin2, "%*d %*d");
488     fscanf(fin3, "%*d %*d");
489     }
490     }
491 greg 2.11 if ((*getval)(scanln[x]) < 0) {
492 greg 1.1 fprintf(stderr, "%s: read error\n", progname);
493     quit(1);
494     }
495 greg 1.7 if (dogamma)
496     setcolor(scanln[x],
497 greg 1.8 pow(colval(scanln[x],RED), gamcor),
498     pow(colval(scanln[x],GRN), gamcor),
499     pow(colval(scanln[x],BLU), gamcor));
500 greg 2.7 if (doexposure)
501     multcolor(scanln[x], exposure);
502 greg 1.1 }
503 greg 1.8 if (fwritescan(scanln, scanlen(&picres), stdout) < 0) {
504 greg 1.1 fprintf(stderr, "%s: write error\n", progname);
505     quit(1);
506     }
507     }
508 greg 2.14 free((void *)scanln);
509 greg 1.1 }
510    
511    
512 greg 2.14 void
513 greg 1.1 quit(code)
514     int code;
515     {
516     exit(code);
517     }
518    
519    
520 greg 2.16 swap16(wp, n) /* swap n 16-bit words */
521     register uint16 *wp;
522     int n;
523     {
524     while (n-- > 0) {
525     *wp = *wp << 8 | ((*wp >> 8) & 0xff);
526     wp++;
527     }
528     }
529    
530 greg 2.23
531     swap32(wp, n) /* swap n 32-bit words */
532     register uint32 *wp;
533     int n;
534     {
535     while (n-- > 0) {
536     *wp = *wp << 24 | ((*wp >> 24) & 0xff) |
537     (*wp & 0xff00) << 8 | (*wp & 0xff0000) >> 8;
538     wp++;
539     }
540     }
541    
542    
543     swap64(wp, n) /* swap n 64-bit words */
544     register char *wp;
545     int n;
546     {
547     register int t;
548    
549     while (n-- > 0) {
550     t = wp[0]; wp[0] = wp[7]; wp[7] = t;
551     t = wp[1]; wp[1] = wp[6]; wp[6] = t;
552     t = wp[2]; wp[2] = wp[5]; wp[5] = t;
553     t = wp[3]; wp[3] = wp[4]; wp[4] = t;
554     wp += 8;
555     }
556     }
557    
558    
559 greg 2.11 getcascii(col) /* get an ascii color value from stream(s) */
560 greg 1.1 COLOR col;
561     {
562 greg 2.5 double vd[3];
563 greg 1.1
564 greg 2.11 if (fin2 == NULL) {
565     if (fscanf(fin, "%lf %lf %lf", &vd[0], &vd[1], &vd[2]) != 3)
566 greg 2.10 return(-1);
567     } else {
568 greg 2.11 if (fscanf(fin, "%lf", &vd[0]) != 1 ||
569     fscanf(fin2, "%lf", &vd[1]) != 1 ||
570     fscanf(fin3, "%lf", &vd[2]) != 1)
571 greg 2.10 return(-1);
572     }
573 greg 2.4 setcolor(col, vd[rord[RED]], vd[rord[GRN]], vd[rord[BLU]]);
574 greg 1.1 return(0);
575     }
576    
577    
578 greg 2.11 getcdouble(col) /* get a double color value from stream(s) */
579 greg 1.1 COLOR col;
580     {
581 greg 2.5 double vd[3];
582 greg 1.1
583 greg 2.11 if (fin2 == NULL) {
584     if (fread((char *)vd, sizeof(double), 3, fin) != 3)
585 greg 2.10 return(-1);
586     } else {
587 greg 2.11 if (fread((char *)vd, sizeof(double), 1, fin) != 1 ||
588     fread((char *)(vd+1), sizeof(double), 1, fin2) != 1 ||
589     fread((char *)(vd+2), sizeof(double), 1, fin3) != 1)
590 greg 2.10 return(-1);
591     }
592 greg 2.23 if (swapbytes)
593     swap64((char *)vd, 3);
594 greg 2.4 setcolor(col, vd[rord[RED]], vd[rord[GRN]], vd[rord[BLU]]);
595 greg 1.1 return(0);
596     }
597    
598    
599 greg 2.11 getcfloat(col) /* get a float color value from stream(s) */
600 greg 1.1 COLOR col;
601     {
602     float vf[3];
603    
604 greg 2.11 if (fin2 == NULL) {
605     if (fread((char *)vf, sizeof(float), 3, fin) != 3)
606 greg 2.10 return(-1);
607     } else {
608 greg 2.11 if (fread((char *)vf, sizeof(float), 1, fin) != 1 ||
609     fread((char *)(vf+1), sizeof(float), 1, fin2) != 1 ||
610     fread((char *)(vf+2), sizeof(float), 1, fin3) != 1)
611 greg 2.10 return(-1);
612     }
613 greg 2.23 if (swapbytes)
614     swap32((uint32 *)vf, 3);
615 greg 2.4 setcolor(col, vf[rord[RED]], vf[rord[GRN]], vf[rord[BLU]]);
616 greg 1.1 return(0);
617     }
618    
619    
620 greg 2.11 getcint(col) /* get an int color value from stream(s) */
621 greg 1.1 COLOR col;
622     {
623     int vi[3];
624    
625 greg 2.11 if (fin2 == NULL) {
626     if (fscanf(fin, "%d %d %d", &vi[0], &vi[1], &vi[2]) != 3)
627 greg 2.10 return(-1);
628     } else {
629 greg 2.11 if (fscanf(fin, "%d", &vi[0]) != 1 ||
630     fscanf(fin2, "%d", &vi[1]) != 1 ||
631     fscanf(fin3, "%d", &vi[2]) != 1)
632 greg 2.10 return(-1);
633     }
634 greg 2.4 setcolor(col, (vi[rord[RED]]+.5)/256.,
635     (vi[rord[GRN]]+.5)/256., (vi[rord[BLU]]+.5)/256.);
636 greg 1.1 return(0);
637     }
638    
639    
640 greg 2.11 getcbyte(col) /* get a byte color value from stream(s) */
641 greg 1.1 COLOR col;
642     {
643     BYTE vb[3];
644    
645 greg 2.11 if (fin2 == NULL) {
646     if (fread((char *)vb, sizeof(BYTE), 3, fin) != 3)
647 greg 2.10 return(-1);
648     } else {
649 greg 2.11 if (fread((char *)vb, sizeof(BYTE), 1, fin) != 1 ||
650     fread((char *)(vb+1), sizeof(BYTE), 1, fin2) != 1 ||
651     fread((char *)(vb+2), sizeof(BYTE), 1, fin3) != 1)
652 greg 2.10 return(-1);
653     }
654 greg 2.4 setcolor(col, (vb[rord[RED]]+.5)/256.,
655     (vb[rord[GRN]]+.5)/256., (vb[rord[BLU]]+.5)/256.);
656 greg 1.1 return(0);
657     }
658    
659    
660 greg 2.15 getcword(col) /* get a 16-bit color value from stream(s) */
661     COLOR col;
662     {
663     uint16 vw[3];
664    
665     if (fin2 == NULL) {
666     if (fread((char *)vw, sizeof(uint16), 3, fin) != 3)
667     return(-1);
668     } else {
669     if (fread((char *)vw, sizeof(uint16), 1, fin) != 1 ||
670     fread((char *)(vw+1), sizeof(uint16), 1, fin2) != 1 ||
671     fread((char *)(vw+2), sizeof(uint16), 1, fin3) != 1)
672     return(-1);
673     }
674 greg 2.16 if (swapbytes)
675     swap16(vw, 3);
676 greg 2.15 setcolor(col, (vw[rord[RED]]+.5)/65536.,
677     (vw[rord[GRN]]+.5)/65536., (vw[rord[BLU]]+.5)/65536.);
678     return(0);
679     }
680    
681    
682 greg 2.11 getbascii(col) /* get an ascii brightness value from fin */
683 greg 1.1 COLOR col;
684     {
685 greg 2.5 double vd;
686 greg 1.1
687 greg 2.11 if (fscanf(fin, "%lf", &vd) != 1)
688 greg 1.1 return(-1);
689     setcolor(col, vd, vd, vd);
690     return(0);
691     }
692    
693    
694 greg 2.11 getbdouble(col) /* get a double brightness value from fin */
695 greg 1.1 COLOR col;
696     {
697 greg 2.5 double vd;
698 greg 1.1
699 greg 2.11 if (fread((char *)&vd, sizeof(double), 1, fin) != 1)
700 greg 1.1 return(-1);
701 greg 2.23 if (swapbytes)
702     swap64((char *)&vd, 1);
703 greg 1.1 setcolor(col, vd, vd, vd);
704     return(0);
705     }
706    
707    
708 greg 2.11 getbfloat(col) /* get a float brightness value from fin */
709 greg 1.1 COLOR col;
710     {
711     float vf;
712    
713 greg 2.11 if (fread((char *)&vf, sizeof(float), 1, fin) != 1)
714 greg 1.1 return(-1);
715 greg 2.23 if (swapbytes)
716     swap32((uint32 *)&vf, 1);
717 greg 1.1 setcolor(col, vf, vf, vf);
718     return(0);
719     }
720    
721    
722 greg 2.11 getbint(col) /* get an int brightness value from fin */
723 greg 1.1 COLOR col;
724     {
725     int vi;
726 greg 2.5 double d;
727 greg 1.1
728 greg 2.11 if (fscanf(fin, "%d", &vi) != 1)
729 greg 1.1 return(-1);
730     d = (vi+.5)/256.;
731     setcolor(col, d, d, d);
732     return(0);
733     }
734    
735    
736 greg 2.11 getbbyte(col) /* get a byte brightness value from fin */
737 greg 1.1 COLOR col;
738     {
739     BYTE vb;
740 greg 2.5 double d;
741 greg 1.1
742 greg 2.11 if (fread((char *)&vb, sizeof(BYTE), 1, fin) != 1)
743 greg 1.1 return(-1);
744     d = (vb+.5)/256.;
745     setcolor(col, d, d, d);
746     return(0);
747     }
748    
749    
750 greg 2.15 getbword(col) /* get a 16-bit brightness value from fin */
751     COLOR col;
752     {
753     uint16 vw;
754     double d;
755    
756     if (fread((char *)&vw, sizeof(uint16), 1, fin) != 1)
757     return(-1);
758 greg 2.16 if (swapbytes)
759     swap16(&vw, 1);
760 greg 2.15 d = (vw+.5)/65536.;
761     setcolor(col, d, d, d);
762     return(0);
763     }
764    
765    
766 greg 2.11 putcascii(col) /* put an ascii color to stdout */
767 greg 1.1 COLOR col;
768     {
769 greg 2.11 fprintf(stdout, "%15.3e %15.3e %15.3e\n",
770 greg 2.4 colval(col,ord[0]),
771     colval(col,ord[1]),
772     colval(col,ord[2]));
773 greg 1.1
774 greg 2.11 return(ferror(stdout) ? -1 : 0);
775 greg 1.1 }
776    
777    
778 greg 2.11 putcfloat(col) /* put a float color to stdout */
779 greg 1.1 COLOR col;
780     {
781     float vf[3];
782    
783 greg 2.4 vf[0] = colval(col,ord[0]);
784     vf[1] = colval(col,ord[1]);
785     vf[2] = colval(col,ord[2]);
786 greg 2.23 if (swapbytes)
787     swap32((uint32 *)vf, 3);
788 greg 2.11 fwrite((char *)vf, sizeof(float), 3, stdout);
789 greg 1.1
790 greg 2.11 return(ferror(stdout) ? -1 : 0);
791 greg 1.1 }
792    
793    
794 greg 2.11 putcdouble(col) /* put a double color to stdout */
795 greg 1.1 COLOR col;
796     {
797 greg 2.5 double vd[3];
798 greg 1.1
799 greg 2.4 vd[0] = colval(col,ord[0]);
800     vd[1] = colval(col,ord[1]);
801     vd[2] = colval(col,ord[2]);
802 greg 2.23 if (swapbytes)
803     swap64((char *)vd, 3);
804 greg 2.11 fwrite((char *)vd, sizeof(double), 3, stdout);
805 greg 1.1
806 greg 2.11 return(ferror(stdout) ? -1 : 0);
807 greg 1.1 }
808    
809    
810 greg 2.11 putcint(col) /* put an int color to stdout */
811 greg 1.1 COLOR col;
812     {
813 greg 2.11 fprintf(stdout, "%d %d %d\n",
814 greg 2.4 (int)(colval(col,ord[0])*256.),
815     (int)(colval(col,ord[1])*256.),
816     (int)(colval(col,ord[2])*256.));
817 greg 1.1
818 greg 2.11 return(ferror(stdout) ? -1 : 0);
819 greg 1.1 }
820    
821    
822 greg 2.11 putcbyte(col) /* put a byte color to stdout */
823 greg 1.1 COLOR col;
824     {
825 greg 2.15 long i;
826 greg 1.1 BYTE vb[3];
827    
828 greg 2.4 i = colval(col,ord[0])*256.;
829 greg 1.1 vb[0] = min(i,255);
830 greg 2.4 i = colval(col,ord[1])*256.;
831 greg 1.1 vb[1] = min(i,255);
832 greg 2.4 i = colval(col,ord[2])*256.;
833 greg 1.1 vb[2] = min(i,255);
834 greg 2.11 fwrite((char *)vb, sizeof(BYTE), 3, stdout);
835 greg 1.1
836 greg 2.11 return(ferror(stdout) ? -1 : 0);
837 greg 1.1 }
838    
839    
840 greg 2.15 putcword(col) /* put a 16-bit color to stdout */
841     COLOR col;
842     {
843     long i;
844     uint16 vw[3];
845    
846     i = colval(col,ord[0])*65536.;
847     vw[0] = min(i,65535);
848     i = colval(col,ord[1])*65536.;
849     vw[1] = min(i,65535);
850     i = colval(col,ord[2])*65536.;
851     vw[2] = min(i,65535);
852 greg 2.16 if (swapbytes)
853     swap16(vw, 3);
854 greg 2.15 fwrite((char *)vw, sizeof(uint16), 3, stdout);
855    
856     return(ferror(stdout) ? -1 : 0);
857     }
858    
859    
860 greg 2.11 putbascii(col) /* put an ascii brightness to stdout */
861 greg 1.1 COLOR col;
862     {
863 greg 2.14 fprintf(stdout, "%15.3e\n", (*mybright)(col));
864 greg 1.1
865 greg 2.11 return(ferror(stdout) ? -1 : 0);
866 greg 1.1 }
867    
868    
869 greg 2.11 putbfloat(col) /* put a float brightness to stdout */
870 greg 1.1 COLOR col;
871     {
872     float vf;
873    
874 greg 2.14 vf = (*mybright)(col);
875 greg 2.23 if (swapbytes)
876     swap32((uint32 *)&vf, 1);
877 greg 2.11 fwrite((char *)&vf, sizeof(float), 1, stdout);
878 greg 1.1
879 greg 2.11 return(ferror(stdout) ? -1 : 0);
880 greg 1.1 }
881    
882    
883 greg 2.11 putbdouble(col) /* put a double brightness to stdout */
884 greg 1.1 COLOR col;
885     {
886 greg 2.5 double vd;
887 greg 1.1
888 greg 2.14 vd = (*mybright)(col);
889 greg 2.23 if (swapbytes)
890     swap64((char *)&vd, 1);
891 greg 2.11 fwrite((char *)&vd, sizeof(double), 1, stdout);
892 greg 1.1
893 greg 2.11 return(ferror(stdout) ? -1 : 0);
894 greg 1.1 }
895    
896    
897 greg 2.11 putbint(col) /* put an int brightness to stdout */
898 greg 1.1 COLOR col;
899     {
900 greg 2.14 fprintf(stdout, "%d\n", (int)((*mybright)(col)*256.));
901 greg 1.1
902 greg 2.11 return(ferror(stdout) ? -1 : 0);
903 greg 1.1 }
904    
905    
906 greg 2.11 putbbyte(col) /* put a byte brightness to stdout */
907 greg 1.1 COLOR col;
908     {
909     register int i;
910     BYTE vb;
911    
912 greg 2.14 i = (*mybright)(col)*256.;
913 greg 1.1 vb = min(i,255);
914 greg 2.11 fwrite((char *)&vb, sizeof(BYTE), 1, stdout);
915 greg 1.1
916 greg 2.11 return(ferror(stdout) ? -1 : 0);
917 greg 1.1 }
918    
919    
920 greg 2.15 putbword(col) /* put a 16-bit brightness to stdout */
921     COLOR col;
922     {
923     long i;
924     uint16 vw;
925    
926     i = (*mybright)(col)*65536.;
927     vw = min(i,65535);
928 greg 2.16 if (swapbytes)
929     swap16(&vw, 1);
930 greg 2.15 fwrite((char *)&vw, sizeof(uint16), 1, stdout);
931    
932     return(ferror(stdout) ? -1 : 0);
933     }
934    
935    
936 greg 2.11 putpascii(col) /* put an ascii primary to stdout */
937 greg 2.10 COLOR col;
938     {
939 greg 2.11 fprintf(stdout, "%15.3e\n", colval(col,putprim));
940 greg 2.10
941 greg 2.11 return(ferror(stdout) ? -1 : 0);
942 greg 2.10 }
943    
944    
945 greg 2.11 putpfloat(col) /* put a float primary to stdout */
946 greg 2.10 COLOR col;
947     {
948     float vf;
949    
950     vf = colval(col,putprim);
951 greg 2.23 if (swapbytes)
952     swap32((uint32 *)&vf, 1);
953 greg 2.11 fwrite((char *)&vf, sizeof(float), 1, stdout);
954 greg 2.10
955 greg 2.11 return(ferror(stdout) ? -1 : 0);
956 greg 2.10 }
957    
958    
959 greg 2.11 putpdouble(col) /* put a double primary to stdout */
960 greg 2.10 COLOR col;
961     {
962     double vd;
963    
964     vd = colval(col,putprim);
965 greg 2.23 if (swapbytes)
966     swap64((char *)&vd, 1);
967 greg 2.11 fwrite((char *)&vd, sizeof(double), 1, stdout);
968 greg 2.10
969 greg 2.11 return(ferror(stdout) ? -1 : 0);
970 greg 2.10 }
971    
972    
973 greg 2.11 putpint(col) /* put an int primary to stdout */
974 greg 2.10 COLOR col;
975     {
976 greg 2.11 fprintf(stdout, "%d\n", (int)(colval(col,putprim)*256.));
977 greg 2.10
978 greg 2.11 return(ferror(stdout) ? -1 : 0);
979 greg 2.10 }
980    
981    
982 greg 2.11 putpbyte(col) /* put a byte primary to stdout */
983 greg 2.10 COLOR col;
984     {
985 greg 2.15 long i;
986 greg 2.10 BYTE vb;
987    
988     i = colval(col,putprim)*256.;
989     vb = min(i,255);
990 greg 2.11 fwrite((char *)&vb, sizeof(BYTE), 1, stdout);
991 greg 2.10
992 greg 2.11 return(ferror(stdout) ? -1 : 0);
993 greg 2.10 }
994    
995    
996 greg 2.15 putpword(col) /* put a 16-bit primary to stdout */
997     COLOR col;
998     {
999     long i;
1000     uint16 vw;
1001    
1002     i = colval(col,putprim)*65536.;
1003     vw = min(i,65535);
1004 greg 2.16 if (swapbytes)
1005     swap16(&vw, 1);
1006 greg 2.15 fwrite((char *)&vw, sizeof(uint16), 1, stdout);
1007    
1008     return(ferror(stdout) ? -1 : 0);
1009     }
1010    
1011    
1012 greg 1.1 set_io() /* set put and get functions */
1013     {
1014     switch (format) {
1015     case 'a': /* ascii */
1016 greg 2.10 if (putprim == BRIGHT) {
1017 greg 1.1 getval = getbascii;
1018     putval = putbascii;
1019 greg 2.10 } else if (putprim != ALL) {
1020     getval = getbascii;
1021     putval = putpascii;
1022 greg 1.1 } else {
1023     getval = getcascii;
1024     putval = putcascii;
1025 greg 2.12 if (reverse && !interleave) {
1026     fprintf(stderr,
1027     "%s: ASCII input files must be interleaved\n",
1028     progname);
1029     quit(1);
1030     }
1031 greg 1.1 }
1032     return;
1033     case 'f': /* binary float */
1034 greg 2.10 if (putprim == BRIGHT) {
1035 greg 1.1 getval = getbfloat;
1036     putval = putbfloat;
1037 greg 2.10 } else if (putprim != ALL) {
1038     getval = getbfloat;
1039     putval = putpfloat;
1040 greg 1.1 } else {
1041     getval = getcfloat;
1042     putval = putcfloat;
1043 greg 2.12 if (reverse && !interleave) {
1044     if (fin2 == NULL)
1045     goto namerr;
1046     if (fseek(fin2,
1047     (long)sizeof(float)*picres.xr*picres.yr, 1))
1048     goto seekerr;
1049     if (fseek(fin3,
1050     (long)sizeof(float)*2*picres.xr*picres.yr, 1))
1051     goto seekerr;
1052     }
1053 greg 1.1 }
1054     return;
1055     case 'd': /* binary double */
1056 greg 2.10 if (putprim == BRIGHT) {
1057 greg 1.1 getval = getbdouble;
1058     putval = putbdouble;
1059 greg 2.10 } else if (putprim != ALL) {
1060     getval = getbdouble;
1061     putval = putpdouble;
1062 greg 1.1 } else {
1063     getval = getcdouble;
1064     putval = putcdouble;
1065 greg 2.12 if (reverse && !interleave) {
1066     if (fin2 == NULL)
1067     goto namerr;
1068     if (fseek(fin2,
1069     (long)sizeof(double)*picres.xr*picres.yr, 1))
1070     goto seekerr;
1071     if (fseek(fin3,
1072     (long)sizeof(double)*2*picres.xr*picres.yr, 1))
1073     goto seekerr;
1074     }
1075 greg 1.1 }
1076     return;
1077     case 'i': /* integer */
1078 greg 2.10 if (putprim == BRIGHT) {
1079 greg 1.1 getval = getbint;
1080     putval = putbint;
1081 greg 2.10 } else if (putprim != ALL) {
1082     getval = getbint;
1083     putval = putpint;
1084 greg 1.1 } else {
1085     getval = getcint;
1086     putval = putcint;
1087 greg 2.12 if (reverse && !interleave) {
1088     fprintf(stderr,
1089     "%s: integer input files must be interleaved\n",
1090     progname);
1091     quit(1);
1092     }
1093 greg 1.1 }
1094     return;
1095     case 'b': /* byte */
1096 greg 2.10 if (putprim == BRIGHT) {
1097 greg 1.1 getval = getbbyte;
1098     putval = putbbyte;
1099 greg 2.10 } else if (putprim != ALL) {
1100     getval = getbbyte;
1101     putval = putpbyte;
1102 greg 1.1 } else {
1103     getval = getcbyte;
1104     putval = putcbyte;
1105 greg 2.12 if (reverse && !interleave) {
1106     if (fin2 == NULL)
1107     goto namerr;
1108     if (fseek(fin2,
1109     (long)sizeof(BYTE)*picres.xr*picres.yr, 1))
1110     goto seekerr;
1111     if (fseek(fin3,
1112     (long)sizeof(BYTE)*2*picres.xr*picres.yr, 1))
1113 greg 2.15 goto seekerr;
1114     }
1115     }
1116     return;
1117     case 'w': /* 16-bit */
1118     if (putprim == BRIGHT) {
1119     getval = getbword;
1120     putval = putbword;
1121     } else if (putprim != ALL) {
1122     getval = getbword;
1123     putval = putpword;
1124     } else {
1125     getval = getcword;
1126     putval = putcword;
1127     if (reverse && !interleave) {
1128     if (fin2 == NULL)
1129     goto namerr;
1130     if (fseek(fin2,
1131     (long)sizeof(uint16)*picres.xr*picres.yr, 1))
1132     goto seekerr;
1133     if (fseek(fin3,
1134     (long)sizeof(uint16)*2*picres.xr*picres.yr, 1))
1135 greg 2.12 goto seekerr;
1136     }
1137 greg 1.1 }
1138     return;
1139     }
1140 greg 2.12 badopt:
1141     fprintf(stderr, "%s: botched file type\n", progname);
1142     quit(1);
1143     namerr:
1144     fprintf(stderr, "%s: non-interleaved file(s) must be named\n",
1145     progname);
1146     quit(1);
1147     seekerr:
1148     fprintf(stderr, "%s: cannot seek on interleaved input file\n",
1149     progname);
1150     quit(1);
1151 greg 1.1 }