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.3 by greg, Thu Aug 6 17:56:40 1992 UTC vs.
Revision 2.15 by greg, Thu Jan 21 17:46:31 1993 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", };
32 < int  rpargc = 7;
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 = 0.0;
38 > double  pixaspect = 1.0;
39   int  hres = 512, vres = 512, hmult = 2, vmult = 2;
40                                  /* output file */
41   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 88 | Line 106 | char  *argv[];
106                                          break;
107                                  vmult = atoi(argv[++i]);
108                                  continue;
109 +                        case 'F':               /* syncronization file */
110 +                                if (argv[i][2])
111 +                                        break;
112 +                                if ((syncfd = open(argv[++i],
113 +                                                O_RDWR|O_CREAT, 0666)) < 0) {
114 +                                        fprintf(stderr, "%s: cannot open\n",
115 +                                                        argv[i]);
116 +                                        exit(1);
117 +                                }
118 +                                continue;
119 +                        case 'z':               /* z-file ist verbotten */
120 +                                fprintf(stderr, "%s: -z option not allowed\n",
121 +                                                argv[0]);
122 +                                exit(1);
123                          case 'o':               /* output file */
124                                  if (argv[i][2])
125                                          break;
# Line 103 | Line 135 | char  *argv[];
135          }
136          init(argc, argv);
137          rpiece();
138 <        rval = cleanup();
107 <        exit(rval);
138 >        exit(cleanup(0));
139   }
140  
141  
# Line 121 | Line 152 | char  **av;
152                  fprintf(stderr, "%s: %s\n", progname, err);
153                  exit(1);
154          }
155 +        if (syncfd != -1) {
156 +                char  buf[32];
157 +                buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
158 +                sscanf(buf, "%d %d", &hmult, &vmult);
159 +        }
160          normaspect(viewaspect(&ourview)*hmult/vmult, &pixaspect, &hres, &vres);
161                                          /* open output file */
162          if ((outfd = open(outfile, O_WRONLY|O_CREAT|O_EXCL, 0666)) >= 0) {
# Line 137 | Line 173 | char  **av;
173                  putc('\n', fp);
174                  fprtresolu(hres*hmult, vres*vmult, fp);
175          } else if ((outfd = open(outfile, O_RDWR)) >= 0) {
140 –                sleep(30);                      /* wait for header */
176                  if ((fp = fdopen(dup(outfd), "r+")) == NULL)
177                          goto filerr;
178 <                getheader(fp, NULL);            /* skip header */
179 <                if (fscnresolu(&hr, &vr, fp) < 0 ||     /* check resolution */
178 >                getheader(fp, NULL, NULL);      /* skip header */
179 >                if (!fscnresolu(&hr, &vr, fp) ||        /* check resolution */
180                                  hr != hres*hmult || vr != vres*vmult) {
181 <                        fprintf(stderr, "%s: picture resolution mismatch\n",
182 <                                        outfile);
181 >                        fprintf(stderr, "%s: resolution mismatch on file \"%s\"\n",
182 >                                        progname, outfile);
183                          exit(1);
184                  }
185          } else {
186 <                fprintf(stderr, "%s: cannot open\n", outfile);
186 >                fprintf(stderr, "%s: cannot open file \"%s\"\n",
187 >                                progname, outfile);
188                  exit(1);
189          }
190          scanorig = ftell(fp);           /* record position of first scanline */
191          if (fclose(fp) == -1)           /* done with stream i/o */
192                  goto filerr;
193 + #if NFS
194 +        sync();                         /* flush NFS buffers */
195 + #endif
196                                          /* start rpict process */
197          if (open_process(rpd, rpargv) <= 0) {
198                  fprintf(stderr, "%s: cannot start %s\n", progname, rpargv[0]);
# Line 165 | Line 204 | char  **av;
204                                  progname, rpargv[0]);
205                  exit(1);
206          }
207 <        if ((scanline = (COLR *)malloc(hres*sizeof(COLR))) == NULL) {
207 >        if ((pbuf = (COLR *)malloc(hres*vres*sizeof(COLR))) == NULL) {
208                  fprintf(stderr, "%s: out of memory\n", progname);
209                  exit(1);
210          }
211 +        signal(SIGALRM, onalrm);
212          return;
213   filerr:
214 <        fprintf(stderr, "%s: file i/o error\n", outfile);
214 >        fprintf(stderr, "%s: i/o error on file \"%s\"\n", progname, outfile);
215          exit(1);
216   }
217  
218  
219   int
220 < cleanup()                       /* close rpict process and clean up */
220 > nextpiece(xp, yp)               /* get next piece assignment */
221 > int  *xp, *yp;
222   {
223 <        register int  rpstat;
223 >        extern char  *fgets();
224 >        struct flock  fls;
225 >        char  buf[64];
226  
227 <        free((char *)scanline);
227 >        if (gotalrm)                    /* someone wants us to quit */
228 >                return(0);
229 >        if (syncfd != -1) {             /* use sync file */
230 >                fls.l_type = F_WRLCK;           /* gain exclusive access */
231 >                fls.l_whence = 0;
232 >                fls.l_start = 0L;
233 >                fls.l_len = 0L;
234 >                fcntl(syncfd, F_SETLKW, &fls);
235 >                lseek(syncfd, 0L, 0);
236 >                buf[read(syncfd, buf, sizeof(buf)-1)] = '\0';
237 >                if (sscanf(buf, "%*d %*d %d %d", xp, yp) < 2) {
238 >                        *xp = hmult-1;
239 >                        *yp = vmult;
240 >                }
241 >                if (--(*yp) < 0) {              /* decrement position */
242 >                        *yp = vmult-1;
243 >                        if (--(*xp) < 0) {      /* all done! */
244 >                                close(syncfd);
245 >                                return(0);
246 >                        }
247 >                }
248 >                sprintf(buf, "%d %d\n%d %d\n", hmult, vmult, *xp, *yp);
249 >                lseek(syncfd, 0L, 0);           /* write new position */
250 >                write(syncfd, buf, strlen(buf));
251 >                fls.l_type = F_UNLCK;           /* release sync file */
252 >                fcntl(syncfd, F_SETLKW, &fls);
253 >                return(1);
254 >        }
255 >        if (fgets(buf, sizeof(buf), stdin) == NULL)     /* use stdin */
256 >                return(0);
257 >        if (sscanf(buf, "%d %d", xp, yp) == 2)
258 >                return(1);
259 >        fprintf(stderr, "%s: input format error\n", progname);
260 >        exit(cleanup(1));
261 > }
262 >
263 >
264 > int
265 > cleanup(rstat)                  /* close rpict process and clean up */
266 > int  rstat;
267 > {
268 >        int  status;
269 >
270 >        free((char *)pbuf);
271          fclose(torp);
272          fclose(fromrp);
273 <        rpstat = close_process(rpd);
274 <        if (rpstat == -1)
275 <                rpstat = 0;
276 <        return(rpstat);
273 >        while (wait(&status) != -1)
274 >                if (rstat == 0)
275 >                        rstat = status>>8 & 0xff;
276 >        return(rstat);
277   }
278  
279  
280   rpiece()                        /* render picture piece by piece */
281   {
196 –        extern char  *gets(), *strcat();
282          VIEW  pview;
198 –        char  buf[48];
283          int  xorg, yorg;
284 <        
285 <        while (gets(buf) != NULL) {
286 <                if (sscanf(buf, "%d %d", &xorg, &yorg) != 2) {
287 <                        fprintf(stderr, "%s: input format error\n", progname);
288 <                        exit(1);
289 <                }
290 <                copystruct(&pview, &ourview);   /* compute view for piece */
291 <                switch (ourview.type) {
292 <                case VT_PER:
293 <                        pview.horiz = 2.*180./PI*atan(
294 <                                        tan(PI/180./2.*ourview.horiz)/hmult );
295 <                        pview.vert = 2.*180./PI*atan(
296 <                                        tan(PI/180./2.*ourview.vert)/vmult );
297 <                        break;
298 <                case VT_PAR:
299 <                case VT_ANG:
300 <                        pview.horiz = ourview.horiz / hmult;
301 <                        pview.vert = ourview.vert / vmult;
302 <                        break;
303 <                case VT_HEM:
304 <                        pview.horiz = 2.*180./PI*asin(
305 <                                        sin(PI/180./2.*ourview.horiz)/hmult );
306 <                        pview.vert = 2.*180./PI*asin(
307 <                                        sin(PI/180./2.*ourview.vert)/vmult );
308 <                        break;
309 <                default:
310 <                        fprintf(stderr, "%s: unknown view type '-vt%c'\n",
311 <                                        progname, ourview.type);
312 <                        exit(1);
229 <                }
230 <                pview.hoff += xorg - 0.5*(hmult-1);
231 <                pview.voff += yorg - 0.5*(vmult-1);
284 >                                        /* compute view parameters */
285 >        copystruct(&pview, &ourview);
286 >        switch (ourview.type) {
287 >        case VT_PER:
288 >                pview.horiz = 2.*180./PI*atan(
289 >                                tan(PI/180./2.*ourview.horiz)/hmult );
290 >                pview.vert = 2.*180./PI*atan(
291 >                                tan(PI/180./2.*ourview.vert)/vmult );
292 >                break;
293 >        case VT_PAR:
294 >        case VT_ANG:
295 >                pview.horiz = ourview.horiz / hmult;
296 >                pview.vert = ourview.vert / vmult;
297 >                break;
298 >        case VT_HEM:
299 >                pview.horiz = 2.*180./PI*asin(
300 >                                sin(PI/180./2.*ourview.horiz)/hmult );
301 >                pview.vert = 2.*180./PI*asin(
302 >                                sin(PI/180./2.*ourview.vert)/vmult );
303 >                break;
304 >        default:
305 >                fprintf(stderr, "%s: unknown view type '-vt%c'\n",
306 >                                progname, ourview.type);
307 >                exit(cleanup(1));
308 >        }
309 >                                        /* render each piece */
310 >        while (nextpiece(&xorg, &yorg)) {
311 >                pview.hoff = ourview.hoff + xorg - 0.5*(hmult-1);
312 >                pview.voff = ourview.voff + yorg - 0.5*(vmult-1);
313                  fputs(VIEWSTR, torp);
314                  fprintview(&pview, torp);
315                  putc('\n', torp);
316 <                fflush(torp);                   /* assign piece to rpict */
316 >                fflush(torp);                   /* assigns piece to rpict */
317                  putpiece(xorg, yorg);           /* place piece in output */
318                  if (verbose) {                  /* notify caller */
319 <                        strcat(buf, " done\n");
320 <                        writebuf(fileno(stdout), buf, strlen(buf));
319 >                        printf("%d %d done\n", xorg, yorg);
320 >                        fflush(stdout);
321                  }
322          }
323   }
324  
325  
326 + int
327   putpiece(xpos, ypos)            /* get next piece from rpict */
328   int  xpos, ypos;
329   {
330 +        struct flock  fls;
331 +        int  pid, status;
332          int  hr, vr;
333 <        int  y;
334 <
335 <        getheader(fromrp, NULL);        /* discard header info. */
336 <        if (fscnresolu(&hr, &vr, fromrp) < 0 || /* check resolution */
337 <                        hr != hres || vr != vres) {
333 >        register int  y;
334 >                                /* check bounds */
335 >        if (xpos < 0 | ypos < 0 | xpos >= hmult | ypos >= vmult) {
336 >                fprintf(stderr, "%s: requested piece (%d,%d) out of range\n",
337 >                                progname, xpos, ypos);
338 >                exit(cleanup(1));
339 >        }
340 >                                /* check header from rpict */
341 >        getheader(fromrp, NULL, NULL);
342 >        if (!fscnresolu(&hr, &vr, fromrp) || hr != hres | vr != vres) {
343                  fprintf(stderr, "%s: resolution mismatch from %s\n",
344                                  progname, rpargv[0]);
345 <                exit(1);
345 >                exit(cleanup(1));
346          }
347 <        for (y = 0; y < vr; y++) {      /* transfer scanlines */
348 <                if (freadcolrs(scanline, hr, fromrp) < 0) {
347 >                                /* load new piece into buffer */
348 >        for (y = 0; y < vr; y++)
349 >                if (freadcolrs(pbuf+y*hr, hr, fromrp) < 0) {
350                          fprintf(stderr, "%s: read error from %s\n",
351                                          progname, rpargv[0]);
352 <                        exit(1);
352 >                        exit(cleanup(1));
353                  }
354 <                if ((y == 0 || hmult != 1) && lseek(outfd,
355 < scanorig+((long)((vmult-1-ypos)*vres+y)*hmult*hres+xpos*hres)*sizeof(COLR),
356 <                                0) == -1) {
357 <                        fprintf(stderr, "%s: seek error\n", outfile);
358 <                        exit(1);
354 > #if MAXFORK
355 >                                /* fork so we don't slow rpict down */
356 >        if ((pid = fork()) > 0) {
357 >                if (++nforked >= MAXFORK) {
358 >                        wait(&status);          /* reap a child */
359 >                        if (status)
360 >                                exit(cleanup(status>>8 & 0xff));
361 >                        nforked--;
362                  }
363 <                if (writebuf(outfd, (char *)scanline, hr*sizeof(COLR)) !=
364 <                                hr*sizeof(COLR)) {
365 <                        fprintf(stderr, "%s: write error\n", outfile);
366 <                        exit(1);
363 >                return(pid);
364 >        }
365 > #else
366 >        pid = -1;               /* no forking */
367 > #endif
368 >        fls.l_len = (long)vres*hmult*hres*sizeof(COLR);
369 >        fls.l_start = scanorig + (vmult-1-ypos)*fls.l_len;
370 > #if NFS
371 >                                /* lock file section so NFS doesn't mess up */
372 >        fls.l_whence = 0;
373 >        fls.l_type = F_WRLCK;
374 >        fcntl(outfd, F_SETLKW, &fls);
375 > #endif
376 >                                /* write new piece to file */
377 >        if (lseek(outfd, fls.l_start+(long)xpos*hres*sizeof(COLR), 0) == -1)
378 >                goto seekerr;
379 >        if (hmult == 1) {
380 >                if (writebuf(outfd, (char *)pbuf,
381 >                                vr*hr*sizeof(COLR)) != vr*hr*sizeof(COLR))
382 >                        goto writerr;
383 >        } else
384 >                for (y = 0; y < vr; y++) {
385 >                        if (writebuf(outfd, (char *)(pbuf+y*hr),
386 >                                        hr*sizeof(COLR)) != hr*sizeof(COLR))
387 >                                goto writerr;
388 >                        if (y < vr-1 && lseek(outfd,
389 >                                        (long)(hmult-1)*hr*sizeof(COLR),
390 >                                        1) == -1)
391 >                                goto seekerr;
392                  }
393 +        if (pid == -1) {        /* fork failed */
394 + #if NFS
395 +                fls.l_type = F_UNLCK;           /* release lock */
396 +                fcntl(outfd, F_SETLKW, &fls);
397 + #endif
398 +                return(0);
399          }
400 +        _exit(0);               /* else exit child process (releasing lock) */
401 + seekerr:
402 +        fprintf(stderr, "%s: seek error on file \"%s\"\n", progname, outfile);
403 +        _exit(1);
404 + writerr:
405 +        fprintf(stderr, "%s: write error on file \"%s\"\n", progname, outfile);
406 +        _exit(1);
407   }

Diff Legend

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