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

Comparing ray/src/rt/rc2.c (file contents):
Revision 2.6 by greg, Thu Jun 21 17:14:32 2012 UTC vs.
Revision 2.27 by greg, Wed May 22 21:44:03 2024 UTC

# Line 6 | Line 6 | static const char RCSid[] = "$Id$";
6   * File i/o and recovery
7   */
8  
9 + #include <ctype.h>
10 + #include "platform.h"
11   #include "rcontrib.h"
12   #include "resolu.h"
13  
# Line 111 | Line 113 | printheader(FILE *fout, const char *info)
113          printargs(gargc-1, gargv, fout);        /* add our command */
114          fprintf(fout, "SOFTWARE= %s\n", VersionID);
115          fputnow(fout);
116 +        fputncomp(NCSAMP, fout);
117 +        if (NCSAMP > 3)
118 +                fputwlsplit(WLPART, fout);
119          if (info != NULL)                       /* add extra info if given */
120                  fputs(info, fout);
121 +        if ((outfmt == 'f') | (outfmt == 'd'))
122 +                fputendian(fout);
123          fputformat(formstr(outfmt), fout);
124          fputc('\n', fout);                      /* empty line ends header */
125   }
# Line 131 | Line 138 | printresolu(FILE *fout, int xr, int yr)
138   STREAMOUT *
139   getostream(const char *ospec, const char *mname, int bn, int noopen)
140   {
134 –        /* static const DCOLOR  nocontrib = BLKCOLOR; */
141          static STREAMOUT        stdos;
142 +        char                    info[1024];
143          int                     ofl;
144          char                    oname[1024];
145          LUENT                   *lep;
146          STREAMOUT               *sop;
147 <        
147 >        char                    *cp;
148 >
149 >        info[0] = '\0';
150          if (ospec == NULL) {                    /* use stdout? */
151                  if (!noopen & !using_stdout) {
152                          if (outfmt != 'a')
153                                  SET_FILE_BINARY(stdout);
145 –                        if (header)
146 –                                printheader(stdout, NULL);
147 –                        printresolu(stdout, xres, yres);
148 –                        if (waitflush > 0)
149 –                                fflush(stdout);
150 –                        stdos.xr = xres; stdos.yr = yres;
154   #ifdef getc_unlocked
155                          flockfile(stdout);      /* avoid lock/unlock overhead */
156   #endif
157 +                        if (header) {
158 +                                cp = info;
159 +                                if (yres > 0) {
160 +                                        sprintf(cp, "NROWS=%d\n", yres *
161 +                                                        (xres + !xres) );
162 +                                        while (*cp) ++cp;
163 +                                }
164 +                                if ((xres <= 0) | (stdos.reclen > 1))
165 +                                        sprintf(cp, "NCOLS=%d\n", stdos.reclen);
166 +                                printheader(stdout, info);
167 +                        }
168 +                        if (stdos.reclen == 1)
169 +                                printresolu(stdout, xres, yres);
170 +                        if (waitflush > 0)
171 +                                fflush(stdout);
172 +                        stdos.xr = xres; stdos.yr = yres;
173                          using_stdout = 1;
174                  }
175                  stdos.ofp = stdout;
# Line 170 | Line 189 | getostream(const char *ospec, const char *mname, int b
189                  sop = (STREAMOUT *)malloc(sizeof(STREAMOUT));
190                  if (sop == NULL)
191                          error(SYSTEM, "out of memory in getostream");
192 <                sop->outpipe = oname[0] == '!';
192 >                sop->outpipe = (oname[0] == '!');
193                  sop->reclen = 0;
194                  sop->ofp = NULL;                /* open iff noopen==0 */
195                  sop->xr = xres; sop->yr = yres;
# Line 180 | Line 199 | getostream(const char *ospec, const char *mname, int b
199                          errno = EEXIST;         /* file exists */
200                          goto openerr;
201                  }
202 +        } else if (noopen && outfmt == 'c' &&   /* stream exists to picture? */
203 +                        (sop->xr > 0) & (sop->yr > 0)) {
204 +                if (ofl & OF_BIN)
205 +                        return(NULL);           /* let caller offset bins */
206 +                sprintf(errmsg, "output '%s' not a valid picture", oname);
207 +                error(WARNING, errmsg);
208          }
209          if (!noopen && sop->ofp == NULL) {      /* open output stream */
185 –                long            i;
210                  if (oname[0] == '!')            /* output to command */
211                          sop->ofp = popen(oname+1, "w");
212                  else                            /* else open file */
# Line 194 | Line 218 | getostream(const char *ospec, const char *mname, int b
218   #ifdef getc_unlocked
219                  flockfile(sop->ofp);            /* avoid lock/unlock overhead */
220   #endif
221 +                if (accumulate > 0) {           /* global resolution */
222 +                        sop->xr = xres; sop->yr = yres;
223 +                }
224                  if (header) {
225 <                        char    info[512];
199 <                        char    *cp = info;
225 >                        cp = info;
226                          if (ofl & OF_MODIFIER || sop->reclen == 1) {
227                                  sprintf(cp, "MODIFIER=%s\n", mname);
228                                  while (*cp) ++cp;
# Line 205 | Line 231 | getostream(const char *ospec, const char *mname, int b
231                                  sprintf(cp, "BIN=%d\n", bn);
232                                  while (*cp) ++cp;
233                          }
234 <                        *cp = '\0';
234 >                        if (sop->yr > 0) {
235 >                                sprintf(cp, "NROWS=%d\n", sop->yr *
236 >                                                (sop->xr + !sop->xr) );
237 >                                while (*cp) ++cp;
238 >                        }
239 >                        if ((sop->xr <= 0) | (sop->reclen > 1))
240 >                                sprintf(cp, "NCOLS=%d\n", sop->reclen);
241                          printheader(sop->ofp, info);
242                  }
243 <                if (accumulate > 0) {           /* global resolution */
244 <                        sop->xr = xres; sop->yr = yres;
213 <                }
214 <                printresolu(sop->ofp, sop->xr, sop->yr);
215 < #if 0
216 <                                                /* play catch-up */
217 <                for (i = accumulate > 0 ? lastdone/accumulate : 0; i--; ) {
218 <                        int     j = sop->reclen;
219 <                        if (j <= 0) j = 1;
220 <                        while (j--)
221 <                                put_contrib(nocontrib, sop->ofp);
222 <                        if (outfmt == 'a')
223 <                                putc('\n', sop->ofp);
224 <                }
225 < #endif
243 >                if (sop->reclen == 1)
244 >                        printresolu(sop->ofp, sop->xr, sop->yr);
245                  if (waitflush > 0)
246                          fflush(sop->ofp);
247          }
# Line 254 | Line 273 | getvec(FVECT vec)
273                  }
274                  break;
275          case 'f':                                       /* binary float */
276 <                if (fread((char *)vf, sizeof(float), 3, stdin) != 3)
276 >                if (getbinary(vf, sizeof(float), 3, stdin) != 3)
277                          return(-1);
278                  VCOPY(vec, vf);
279                  break;
280          case 'd':                                       /* binary double */
281 <                if (fread((char *)vd, sizeof(double), 3, stdin) != 3)
281 >                if (getbinary(vd, sizeof(double), 3, stdin) != 3)
282                          return(-1);
283                  VCOPY(vec, vd);
284                  break;
# Line 272 | Line 291 | getvec(FVECT vec)
291  
292   /* Put out ray contribution to file */
293   static void
294 < put_contrib(const DCOLOR cnt, FILE *fout)
294 > put_contrib(const DCOLORV *cnt, FILE *fout)
295   {
296          double  sf = 1;
297 <        COLOR   fv;
298 <        COLR    cv;
297 >        SCOLOR  fv;
298 >        SCOLR   cv;
299 >        int     i;
300  
301          if (accumulate > 1)
302                  sf = 1./(double)accumulate;
303          switch (outfmt) {
304          case 'a':
305 <                if (accumulate > 1)
306 <                        fprintf(fout, "%.6e\t%.6e\t%.6e\t",
287 <                                        sf*cnt[0], sf*cnt[1], sf*cnt[2]);
288 <                else
289 <                        fprintf(fout, "%.6e\t%.6e\t%.6e\t",
290 <                                        cnt[0], cnt[1], cnt[2]);
305 >                for (i = 0; i < NCSAMP; i++)
306 >                        fprintf(fout, "%.6e\t", sf*cnt[i]);
307                  break;
308          case 'f':
309 <                if (accumulate > 1) {
310 <                        copycolor(fv, cnt);
311 <                        scalecolor(fv, sf);
312 <                } else
313 <                        copycolor(fv, cnt);
298 <                fwrite(fv, sizeof(float), 3, fout);
309 >                for (i = NCSAMP; i-- > 0; )
310 >                        fv[i] = cnt[i];
311 >                if (accumulate > 1)
312 >                        scalescolor(fv, sf);
313 >                putbinary(fv, sizeof(COLORV), NCSAMP, fout);
314                  break;
315          case 'd':
316                  if (accumulate > 1) {
317 <                        DCOLOR  dv;
318 <                        copycolor(dv, cnt);
319 <                        scalecolor(dv, sf);
320 <                        fwrite(dv, sizeof(double), 3, fout);
317 >                        DCOLORV dv[MAXCSAMP];
318 >                        for (i = NCSAMP; i-- > 0; )
319 >                                dv[i] = sf*cnt[i];
320 >                        putbinary(dv, sizeof(DCOLORV), NCSAMP, fout);
321                  } else
322 <                        fwrite(cnt, sizeof(double), 3, fout);
322 >                        putbinary(cnt, sizeof(DCOLORV), NCSAMP, fout);
323                  break;
324          case 'c':
325 +                for (i = NCSAMP; i-- > 0; )
326 +                        fv[i] = cnt[i];
327                  if (accumulate > 1)
328 <                        setcolr(cv, sf*cnt[0], sf*cnt[1], sf*cnt[2]);
329 <                else
330 <                        setcolr(cv, cnt[0], cnt[1], cnt[2]);
314 <                fwrite(cv, sizeof(cv), 1, fout);
328 >                        scalescolor(fv, sf);
329 >                scolor_scolr(cv, fv);
330 >                putbinary(cv, 1, LSCOLR, fout);
331                  break;
332          default:
333                  error(INTERNAL, "botched output format");
# Line 323 | Line 339 | put_contrib(const DCOLOR cnt, FILE *fout)
339   void
340   mod_output(MODCONT *mp)
341   {
342 <        STREAMOUT       *sop = getostream(mp->outspec, mp->modname, 0, 0);
342 >        STREAMOUT       *sop = getostream(mp->outspec, mp->modname, mp->bin0, 0);
343          int             j;
344  
345 <        put_contrib(mp->cbin[0], sop->ofp);
345 >        put_contrib(mp->cbin, sop->ofp);
346          if (mp->nbins > 3 &&    /* minor optimization */
347 <                        sop == getostream(mp->outspec, mp->modname, 1, 0)) {
347 >                        sop == getostream(mp->outspec, mp->modname, mp->bin0+1, 0)) {
348                  for (j = 1; j < mp->nbins; j++)
349 <                        put_contrib(mp->cbin[j], sop->ofp);
349 >                        put_contrib(mcbin(mp,j), sop->ofp);
350          } else {
351                  for (j = 1; j < mp->nbins; j++) {
352 <                        sop = getostream(mp->outspec, mp->modname, j, 0);
353 <                        put_contrib(mp->cbin[j], sop->ofp);
352 >                        sop = getostream(mp->outspec, mp->modname, mp->bin0+j, 0);
353 >                        put_contrib(mcbin(mp,j), sop->ofp);
354                  }
355          }
356   }
# Line 363 | Line 379 | void
379   end_record()
380   {
381          --waitflush;
382 <        lu_doall(&ofiletab, puteol, NULL);
382 >        lu_doall(&ofiletab, &puteol, NULL);
383          if (using_stdout & (outfmt == 'a'))
384                  putc('\n', stdout);
385          if (!waitflush) {
# Line 377 | Line 393 | end_record()
393  
394   /* Get ray contribution from previous file */
395   static int
396 < get_contrib(DCOLOR cnt, FILE *finp)
396 > get_contrib(DCOLORV *cnt, FILE *finp)
397   {
398 <        COLOR   fv;
399 <        COLR    cv;
398 >        SCOLOR  fv;
399 >        SCOLR   cv;
400 >        int     i;
401  
402          switch (outfmt) {
403          case 'a':
404 <                return(fscanf(finp,"%lf %lf %lf",&cnt[0],&cnt[1],&cnt[2]) == 3);
405 <        case 'f':
406 <                if (fread(fv, sizeof(fv[0]), 3, finp) != 3)
390 <                        return(0);
391 <                copycolor(cnt, fv);
404 >                for (i = 0; i < NCSAMP; i++)
405 >                        if (fscanf(finp, "%lf", &cnt[i]) != 1)
406 >                                return(0);
407                  return(1);
408          case 'd':
409 <                return(fread(cnt, sizeof(cnt[0]), 3, finp) == 3);
409 >                return(getbinary(cnt, sizeof(DCOLORV), NCSAMP, finp) == NCSAMP);
410 >        case 'f':
411 >                if (getbinary(fv, sizeof(COLORV), NCSAMP, finp) != NCSAMP)
412 >                        return(0);
413 >                break;
414          case 'c':
415 <                if (fread(cv, sizeof(cv), 1, finp) != 1)
415 >                if (getbinary(cv, 1, LSCOLR, finp) != LSCOLR)
416                          return(0);
417 <                colr_color(fv, cv);
418 <                copycolor(cnt, fv);
400 <                return(1);
417 >                scolr_scolor(fv, cv);
418 >                break;
419          default:
420                  error(INTERNAL, "botched output format");
421          }
422 <        return(0);      /* pro forma return */
422 >                        /* copy result from SCOLOR */
423 >        for (i = NCSAMP; i-- > 0; )
424 >                cnt[i] = fv[i];
425 >        return(1);
426   }
427  
428  
# Line 431 | Line 452 | reload_output()
452          char            *outvfmt;
453          LUENT           *oent;
454          int             xr, yr;
455 <        STREAMOUT       sout;
456 <        DCOLOR          rgbv;
455 >        STREAMOUT       *sop;
456 >        DCOLORV         contr[MAXCSAMP];
457  
458          if (outfmt == 'a')
459                  fmode = "r";
460 <        outvfmt = formstr(outfmt);
460 >        outvfmt = (char *)formstr(outfmt);
461                                                  /* reload modifier values */
462          for (i = 0; i < nmods; i++) {
463                  mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
# Line 444 | Line 465 | reload_output()
465                          error(USER, "cannot reload from stdout");
466                  if (mp->outspec[0] == '!')
467                          error(USER, "cannot reload from command");
468 <                for (j = 0; ; j++) {            /* load each modifier bin */
469 <                        ofl = ofname(oname, mp->outspec, mp->modname, j);
468 >                for (j = 0; j < mp->nbins; j++) { /* load each modifier bin */
469 >                        ofl = ofname(oname, mp->outspec, mp->modname, mp->bin0+j);
470                          if (ofl < 0)
471                                  error(USER, "bad output file specification");
472                          oent = lu_find(&ofiletab, oname);
473 <                        if (oent->data != NULL) {
474 <                                sout = *(STREAMOUT *)oent->data;
475 <                        } else {
476 <                                sout.reclen = 0;
477 <                                sout.outpipe = 0;
478 <                                sout.xr = xres; sout.yr = yres;
458 <                                sout.ofp = NULL;
459 <                        }
460 <                        if (sout.ofp == NULL) { /* open output as input */
461 <                                sout.ofp = fopen(oname, fmode);
462 <                                if (sout.ofp == NULL) {
463 <                                        if (j == mp->nbins)
464 <                                                break;  /* assume end of modifier */
473 >                        if (oent->data == NULL)
474 >                                error(INTERNAL, "unallocated stream in reload_output()");
475 >                        sop = (STREAMOUT *)oent->data;
476 >                        if (sop->ofp == NULL) { /* open output as input */
477 >                                sop->ofp = fopen(oname, fmode);
478 >                                if (sop->ofp == NULL) {
479                                          sprintf(errmsg, "missing reload file '%s'",
480                                                          oname);
481                                          error(WARNING, errmsg);
482                                          break;
483                                  }
484   #ifdef getc_unlocked
485 <                                flockfile(sout.ofp);
485 >                                flockfile(sop->ofp);
486   #endif
487 <                                if (header && checkheader(sout.ofp, outvfmt, NULL) != 1) {
487 >                                if (header && checkheader(sop->ofp, outvfmt, NULL) != 1) {
488                                          sprintf(errmsg, "format mismatch for '%s'",
489                                                          oname);
490                                          error(USER, errmsg);
491                                  }
492 <                                if ((sout.xr > 0) & (sout.yr > 0) &&
493 <                                                (!fscnresolu(&xr, &yr, sout.ofp) ||
494 <                                                        (xr != sout.xr) |
495 <                                                        (yr != sout.yr))) {
492 >                                if ((sop->reclen == 1) & (sop->xr > 0) & (sop->yr > 0) &&
493 >                                                (!fscnresolu(&xr, &yr, sop->ofp) ||
494 >                                                        (xr != sop->xr) |
495 >                                                        (yr != sop->yr))) {
496                                          sprintf(errmsg, "resolution mismatch for '%s'",
497                                                          oname);
498                                          error(USER, errmsg);
499                                  }
500                          }
501 <                                                        /* read in RGB value */
502 <                        if (!get_contrib(rgbv, sout.ofp)) {
501 >                                                        /* read in spectral value */
502 >                        if (!get_contrib(contr, sop->ofp)) {
503                                  if (!j) {
504 <                                        fclose(sout.ofp);
504 >                                        fclose(sop->ofp);
505                                          break;          /* ignore empty file */
506                                  }
507                                  if (j < mp->nbins) {
# Line 497 | Line 511 | reload_output()
511                                  }
512                                  break;
513                          }
514 <                        if (j >= mp->nbins) {           /* check modifier size */
501 <                                sprintf(errmsg,
502 <                                "mismatched -bn setting for reloading '%s'",
503 <                                                modname[i]);
504 <                                error(USER, errmsg);
505 <                        }
506 <                                
507 <                        copycolor(mp->cbin[j], rgbv);
508 <                        if (oent->key == NULL)          /* new file entry */
509 <                                oent->key = strcpy((char *)
510 <                                                malloc(strlen(oname)+1), oname);
511 <                        if (oent->data == NULL)
512 <                                oent->data = (char *)malloc(sizeof(STREAMOUT));
513 <                        *(STREAMOUT *)oent->data = sout;
514 >                        memcpy(mcbin(mp,j), contr, DCOLORSIZ);
515                  }
516          }
517 <        lu_doall(&ofiletab, myclose, NULL);     /* close all files */
517 >        lu_doall(&ofiletab, &myclose, NULL);    /* close all files */
518   }
519  
520  
# Line 525 | Line 526 | myseeko(const LUENT *e, void *p)
526          off_t           nbytes = *(off_t *)p;
527          
528          if (sop->reclen > 1)
529 <                nbytes = nbytes * sop->reclen;
529 >                nbytes *= (off_t)sop->reclen;
530          if (fseeko(sop->ofp, nbytes, SEEK_CUR) < 0) {
531                  sprintf(errmsg, "seek error on file '%s'", e->key);
532                  error(SYSTEM, errmsg);
# Line 546 | Line 547 | recover_output()
547          int             ofl;
548          char            oname[1024];
549          LUENT           *oent;
550 <        STREAMOUT       sout;
550 >        STREAMOUT       *sop;
551          off_t           nvals;
552          int             xr, yr;
553  
# Line 555 | Line 556 | recover_output()
556                  error(USER, "cannot recover ASCII output");
557                  return;
558          case 'f':
559 <                outvsiz = sizeof(float)*3;
559 >                outvsiz = sizeof(float)*NCSAMP;
560                  break;
561          case 'd':
562 <                outvsiz = sizeof(double)*3;
562 >                outvsiz = sizeof(double)*NCSAMP;
563                  break;
564          case 'c':
565 <                outvsiz = sizeof(COLR);
565 >                outvsiz = LSCOLR;
566                  break;
567          default:
568                  error(INTERNAL, "botched output format");
569                  return;
570          }
571 <        outvfmt = formstr(outfmt);
571 >        outvfmt = (char *)formstr(outfmt);
572                                                  /* check modifier outputs */
573          for (i = 0; i < nmods; i++) {
574                  mp = (MODCONT *)lu_find(&modconttab,modname[i])->data;
# Line 575 | Line 576 | recover_output()
576                          error(USER, "cannot recover from stdout");
577                  if (mp->outspec[0] == '!')
578                          error(USER, "cannot recover from command");
579 <                for (j = 0; ; j++) {            /* check each bin's file */
580 <                        ofl = ofname(oname, mp->outspec, mp->modname, j);
579 >                for (j = 0; j < mp->nbins; j++) { /* check each bin's file */
580 >                        ofl = ofname(oname, mp->outspec, mp->modname, mp->bin0+j);
581                          if (ofl < 0)
582                                  error(USER, "bad output file specification");
583                          oent = lu_find(&ofiletab, oname);
584 <                        if (oent->data != NULL) {
585 <                                sout = *(STREAMOUT *)oent->data;
586 <                        } else {
587 <                                sout.reclen = 0;
587 <                                sout.outpipe = 0;
588 <                                sout.ofp = NULL;
589 <                        }
590 <                        if (sout.ofp != NULL) { /* already open? */
584 >                        if (oent->data == NULL)
585 >                                error(INTERNAL, "unallocated stream in recover_output()");
586 >                        sop = (STREAMOUT *)oent->data;
587 >                        if (sop->ofp != NULL) { /* already open? */
588                                  if (ofl & OF_BIN)
589                                          continue;
590                                  break;
591                          }
592                                                  /* open output */
593 <                        sout.ofp = fopen(oname, "rb+");
594 <                        if (sout.ofp == NULL) {
598 <                                if (j == mp->nbins)
599 <                                        break;  /* assume end of modifier */
593 >                        sop->ofp = fopen(oname, "rb+");
594 >                        if (sop->ofp == NULL) {
595                                  sprintf(errmsg, "missing recover file '%s'",
596                                                  oname);
597                                  error(WARNING, errmsg);
598 +                                lastout = 0;
599                                  break;
600                          }
601 <                        nvals = lseek(fileno(sout.ofp), 0, SEEK_END);
601 >                        nvals = lseek(fileno(sop->ofp), 0, SEEK_END);
602                          if (nvals <= 0) {
603                                  lastout = 0;    /* empty output, quit here */
604 <                                fclose(sout.ofp);
604 >                                fclose(sop->ofp);
605                                  break;
606                          }
607 <                        if (!sout.reclen) {
612 <                                if (!(ofl & OF_BIN)) {
613 <                                        sprintf(errmsg,
614 <                                                "need -bn to recover file '%s'",
615 <                                                        oname);
616 <                                        error(USER, errmsg);
617 <                                }
618 <                                recsiz = outvsiz;
619 <                        } else
620 <                                recsiz = outvsiz * sout.reclen;
607 >                        recsiz = outvsiz * sop->reclen;
608  
609 <                        lseek(fileno(sout.ofp), 0, SEEK_SET);
610 <                        if (header && checkheader(sout.ofp, outvfmt, NULL) != 1) {
609 >                        lseek(fileno(sop->ofp), 0, SEEK_SET);
610 >                        if (header && checkheader(sop->ofp, outvfmt, NULL) != 1) {
611                                  sprintf(errmsg, "format mismatch for '%s'",
612                                                  oname);
613                                  error(USER, errmsg);
614                          }
615 <                        sout.xr = xres; sout.yr = yres;
616 <                        if ((sout.xr > 0) & (sout.yr > 0) &&
617 <                                        (!fscnresolu(&xr, &yr, sout.ofp) ||
618 <                                                (xr != sout.xr) |
632 <                                                (yr != sout.yr))) {
615 >                        if ((sop->reclen == 1) & (sop->xr > 0) & (sop->yr > 0) &&
616 >                                        (!fscnresolu(&xr, &yr, sop->ofp) ||
617 >                                                (xr != sop->xr) |
618 >                                                (yr != sop->yr))) {
619                                  sprintf(errmsg, "resolution mismatch for '%s'",
620                                                  oname);
621                                  error(USER, errmsg);
622                          }
623 <                        nvals = (nvals - (off_t)ftell(sout.ofp)) / recsiz;
623 >                        nvals = (nvals - (off_t)ftell(sop->ofp)) / recsiz;
624                          if ((lastout < 0) | (nvals < lastout))
625                                  lastout = nvals;
640 –                        if (oent->key == NULL)  /* new entry */
641 –                                oent->key = strcpy((char *)
642 –                                                malloc(strlen(oname)+1), oname);
643 –                        if (oent->data == NULL)
644 –                                oent->data = (char *)malloc(sizeof(STREAMOUT));
645 –                        *(STREAMOUT *)oent->data = sout;
626                          if (!(ofl & OF_BIN))
627                                  break;          /* no bin separation */
628                  }
629                  if (!lastout) {                 /* empty output */
630                          error(WARNING, "no previous data to recover");
631 <                        lu_done(&ofiletab);     /* reclose all outputs */
631 >                                                /* reclose all outputs */
632 >                        lu_doall(&ofiletab, &myclose, NULL);
633                          return;
634                  }
654 –                if (j > mp->nbins) {            /* check modifier size */
655 –                        sprintf(errmsg,
656 –                                "mismatched -bn setting for recovering '%s'",
657 –                                        modname[i]);
658 –                        error(USER, errmsg);
659 –                }
635          }
636          if (lastout < 0) {
637                  error(WARNING, "no output files to recover");
# Line 669 | Line 644 | recover_output()
644          }
645                                                  /* seek on all files */
646          nvals = lastout * outvsiz;
647 <        lu_doall(&ofiletab, myseeko, &nvals);
647 >        lu_doall(&ofiletab, &myseeko, &nvals);
648                                                  /* skip repeated input */
649          lastout *= accumulate;
650          for (nvals = 0; nvals < lastout; nvals++) {

Diff Legend

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