ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.36
Committed: Mon Jul 15 23:42:44 2019 UTC (4 years, 10 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.35: +35 -29 lines
Log Message: 
Allow skipping header bytes on standard input and more logical binary mode

File Contents

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