ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/cal/rsplit.c
(Generate patch)

Comparing ray/src/cal/rsplit.c (file contents):
Revision 1.1 by greg, Fri Jul 5 00:20:57 2019 UTC vs.
Revision 1.13 by greg, Sat Apr 4 16:23:00 2020 UTC

# Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7   *      7/4/19          Greg Ward
8   */
9  
10 – #include <stdlib.h>
11 – #include <string.h>
12 – #include <stdio.h>
10   #include <ctype.h>
11  
12 + #include "rtio.h"
13   #include "platform.h"
14 + #include "paths.h"
15   #include "resolu.h"
17 – #include "rtio.h"
16  
17   #define DOHEADER        1
18   #define DORESOLU        2
19  
20   #define MAXFILE         512             /* maximum number of files */
21  
22 < FILE            *output[MAXFILE];
25 < int             bytsiz[MAXFILE];
26 < short           hdrflags[MAXFILE];
27 < const char      *format[MAXFILE];
28 < int             termc[MAXFILE];
29 < int             nfiles = 0;
22 > static int              swapped = 0;    /* input is byte-swapped */
23  
24 < int             outheader = 0;          /* output header to each stream? */
24 > static FILE             *output[MAXFILE];
25 > static int              ncomp[MAXFILE];
26 > static int              bytsiz[MAXFILE];
27 > static int              hdrflags[MAXFILE];
28 > static const char       *format[MAXFILE];
29 > static int              termc[MAXFILE];
30 > static int              nfiles = 0;
31  
32 < RESOLU          ourres = {PIXSTANDARD, 0, 0};
32 > static RESOLU   ourres = {PIXSTANDARD, 0, 0};
33  
34 < char            buf[16384];
34 > static char     buf[16384];             /* input buffer used in scanOK() */
35  
36  
37   /* process header line */
# Line 40 | Line 39 | static int
39   headline(char *s, void *p)
40   {
41          extern const char       FMTSTR[];
42 <        int                     i = nfiles;
42 >        int                     i;
43  
44          if (strstr(s, FMTSTR) == s)
45                  return(0);              /* don't copy format */
# Line 50 | Line 49 | headline(char *s, void *p)
49                  return(0);
50          if (!strncmp(s, "NCOMP=", 6))
51                  return(0);
52 +        if ((i = isbigendian(s)) >= 0) {
53 +                swapped = (nativebigendian() != i);
54 +                return(0);
55 +        }
56 +        i = nfiles;
57          while (i--)                     /* else copy line to output streams */
58                  if (hdrflags[i] & DOHEADER)
59                          fputs(s, output[i]);
# Line 61 | Line 65 | headline(char *s, void *p)
65   static int
66   scanOK(int termc)
67   {
68 +        int     skip_white = (termc == ' ');
69          char    *cp = buf;
70          int     c;
71  
72          while ((c = getchar()) != EOF) {
73 +                if (skip_white && isspace(c))
74 +                        continue;
75 +                skip_white = 0;
76 +                if (c == '\n' && isspace(termc))
77 +                        c = termc;      /* forgiving assumption */
78                  *cp++ = c;
79                  if (cp-buf >= sizeof(buf))
80                          break;
81 <                if (c == termc) {
81 >                if ((termc == ' ') ? isspace(c) : (c == termc)) {
82                          *cp = '\0';
83                          return(cp-buf);
84                  }
# Line 80 | Line 90 | scanOK(int termc)
90   int
91   main(int argc, char *argv[])
92   {
93 <        int             inpheader = 0;
94 <        int             inpres = 0;
85 <        int             outres = 0;
93 >        int             inpflags = 0;
94 >        int             needres = 0;
95          int             force = 0;
96          int             append = 0;
97          long            outcnt = 0;
98          int             bininp = 0;
99          int             curterm = '\n';
100 +        int             curncomp = 1;
101          int             curbytes = 0;
102          int             curflags = 0;
103          const char      *curfmt = "ascii";
# Line 98 | Line 108 | main(int argc, char *argv[])
108                          switch (argv[i][1]) {
109                          case 't':
110                                  curterm = argv[i][2];
111 +                                if (!curterm) curterm = '\n';
112                                  break;
113                          case 'i':
114                                  switch (argv[i][2]) {
115                                  case 'h':
116 <                                        inpheader = !inpheader;
116 >                                        inpflags ^= DOHEADER;
117                                          break;
118                                  case 'H':
119 <                                        inpres = !inpres;
119 >                                        inpflags ^= DORESOLU;
120                                          break;
121                                  default:
122                                          goto badopt;
123                                  }
124                                  break;
125                          case 'f':
126 <                                ++force;
116 <                                append = 0;
126 >                                force = !force;
127                                  break;
128                          case 'a':
129 <                                if (outheader | outres) {
120 <                                        fputs(argv[0], stderr);
121 <                                        fputs(": -a option incompatible with -oh and -oH\n",
122 <                                                        stderr);
123 <                                        return(1);
124 <                                }
125 <                                append = 1;
129 >                                append = !append;
130                                  break;
131                          case 'x':
132                                  ourres.xr = atoi(argv[++i]);
129 –                                outres = 1;
133                                  break;
134                          case 'y':
135                                  ourres.yr = atoi(argv[++i]);
133 –                                outres = 1;
136                                  break;
137                          case 'o':
138                                  switch (argv[i][2]) {
# Line 165 | Line 167 | main(int argc, char *argv[])
167                                          break;
168                                  case 'a':
169                                          curfmt = "ascii";
170 <                                        curbytes = argv[i][3] ? -1 : 0;
170 >                                        curbytes = 0;
171                                          break;
172                                  default:
173                                          goto badopt;
174                                  }
175 <                                if (isdigit(argv[i][3]))
176 <                                        curbytes *= atoi(argv[i]+3);
177 <                                curbytes += (curbytes == -1);
176 <                                if (curbytes > (int)sizeof(buf)) {
175 >                                curncomp = isdigit(argv[i][3]) ?
176 >                                                        atoi(argv[i]+3) : 1 ;
177 >                                if (curbytes*curncomp > (int)sizeof(buf)) {
178                                          fputs(argv[0], stderr);
179                                          fputs(": output size too big\n", stderr);
180                                          return(1);
181                                  }
182 <                                if (curbytes > 0) {
182 <                                        curterm = '\0';
183 <                                        ++bininp;
184 <                                }
182 >                                bininp += (curbytes > 0);
183                                  break;
184                          case '\0':
185 <                                outres |= (curflags & DORESOLU);
185 >                                needres |= (curflags & DORESOLU);
186                                  termc[nfiles] = curterm;
187                                  hdrflags[nfiles] = curflags;
188                                  output[nfiles] = stdout;
189                                  if (curbytes > 0)
190                                          SET_FILE_BINARY(output[nfiles]);
191                                  format[nfiles] = curfmt;
192 +                                ncomp[nfiles] = curncomp;
193                                  bytsiz[nfiles++] = curbytes;
194                                  break;
195                          badopt:;
# Line 199 | Line 198 | main(int argc, char *argv[])
198                                  fputs(": bad option\n", stderr);
199                                  return(1);
200                          }
201 +                } else if (argv[i][0] == '.' && !argv[i][1]) {
202 +                        output[nfiles] = NULL;          /* discard data */
203 +                        termc[nfiles] = curterm;
204 +                        format[nfiles] = curfmt;
205 +                        ncomp[nfiles] = curncomp;
206 +                        bytsiz[nfiles++] = curbytes;
207                  } else if (argv[i][0] == '!') {
208 <                        outres |= (curflags & DORESOLU);
208 >                        needres |= (curflags & DORESOLU);
209                          termc[nfiles] = curterm;
210                          hdrflags[nfiles] = curflags;
211                          if ((output[nfiles] = popen(argv[i]+1, "w")) == NULL) {
# Line 211 | Line 216 | main(int argc, char *argv[])
216                          if (curbytes > 0)
217                                  SET_FILE_BINARY(output[nfiles]);
218                          format[nfiles] = curfmt;
219 +                        ncomp[nfiles] = curncomp;
220                          bytsiz[nfiles++] = curbytes;
221                  } else {
222 <                        outres |= (curflags & DORESOLU);
222 >                        if (append & (curflags != 0)) {
223 >                                fputs(argv[0], stderr);
224 >                                fputs(": -a option incompatible with -oh and -oH\n",
225 >                                                stderr);
226 >                                return(1);
227 >                        }
228 >                        needres |= (curflags & DORESOLU);
229                          termc[nfiles] = curterm;
230                          hdrflags[nfiles] = curflags;
231                          if (!append & !force && access(argv[i], F_OK) == 0) {
# Line 231 | Line 243 | main(int argc, char *argv[])
243                          if (curbytes > 0)
244                                  SET_FILE_BINARY(output[nfiles]);
245                          format[nfiles] = curfmt;
246 +                        ncomp[nfiles] = curncomp;
247                          bytsiz[nfiles++] = curbytes;
248                  }
249                  if (nfiles >= MAXFILE) {
# Line 249 | Line 262 | main(int argc, char *argv[])
262   #ifdef getc_unlocked                            /* avoid lock/unlock overhead */
263          flockfile(stdin);
264          for (i = nfiles; i--; )
265 <                flockfile(output[i]);
265 >                if (output[i] != NULL)
266 >                        flockfile(output[i]);
267   #endif
268                                                  /* load/copy header */
269 <        if (inpheader && getheader(stdin, headline, NULL) < 0) {
269 >        if (inpflags & DOHEADER && getheader(stdin, headline, NULL) < 0) {
270                  fputs(argv[0], stderr);
271                  fputs(": cannot get header from standard input\n",
272                                  stderr);
273                  return(1);
274          }
275                                                  /* handle resolution string */
276 <        if (inpres && !fgetsresolu(&ourres, stdin)) {
276 >        if (inpflags & DORESOLU && !fgetsresolu(&ourres, stdin)) {
277                  fputs(argv[0], stderr);
278                  fputs(": cannot get resolution string from standard input\n",
279                                  stderr);
280                  return(1);
281          }
282 <        if (outres && (ourres.xr <= 0) | (ourres.yr <= 0)) {
282 >        if (needres && (ourres.xr <= 0) | (ourres.yr <= 0)) {
283                  fputs(argv[0], stderr);
284                  fputs(": -oH option requires -iH or -x and -y options\n", stderr);
285                  return(1);
# Line 281 | Line 295 | main(int argc, char *argv[])
295          }
296          for (i = 0; i < nfiles; i++) {          /* complete headers */
297                  if (hdrflags[i] & DOHEADER) {
298 <                        if (!inpheader)
298 >                        if (!(inpflags & DOHEADER))
299                                  newheader("RADIANCE", output[i]);
300                          printargs(argc, argv, output[i]);
301 <                        if (format[i] != NULL)
301 >                        fprintf(output[i], "NCOMP=%d\n", ncomp[i]);
302 >                        if (format[i] != NULL) {
303 >                                extern const char  BIGEND[];
304 >                                if ((format[i][0] == 'f') |
305 >                                                (format[i][0] == 'd')) {
306 >                                        fputs(BIGEND, output[i]);
307 >                                        fputs(nativebigendian() ^ swapped ?
308 >                                                "1\n" : "0\n", output[i]);
309 >                                }
310                                  fputformat(format[i], output[i]);
311 +                        }
312                          fputc('\n', output[i]);
313                  }
314                  if (hdrflags[i] & DORESOLU)
# Line 294 | Line 317 | main(int argc, char *argv[])
317          do {                                    /* main loop */
318                  for (i = 0; i < nfiles; i++) {
319                          if (bytsiz[i] > 0) {            /* binary output */
320 <                                if (getbinary(buf, bytsiz[i], 1, stdin) < 1)
320 >                                if (getbinary(buf, bytsiz[i], ncomp[i],
321 >                                                        stdin) < ncomp[i])
322                                          break;
323 <                                putbinary(buf, bytsiz[i], 1, output[i]);
324 <                        } else if (bytsiz[i] < 0) {     /* N-field output */
325 <                                int     n = -bytsiz[i];
323 >                                if (output[i] != NULL &&
324 >                                            putbinary(buf, bytsiz[i], ncomp[i],
325 >                                                        output[i]) < ncomp[i])
326 >                                        break;
327 >                        } else if (ncomp[i] > 1) {      /* N-field output */
328 >                                int     n = ncomp[i];
329                                  while (n--) {
330                                          if (!scanOK(termc[i]))
331                                                  break;
332 <                                        fputs(buf, output[i]);
332 >                                        if (output[i] != NULL &&
333 >                                                    fputs(buf, output[i]) == EOF)
334 >                                                break;
335                                  }
336                                  if (n >= 0)             /* fell short? */
337                                          break;
338 +                                if ((output[i] != NULL) &  /* add EOL if none */
339 +                                                (termc[i] != '\n'))
340 +                                        fputc('\n', output[i]);
341                          } else {                        /* 1-field output */
342                                  if (!scanOK(termc[i]))
343                                          break;
344 <                                fputs(buf, output[i]);
344 >                                if (output[i] != NULL) {
345 >                                        if (fputs(buf, output[i]) == EOF)
346 >                                                break;
347 >                                        if (termc[i] != '\n')   /* add EOL? */
348 >                                                fputc('\n', output[i]);
349 >                                }
350                          }
351 +                                                        /* skip input EOL? */
352 +                        if (!bininp && termc[nfiles-1] != '\n') {
353 +                                int     c = getchar();
354 +                                if ((c != '\n') & (c != EOF))
355 +                                        ungetc(c, stdin);
356 +                        }
357                  }
358                  if (i < nfiles)
359                          break;
360          } while (--outcnt);
361 +                                                        /* check ending */
362 +        if (fflush(NULL) == EOF) {
363 +                fputs(argv[0], stderr);
364 +                fputs(": write error on one or more outputs\n", stderr);
365 +                return(1);
366 +        }
367 +        if (outcnt > 0) {
368 +                fputs(argv[0], stderr);
369 +                fputs(": warning: premature EOD\n", stderr);
370 +        }
371          return(0);
372   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines