ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.26
Committed: Sun Mar 28 20:33:14 2004 UTC (20 years ago) by schorsch
Content type: text/plain
Branch: MAIN
Changes since 2.25: +182 -104 lines
Log Message: 
Continued ANSIfication, and other fixes and clarifications.

File Contents

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