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.10 by greg, Sun Aug 9 18:09:46 1992 UTC vs.
Revision 2.22 by greg, Wed Aug 4 10:08:47 1993 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1992 Regents of the University of California */
1 > /* Copyright (c) 1993 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 10 | Line 10 | static char SCCSid[] = "$SunId$ LBL";
10  
11   #include "standard.h"
12   #include <fcntl.h>
13 +
14 + #ifndef F_SETLKW
15 +
16 + main(argc, argv)
17 + int argc;
18 + char *argv[];
19 + {
20 +        fprintf(stderr, "%s: no NFS lock manager on this machine\n", argv[0]);
21 +        exit(1);
22 + }
23 +
24 + #else
25 +
26   #include <signal.h>
27   #include "color.h"
28   #include "view.h"
29   #include "resolu.h"
30  
31 + #ifndef NFS
32 + #define  NFS                    1
33 + #endif
34                                  /* set the following to 0 to forgo forking */
35   #ifndef MAXFORK
36 + #if NFS
37   #define  MAXFORK                3       /* allotment of duped processes */
38 + #else
39 + #define  MAXFORK                0
40   #endif
41 <
41 > #endif
42 >                                        /* protection from SYSV signals(!) */
43 > #if defined(sgi) || defined(hpux)
44 > #define guard_io()      sighold(SIGALRM)
45 > #define unguard()       sigrelse(SIGALRM)
46 > #endif
47 > #ifndef guard_io
48 > #define guard_io()      0
49 > #define unguard()       0
50 > #endif
51                                  /* rpict command */
52   char  *rpargv[128] = {"rpict", "-S", "1", "-x", "512", "-y", "512", "-pa", "1"};
53   int  rpargc = 9;
# Line 54 | Line 82 | char  *argv[];
82          
83          progname = argv[0];
84          for (i = 1; i < argc; i++) {
85 +                                                /* expand arguments */
86 +                while (rval = expandarg(&argc, &argv, i))
87 +                        if (rval < 0) {
88 +                                fprintf(stderr, "%s: cannot expand '%s'",
89 +                                                argv[0], argv[i]);
90 +                                exit(1);
91 +                        }
92                  if (argv[i][0] == '-')
93                          switch (argv[i][1]) {
94                          case 'v':
# Line 102 | Line 137 | char  *argv[];
137                          case 'F':               /* syncronization file */
138                                  if (argv[i][2])
139                                          break;
140 <                                if ((syncfd = open(argv[++i], O_RDWR)) < 0) {
140 >                                if ((syncfd = open(argv[++i],
141 >                                                O_RDWR|O_CREAT, 0666)) < 0) {
142                                          fprintf(stderr, "%s: cannot open\n",
143                                                          argv[i]);
144                                          exit(1);
145                                  }
146                                  continue;
147 +                        case 'z':               /* z-file ist verbotten */
148 +                                fprintf(stderr, "%s: -z option not allowed\n",
149 +                                                argv[0]);
150 +                                exit(1);
151                          case 'o':               /* output file */
152                                  if (argv[i][2])
153                                          break;
# Line 123 | Line 163 | char  *argv[];
163          }
164          init(argc, argv);
165          rpiece();
166 <        rval = cleanup(0);
127 <        exit(rval);
166 >        exit(cleanup(0));
167   }
168  
169  
# Line 164 | Line 203 | char  **av;
203          } else if ((outfd = open(outfile, O_RDWR)) >= 0) {
204                  if ((fp = fdopen(dup(outfd), "r+")) == NULL)
205                          goto filerr;
206 <                getheader(fp, NULL);            /* skip header */
207 <                if (fscnresolu(&hr, &vr, fp) < 0 ||     /* check resolution */
206 >                getheader(fp, NULL, NULL);      /* skip header */
207 >                if (!fscnresolu(&hr, &vr, fp) ||        /* check resolution */
208                                  hr != hres*hmult || vr != vres*vmult) {
209                          fprintf(stderr, "%s: resolution mismatch on file \"%s\"\n",
210                                          progname, outfile);
# Line 179 | Line 218 | char  **av;
218          scanorig = ftell(fp);           /* record position of first scanline */
219          if (fclose(fp) == -1)           /* done with stream i/o */
220                  goto filerr;
221 + #if NFS
222          sync();                         /* flush NFS buffers */
223 + #endif
224                                          /* start rpict process */
225          if (open_process(rpd, rpargv) <= 0) {
226                  fprintf(stderr, "%s: cannot start %s\n", progname, rpargv[0]);
# Line 207 | Line 248 | int
248   nextpiece(xp, yp)               /* get next piece assignment */
249   int  *xp, *yp;
250   {
210 –        extern char  *fgets();
251          struct flock  fls;
252          char  buf[64];
253  
# Line 232 | Line 272 | int  *xp, *yp;
272                                  return(0);
273                          }
274                  }
275 <                sprintf(buf, "%d %d\n%d %d\n", hmult, vmult, *xp, *yp);
275 >                sprintf(buf, "%4d %4d\n%4d %4d\n", hmult, vmult, *xp, *yp);
276                  lseek(syncfd, 0L, 0);           /* write new position */
277                  write(syncfd, buf, strlen(buf));
278                  fls.l_type = F_UNLCK;           /* release sync file */
# Line 268 | Line 308 | rpiece()                       /* render picture piece by piece */
308   {
309          VIEW  pview;
310          int  xorg, yorg;
311 <        
311 >                                        /* compute view parameters */
312 >        copystruct(&pview, &ourview);
313 >        switch (ourview.type) {
314 >        case VT_PER:
315 >                pview.horiz = 2.*180./PI*atan(
316 >                                tan(PI/180./2.*ourview.horiz)/hmult );
317 >                pview.vert = 2.*180./PI*atan(
318 >                                tan(PI/180./2.*ourview.vert)/vmult );
319 >                break;
320 >        case VT_PAR:
321 >        case VT_ANG:
322 >                pview.horiz = ourview.horiz / hmult;
323 >                pview.vert = ourview.vert / vmult;
324 >                break;
325 >        case VT_HEM:
326 >                pview.horiz = 2.*180./PI*asin(
327 >                                sin(PI/180./2.*ourview.horiz)/hmult );
328 >                pview.vert = 2.*180./PI*asin(
329 >                                sin(PI/180./2.*ourview.vert)/vmult );
330 >                break;
331 >        default:
332 >                fprintf(stderr, "%s: unknown view type '-vt%c'\n",
333 >                                progname, ourview.type);
334 >                exit(cleanup(1));
335 >        }
336 >                                        /* render each piece */
337          while (nextpiece(&xorg, &yorg)) {
338 <                copystruct(&pview, &ourview);   /* compute view for piece */
339 <                switch (ourview.type) {
275 <                case VT_PER:
276 <                        pview.horiz = 2.*180./PI*atan(
277 <                                        tan(PI/180./2.*ourview.horiz)/hmult );
278 <                        pview.vert = 2.*180./PI*atan(
279 <                                        tan(PI/180./2.*ourview.vert)/vmult );
280 <                        break;
281 <                case VT_PAR:
282 <                case VT_ANG:
283 <                        pview.horiz = ourview.horiz / hmult;
284 <                        pview.vert = ourview.vert / vmult;
285 <                        break;
286 <                case VT_HEM:
287 <                        pview.horiz = 2.*180./PI*asin(
288 <                                        sin(PI/180./2.*ourview.horiz)/hmult );
289 <                        pview.vert = 2.*180./PI*asin(
290 <                                        sin(PI/180./2.*ourview.vert)/vmult );
291 <                        break;
292 <                default:
293 <                        fprintf(stderr, "%s: unknown view type '-vt%c'\n",
294 <                                        progname, ourview.type);
295 <                        exit(cleanup(1));
296 <                }
297 <                pview.hoff += xorg - 0.5*(hmult-1);
298 <                pview.voff += yorg - 0.5*(vmult-1);
338 >                pview.hoff = ourview.hoff + xorg - 0.5*(hmult-1);
339 >                pview.voff = ourview.voff + yorg - 0.5*(vmult-1);
340                  fputs(VIEWSTR, torp);
341                  fprintview(&pview, torp);
342                  putc('\n', torp);
343 <                fflush(torp);                   /* assign piece to rpict */
343 >                fflush(torp);                   /* assigns piece to rpict */
344                  putpiece(xorg, yorg);           /* place piece in output */
304 –                if (verbose) {                  /* notify caller */
305 –                        printf("%d %d done\n", xorg, yorg);
306 –                        fflush(stdout);
307 –                }
345          }
346   }
347  
# Line 324 | Line 361 | int  xpos, ypos;
361                  exit(cleanup(1));
362          }
363                                  /* check header from rpict */
364 <        getheader(fromrp, NULL);
365 <        if (fscnresolu(&hr, &vr, fromrp) < 0 || hr != hres || vr != vres) {
364 >        guard_io();
365 >        getheader(fromrp, NULL, NULL);
366 >        if (!fscnresolu(&hr, &vr, fromrp) || hr != hres | vr != vres) {
367                  fprintf(stderr, "%s: resolution mismatch from %s\n",
368                                  progname, rpargv[0]);
369                  exit(cleanup(1));
370          }
371 +        unguard();
372                                  /* load new piece into buffer */
373 <        for (y = 0; y < vr; y++)
373 >        for (y = 0; y < vr; y++) {
374 >                guard_io();
375                  if (freadcolrs(pbuf+y*hr, hr, fromrp) < 0) {
376                          fprintf(stderr, "%s: read error from %s\n",
377                                          progname, rpargv[0]);
378                          exit(cleanup(1));
379                  }
380 +                unguard();
381 +        }
382   #if MAXFORK
383                                  /* fork so we don't slow rpict down */
384          if ((pid = fork()) > 0) {
# Line 351 | Line 393 | int  xpos, ypos;
393   #else
394          pid = -1;               /* no forking */
395   #endif
396 +        fls.l_start = scanorig +
397 +                ((long)(vmult-1-ypos)*vres*hmult+xpos)*hres*sizeof(COLR);
398 + #if NFS
399 +        fls.l_len = ((long)(vres-1)*hmult+1)*hres*sizeof(COLR);
400                                  /* lock file section so NFS doesn't mess up */
401          fls.l_whence = 0;
356 –        fls.l_len = (long)vres*hmult*hres*sizeof(COLR);
357 –        fls.l_start = scanorig + (vmult-1-ypos)*fls.l_len;
402          fls.l_type = F_WRLCK;
403          fcntl(outfd, F_SETLKW, &fls);
404 + #endif
405                                  /* write new piece to file */
406 <        if (lseek(outfd, fls.l_start+(long)xpos*hres*sizeof(COLR), 0) == -1)
406 >        if (lseek(outfd, fls.l_start, 0) == -1)
407                  goto seekerr;
408          if (hmult == 1) {
409                  if (writebuf(outfd, (char *)pbuf,
# Line 374 | Line 419 | int  xpos, ypos;
419                                          1) == -1)
420                                  goto seekerr;
421                  }
422 <        if (pid == -1) {        /* fork failed */
422 >        if (verbose) {                          /* notify caller */
423 >                printf("%d %d done\n", xpos, ypos);
424 >                fflush(stdout);
425 >        }
426 >        if (pid == -1) {        /* didn't fork or fork failed */
427 > #if NFS
428                  fls.l_type = F_UNLCK;           /* release lock */
429                  fcntl(outfd, F_SETLKW, &fls);
430 + #endif
431                  return(0);
432          }
433          _exit(0);               /* else exit child process (releasing lock) */
# Line 387 | Line 438 | writerr:
438          fprintf(stderr, "%s: write error on file \"%s\"\n", progname, outfile);
439          _exit(1);
440   }
441 +
442 + #endif

Diff Legend

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