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

Comparing src/hd/rholo4.c (file contents):
Revision 3.26 by gwlarson, Fri Feb 12 11:32:22 1999 UTC vs.
Revision 3.39 by greg, Fri Feb 28 05:18:49 2020 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1999 Silicon Graphics, Inc. */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ SGI";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   * Holodeck display process communication
6   */
7  
8   #include "rholo.h"
9   #include "rhdisp.h"
10 + #include "rtprocess.h"
11   #include <sys/uio.h>
12 + #include <string.h>
13  
14   #ifndef HDSUF
15   #define HDSUF           ".hdi"
# Line 24 | Line 23 | static char SCCSid[] = "$SunId$ SGI";
23   #endif
24  
25   static int      inp_flags;
26 < static int      dpd[3];
26 > static SUBPROC  dpd = SP_INACTIVE;
27   static FILE     *dpout;
28  
29 + static void disp_flush(void);
30 + static void disp_result(int type, int nbytes, char *p);
31  
32 < disp_open(dname)                /* open the named display driver */
33 < char    *dname;
32 >
33 > void
34 > disp_open(              /* open the named display driver */
35 >        char    *dname
36 > )
37   {
38          char    buf[sizeof(HDGRID)+512], fd0[8], fd1[8], *cmd[5], *sfn;
39          int     i, n, len;
40  
41          if (!strcmp(dname, SLAVENAME)) {
42 <                dpd[0] = 0;             /* read from stdin */
42 >                dpd.r = 0;              /* read from stdin */
43                  dpout = stdout;         /* write to stdout */
44 <                dpd[2] = -1;            /* we're the slave process */
44 >                dpd.flags = 0;          /* we're the slave procees */
45          } else {
46                                          /* get full display program name */
47   #ifdef DEVPATH
# Line 55 | Line 59 | char   *dname;
59                  cmd[0] = buf;
60                  cmd[1] = froot; cmd[2] = fd1; cmd[3] = fd0;
61                  cmd[4] = NULL;
62 <                i = open_process(dpd, cmd);
62 >                i = open_process(&dpd, cmd);
63                  if (i <= 0)
64                          error(USER, "cannot start display process");
65 <                if ((dpout = fdopen(dpd[1], "w")) == NULL)
65 >                if ((dpout = fdopen(dpd.w, "w")) == NULL)
66                          error(SYSTEM, "problem opening display pipe");
67                                          /* close dup'ed stdin and stdout */
68                  if (readinp)
69                          close(atoi(fd0));
70                  close(atoi(fd1));
71          }
72 <        dpd[1] = -1;            /* causes ignored error in close_process() */
72 >        dpd.w = -1;             /* causes ignored error in close_process() */
73          inp_flags = 0;
74                                  /* check if outside */
75          if (vdef(OBSTRUCTIONS) && vbool(OBSTRUCTIONS))
# Line 77 | Line 81 | char   *dname;
81          }
82                                  /* write out hologram grids & octrees */
83          for (i = 0; hdlist[i] != NULL; i++) {
84 <                bcopy((char *)hdlist[i], buf, sizeof(HDGRID));
84 >                memcpy(buf, (void *)hdlist[i], sizeof(HDGRID));
85                  len = sizeof(HDGRID);
86                  n = vdef(GEOMETRY);
87                  sfn = i<n ? nvalue(GEOMETRY,i) :
# Line 94 | Line 98 | char   *dname;
98   }
99  
100  
101 < disp_packet(p)                  /* display a packet */
102 < register PACKHEAD       *p;
101 > void
102 > disp_packet(                    /* display a packet */
103 >        PACKHEAD        *p
104 > )
105   {
106          disp_result(DS_BUNDLE, packsiz(p->nr), (char *)p);
107   }
108  
109  
110 < disp_check(block)               /* check display process */
111 < int     block;
110 > int
111 > disp_check(             /* check display process */
112 >        int     block
113 > )
114   {
115          MSGHEAD msg;
116          int     n;
# Line 115 | Line 123 | int    block;
123                                          /* check read blocking */
124          if (block != (inp_flags == 0)) {
125                  inp_flags = block ? 0 : FNONBLK;
126 <                if (fcntl(dpd[0], F_SETFL, inp_flags) < 0)
126 >                if (fcntl(dpd.r, F_SETFL, inp_flags) < 0)
127                          goto fcntlerr;
128          }
129                                          /* read message header */
130 <        n = read(dpd[0], (char *)&msg, sizeof(MSGHEAD));
130 >        n = read(dpd.r, (char *)&msg, sizeof(MSGHEAD));
131          if (n != sizeof(MSGHEAD)) {
132                  if (n >= 0) {
133                          dpout = NULL;
134                          error(USER, "display process died");
135                  }
136 <                if (errno != EAGAIN & errno != EINTR)
136 >                if ((errno != EAGAIN) & (errno != EINTR))
137                          goto readerr;
138                  return(2);              /* acceptable failure */
139          }
# Line 135 | Line 143 | int    block;
143                  buf = (char *)malloc(msg.nbytes);
144                  if (buf == NULL)
145                          error(SYSTEM, "out of memory in disp_check");
146 <                if (inp_flags != 0 && fcntl(dpd[0], F_SETFL, inp_flags=0) < 0)
146 >                if (inp_flags != 0 && fcntl(dpd.r, F_SETFL, inp_flags=0) < 0)
147                          goto fcntlerr;
148 <                if (readbuf(dpd[0], buf, msg.nbytes) != msg.nbytes)
148 >                if (readbuf(dpd.r, buf, msg.nbytes) != msg.nbytes)
149                          goto readerr;
150          }
151          switch (msg.type) {             /* take appropriate action */
# Line 187 | Line 195 | int    block;
195          case DR_VIEWPOINT:      /* set target eye position */
196                  if (msg.nbytes != sizeof(VIEWPOINT))
197                          error(INTERNAL, "bad DR_VIEWPOINT from display process");
198 <                copystruct(&myeye, (VIEWPOINT *)buf);
198 >                myeye = *((VIEWPOINT *)buf);
199                  break;
200          case DR_ATTEN:          /* block for priority request */
201                  if (msg.nbytes)
# Line 216 | Line 224 | int    block;
224          case DR_CLOBBER:        /* clobber holodeck */
225                  if (msg.nbytes)
226                          error(INTERNAL, "bad DR_CLOBBER from display process");
227 <                if (!force || !ncprocs)
227 >                if ((force <= 0) | (ncprocs <= 0))
228                          error(WARNING, "request to clobber holodeck denied");
229                  else {
230                          error(WARNING, "clobbering holodeck contents");
# Line 239 | Line 247 | fcntlerr:
247          error(SYSTEM, "cannot change display blocking mode");
248   readerr:
249          error(SYSTEM, "error reading from display process");
250 +        return -1; /* pro forma return */
251   }
252  
253  
254   int
255 < disp_close()                    /* close our display process */
255 > disp_close(void)                        /* close our display process */
256   {
248 –        int     rval;
249 –
257          if (dpout == NULL)
258                  return(-1);
259          myeye.rng = 0;
260          disp_result(DS_SHUTDOWN, 0, NULL);
261          fclose(dpout);
262          dpout = NULL;
263 <        return(dpd[2]<0 ? 0 : close_process(dpd));
263 >        return(dpd.flags&PF_RUNNING ? close_process(&dpd) : 0);
264 >
265   }
266  
267  
268 < disp_result(type, nbytes, p)    /* queue result message to display process */
269 < int     type, nbytes;
270 < char    *p;
268 > static void
269 > disp_result(    /* queue result message to display process */
270 >        int     type,
271 >        int     nbytes,
272 >        char    *p
273 > )
274   {
275          MSGHEAD msg;
276                                          /* consistency checks */
# Line 271 | Line 282 | char   *p;
282                  return;
283          msg.type = type;
284          msg.nbytes = nbytes;
285 <        fwrite((char *)&msg, sizeof(MSGHEAD), 1, dpout);
285 >        putbinary(&msg, sizeof(MSGHEAD), 1, dpout);
286          if (nbytes > 0)
287 <                fwrite(p, 1, nbytes, dpout);
287 >                putbinary(p, 1, nbytes, dpout);
288   }
289  
290  
291 < disp_flush()                    /* flush output to display */
291 > static void
292 > disp_flush(void)                        /* flush output to display */
293   {
294          if (fflush(dpout) < 0)
295                  error(SYSTEM, "error writing to the display process");

Diff Legend

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