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.9 by greg, Tue Aug 13 16:31:35 2019 UTC vs.
Revision 1.15 by greg, Sun Apr 5 15:07:09 2020 UTC

# Line 19 | Line 19 | static const char      RCSid[] = "$Id$";
19  
20   #define MAXFILE         512             /* maximum number of files */
21  
22 + static int              swapped = 0;    /* input is byte-swapped */
23 +
24   static FILE             *output[MAXFILE];
25 + static int              ncomp[MAXFILE];
26   static int              bytsiz[MAXFILE];
27 < static short            hdrflags[MAXFILE];
27 > static int              hdrflags[MAXFILE];
28   static const char       *format[MAXFILE];
29   static int              termc[MAXFILE];
30   static int              nfiles = 0;
# Line 36 | 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 46 | 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 57 | 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 82 | Line 96 | main(int argc, char *argv[])
96          int             append = 0;
97          long            outcnt = 0;
98          int             bininp = 0;
99 +        int             nstdoutcomp = 0;
100          int             curterm = '\n';
101 +        int             curncomp = 1;
102          int             curbytes = 0;
103          int             curflags = 0;
104          const char      *curfmt = "ascii";
105 <        int     i;
105 >        short           outndx[MAXFILE];
106 >        int             i;
107  
108 +        memset(outndx, 0, sizeof(outndx));
109          for (i = 1; i < argc; i++) {
110                  if (argv[i][0] == '-') {
111                          switch (argv[i][1]) {
# Line 152 | Line 170 | main(int argc, char *argv[])
170                                          break;
171                                  case 'a':
172                                          curfmt = "ascii";
173 <                                        curbytes = -1;
173 >                                        curbytes = 0;
174                                          break;
175                                  default:
176                                          goto badopt;
177                                  }
178 <                                if (isdigit(argv[i][3]))
179 <                                        curbytes *= atoi(argv[i]+3);
180 <                                curbytes += (curbytes == -1);
163 <                                if (curbytes > (int)sizeof(buf)) {
178 >                                curncomp = isdigit(argv[i][3]) ?
179 >                                                        atoi(argv[i]+3) : 1 ;
180 >                                if (curbytes*curncomp > (int)sizeof(buf)) {
181                                          fputs(argv[0], stderr);
182                                          fputs(": output size too big\n", stderr);
183                                          return(1);
184                                  }
185                                  bininp += (curbytes > 0);
186                                  break;
187 <                        case '\0':
188 <                                needres |= (curflags & DORESOLU);
189 <                                termc[nfiles] = curterm;
190 <                                hdrflags[nfiles] = curflags;
187 >                        case '\0':                      /* stdout */
188 >                                if (!nstdoutcomp) {     /* first use? */
189 >                                        needres |= (curflags & DORESOLU);
190 >                                        hdrflags[nfiles] = curflags;
191 >                                }
192                                  output[nfiles] = stdout;
193                                  if (curbytes > 0)
194                                          SET_FILE_BINARY(output[nfiles]);
195 +                                termc[nfiles] = curterm;
196                                  format[nfiles] = curfmt;
197 <                                bytsiz[nfiles++] = curbytes;
197 >                                nstdoutcomp +=
198 >                                        ncomp[nfiles] = curncomp;
199 >                                bytsiz[nfiles] = curbytes;
200 >                                outndx[nfiles++] = i;
201                                  break;
202                          badopt:;
203                          default:
# Line 183 | Line 205 | main(int argc, char *argv[])
205                                  fputs(": bad option\n", stderr);
206                                  return(1);
207                          }
208 +                } else if (argv[i][0] == '.' && !argv[i][1]) {
209 +                        output[nfiles] = NULL;          /* discard data */
210 +                        termc[nfiles] = curterm;
211 +                        format[nfiles] = curfmt;
212 +                        ncomp[nfiles] = curncomp;
213 +                        bytsiz[nfiles] = curbytes;
214 +                        outndx[nfiles++] = i;
215                  } else if (argv[i][0] == '!') {
216                          needres |= (curflags & DORESOLU);
188 –                        termc[nfiles] = curterm;
217                          hdrflags[nfiles] = curflags;
218 +                        termc[nfiles] = curterm;
219                          if ((output[nfiles] = popen(argv[i]+1, "w")) == NULL) {
220                                  fputs(argv[i], stderr);
221                                  fputs(": cannot start command\n", stderr);
# Line 195 | Line 224 | main(int argc, char *argv[])
224                          if (curbytes > 0)
225                                  SET_FILE_BINARY(output[nfiles]);
226                          format[nfiles] = curfmt;
227 <                        bytsiz[nfiles++] = curbytes;
227 >                        ncomp[nfiles] = curncomp;
228 >                        bytsiz[nfiles] = curbytes;
229 >                        outndx[nfiles++] = i;
230                  } else {
231 +                        int     j = nfiles;
232 +                        while (j--)                     /* check duplicates */
233 +                                if (!strcmp(argv[i], argv[outndx[j]])) {
234 +                                        fputs(argv[0], stderr);
235 +                                        fputs(": duplicate output: ", stderr);
236 +                                        fputs(argv[i], stderr);
237 +                                        fputc('\n', stderr);
238 +                                        return(1);
239 +                                }
240                          if (append & (curflags != 0)) {
241                                  fputs(argv[0], stderr);
242                                  fputs(": -a option incompatible with -oh and -oH\n",
# Line 204 | Line 244 | main(int argc, char *argv[])
244                                  return(1);
245                          }
246                          needres |= (curflags & DORESOLU);
207 –                        termc[nfiles] = curterm;
247                          hdrflags[nfiles] = curflags;
248 +                        termc[nfiles] = curterm;
249                          if (!append & !force && access(argv[i], F_OK) == 0) {
250                                  fputs(argv[i], stderr);
251                                  fputs(": file exists -- use -f to overwrite\n",
# Line 221 | Line 261 | main(int argc, char *argv[])
261                          if (curbytes > 0)
262                                  SET_FILE_BINARY(output[nfiles]);
263                          format[nfiles] = curfmt;
264 <                        bytsiz[nfiles++] = curbytes;
264 >                        ncomp[nfiles] = curncomp;
265 >                        bytsiz[nfiles] = curbytes;
266 >                        outndx[nfiles++] = i;
267                  }
268                  if (nfiles >= MAXFILE) {
269                          fputs(argv[0], stderr);
# Line 239 | Line 281 | main(int argc, char *argv[])
281   #ifdef getc_unlocked                            /* avoid lock/unlock overhead */
282          flockfile(stdin);
283          for (i = nfiles; i--; )
284 <                flockfile(output[i]);
284 >                if (output[i] != NULL)
285 >                        ftrylockfile(output[i]);
286   #endif
287                                                  /* load/copy header */
288          if (inpflags & DOHEADER && getheader(stdin, headline, NULL) < 0) {
289                  fputs(argv[0], stderr);
290 <                fputs(": cannot get header from standard input\n",
290 >                fputs(": cannot read header from standard input\n",
291                                  stderr);
292                  return(1);
293          }
294                                                  /* handle resolution string */
295          if (inpflags & DORESOLU && !fgetsresolu(&ourres, stdin)) {
296                  fputs(argv[0], stderr);
297 <                fputs(": cannot get resolution string from standard input\n",
255 <                                stderr);
297 >                fputs(": bad resolution string on standard input\n", stderr);
298                  return(1);
299          }
300          if (needres && (ourres.xr <= 0) | (ourres.yr <= 0)) {
# Line 274 | Line 316 | main(int argc, char *argv[])
316                          if (!(inpflags & DOHEADER))
317                                  newheader("RADIANCE", output[i]);
318                          printargs(argc, argv, output[i]);
319 <                        if (format[i] != NULL)
319 >                        fprintf(output[i], "NCOMP=%d\n", output[i]==stdout ?
320 >                                                nstdoutcomp : ncomp[i]);
321 >                        if (format[i] != NULL) {
322 >                                extern const char  BIGEND[];
323 >                                if (bytsiz[i] > 1) {
324 >                                        fputs(BIGEND, output[i]);
325 >                                        fputs(nativebigendian() ^ swapped ?
326 >                                                "1\n" : "0\n", output[i]);
327 >                                }
328                                  fputformat(format[i], output[i]);
329 +                        }
330                          fputc('\n', output[i]);
331                  }
332                  if (hdrflags[i] & DORESOLU)
# Line 284 | Line 335 | main(int argc, char *argv[])
335          do {                                    /* main loop */
336                  for (i = 0; i < nfiles; i++) {
337                          if (bytsiz[i] > 0) {            /* binary output */
338 <                                if (getbinary(buf, bytsiz[i], 1, stdin) < 1)
338 >                                if (getbinary(buf, bytsiz[i], ncomp[i],
339 >                                                        stdin) < ncomp[i])
340                                          break;
341 <                                if (putbinary(buf, bytsiz[i], 1, output[i]) < 1)
341 >                                if (output[i] != NULL &&
342 >                                            putbinary(buf, bytsiz[i], ncomp[i],
343 >                                                        output[i]) < ncomp[i])
344                                          break;
345 <                        } else if (bytsiz[i] < 0) {     /* N-field output */
346 <                                int     n = -bytsiz[i];
345 >                        } else if (ncomp[i] > 1) {      /* N-field output */
346 >                                int     n = ncomp[i];
347                                  while (n--) {
348                                          if (!scanOK(termc[i]))
349                                                  break;
350 <                                        if (fputs(buf, output[i]) == EOF)
350 >                                        if (output[i] != NULL &&
351 >                                                    fputs(buf, output[i]) == EOF)
352                                                  break;
353                                  }
354                                  if (n >= 0)             /* fell short? */
355                                          break;
356 <                                if (termc[i] != '\n')   /* add EOL if none */
356 >                                if ((output[i] != NULL) &  /* add EOL if none */
357 >                                                (termc[i] != '\n'))
358                                          fputc('\n', output[i]);
359                          } else {                        /* 1-field output */
360                                  if (!scanOK(termc[i]))
361                                          break;
362 <                                if (fputs(buf, output[i]) == EOF)
363 <                                        break;
364 <                                if (termc[i] != '\n')   /* add EOL if none */
365 <                                        fputc('\n', output[i]);
362 >                                if (output[i] != NULL) {
363 >                                        if (fputs(buf, output[i]) == EOF)
364 >                                                break;
365 >                                        if (termc[i] != '\n')   /* add EOL? */
366 >                                                fputc('\n', output[i]);
367 >                                }
368                          }
369                                                          /* skip input EOL? */
370                          if (!bininp && termc[nfiles-1] != '\n') {

Diff Legend

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