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

Comparing ray/src/hd/rhoptimize.c (file contents):
Revision 3.8 by greg, Sat Feb 22 02:07:25 2003 UTC vs.
Revision 3.23 by greg, Mon Oct 21 18:19:32 2019 UTC

# Line 7 | Line 7 | static const char      RCSid[] = "$Id$";
7   *      11/4/98         Greg Ward Larson
8   */
9  
10 – #include "holo.h"
11 –
10   #include <signal.h>
11 + #include <string.h>
12 + #include <stdio.h>
13  
14 + #include "platform.h"
15 + #include "rterror.h"
16 + #include "resolu.h"
17 + #include "rtprocess.h" /* getpid() */
18 + #include "holo.h"
19 +
20   #ifndef BKBSIZE
21   #define BKBSIZE         256             /* beam clump size (kilobytes) */
22   #endif
# Line 19 | Line 25 | char   *progname;
25   char    tempfile[128];
26   int     dupchecking = 0;
27  
28 < extern char     *rindex();
29 < extern long     rhinitcopy();
28 > static long rhinitcopy(int hfd[2], char *infn, char *outfn);
29 > static int nuniq(RAYVAL *rva, int n);
30 > static int bpcmp(const void *b1p, const void *b2p);
31 > static int xferclump(HOLO *hp, int *bq, int nb);
32 > static void copysect(int ifd, int ofd);
33  
34  
35 < main(argc, argv)
36 < int     argc;
37 < char    *argv[];
35 > int
36 > main(
37 >        int     argc,
38 >        char    *argv[]
39 > )
40   {
41          char    *inpname, *outname;
42          int     hdfd[2];
43 <        long    nextipos, lastopos, thisopos;
43 >        off_t   nextipos, lastopos, thisopos;
44  
45          progname = argv[0];
46          argv++; argc--;                 /* duplicate checking flag? */
# Line 37 | Line 48 | char   *argv[];
48                  dupchecking++;
49                  argv++; argc--;
50          }
51 <        if (argc < 1 | argc > 2) {
51 >        if ((argc < 1) | (argc > 2)) {
52                  fprintf(stderr, "Usage: %s [-u] input.hdk [output.hdk]\n",
53                                  progname);
54                  exit(1);
# Line 52 | Line 63 | char   *argv[];
63                          error(SYSTEM, errmsg);
64                  }
65                  strcpy(tempfile, inpname);
66 <                if ((outname = rindex(tempfile, '/')) != NULL)
66 >                if ((outname = strrchr(tempfile, '/')) != NULL)
67                          outname++;
68                  else
69                          outname = tempfile;
# Line 61 | Line 72 | char   *argv[];
72          }
73                                          /* copy holodeck file header */
74          nextipos = rhinitcopy(hdfd, inpname, outname);
75 <        lastopos = 0L;                  /* copy sections one by one */
75 >        lastopos = 0;                   /* copy sections one by one */
76          while (nextipos != 0L) {
77                                          /* set input position; get next */
78 <                lseek(hdfd[0], (off_t)nextipos, 0);
78 >                lseek(hdfd[0], nextipos, SEEK_SET);
79                  read(hdfd[0], (char *)&nextipos, sizeof(nextipos));
80                                          /* get output position; set last */
81 <                thisopos = lseek(hdfd[1], (off_t)0L, 2);
82 <                if (lastopos > 0L) {
83 <                        lseek(hdfd[1], (off_t)lastopos, 0);
81 >                thisopos = lseek(hdfd[1], (off_t)0, SEEK_END);
82 >                if (lastopos > 0) {
83 >                        lseek(hdfd[1], lastopos, SEEK_SET);
84                          write(hdfd[1], (char *)&thisopos, sizeof(thisopos));
85 <                        lseek(hdfd[1], (off_t)0L, 2);
85 >                        lseek(hdfd[1], (off_t)0, SEEK_END);
86                  }
87                  lastopos = thisopos;
88 <                thisopos = 0L;          /* write place holder */
88 >                thisopos = 0;           /* write place holder */
89                  write(hdfd[1], (char *)&thisopos, sizeof(thisopos));
90                                          /* copy holodeck section */
91                  copysect(hdfd[0], hdfd[1]);
# Line 87 | Line 98 | char   *argv[];
98                                  outname, inpname);
99                  error(SYSTEM, errmsg);
100          }
101 <        exit(0);
101 >        return(0);
102   }
103  
104  
105 < long
106 < rhinitcopy(hfd, infn, outfn)    /* open files and copy header */
107 < int     hfd[2];                 /* returned file descriptors */
108 < char    *infn, *outfn;
105 > static long
106 > rhinitcopy(     /* open files and copy header */
107 >        int     hfd[2],                 /* returned file descriptors */
108 >        char    *infn,
109 >        char    *outfn
110 > )
111   {
112          FILE    *infp, *outfp;
113          long    ifpos;
114                                          /* open files for i/o */
115 <        if ((infp = fopen(infn, "r")) == NULL) {
115 >        if ((infp = fopen(infn, "rb")) == NULL) {
116                  sprintf(errmsg, "cannot open \"%s\" for reading", infn);
117                  error(SYSTEM, errmsg);
118          }
# Line 107 | Line 120 | char   *infn, *outfn;
120                  sprintf(errmsg, "output file \"%s\" already exists!", outfn);
121                  error(USER, errmsg);
122          }
123 <        if ((outfp = fopen(outfn, "w+")) == NULL) {
123 >        if ((outfp = fopen(outfn, "wb+")) == NULL) {
124                  sprintf(errmsg, "cannot open \"%s\" for writing", outfn);
125                  error(SYSTEM, errmsg);
126          }
127                                          /* set up signal handling */
128 + #ifdef SIGINT
129          if (signal(SIGINT, quit) == SIG_IGN) signal(SIGINT, SIG_IGN);
130 + #endif
131 + #ifdef SIGHUP
132          if (signal(SIGHUP, quit) == SIG_IGN) signal(SIGHUP, SIG_IGN);
133 + #endif
134 + #ifdef SIGTERM
135          if (signal(SIGTERM, quit) == SIG_IGN) signal(SIGTERM, SIG_IGN);
136 + #endif
137   #ifdef SIGXCPU
138          if (signal(SIGXCPU, quit) == SIG_IGN) signal(SIGXCPU, SIG_IGN);
139          if (signal(SIGXFSZ, quit) == SIG_IGN) signal(SIGXFSZ, SIG_IGN);
# Line 141 | Line 160 | char   *infn, *outfn;
160   }
161  
162  
163 < int
164 < nuniq(rva, n)                   /* sort unique rays to front of beam list */
165 < register RAYVAL *rva;
166 < int     n;
163 > static int
164 > nuniq(                  /* sort unique rays to front of beam list */
165 >        RAYVAL  *rva,
166 >        int     n
167 > )
168   {
169 <        register int    i, j;
169 >        int     i, j;
170          RAYVAL  rtmp;
171  
172          for (j = 0; j < n; j++)
# Line 157 | Line 177 | int    n;
177                                          rva[i].r[1][0]==rva[j].r[1][0] &&
178                                          rva[i].r[1][1]==rva[j].r[1][1] ) {
179                                  n--;            /* swap duplicate with end */
180 <                                copystruct(&rtmp, rva+n);
181 <                                copystruct(rva+n, rva+i);
182 <                                copystruct(rva+i, &rtmp);
180 >                                rtmp = *(rva+n);
181 >                                *(rva+n) = *(rva+i);
182 >                                *(rva+i) = rtmp;
183                                  i--;            /* recheck one we swapped */
184                          }
185          return(n);
# Line 169 | Line 189 | int    n;
189   static BEAMI    *beamdir;
190  
191   static int
192 < bpcmp(b1p, b2p)                 /* compare beam positions on disk */
193 < int     *b1p, *b2p;
192 > bpcmp(                  /* compare beam positions on disk */
193 >        const void      *b1p,
194 >        const void      *b2p
195 > )
196   {
197 <        register long   pdif = beamdir[*b1p].fo - beamdir[*b2p].fo;
197 >        off_t   pdif = beamdir[*(int*)b1p].fo - beamdir[*(int*)b2p].fo;
198  
199          if (pdif < 0L) return(-1);
200          return(pdif > 0L);
# Line 181 | Line 203 | int    *b1p, *b2p;
203   static HOLO     *hout;
204  
205   static int
206 < xferclump(hp, bq, nb)           /* transfer the given clump to hout and free */
207 < HOLO    *hp;
208 < int     *bq, nb;
206 > xferclump(              /* transfer the given clump to hout and free */
207 >        HOLO    *hp,
208 >        int     *bq,
209 >        int     nb
210 > )
211   {
212 <        register int    i;
213 <        register BEAM   *bp;
212 >        int     i;
213 >        BEAM    *bp;
214          int     n;
215  
216          beamdir = hp->bi;               /* sort based on file position */
217 <        qsort((char *)bq, nb, sizeof(*bq), bpcmp);
217 >        qsort((void *)bq, nb, sizeof(*bq), bpcmp);
218                                          /* transfer and free each beam */
219          for (i = 0; i < nb; i++) {
220                  bp = hdgetbeam(hp, bq[i]);
221                  DCHECK(bp==NULL, CONSISTENCY, "empty beam in xferclump");
222                  n = dupchecking ? nuniq(hdbray(bp),bp->nrm) : bp->nrm;
223 <                bcopy((char *)hdbray(bp), (char *)hdnewrays(hout,bq[i],n),
223 >                memcpy((void *)hdnewrays(hout,bq[i],n),(void *)hdbray(bp),
224                                  n*sizeof(RAYVAL));
225                  hdfreebeam(hp, bq[i]);
226          }
# Line 204 | Line 228 | int    *bq, nb;
228          return(0);
229   }
230  
231 < copysect(ifd, ofd)              /* copy holodeck section from ifd to ofd */
232 < int     ifd, ofd;
231 > static void
232 > copysect(               /* copy holodeck section from ifd to ofd */
233 >        int     ifd,
234 >        int     ofd
235 > )
236   {
237          HOLO    *hinp;
238                                          /* load input section directory */
# Line 222 | Line 249 | int    ifd, ofd;
249  
250   void
251   eputs(s)                        /* put error message to stderr */
252 < register char  *s;
252 > char  *s;
253   {
254          static int  midline = 0;
255  

Diff Legend

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