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.9 by gregl, Wed Nov 26 21:34:28 1997 UTC

# Line 18 | Line 18 | static char SCCSid[] = "$SunId$ SGI";
18  
19   static int      inp_flags;
20   static int      dpd[3];
21 < static int      pipesiz;
21 > static FILE     *dpout;
22  
23  
24   disp_open(dname)                /* open the named display driver */
25   char    *dname;
26   {
27 <        char    dpath[128], *com[2];
27 >        char    dpath[128], *com[3];
28          int     i;
29  
30   #ifdef DEVPATH
# Line 32 | Line 32 | char   *dname;
32   #else
33          sprintf(dpath, "dev/%s%s", dname, HDSUF);
34   #endif
35 <        com[0] = dpath; com[1] = NULL;
36 <        pipesiz = open_process(dpd, com);
37 <        if (pipesiz <= 0)
35 >        com[0] = dpath; com[1] = froot; com[2] = NULL;
36 >        i = open_process(dpd, com);
37 >        if (i <= 0)
38                  error(USER, "cannot start display process");
39 +        if ((dpout = fdopen(dup(dpd[1]), "w")) == NULL)
40 +                error(SYSTEM, "cannot associate FILE with display pipe");
41          inp_flags = 0;
42                                  /* write out hologram grids */
43          for (i = 0; hdlist[i] != NULL; i++)
44                  disp_result(DS_ADDHOLO, sizeof(HDGRID), (char *)hdlist[i]);
45 +        disp_flush();
46   }
47  
48  
49   disp_packet(p)                  /* display a packet */
50 < register PACKET *p;
50 > register PACKHEAD       *p;
51   {
52 <        if (pipesiz <= 0)
50 <                return;
51 <        disp_result(DS_BUNDLE, sizeof(PACKHEAD) + p->nr*sizeof(RAYVAL),
52 <                        (char *)p);
52 >        disp_result(DS_BUNDLE, packsiz(p->nr), (char *)p);
53   }
54  
55  
# Line 60 | Line 60 | int    block;
60          int     n;
61          char    *buf = NULL;
62  
63 <        if (pipesiz <= 0)
63 >        if (dpout == NULL)
64                  return(-1);
65 < restart:                                /* check read blocking */
65 >                                        /* flush display output */
66 >        disp_flush();
67 >                                        /* check read blocking */
68          if (block != (inp_flags == 0)) {
69                  inp_flags = block ? 0 : FNONBLK;
70                  if (fcntl(dpd[0], F_SETFL, inp_flags) < 0)
# Line 75 | Line 77 | restart:                               /* check read blocking */
77                          error(USER, "display process died");
78                  if (errno != EAGAIN & errno != EINTR)
79                          goto readerr;
80 <                return(2);              /* else acceptable failure */
80 >                return(2);              /* acceptable failure */
81          }
82          if (msg.nbytes) {               /* get the message body */
83                  buf = (char *)malloc(msg.nbytes);
# Line 98 | Line 100 | restart:                               /* check read blocking */
100                  disp_result(DS_STARTIMM, 0, NULL);
101                  bundle_set(BS_NEW, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
102                  disp_result(DS_ENDIMM, 0, NULL);
103 +                disp_flush();
104                  break;
105          case DR_ADDSET:
106                  if (msg.nbytes % sizeof(PACKHEAD))
# Line 105 | Line 108 | restart:                               /* check read blocking */
108                  disp_result(DS_STARTIMM, 0, NULL);
109                  bundle_set(BS_ADD, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
110                  disp_result(DS_ENDIMM, 0, NULL);
111 +                disp_check(0);          /* hack -- delete usu. follows add */
112                  break;
113 +        case DR_ADJSET:
114 +                if (msg.nbytes % sizeof(PACKHEAD))
115 +                        error(INTERNAL, "bad DR_ADJSET from display process");
116 +                disp_result(DS_STARTIMM, 0, NULL);
117 +                bundle_set(BS_ADJ, (PACKHEAD *)buf, msg.nbytes/sizeof(PACKHEAD));
118 +                disp_result(DS_ENDIMM, 0, NULL);
119 +                disp_flush();
120 +                break;
121          case DR_DELSET:
122                  if (msg.nbytes % sizeof(PACKHEAD))
123                          error(INTERNAL, "bad DR_DELSET from display process");
# Line 116 | Line 128 | restart:                               /* check read blocking */
128                          error(INTERNAL, "bad DR_ATTEN from display process");
129                                          /* send acknowledgement */
130                  disp_result(DS_ACKNOW, 0, NULL);
131 <                block = 1;              /* block on following request */
120 <                goto restart;
131 >                return(disp_check(1));  /* block on following request */
132          case DR_SHUTDOWN:
133                  if (msg.nbytes)
134                          error(INTERNAL, "bad DR_SHUTDOWN from display process");
135                  return(0);              /* zero return signals shutdown */
136 +        case DR_NOOP:
137 +                break;
138          default:
139                  error(INTERNAL, "unrecognized request from display process");
140          }
141 <        if (msg.nbytes)
141 >        if (msg.nbytes)                 /* clean up */
142                  free(buf);
143          return(1);                      /* normal return value */
144   fcntlerr:
# Line 140 | Line 153 | disp_close()                   /* close our display process */
153   {
154          int     rval;
155  
156 <        if (pipesiz <= 0)
156 >        if (dpout == NULL)
157                  return(-1);
158          disp_result(DS_SHUTDOWN, 0, NULL);
159 <        pipesiz = 0;
159 >        fclose(dpout);
160 >        dpout = NULL;
161          return(close_process(dpd));
162   }
163  
164  
165 < disp_result(type, nbytes, p)    /* send result message to display process */
165 > disp_result(type, nbytes, p)    /* queue result message to display process */
166   int     type, nbytes;
167   char    *p;
168   {
155 –        struct iovec    iov[2];
169          MSGHEAD msg;
157 –        int     n;
170  
171 +        if (dpout == NULL)
172 +                return;
173          msg.type = type;
174          msg.nbytes = nbytes;
175 <        if (nbytes == 0 || sizeof(MSGHEAD)+nbytes > pipesiz) {
176 <                n = write(dpd[1], (char *)&msg, sizeof(MSGHEAD));
177 <                if (n != sizeof(MSGHEAD))
178 <                        goto writerr;
179 <                if (nbytes > 0) {
180 <                        n = writebuf(dpd[1], p, nbytes);
181 <                        if (n != nbytes)
182 <                                goto writerr;
183 <                }
184 <                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");
175 >        fwrite((char *)&msg, sizeof(MSGHEAD), 1, dpout);
176 >        if (nbytes > 0)
177 >                fwrite(p, 1, nbytes, dpout);
178 > }
179 >
180 >
181 > disp_flush()                    /* flush output to display */
182 > {
183 >        if (fflush(dpout) < 0)
184 >                error(SYSTEM, "error writing to the display process");
185   }

Diff Legend

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