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

Comparing ray/src/util/rpiece.c (file contents):
Revision 2.5 by greg, Fri Aug 7 11:05:30 1992 UTC vs.
Revision 2.13 by greg, Thu Nov 12 10:13:35 1992 UTC

# Line 10 | Line 10 | static char SCCSid[] = "$SunId$ LBL";
10  
11   #include "standard.h"
12   #include <fcntl.h>
13 + #include <signal.h>
14   #include "color.h"
15   #include "view.h"
16   #include "resolu.h"
17  
18 + #ifndef NFS
19 + #define  NFS                    1
20 + #endif
21 +                                /* set the following to 0 to forgo forking */
22 + #ifndef MAXFORK
23 + #if NFS
24 + #define  MAXFORK                3       /* allotment of duped processes */
25 + #else
26 + #define  MAXFORK                0
27 + #endif
28 + #endif
29 +
30                                  /* rpict command */
31   char  *rpargv[128] = {"rpict", "-S", "1", "-x", "512", "-y", "512", "-pa", "1"};
32   int  rpargc = 9;
33   int  rpd[3];
34   FILE  *torp, *fromrp;
35 < COLR  *scanline;
35 > COLR  *pbuf;
36                                  /* our view parameters */
37   VIEW  ourview = STDVIEW;
38   double  pixaspect = 1.0;
# Line 29 | Line 42 | char  *outfile = NULL;
42   int  outfd;
43   long  scanorig;
44   int  syncfd = -1;               /* lock file descriptor */
45 + int  nforked = 0;
46  
47   char  *progname;
48   int  verbose = 0;
49  
50   extern long  lseek(), ftell();
51  
52 + int  gotalrm = 0;
53 + int  onalrm() { gotalrm++; }
54  
55 +
56   main(argc, argv)
57   int  argc;
58   char  *argv[];
# Line 113 | Line 130 | char  *argv[];
130          }
131          init(argc, argv);
132          rpiece();
133 <        rval = cleanup();
133 >        rval = cleanup(0);
134          exit(rval);
135   }
136  
# Line 154 | Line 171 | char  **av;
171          } else if ((outfd = open(outfile, O_RDWR)) >= 0) {
172                  if ((fp = fdopen(dup(outfd), "r+")) == NULL)
173                          goto filerr;
174 <                getheader(fp, NULL);            /* skip header */
174 >                getheader(fp, NULL, NULL);      /* skip header */
175                  if (fscnresolu(&hr, &vr, fp) < 0 ||     /* check resolution */
176                                  hr != hres*hmult || vr != vres*vmult) {
177 <                        fprintf(stderr, "%s: picture resolution mismatch\n",
178 <                                        outfile);
177 >                        fprintf(stderr, "%s: resolution mismatch on file \"%s\"\n",
178 >                                        progname, outfile);
179                          exit(1);
180                  }
181          } else {
182 <                fprintf(stderr, "%s: cannot open\n", outfile);
182 >                fprintf(stderr, "%s: cannot open file \"%s\"\n",
183 >                                progname, outfile);
184                  exit(1);
185          }
186          scanorig = ftell(fp);           /* record position of first scanline */
187          if (fclose(fp) == -1)           /* done with stream i/o */
188                  goto filerr;
189 <        sync();                         /* avoid NFS buffering */
189 > #if NFS
190 >        sync();                         /* flush NFS buffers */
191 > #endif
192                                          /* start rpict process */
193          if (open_process(rpd, rpargv) <= 0) {
194                  fprintf(stderr, "%s: cannot start %s\n", progname, rpargv[0]);
# Line 180 | Line 200 | char  **av;
200                                  progname, rpargv[0]);
201                  exit(1);
202          }
203 <        if ((scanline = (COLR *)malloc(hres*sizeof(COLR))) == NULL) {
203 >        if ((pbuf = (COLR *)malloc(hres*vres*sizeof(COLR))) == NULL) {
204                  fprintf(stderr, "%s: out of memory\n", progname);
205                  exit(1);
206          }
207 +        signal(SIGALRM, onalrm);
208          return;
209   filerr:
210 <        fprintf(stderr, "%s: file i/o error\n", outfile);
210 >        fprintf(stderr, "%s: i/o error on file \"%s\"\n", progname, outfile);
211          exit(1);
212   }
213  
# Line 199 | Line 220 | int  *xp, *yp;
220          struct flock  fls;
221          char  buf[64];
222  
223 <        if (syncfd != -1) {             /* using sync file */
223 >        if (gotalrm)                    /* someone wants us to quit */
224 >                return(0);
225 >        if (syncfd != -1) {             /* use sync file */
226                  fls.l_type = F_WRLCK;           /* gain exclusive access */
227                  fls.l_whence = 0;
228                  fls.l_start = 0L;
# Line 208 | Line 231 | int  *xp, *yp;
231                  lseek(syncfd, 0L, 0);
232                  buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
233                  if (sscanf(buf, "%*d %*d %d %d", xp, yp) < 2) {
211 –                        *xp = hmult;
212 –                        *yp = vmult-1;
213 –                }
214 –                if (--(*xp) < 0) {              /* decrement position */
234                          *xp = hmult-1;
235 <                        if (--(*yp) < 0) {      /* all done! */
235 >                        *yp = vmult;
236 >                }
237 >                if (--(*yp) < 0) {              /* decrement position */
238 >                        *yp = vmult-1;
239 >                        if (--(*xp) < 0) {      /* all done! */
240                                  close(syncfd);
241                                  return(0);
242                          }
# Line 225 | Line 248 | int  *xp, *yp;
248                  fcntl(syncfd, F_SETLKW, &fls);
249                  return(1);
250          }
251 <        if (fgets(buf, sizeof(buf), stdin) == NULL)     /* using stdin */
251 >        if (fgets(buf, sizeof(buf), stdin) == NULL)     /* use stdin */
252                  return(0);
253          if (sscanf(buf, "%d %d", xp, yp) == 2)
254                  return(1);
255          fprintf(stderr, "%s: input format error\n", progname);
256 <        exit(1);
256 >        exit(cleanup(1));
257   }
258  
259  
260   int
261 < cleanup()                       /* close rpict process and clean up */
261 > cleanup(rstat)                  /* close rpict process and clean up */
262 > int  rstat;
263   {
264 <        register int  rpstat;
264 >        int  status;
265  
266 <        free((char *)scanline);
266 >        free((char *)pbuf);
267          fclose(torp);
268          fclose(fromrp);
269 <        rpstat = close_process(rpd);
270 <        if (rpstat == -1)
271 <                rpstat = 0;
272 <        return(rpstat);
269 >        while (wait(&status) != -1)
270 >                if (rstat == 0)
271 >                        rstat = status>>8 & 0xff;
272 >        return(rstat);
273   }
274  
275  
# Line 253 | Line 277 | rpiece()                       /* render picture piece by piece */
277   {
278          VIEW  pview;
279          int  xorg, yorg;
280 <        
280 >                                        /* compute view parameters */
281 >        copystruct(&pview, &ourview);
282 >        switch (ourview.type) {
283 >        case VT_PER:
284 >                pview.horiz = 2.*180./PI*atan(
285 >                                tan(PI/180./2.*ourview.horiz)/hmult );
286 >                pview.vert = 2.*180./PI*atan(
287 >                                tan(PI/180./2.*ourview.vert)/vmult );
288 >                break;
289 >        case VT_PAR:
290 >        case VT_ANG:
291 >                pview.horiz = ourview.horiz / hmult;
292 >                pview.vert = ourview.vert / vmult;
293 >                break;
294 >        case VT_HEM:
295 >                pview.horiz = 2.*180./PI*asin(
296 >                                sin(PI/180./2.*ourview.horiz)/hmult );
297 >                pview.vert = 2.*180./PI*asin(
298 >                                sin(PI/180./2.*ourview.vert)/vmult );
299 >                break;
300 >        default:
301 >                fprintf(stderr, "%s: unknown view type '-vt%c'\n",
302 >                                progname, ourview.type);
303 >                exit(cleanup(1));
304 >        }
305 >                                        /* render each piece */
306          while (nextpiece(&xorg, &yorg)) {
307 <                copystruct(&pview, &ourview);   /* compute view for piece */
308 <                switch (ourview.type) {
260 <                case VT_PER:
261 <                        pview.horiz = 2.*180./PI*atan(
262 <                                        tan(PI/180./2.*ourview.horiz)/hmult );
263 <                        pview.vert = 2.*180./PI*atan(
264 <                                        tan(PI/180./2.*ourview.vert)/vmult );
265 <                        break;
266 <                case VT_PAR:
267 <                case VT_ANG:
268 <                        pview.horiz = ourview.horiz / hmult;
269 <                        pview.vert = ourview.vert / vmult;
270 <                        break;
271 <                case VT_HEM:
272 <                        pview.horiz = 2.*180./PI*asin(
273 <                                        sin(PI/180./2.*ourview.horiz)/hmult );
274 <                        pview.vert = 2.*180./PI*asin(
275 <                                        sin(PI/180./2.*ourview.vert)/vmult );
276 <                        break;
277 <                default:
278 <                        fprintf(stderr, "%s: unknown view type '-vt%c'\n",
279 <                                        progname, ourview.type);
280 <                        exit(1);
281 <                }
282 <                pview.hoff += xorg - 0.5*(hmult-1);
283 <                pview.voff += yorg - 0.5*(vmult-1);
307 >                pview.hoff = ourview.hoff + xorg - 0.5*(hmult-1);
308 >                pview.voff = ourview.voff + yorg - 0.5*(vmult-1);
309                  fputs(VIEWSTR, torp);
310                  fprintview(&pview, torp);
311                  putc('\n', torp);
312 <                fflush(torp);                   /* assign piece to rpict */
312 >                fflush(torp);                   /* assigns piece to rpict */
313                  putpiece(xorg, yorg);           /* place piece in output */
314                  if (verbose) {                  /* notify caller */
315                          printf("%d %d done\n", xorg, yorg);
# Line 294 | Line 319 | rpiece()                       /* render picture piece by piece */
319   }
320  
321  
322 + int
323   putpiece(xpos, ypos)            /* get next piece from rpict */
324   int  xpos, ypos;
325   {
326 +        struct flock  fls;
327 +        int  pid, status;
328          int  hr, vr;
329 <        int  y;
330 <
329 >        register int  y;
330 >                                /* check bounds */
331          if (xpos < 0 | ypos < 0 | xpos >= hmult | ypos >= vmult) {
332                  fprintf(stderr, "%s: requested piece (%d,%d) out of range\n",
333                                  progname, xpos, ypos);
334 <                exit(1);
334 >                exit(cleanup(1));
335          }
336 <        getheader(fromrp, NULL);        /* discard header info. */
337 <        if (fscnresolu(&hr, &vr, fromrp) < 0 || /* check resolution */
338 <                        hr != hres || vr != vres) {
336 >                                /* check header from rpict */
337 >        getheader(fromrp, NULL, NULL);
338 >        if (fscnresolu(&hr, &vr, fromrp) < 0 || hr != hres | vr != vres) {
339                  fprintf(stderr, "%s: resolution mismatch from %s\n",
340                                  progname, rpargv[0]);
341 <                exit(1);
341 >                exit(cleanup(1));
342          }
343 <        for (y = 0; y < vr; y++) {      /* transfer scanlines */
344 <                if (freadcolrs(scanline, hr, fromrp) < 0) {
343 >                                /* load new piece into buffer */
344 >        for (y = 0; y < vr; y++)
345 >                if (freadcolrs(pbuf+y*hr, hr, fromrp) < 0) {
346                          fprintf(stderr, "%s: read error from %s\n",
347                                          progname, rpargv[0]);
348 <                        exit(1);
348 >                        exit(cleanup(1));
349                  }
350 <                if ((y == 0 || hmult != 1) && lseek(outfd,
351 < scanorig+((long)((vmult-1-ypos)*vres+y)*hmult*hres+xpos*hres)*sizeof(COLR),
352 <                                0) == -1) {
353 <                        fprintf(stderr, "%s: seek error\n", outfile);
354 <                        exit(1);
350 > #if MAXFORK
351 >                                /* fork so we don't slow rpict down */
352 >        if ((pid = fork()) > 0) {
353 >                if (++nforked >= MAXFORK) {
354 >                        wait(&status);          /* reap a child */
355 >                        if (status)
356 >                                exit(cleanup(status>>8 & 0xff));
357 >                        nforked--;
358                  }
359 <                if (writebuf(outfd, (char *)scanline, hr*sizeof(COLR)) !=
360 <                                hr*sizeof(COLR)) {
361 <                        fprintf(stderr, "%s: write error\n", outfile);
362 <                        exit(1);
359 >                return(pid);
360 >        }
361 > #else
362 >        pid = -1;               /* no forking */
363 > #endif
364 > #if NFS
365 >                                /* lock file section so NFS doesn't mess up */
366 >        fls.l_whence = 0;
367 >        fls.l_len = (long)vres*hmult*hres*sizeof(COLR);
368 >        fls.l_start = scanorig + (vmult-1-ypos)*fls.l_len;
369 >        fls.l_type = F_WRLCK;
370 >        fcntl(outfd, F_SETLKW, &fls);
371 > #endif
372 >                                /* write new piece to file */
373 >        if (lseek(outfd, fls.l_start+(long)xpos*hres*sizeof(COLR), 0) == -1)
374 >                goto seekerr;
375 >        if (hmult == 1) {
376 >                if (writebuf(outfd, (char *)pbuf,
377 >                                vr*hr*sizeof(COLR)) != vr*hr*sizeof(COLR))
378 >                        goto writerr;
379 >        } else
380 >                for (y = 0; y < vr; y++) {
381 >                        if (writebuf(outfd, (char *)(pbuf+y*hr),
382 >                                        hr*sizeof(COLR)) != hr*sizeof(COLR))
383 >                                goto writerr;
384 >                        if (y < vr-1 && lseek(outfd,
385 >                                        (long)(hmult-1)*hr*sizeof(COLR),
386 >                                        1) == -1)
387 >                                goto seekerr;
388                  }
389 +        if (pid == -1) {        /* fork failed */
390 + #if NFS
391 +                fls.l_type = F_UNLCK;           /* release lock */
392 +                fcntl(outfd, F_SETLKW, &fls);
393 + #endif
394 +                return(0);
395          }
396 +        _exit(0);               /* else exit child process (releasing lock) */
397 + seekerr:
398 +        fprintf(stderr, "%s: seek error on file \"%s\"\n", progname, outfile);
399 +        _exit(1);
400 + writerr:
401 +        fprintf(stderr, "%s: write error on file \"%s\"\n", progname, outfile);
402 +        _exit(1);
403   }

Diff Legend

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