ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/pvalue.c
Revision: 2.44
Committed: Wed Sep 11 23:21:01 2024 UTC (7 months, 4 weeks ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.43: +3 -2 lines
Log Message: 
fix(pvalue): Don't output NCOMP line in header if including pixel coords

File Contents

# User Rev Content
1 greg 1.1 #ifndef lint
2 greg 2.44 static const char RCSid[] = "$Id: pvalue.c,v 2.43 2024/09/11 18:56:12 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.44 if (dataonly)
417     printf("%s%c\n", NCOMPSTR, "13"[putprim==ALL]);
418 greg 2.43 if (dataonly && !resolution & !uniq)
419 greg 2.39 printf("NCOLS=%d\nNROWS=%d\n", scanlen(&picres),
420     numscans(&picres));
421 greg 2.43 if ((expval < .99) | (expval > 1.01))
422 greg 2.7 fputexpos(expval, stdout);
423 greg 2.37 if (swapbytes) {
424     if (nativebigendian())
425     puts("BigEndian=0");
426     else
427     puts("BigEndian=1");
428 greg 2.40 } else if ((format != 'a') & (format != 'i') &
429     (format != 'b'))
430 greg 2.37 fputendian(stdout);
431 greg 1.6 fputformat(fmtid, stdout);
432 greg 1.8 putchar('\n');
433 greg 1.1 }
434 greg 2.3 if (resolution) /* put resolution */
435     fputsresolu(&picres, stdout);
436 greg 1.1 pixtoval();
437     }
438    
439     quit(0);
440 schorsch 2.26 return 0; /* pro forma return */
441 greg 1.1 }
442    
443    
444 schorsch 2.25 static int
445 greg 2.43 IDformat(const char *s)
446     {
447     if (!s || !*s) return(0);
448     if (!strcmp(s, "ascii")) return('a');
449     if (!strcmp(s, "float")) return('f');
450     if (!strcmp(s, "double")) return('d');
451     if (!strcmp(s, "byte")) return('b');
452     if (!strcmp(s, "16-bit")) return('w');
453     return(0);
454     }
455    
456    
457     static int
458 schorsch 2.25 checkhead( /* deal with line from header */
459     char *line,
460     void *p
461     )
462 greg 1.1 {
463 greg 2.43 static char fmt[MAXFMTLEN];
464 greg 2.38 FILE *fout = (FILE *)p;
465 greg 1.5 double d;
466     COLOR ctmp;
467 greg 2.37 int rv;
468 greg 1.5
469 greg 2.14 if (formatval(fmt, line)) {
470 greg 2.43 if (reverse) {
471     if (format == 'a') {
472     format = IDformat(fmt);
473     if (format)
474     fmtid = fmt;
475     else
476     wrongformat = 1;
477     } else
478     wrongformat = strcmp(fmt, fmtid);
479     } else if (!strcmp(fmt, CIEFMT))
480 greg 2.14 mybright = &xyz_bright;
481 greg 2.43 else if (!strcmp(fmt, COLRFMT) || !strcmp(fmt, SPECFMT))
482 greg 2.14 mybright = &rgb_bright;
483     else
484 greg 2.43 wrongformat = 1;
485     return(1);
486     }
487     if (!strncmp(line,"NROWS=",6)) {
488     picres.yr = atoi(line+6);
489     return(1);
490     }
491     if (!strncmp(line,"NCOLS=",6)) {
492     picres.xr = atoi(line+6);
493 greg 2.39 return(1);
494     }
495 greg 2.43 if (isncomp(line)) {
496     NCSAMP = ncompval(line);
497     dataonly |= reverse; /* pretty safe assumption */
498 greg 2.42 return(1);
499 greg 2.43 }
500     if (iswlsplit(line)) {
501     wlsplitval(WLPART, line);
502     return(1);
503     }
504 greg 2.39 if (original && isexpos(line)) {
505 greg 1.5 d = 1.0/exposval(line);
506     scalecolor(exposure, d);
507 greg 2.7 doexposure++;
508 greg 2.39 return(1);
509     }
510     if (original && iscolcor(line)) {
511 greg 1.5 colcorval(ctmp, line);
512 greg 1.7 setcolor(exposure, colval(exposure,RED)/colval(ctmp,RED),
513     colval(exposure,GRN)/colval(ctmp,GRN),
514     colval(exposure,BLU)/colval(ctmp,BLU));
515 greg 2.7 doexposure++;
516 greg 2.39 return(1);
517     }
518     if ((rv = isbigendian(line)) >= 0) {
519 greg 2.38 if (reverse)
520     swapbytes = (nativebigendian() != rv);
521 greg 2.39 return(1);
522     }
523     if (fout != NULL)
524 greg 2.38 fputs(line, fout);
525 gwlarson 2.13 return(0);
526 greg 1.1 }
527    
528    
529 schorsch 2.26 static void
530     pixtoval(void) /* convert picture to values */
531 greg 1.1 {
532 greg 2.35 COLOR *scanln;
533 greg 1.7 int dogamma;
534 greg 1.1 COLOR lastc;
535 schorsch 2.21 RREAL hv[2];
536 greg 2.12 int startprim, endprim;
537     long startpos;
538 greg 2.35 int x, y;
539 greg 1.1
540 greg 1.8 scanln = (COLOR *)malloc(scanlen(&picres)*sizeof(COLOR));
541 greg 1.1 if (scanln == NULL) {
542     fprintf(stderr, "%s: out of memory\n", progname);
543     quit(1);
544     }
545 greg 1.8 dogamma = gamcor < .95 || gamcor > 1.05;
546 greg 2.36 if ((putprim == ALL) & !interleave) {
547 greg 2.12 startprim = RED; endprim = BLU;
548     startpos = ftell(fin);
549     } else {
550     startprim = putprim; endprim = putprim;
551     }
552     for (putprim = startprim; putprim <= endprim; putprim++) {
553 greg 2.36 if (putprim != startprim && fseek(fin, startpos, SEEK_SET)) {
554 greg 2.12 fprintf(stderr, "%s: seek error on input file\n",
555     progname);
556 greg 1.1 quit(1);
557     }
558 greg 2.12 set_io();
559     setcolor(lastc, 0.0, 0.0, 0.0);
560     for (y = 0; y < numscans(&picres); y++) {
561 greg 2.43 if (fread2scan(scanln, scanlen(&picres), fin,
562     NCSAMP, WLPART) < 0) {
563 greg 2.12 fprintf(stderr, "%s: read error\n", progname);
564 greg 1.1 quit(1);
565     }
566 greg 2.12 for (x = 0; x < scanlen(&picres); x++) {
567 schorsch 2.22 if (uniq) {
568 greg 2.12 if ( colval(scanln[x],RED) ==
569     colval(lastc,RED) &&
570     colval(scanln[x],GRN) ==
571     colval(lastc,GRN) &&
572     colval(scanln[x],BLU) ==
573     colval(lastc,BLU) )
574     continue;
575     else
576     copycolor(lastc, scanln[x]);
577 schorsch 2.22 }
578 greg 2.12 if (doexposure)
579     multcolor(scanln[x], exposure);
580     if (dogamma)
581     setcolor(scanln[x],
582     pow(colval(scanln[x],RED), 1.0/gamcor),
583     pow(colval(scanln[x],GRN), 1.0/gamcor),
584     pow(colval(scanln[x],BLU), 1.0/gamcor));
585     if (!dataonly) {
586     pix2loc(hv, &picres, x, y);
587     printf("%7d %7d ",
588     (int)(hv[0]*picres.xr),
589     (int)(hv[1]*picres.yr));
590     }
591     if ((*putval)(scanln[x]) < 0) {
592     fprintf(stderr, "%s: write error\n",
593     progname);
594     quit(1);
595     }
596     }
597 greg 1.1 }
598     }
599 greg 2.14 free((void *)scanln);
600 greg 1.1 }
601    
602    
603 schorsch 2.26 static void
604     valtopix(void) /* convert values to a pixel file */
605 greg 1.1 {
606 greg 2.35 int dogamma;
607     COLOR *scanln;
608     COLR rgbe;
609     int x, y;
610 greg 1.1
611 greg 1.8 scanln = (COLOR *)malloc(scanlen(&picres)*sizeof(COLOR));
612 greg 1.1 if (scanln == NULL) {
613     fprintf(stderr, "%s: out of memory\n", progname);
614     quit(1);
615     }
616 greg 1.8 dogamma = gamcor < .95 || gamcor > 1.05;
617 greg 2.12 set_io();
618 greg 1.8 for (y = 0; y < numscans(&picres); y++) {
619     for (x = 0; x < scanlen(&picres); x++) {
620 greg 2.10 if (!dataonly) {
621 greg 1.1 fscanf(fin, "%*d %*d");
622 greg 2.10 if (fin2 != NULL) {
623     fscanf(fin2, "%*d %*d");
624     fscanf(fin3, "%*d %*d");
625     }
626     }
627 greg 2.11 if ((*getval)(scanln[x]) < 0) {
628 greg 1.1 fprintf(stderr, "%s: read error\n", progname);
629     quit(1);
630     }
631 greg 1.7 if (dogamma)
632     setcolor(scanln[x],
633 greg 1.8 pow(colval(scanln[x],RED), gamcor),
634     pow(colval(scanln[x],GRN), gamcor),
635     pow(colval(scanln[x],BLU), gamcor));
636 greg 2.7 if (doexposure)
637     multcolor(scanln[x], exposure);
638 greg 2.35 if (uniq) { /* uncompressed? */
639     setcolr(rgbe, scanln[x][RED],
640     scanln[x][GRN],
641     scanln[x][BLU]);
642     if (putbinary(rgbe, sizeof(COLR), 1, stdout) != 1)
643     goto writerr;
644     }
645 greg 1.1 }
646 greg 2.35 /* write scan if compressed */
647     if (!uniq && fwritescan(scanln, scanlen(&picres), stdout) < 0)
648     goto writerr;
649 greg 1.1 }
650 greg 2.14 free((void *)scanln);
651 greg 2.35 return;
652     writerr:
653     fprintf(stderr, "%s: write error\n", progname);
654     quit(1);
655 greg 1.1 }
656    
657    
658 greg 2.14 void
659 greg 1.1 quit(code)
660     int code;
661     {
662     exit(code);
663     }
664    
665    
666 schorsch 2.26 static int
667     getcascii( /* get an ascii color value from stream(s) */
668     COLOR col
669     )
670 greg 1.1 {
671 greg 2.5 double vd[3];
672 greg 1.1
673 greg 2.11 if (fin2 == NULL) {
674     if (fscanf(fin, "%lf %lf %lf", &vd[0], &vd[1], &vd[2]) != 3)
675 greg 2.10 return(-1);
676     } else {
677 greg 2.11 if (fscanf(fin, "%lf", &vd[0]) != 1 ||
678     fscanf(fin2, "%lf", &vd[1]) != 1 ||
679     fscanf(fin3, "%lf", &vd[2]) != 1)
680 greg 2.10 return(-1);
681     }
682 greg 2.4 setcolor(col, vd[rord[RED]], vd[rord[GRN]], vd[rord[BLU]]);
683 greg 1.1 return(0);
684     }
685    
686    
687 schorsch 2.26 static int
688     getcdouble( /* get a double color value from stream(s) */
689     COLOR col
690     )
691 greg 1.1 {
692 greg 2.5 double vd[3];
693 greg 1.1
694 greg 2.11 if (fin2 == NULL) {
695 greg 2.33 if (getbinary(vd, sizeof(double), 3, fin) != 3)
696 greg 2.10 return(-1);
697     } else {
698 greg 2.33 if (getbinary(vd, sizeof(double), 1, fin) != 1 ||
699     getbinary(vd+1, sizeof(double), 1, fin2) != 1 ||
700     getbinary(vd+2, sizeof(double), 1, fin3) != 1)
701 greg 2.10 return(-1);
702     }
703 greg 2.23 if (swapbytes)
704     swap64((char *)vd, 3);
705 greg 2.4 setcolor(col, vd[rord[RED]], vd[rord[GRN]], vd[rord[BLU]]);
706 greg 1.1 return(0);
707     }
708    
709    
710 schorsch 2.26 static int
711     getcfloat( /* get a float color value from stream(s) */
712     COLOR col
713     )
714 greg 1.1 {
715     float vf[3];
716    
717 greg 2.11 if (fin2 == NULL) {
718 greg 2.33 if (getbinary(vf, sizeof(float), 3, fin) != 3)
719 greg 2.10 return(-1);
720     } else {
721 greg 2.33 if (getbinary(vf, sizeof(float), 1, fin) != 1 ||
722     getbinary(vf+1, sizeof(float), 1, fin2) != 1 ||
723     getbinary(vf+2, sizeof(float), 1, fin3) != 1)
724 greg 2.10 return(-1);
725     }
726 greg 2.23 if (swapbytes)
727 greg 2.29 swap32((char *)vf, 3);
728 greg 2.4 setcolor(col, vf[rord[RED]], vf[rord[GRN]], vf[rord[BLU]]);
729 greg 1.1 return(0);
730     }
731    
732    
733 schorsch 2.26 static int
734     getcint( /* get an int color value from stream(s) */
735     COLOR col
736     )
737 greg 1.1 {
738     int vi[3];
739    
740 greg 2.11 if (fin2 == NULL) {
741     if (fscanf(fin, "%d %d %d", &vi[0], &vi[1], &vi[2]) != 3)
742 greg 2.10 return(-1);
743     } else {
744 greg 2.11 if (fscanf(fin, "%d", &vi[0]) != 1 ||
745     fscanf(fin2, "%d", &vi[1]) != 1 ||
746     fscanf(fin3, "%d", &vi[2]) != 1)
747 greg 2.10 return(-1);
748     }
749 greg 2.4 setcolor(col, (vi[rord[RED]]+.5)/256.,
750     (vi[rord[GRN]]+.5)/256., (vi[rord[BLU]]+.5)/256.);
751 greg 1.1 return(0);
752     }
753    
754    
755 schorsch 2.26 static int
756     getcbyte( /* get a byte color value from stream(s) */
757     COLOR col
758     )
759 greg 1.1 {
760 greg 2.31 uby8 vb[3];
761 greg 1.1
762 greg 2.11 if (fin2 == NULL) {
763 greg 2.33 if (getbinary(vb, sizeof(uby8), 3, fin) != 3)
764 greg 2.10 return(-1);
765     } else {
766 greg 2.33 if (getbinary(vb, sizeof(uby8), 1, fin) != 1 ||
767     getbinary(vb+1, sizeof(uby8), 1, fin2) != 1 ||
768     getbinary(vb+2, sizeof(uby8), 1, fin3) != 1)
769 greg 2.10 return(-1);
770     }
771 greg 2.4 setcolor(col, (vb[rord[RED]]+.5)/256.,
772     (vb[rord[GRN]]+.5)/256., (vb[rord[BLU]]+.5)/256.);
773 greg 1.1 return(0);
774     }
775    
776    
777 schorsch 2.26 static int
778     getcword( /* get a 16-bit color value from stream(s) */
779     COLOR col
780     )
781 greg 2.15 {
782     uint16 vw[3];
783    
784     if (fin2 == NULL) {
785 greg 2.33 if (getbinary(vw, sizeof(uint16), 3, fin) != 3)
786 greg 2.15 return(-1);
787     } else {
788 greg 2.33 if (getbinary(vw, sizeof(uint16), 1, fin) != 1 ||
789     getbinary(vw+1, sizeof(uint16), 1, fin2) != 1 ||
790     getbinary(vw+2, sizeof(uint16), 1, fin3) != 1)
791 greg 2.15 return(-1);
792     }
793 greg 2.16 if (swapbytes)
794 greg 2.29 swap16((char *)vw, 3);
795 greg 2.15 setcolor(col, (vw[rord[RED]]+.5)/65536.,
796     (vw[rord[GRN]]+.5)/65536., (vw[rord[BLU]]+.5)/65536.);
797     return(0);
798     }
799    
800    
801 schorsch 2.26 static int
802     getbascii( /* get an ascii brightness value from fin */
803     COLOR col
804     )
805 greg 1.1 {
806 greg 2.5 double vd;
807 greg 1.1
808 greg 2.11 if (fscanf(fin, "%lf", &vd) != 1)
809 greg 1.1 return(-1);
810     setcolor(col, vd, vd, vd);
811     return(0);
812     }
813    
814    
815 schorsch 2.26 static int
816     getbdouble( /* get a double brightness value from fin */
817     COLOR col
818     )
819 greg 1.1 {
820 greg 2.5 double vd;
821 greg 1.1
822 greg 2.33 if (getbinary(&vd, sizeof(double), 1, fin) != 1)
823 greg 1.1 return(-1);
824 greg 2.23 if (swapbytes)
825     swap64((char *)&vd, 1);
826 greg 1.1 setcolor(col, vd, vd, vd);
827     return(0);
828     }
829    
830    
831 schorsch 2.26 static int
832     getbfloat( /* get a float brightness value from fin */
833     COLOR col
834     )
835 greg 1.1 {
836     float vf;
837    
838 greg 2.33 if (getbinary(&vf, sizeof(float), 1, fin) != 1)
839 greg 1.1 return(-1);
840 greg 2.23 if (swapbytes)
841 greg 2.29 swap32((char *)&vf, 1);
842 greg 1.1 setcolor(col, vf, vf, vf);
843     return(0);
844     }
845    
846    
847 schorsch 2.26 static int
848     getbint( /* get an int brightness value from fin */
849     COLOR col
850     )
851 greg 1.1 {
852     int vi;
853 greg 2.5 double d;
854 greg 1.1
855 greg 2.11 if (fscanf(fin, "%d", &vi) != 1)
856 greg 1.1 return(-1);
857     d = (vi+.5)/256.;
858     setcolor(col, d, d, d);
859     return(0);
860     }
861    
862    
863 schorsch 2.26 static int
864     getbbyte( /* get a byte brightness value from fin */
865     COLOR col
866     )
867 greg 1.1 {
868 greg 2.31 uby8 vb;
869 greg 2.5 double d;
870 greg 1.1
871 greg 2.33 if (getbinary(&vb, sizeof(uby8), 1, fin) != 1)
872 greg 1.1 return(-1);
873     d = (vb+.5)/256.;
874     setcolor(col, d, d, d);
875     return(0);
876     }
877    
878    
879 schorsch 2.26 static int
880     getbword( /* get a 16-bit brightness value from fin */
881     COLOR col
882     )
883 greg 2.15 {
884     uint16 vw;
885     double d;
886    
887 greg 2.33 if (getbinary(&vw, sizeof(uint16), 1, fin) != 1)
888 greg 2.15 return(-1);
889 greg 2.16 if (swapbytes)
890 greg 2.29 swap16((char *)&vw, 1);
891 greg 2.15 d = (vw+.5)/65536.;
892     setcolor(col, d, d, d);
893     return(0);
894     }
895    
896    
897 schorsch 2.26 static int
898     putcascii( /* put an ascii color to stdout */
899     COLOR col
900     )
901 greg 1.1 {
902 greg 2.11 fprintf(stdout, "%15.3e %15.3e %15.3e\n",
903 greg 2.4 colval(col,ord[0]),
904     colval(col,ord[1]),
905     colval(col,ord[2]));
906 greg 1.1
907 greg 2.11 return(ferror(stdout) ? -1 : 0);
908 greg 1.1 }
909    
910    
911 schorsch 2.26 static int
912     putcfloat( /* put a float color to stdout */
913     COLOR col
914     )
915 greg 1.1 {
916     float vf[3];
917    
918 greg 2.4 vf[0] = colval(col,ord[0]);
919     vf[1] = colval(col,ord[1]);
920     vf[2] = colval(col,ord[2]);
921 greg 2.23 if (swapbytes)
922 greg 2.29 swap32((char *)vf, 3);
923 greg 2.33 putbinary(vf, sizeof(float), 3, stdout);
924 greg 1.1
925 greg 2.11 return(ferror(stdout) ? -1 : 0);
926 greg 1.1 }
927    
928    
929 schorsch 2.26 static int
930     putcdouble( /* put a double color to stdout */
931     COLOR col
932     )
933 greg 1.1 {
934 greg 2.5 double vd[3];
935 greg 1.1
936 greg 2.4 vd[0] = colval(col,ord[0]);
937     vd[1] = colval(col,ord[1]);
938     vd[2] = colval(col,ord[2]);
939 greg 2.23 if (swapbytes)
940     swap64((char *)vd, 3);
941 greg 2.33 putbinary(vd, sizeof(double), 3, stdout);
942 greg 1.1
943 greg 2.11 return(ferror(stdout) ? -1 : 0);
944 greg 1.1 }
945    
946    
947 schorsch 2.26 static int
948     putcint( /* put an int color to stdout */
949     COLOR col
950     )
951 greg 1.1 {
952 greg 2.11 fprintf(stdout, "%d %d %d\n",
953 greg 2.4 (int)(colval(col,ord[0])*256.),
954     (int)(colval(col,ord[1])*256.),
955     (int)(colval(col,ord[2])*256.));
956 greg 1.1
957 greg 2.11 return(ferror(stdout) ? -1 : 0);
958 greg 1.1 }
959    
960    
961 schorsch 2.26 static int
962     putcbyte( /* put a byte color to stdout */
963     COLOR col
964     )
965 greg 1.1 {
966 greg 2.15 long i;
967 greg 2.31 uby8 vb[3];
968 greg 1.1
969 greg 2.4 i = colval(col,ord[0])*256.;
970 greg 1.1 vb[0] = min(i,255);
971 greg 2.4 i = colval(col,ord[1])*256.;
972 greg 1.1 vb[1] = min(i,255);
973 greg 2.4 i = colval(col,ord[2])*256.;
974 greg 1.1 vb[2] = min(i,255);
975 greg 2.33 putbinary(vb, sizeof(uby8), 3, stdout);
976 greg 1.1
977 greg 2.11 return(ferror(stdout) ? -1 : 0);
978 greg 1.1 }
979    
980    
981 schorsch 2.26 static int
982     putcword( /* put a 16-bit color to stdout */
983     COLOR col
984     )
985 greg 2.15 {
986     long i;
987     uint16 vw[3];
988    
989     i = colval(col,ord[0])*65536.;
990     vw[0] = min(i,65535);
991     i = colval(col,ord[1])*65536.;
992     vw[1] = min(i,65535);
993     i = colval(col,ord[2])*65536.;
994     vw[2] = min(i,65535);
995 greg 2.16 if (swapbytes)
996 greg 2.29 swap16((char *)vw, 3);
997 greg 2.33 putbinary(vw, sizeof(uint16), 3, stdout);
998 greg 2.15
999     return(ferror(stdout) ? -1 : 0);
1000     }
1001    
1002    
1003 schorsch 2.26 static int
1004     putbascii( /* put an ascii brightness to stdout */
1005     COLOR col
1006     )
1007 greg 1.1 {
1008 greg 2.14 fprintf(stdout, "%15.3e\n", (*mybright)(col));
1009 greg 1.1
1010 greg 2.11 return(ferror(stdout) ? -1 : 0);
1011 greg 1.1 }
1012    
1013    
1014 schorsch 2.26 static int
1015     putbfloat( /* put a float brightness to stdout */
1016     COLOR col
1017     )
1018 greg 1.1 {
1019     float vf;
1020    
1021 greg 2.14 vf = (*mybright)(col);
1022 greg 2.23 if (swapbytes)
1023 greg 2.29 swap32((char *)&vf, 1);
1024 greg 2.33 putbinary(&vf, sizeof(float), 1, stdout);
1025 greg 1.1
1026 greg 2.11 return(ferror(stdout) ? -1 : 0);
1027 greg 1.1 }
1028    
1029    
1030 schorsch 2.26 static int
1031     putbdouble( /* put a double brightness to stdout */
1032     COLOR col
1033     )
1034 greg 1.1 {
1035 greg 2.5 double vd;
1036 greg 1.1
1037 greg 2.14 vd = (*mybright)(col);
1038 greg 2.23 if (swapbytes)
1039     swap64((char *)&vd, 1);
1040 greg 2.33 putbinary(&vd, sizeof(double), 1, stdout);
1041 greg 1.1
1042 greg 2.11 return(ferror(stdout) ? -1 : 0);
1043 greg 1.1 }
1044    
1045    
1046 schorsch 2.26 static int
1047     putbint( /* put an int brightness to stdout */
1048     COLOR col
1049     )
1050 greg 1.1 {
1051 greg 2.14 fprintf(stdout, "%d\n", (int)((*mybright)(col)*256.));
1052 greg 1.1
1053 greg 2.11 return(ferror(stdout) ? -1 : 0);
1054 greg 1.1 }
1055    
1056    
1057 schorsch 2.26 static int
1058     putbbyte( /* put a byte brightness to stdout */
1059     COLOR col
1060     )
1061 greg 1.1 {
1062 greg 2.35 int i;
1063 greg 2.31 uby8 vb;
1064 greg 1.1
1065 greg 2.14 i = (*mybright)(col)*256.;
1066 greg 1.1 vb = min(i,255);
1067 greg 2.33 putbinary(&vb, sizeof(uby8), 1, stdout);
1068 greg 1.1
1069 greg 2.11 return(ferror(stdout) ? -1 : 0);
1070 greg 1.1 }
1071    
1072    
1073 schorsch 2.26 static int
1074     putbword( /* put a 16-bit brightness to stdout */
1075     COLOR col
1076     )
1077 greg 2.15 {
1078     long i;
1079     uint16 vw;
1080    
1081     i = (*mybright)(col)*65536.;
1082     vw = min(i,65535);
1083 greg 2.16 if (swapbytes)
1084 greg 2.29 swap16((char *)&vw, 1);
1085 greg 2.33 putbinary(&vw, sizeof(uint16), 1, stdout);
1086 greg 2.15
1087     return(ferror(stdout) ? -1 : 0);
1088     }
1089    
1090    
1091 schorsch 2.26 static int
1092     putpascii( /* put an ascii primary to stdout */
1093     COLOR col
1094     )
1095 greg 2.10 {
1096 greg 2.11 fprintf(stdout, "%15.3e\n", colval(col,putprim));
1097 greg 2.10
1098 greg 2.11 return(ferror(stdout) ? -1 : 0);
1099 greg 2.10 }
1100    
1101    
1102 schorsch 2.26 static int
1103     putpfloat( /* put a float primary to stdout */
1104     COLOR col
1105     )
1106 greg 2.10 {
1107     float vf;
1108    
1109     vf = colval(col,putprim);
1110 greg 2.23 if (swapbytes)
1111 greg 2.29 swap32((char *)&vf, 1);
1112 greg 2.33 putbinary(&vf, sizeof(float), 1, stdout);
1113 greg 2.10
1114 greg 2.11 return(ferror(stdout) ? -1 : 0);
1115 greg 2.10 }
1116    
1117    
1118 schorsch 2.26 static int
1119     putpdouble( /* put a double primary to stdout */
1120     COLOR col
1121     )
1122 greg 2.10 {
1123     double vd;
1124    
1125     vd = colval(col,putprim);
1126 greg 2.23 if (swapbytes)
1127     swap64((char *)&vd, 1);
1128 greg 2.33 putbinary(&vd, sizeof(double), 1, stdout);
1129 greg 2.10
1130 greg 2.11 return(ferror(stdout) ? -1 : 0);
1131 greg 2.10 }
1132    
1133    
1134 schorsch 2.26 static int
1135     putpint( /* put an int primary to stdout */
1136     COLOR col
1137     )
1138 greg 2.10 {
1139 greg 2.11 fprintf(stdout, "%d\n", (int)(colval(col,putprim)*256.));
1140 greg 2.10
1141 greg 2.11 return(ferror(stdout) ? -1 : 0);
1142 greg 2.10 }
1143    
1144    
1145 schorsch 2.26 static int
1146     putpbyte( /* put a byte primary to stdout */
1147     COLOR col
1148     )
1149 greg 2.10 {
1150 greg 2.15 long i;
1151 greg 2.31 uby8 vb;
1152 greg 2.10
1153     i = colval(col,putprim)*256.;
1154     vb = min(i,255);
1155 greg 2.33 putbinary(&vb, sizeof(uby8), 1, stdout);
1156 greg 2.10
1157 greg 2.11 return(ferror(stdout) ? -1 : 0);
1158 greg 2.10 }
1159    
1160    
1161 schorsch 2.26 static int
1162     putpword( /* put a 16-bit primary to stdout */
1163     COLOR col
1164     )
1165 greg 2.15 {
1166     long i;
1167     uint16 vw;
1168    
1169     i = colval(col,putprim)*65536.;
1170     vw = min(i,65535);
1171 greg 2.16 if (swapbytes)
1172 greg 2.29 swap16((char *)&vw, 1);
1173 greg 2.33 putbinary(&vw, sizeof(uint16), 1, stdout);
1174 greg 2.15
1175     return(ferror(stdout) ? -1 : 0);
1176     }
1177    
1178    
1179 schorsch 2.26 static void
1180     set_io(void) /* set put and get functions */
1181 greg 1.1 {
1182     switch (format) {
1183     case 'a': /* ascii */
1184 greg 2.10 if (putprim == BRIGHT) {
1185 greg 1.1 getval = getbascii;
1186     putval = putbascii;
1187 greg 2.10 } else if (putprim != ALL) {
1188     getval = getbascii;
1189     putval = putpascii;
1190 greg 1.1 } else {
1191     getval = getcascii;
1192     putval = putcascii;
1193 greg 2.12 if (reverse && !interleave) {
1194     fprintf(stderr,
1195     "%s: ASCII input files must be interleaved\n",
1196     progname);
1197     quit(1);
1198     }
1199 greg 1.1 }
1200     return;
1201     case 'f': /* binary float */
1202 greg 2.10 if (putprim == BRIGHT) {
1203 greg 1.1 getval = getbfloat;
1204     putval = putbfloat;
1205 greg 2.10 } else if (putprim != ALL) {
1206     getval = getbfloat;
1207     putval = putpfloat;
1208 greg 1.1 } else {
1209     getval = getcfloat;
1210     putval = putcfloat;
1211 greg 2.12 if (reverse && !interleave) {
1212     if (fin2 == NULL)
1213     goto namerr;
1214     if (fseek(fin2,
1215 greg 2.36 (long)sizeof(float)*picres.xr*picres.yr, SEEK_CUR))
1216 greg 2.12 goto seekerr;
1217     if (fseek(fin3,
1218 greg 2.36 (long)sizeof(float)*2*picres.xr*picres.yr, SEEK_CUR))
1219 greg 2.12 goto seekerr;
1220     }
1221 greg 1.1 }
1222     return;
1223     case 'd': /* binary double */
1224 greg 2.10 if (putprim == BRIGHT) {
1225 greg 1.1 getval = getbdouble;
1226     putval = putbdouble;
1227 greg 2.10 } else if (putprim != ALL) {
1228     getval = getbdouble;
1229     putval = putpdouble;
1230 greg 1.1 } else {
1231     getval = getcdouble;
1232     putval = putcdouble;
1233 greg 2.12 if (reverse && !interleave) {
1234     if (fin2 == NULL)
1235     goto namerr;
1236     if (fseek(fin2,
1237 greg 2.36 (long)sizeof(double)*picres.xr*picres.yr, SEEK_CUR))
1238 greg 2.12 goto seekerr;
1239     if (fseek(fin3,
1240 greg 2.36 (long)sizeof(double)*2*picres.xr*picres.yr, SEEK_CUR))
1241 greg 2.12 goto seekerr;
1242     }
1243 greg 1.1 }
1244     return;
1245     case 'i': /* integer */
1246 greg 2.10 if (putprim == BRIGHT) {
1247 greg 1.1 getval = getbint;
1248     putval = putbint;
1249 greg 2.10 } else if (putprim != ALL) {
1250     getval = getbint;
1251     putval = putpint;
1252 greg 1.1 } else {
1253     getval = getcint;
1254     putval = putcint;
1255 greg 2.12 if (reverse && !interleave) {
1256     fprintf(stderr,
1257     "%s: integer input files must be interleaved\n",
1258     progname);
1259     quit(1);
1260     }
1261 greg 1.1 }
1262     return;
1263     case 'b': /* byte */
1264 greg 2.10 if (putprim == BRIGHT) {
1265 greg 1.1 getval = getbbyte;
1266     putval = putbbyte;
1267 greg 2.10 } else if (putprim != ALL) {
1268     getval = getbbyte;
1269     putval = putpbyte;
1270 greg 1.1 } else {
1271     getval = getcbyte;
1272     putval = putcbyte;
1273 greg 2.12 if (reverse && !interleave) {
1274     if (fin2 == NULL)
1275     goto namerr;
1276     if (fseek(fin2,
1277 greg 2.36 (long)sizeof(uby8)*picres.xr*picres.yr, SEEK_CUR))
1278 greg 2.12 goto seekerr;
1279     if (fseek(fin3,
1280 greg 2.36 (long)sizeof(uby8)*2*picres.xr*picres.yr, SEEK_CUR))
1281 greg 2.15 goto seekerr;
1282     }
1283     }
1284     return;
1285     case 'w': /* 16-bit */
1286     if (putprim == BRIGHT) {
1287     getval = getbword;
1288     putval = putbword;
1289     } else if (putprim != ALL) {
1290     getval = getbword;
1291     putval = putpword;
1292     } else {
1293     getval = getcword;
1294     putval = putcword;
1295     if (reverse && !interleave) {
1296     if (fin2 == NULL)
1297     goto namerr;
1298     if (fseek(fin2,
1299 greg 2.36 (long)sizeof(uint16)*picres.xr*picres.yr, SEEK_CUR))
1300 greg 2.15 goto seekerr;
1301     if (fseek(fin3,
1302 greg 2.36 (long)sizeof(uint16)*2*picres.xr*picres.yr, SEEK_CUR))
1303 greg 2.12 goto seekerr;
1304     }
1305 greg 1.1 }
1306     return;
1307     }
1308 schorsch 2.26 /* badopt: */ /* label not used */
1309 greg 2.12 fprintf(stderr, "%s: botched file type\n", progname);
1310     quit(1);
1311     namerr:
1312     fprintf(stderr, "%s: non-interleaved file(s) must be named\n",
1313     progname);
1314     quit(1);
1315     seekerr:
1316     fprintf(stderr, "%s: cannot seek on interleaved input file\n",
1317     progname);
1318     quit(1);
1319 greg 1.1 }