ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.23
Committed: Sat Sep 13 15:24:13 2003 UTC (20 years, 7 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.22: +55 -4 lines
Log Message: 
Added -dF and -dD options for byte-swapped float's and double's

File Contents

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