ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.43
Committed: Wed Sep 11 18:56:12 2024 UTC (7 months, 4 weeks ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.42: +94 -35 lines
Log Message: 
feat(pcond,pvalue): Added hyperspectral input handling

File Contents

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