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

Comparing ray/src/hd/rholo4.c (file contents):
Revision 3.2 by gregl, Mon Nov 3 18:33:14 1997 UTC vs.
Revision 3.23 by gwlarson, Fri Dec 18 11:56:11 1998 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1997 Silicon Graphics, Inc. */
1 > /* Copyright (c) 1998 Silicon Graphics, Inc. */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ SGI";
# Line 13 | Line 13 | static char SCCSid[] = "$SunId$ SGI";
13   #include <sys/uio.h>
14  
15   #ifndef HDSUF
16 < #define HDSUF   ".hdisp"
16 > #define HDSUF   ".hdi"
17   #endif
18  
19 + #ifndef FNONBLK
20 + #define FNONBLK         O_NONBLOCK
21 + #endif
22 +
23   static int      inp_flags;
24   static int      dpd[3];
25 < static int      pipesiz;
25 > static FILE     *dpout;
26  
27  
28   disp_open(dname)                /* open the named display driver */
29   char    *dname;
30   {
31 <        char    dpath[128], *com[2];
32 <        int     i;
33 <
31 >        char    buf[128], fd0[8], fd1[8], *cmd[5], *ofn;
32 >        int     i, n;
33 >                                /* get full display program name */
34   #ifdef DEVPATH
35 <        sprintf(dpath, "%s/%s%s", DEVPATH, dname, HDSUF);
35 >        sprintf(buf, "%s/%s%s", DEVPATH, dname, HDSUF);
36   #else
37 <        sprintf(dpath, "dev/%s%s", dname, HDSUF);
37 >        sprintf(buf, "dev/%s%s", dname, HDSUF);
38   #endif
39 <        com[0] = dpath; com[1] = NULL;
40 <        pipesiz = open_process(dpd, com);
41 <        if (pipesiz <= 0)
39 >                                /* dup stdin and stdout */
40 >        if (readinp)
41 >                sprintf(fd0, "%d", dup(0));
42 >        else
43 >                strcpy(fd0, "-1");
44 >        sprintf(fd1, "%d", dup(1));
45 >                                /* start the display process */
46 >        cmd[0] = buf;
47 >        cmd[1] = froot; cmd[2] = fd1; cmd[3] = fd0;
48 >        cmd[4] = NULL;
49 >        i = open_process(dpd, cmd);
50 >        if (i <= 0)
51                  error(USER, "cannot start display process");
52 +        if ((dpout = fdopen(dpd[1], "w")) == NULL)
53 +                error(SYSTEM, "cannot associate FILE with display pipe");
54 +        dpd[1] = -1;            /* causes ignored error in close_process() */
55          inp_flags = 0;
56 <                                /* write out hologram grids */
57 <        for (i = 0; hdlist[i] != NULL; i++)
58 <                disp_result(DS_ADDHOLO, sizeof(HDGRID), (char *)hdlist[i]);
56 >                                /* close dup'ed stdin and stdout */
57 >        if (readinp)
58 >                close(atoi(fd0));
59 >        close(atoi(fd1));
60 >                                /* check if outside */
61 >        if (vdef(OBSTRUCTIONS) && vbool(OBSTRUCTIONS))
62 >                disp_result(DS_OUTSECT, 0, NULL);
63 >                                /* send eye separation if specified */
64 >        if (vdef(EYESEP)) {
65 >                sprintf(buf, "%.9e", vflt(EYESEP));
66 >                disp_result(DS_EYESEP, strlen(buf)+1, buf);
67 >        }
68 >                                /* write out hologram grids & octrees */
69 >        for (i = 0; hdlist[i] != NULL; i++) {
70 >                bcopy((char *)hdlist[i], buf, sizeof(HDGRID));
71 >                n = vdef(OSECTION);
72 >                ofn = i<n ? nvalue(OSECTION,i) :
73 >                                n ? nvalue(OSECTION,n-1) : vval(OCTREE);
74 >                strcpy(buf+sizeof(HDGRID), ofn);
75 >                disp_result(DS_ADDHOLO, sizeof(HDGRID)+1+strlen(ofn), buf);
76 >        }
77 >        disp_flush();
78   }
79  
80  
81   disp_packet(p)                  /* display a packet */
82 < register PACKET *p;
82 > register PACKHEAD       *p;
83   {
84 <        if (pipesiz <= 0)
50 <                return;
51 <        disp_result(DS_BUNDLE, sizeof(PACKHEAD) + p->nr*sizeof(RAYVAL),
52 <                        (char *)p);
84 >        disp_result(DS_BUNDLE, packsiz(p->nr), (char *)p);
85   }
86  
87  
# Line 60 | Line 92 | int    block;
92          int     n;
93          char    *buf = NULL;
94  
95 <        if (pipesiz <= 0)
95 >        if (dpout == NULL)
96                  return(-1);
97 < restart:                                /* check read blocking */
97 >                                        /* flush display output */
98 >        disp_flush();
99 >                                        /* check read blocking */
100          if (block != (inp_flags == 0)) {
101                  inp_flags = block ? 0 : FNONBLK;
102                  if (fcntl(dpd[0], F_SETFL, inp_flags) < 0)
# Line 71 | Line 105 | restart:                               /* check read blocking */
105                                          /* read message header */
106          n = read(dpd[0], (char *)&msg, sizeof(MSGHEAD));
107          if (n != sizeof(MSGHEAD)) {
108 <                if (n >= 0)
108 >                if (n >= 0) {
109 >                        dpout = NULL;
110                          error(USER, "display process died");
111 +                }
112                  if (errno != EAGAIN & errno != EINTR)
113                          goto readerr;
114 <                return(2);              /* else acceptable failure */
114 >                return(2);              /* acceptable failure */
115          }
116          if (msg.nbytes) {               /* get the message body */
117 +                if (msg.nbytes < 0)
118 +                        error(INTERNAL, "anti-message from display process");
119                  buf = (char *)malloc(msg.nbytes);
120                  if (buf == NULL)
121                          error(SYSTEM, "out of memory in disp_check");
122 <                if (fcntl(dpd[0], F_SETFL, inp_flags=0) < 0)
122 >                if (inp_flags != 0 && fcntl(dpd[0], F_SETFL, inp_flags=0) < 0)
123                          goto fcntlerr;
124                  if (readbuf(dpd[0], buf, msg.nbytes) != msg.nbytes)
125                          goto readerr;
126          }
127          switch (msg.type) {             /* take appropriate action */
128 <        case DR_BUNDLE:
128 >        case DR_BUNDLE:         /* new bundle to calculate */
129                  if (msg.nbytes != sizeof(PACKHEAD))
130                          error(INTERNAL, "bad DR_BUNDLE from display process");
131                  bundle_set(BS_ADD, (PACKHEAD *)buf, 1);
132                  break;
133 <        case DR_NEWSET:
133 >        case DR_NEWSET:         /* new calculation set */
134                  if (msg.nbytes % sizeof(PACKHEAD))
135                          error(INTERNAL, "bad DR_NEWSET from display process");
136 <                disp_result(DS_STARTIMM, 0, NULL);
136 >                if (msg.nbytes)
137 >                        disp_result(DS_STARTIMM, 0, NULL);
138                  bundle_set(BS_NEW, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
139 <                disp_result(DS_ENDIMM, 0, NULL);
139 >                if (msg.nbytes) {
140 >                        disp_result(DS_ENDIMM, 0, NULL);
141 >                        disp_flush();
142 >                }
143                  break;
144 <        case DR_ADDSET:
144 >        case DR_ADDSET:         /* add to calculation set */
145 >                if (!msg.nbytes)
146 >                        break;
147                  if (msg.nbytes % sizeof(PACKHEAD))
148                          error(INTERNAL, "bad DR_ADDSET from display process");
149                  disp_result(DS_STARTIMM, 0, NULL);
150                  bundle_set(BS_ADD, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
151                  disp_result(DS_ENDIMM, 0, NULL);
152 +                disp_flush();
153                  break;
154 <        case DR_DELSET:
154 >        case DR_ADJSET:         /* adjust calculation set members */
155 >                if (!msg.nbytes)
156 >                        break;
157                  if (msg.nbytes % sizeof(PACKHEAD))
158 +                        error(INTERNAL, "bad DR_ADJSET from display process");
159 +                disp_result(DS_STARTIMM, 0, NULL);
160 +                bundle_set(BS_ADJ, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
161 +                disp_result(DS_ENDIMM, 0, NULL);
162 +                disp_flush();
163 +                break;
164 +        case DR_DELSET:         /* delete from calculation set */
165 +                if (!msg.nbytes)
166 +                        break;
167 +                if (msg.nbytes % sizeof(PACKHEAD))
168                          error(INTERNAL, "bad DR_DELSET from display process");
169                  bundle_set(BS_DEL, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
170                  break;
171 <        case DR_ATTEN:
171 >        case DR_VIEWPOINT:      /* set target eye position */
172 >                if (msg.nbytes != sizeof(VIEWPOINT))
173 >                        error(INTERNAL, "bad DR_VIEWPOINT from display process");
174 >                copystruct(&myeye, (VIEWPOINT *)buf);
175 >                break;
176 >        case DR_ATTEN:          /* block for priority request */
177                  if (msg.nbytes)
178                          error(INTERNAL, "bad DR_ATTEN from display process");
179                                          /* send acknowledgement */
180                  disp_result(DS_ACKNOW, 0, NULL);
181 <                block = 1;              /* block on following request */
182 <                goto restart;
121 <        case DR_SHUTDOWN:
181 >                return(disp_check(1));  /* block on following request */
182 >        case DR_KILL:           /* kill computation process(es) */
183                  if (msg.nbytes)
184 +                        error(INTERNAL, "bad DR_KILL from display process");
185 +                if (nprocs > 0)
186 +                        done_rtrace();
187 +                else
188 +                        error(WARNING, "no rtrace process to kill");
189 +                break;
190 +        case DR_RESTART:        /* restart computation process(es) */
191 +                if (msg.nbytes)
192 +                        error(INTERNAL, "bad DR_RESTART from display process");
193 +                if (ncprocs > nprocs)
194 +                        new_rtrace();
195 +                else if (nprocs > 0)
196 +                        error(WARNING, "rtrace already runnning");
197 +                else
198 +                        error(WARNING, "holodeck not open for writing");
199 +                break;
200 +        case DR_CLOBBER:        /* clobber holodeck */
201 +                if (msg.nbytes)
202 +                        error(INTERNAL, "bad DR_CLOBBER from display process");
203 +                if (!force || !ncprocs)
204 +                        error(WARNING, "request to clobber holodeck denied");
205 +                else {
206 +                        error(WARNING, "clobbering holodeck contents");
207 +                        hdclobber(NULL);
208 +                }
209 +                break;
210 +        case DR_SHUTDOWN:       /* shut down program */
211 +                if (msg.nbytes)
212                          error(INTERNAL, "bad DR_SHUTDOWN from display process");
213                  return(0);              /* zero return signals shutdown */
214 +        case DR_NOOP:           /* do nothing */
215 +                break;
216          default:
217                  error(INTERNAL, "unrecognized request from display process");
218          }
219 <        if (msg.nbytes)
219 >        if (msg.nbytes)                 /* clean up */
220                  free(buf);
221          return(1);                      /* normal return value */
222   fcntlerr:
# Line 140 | Line 231 | disp_close()                   /* close our display process */
231   {
232          int     rval;
233  
234 <        if (pipesiz <= 0)
234 >        if (dpout == NULL)
235                  return(-1);
236 +        myeye.rng = 0;
237          disp_result(DS_SHUTDOWN, 0, NULL);
238 <        pipesiz = 0;
238 >        fclose(dpout);
239 >        dpout = NULL;
240          return(close_process(dpd));
241   }
242  
243  
244 < disp_result(type, nbytes, p)    /* send result message to display process */
244 > disp_result(type, nbytes, p)    /* queue result message to display process */
245   int     type, nbytes;
246   char    *p;
247   {
155 –        struct iovec    iov[2];
248          MSGHEAD msg;
249 <        int     n;
250 <
249 >                                        /* consistency checks */
250 > #ifdef DEBUG
251 >        if (nbytes < 0 || nbytes > 0 & p == NULL)
252 >                error(CONSISTENCY, "bad buffer handed to disp_result");
253 > #endif
254 >        if (dpout == NULL)
255 >                return;
256          msg.type = type;
257          msg.nbytes = nbytes;
258 <        if (nbytes == 0 || sizeof(MSGHEAD)+nbytes > pipesiz) {
259 <                n = write(dpd[1], (char *)&msg, sizeof(MSGHEAD));
260 <                if (n != sizeof(MSGHEAD))
261 <                        goto writerr;
262 <                if (nbytes > 0) {
263 <                        n = writebuf(dpd[1], p, nbytes);
264 <                        if (n != nbytes)
265 <                                goto writerr;
266 <                }
267 <                return;
171 <        }
172 <        iov[0].iov_base = (char *)&msg;
173 <        iov[0].iov_len = sizeof(MSGHEAD);
174 <        iov[1].iov_base = p;
175 <        iov[1].iov_len = nbytes;
176 <        n = writev(dpd[1], iov, 2);
177 <        if (n == nbytes+sizeof(MSGHEAD))
178 <                return;
179 < writerr:
180 <        error(SYSTEM, "write error in disp_result");
258 >        fwrite((char *)&msg, sizeof(MSGHEAD), 1, dpout);
259 >        if (nbytes > 0)
260 >                fwrite(p, 1, nbytes, dpout);
261 > }
262 >
263 >
264 > disp_flush()                    /* flush output to display */
265 > {
266 >        if (fflush(dpout) < 0)
267 >                error(SYSTEM, "error writing to the display process");
268   }

Diff Legend

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