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

Comparing ray/src/common/depthcodec.c (file contents):
Revision 2.1 by greg, Fri Jul 26 16:18:06 2019 UTC vs.
Revision 2.7 by greg, Sat Jan 25 02:36:25 2020 UTC

# Line 8 | Line 8 | static const char RCSid[] = "$Id$";
8   #include "copyright.h"
9  
10   #include <stdlib.h>
11 – #include <string.h>
11   #include <math.h>
12   #include <ctype.h>
13   #include "rtio.h"
# Line 16 | Line 15 | static const char RCSid[] = "$Id$";
15   #include "depthcodec.h"
16  
17  
18 < #if 0                   /* defined as macro in depthcodec.h */
18 > #ifndef depth2code
19   /* Encode depth as 16-bit signed integer */
20   int
21   depth2code(double d, double dref)
# Line 25 | Line 24 | depth2code(double d, double dref)
24                  return -32768;
25  
26          if (d > dref)
27 <                return (int)(32768 - 32768*dref/d) - 1;
27 >                return (int)(32768.001 - 32768.*dref/d) - 1;
28  
29 <        return (int)(32767*d/dref - 32768);
29 >        return (int)(32767.*d/dref - 32768.);
30   }
31   #endif
32  
33  
34 + #ifndef code2depth
35   /* Decode depth from 16-bit signed integer */
36   double
37   code2depth(int c, double dref)
# Line 41 | Line 41 | code2depth(int c, double dref)
41  
42          if (c >= 32767)
43                  return FHUGE;
44 <                
45 <        if (c < 0)
46 <                return dref*(32767.5 + c)*(1./32767.);
47 <        
48 <        return dref*32768./(32766.5 - c);
44 >
45 >        if (c >= -1)
46 >                return dref*32768./(32766.5 - c);
47 >
48 >        return dref*(32768.5 + c)*(1./32767.);
49   }
50 + #endif
51  
52  
53   /* Set codec defaults */
# Line 70 | Line 71 | static int
71   headline(char *s, void *p)
72   {
73          DEPTHCODEC      *dcp = (DEPTHCODEC *)p;
74 +        int             rv;
75  
76          if (formatval(dcp->inpfmt, s))  /* don't pass format */
77                  return 0;
78 +
79 +        if ((rv = isbigendian(s)) >= 0) {
80 +                dcp->swapped = (nativebigendian() != rv);
81 +                return 0;
82 +        }
83                                          /* check for reference depth */
84          if (!strncmp(s, DEPTHSTR, LDEPTHSTR)) {
85                  char    *cp;
# Line 83 | Line 90 | headline(char *s, void *p)
90                  *cp = '\0';
91                  dcp->refdepth = atof(dcp->depth_unit);
92                  if (dcp->refdepth <= .0) {
93 <                        fputs(dcp->inpname, stderr);
94 <                        fputs(": bad reference depth in input header\n", stderr);
93 >                        if (dcp->hdrflags & HF_STDERR) {
94 >                                fputs(dcp->inpname, stderr);
95 >                                fputs(": bad reference depth in input header\n",
96 >                                                stderr);
97 >                        }
98                          return -1;
99                  }
100 <        } else if (isview(s))           /* get view params */
100 >        } else if (!strncmp(s, "SAMP360=", 8))
101 >                dcp->gotview--;
102 >        else if (isview(s))             /* get view params */
103                  dcp->gotview += (sscanview(&dcp->vw, s) > 0);
104          if (dcp->hdrflags & HF_HEADOUT)
105                  fputs(s, stdout);       /* copy to standard output */
# Line 101 | Line 113 | process_dc_header(DEPTHCODEC *dcp, int ac, char *av[])
113   {
114          if (dcp->hdrflags & HF_HEADIN &&
115                          getheader(dcp->finp, headline, dcp) < 0) {
116 <                fputs(dcp->inpname, stderr);
117 <                fputs(": bad header\n", stderr);
118 <                return 1;
116 >                if (dcp->hdrflags & HF_STDERR) {
117 >                        fputs(dcp->inpname, stderr);
118 >                        fputs(": bad header\n", stderr);
119 >                }
120 >                return 0;
121          }
122 +        dcp->gotview *= (dcp->gotview > 0);
123          if (dcp->hdrflags & HF_HEADOUT) {       /* finish header */
124                  if (!(dcp->hdrflags & HF_HEADIN))
125                          newheader("RADIANCE", stdout);
# Line 121 | Line 136 | process_dc_header(DEPTHCODEC *dcp, int ac, char *av[])
136                                  fputformat("ascii", stdout);
137                                  break;
138                          case 'f':
139 +                                fputendian(stdout);
140                                  fputformat("float", stdout);
141                                  break;
142                          case 'd':
143 +                                fputendian(stdout);
144                                  fputformat("double", stdout);
145                                  break;
146                          }
# Line 131 | Line 148 | process_dc_header(DEPTHCODEC *dcp, int ac, char *av[])
148          }
149                                          /* get/put resolution string */
150          if (dcp->hdrflags & HF_RESIN && !fgetsresolu(&dcp->res, dcp->finp)) {
151 <                fputs(dcp->inpname, stderr);
152 <                fputs(": bad resolution string\n", stderr);
153 <                return 1;
151 >                if (dcp->hdrflags & HF_STDERR) {
152 >                        fputs(dcp->inpname, stderr);
153 >                        fputs(": bad resolution string\n", stderr);
154 >                }
155 >                return 0;
156          }
157          if (dcp->hdrflags & HF_RESOUT)
158                  fputsresolu(&dcp->res, stdout);
# Line 148 | Line 167 | int
167   check_decode_depths(DEPTHCODEC *dcp)
168   {
169          if (dcp->hdrflags & HF_ENCODE) {
170 <                fputs(progname, stderr);
171 <                fputs(": wrong header mode for decode\n", stderr);
170 >                if (dcp->hdrflags & HF_STDERR) {
171 >                        fputs(progname, stderr);
172 >                        fputs(": wrong header mode for decode\n", stderr);
173 >                }
174                  return 0;
175          }
176          if (dcp->inpfmt[0] && strcmp(dcp->inpfmt, DEPTH16FMT)) {
177 <                fputs(dcp->inpname, stderr);
178 <                fputs(": unexpected input format: ", stderr);
179 <                fputs(dcp->inpfmt, stderr);
180 <                fputc('\n', stderr);
177 >                if (dcp->hdrflags & HF_STDERR) {
178 >                        fputs(dcp->inpname, stderr);
179 >                        fputs(": unexpected input format: ", stderr);
180 >                        fputs(dcp->inpfmt, stderr);
181 >                        fputc('\n', stderr);
182 >                }
183                  return 0;
184          }
185          return 1;
# Line 172 | Line 195 | check_decode_worldpos(DEPTHCODEC *dcp)
195          if (!check_decode_depths(dcp))
196                  return 0;
197          if ((dcp->res.xr <= 0) | (dcp->res.yr <= 0)) {
198 <                fputs(progname, stderr);
199 <                fputs(": missing map resolution\n", stderr);
198 >                if (dcp->hdrflags & HF_STDERR) {
199 >                        fputs(progname, stderr);
200 >                        fputs(": missing map resolution\n", stderr);
201 >                }
202                  return 0;
203          }
204          if (!dcp->gotview) {
205 <                fputs(dcp->inpname, stderr);
206 <                fputs(": missing view\n", stderr);
205 >                if (dcp->hdrflags & HF_STDERR) {
206 >                        fputs(dcp->inpname, stderr);
207 >                        fputs(": missing view\n", stderr);
208 >                }
209                  return 0;
210          }
211          if ((err = setview(&dcp->vw)) != NULL) {
212 <                fputs(dcp->inpname, stderr);
213 <                fputs(": input view error: ", stderr);
214 <                fputs(err, stderr);
215 <                fputc('\n', stderr);
212 >                if (dcp->hdrflags & HF_STDERR) {
213 >                        fputs(dcp->inpname, stderr);
214 >                        fputs(": input view error: ", stderr);
215 >                        fputs(err, stderr);
216 >                        fputc('\n', stderr);
217 >                }
218                  return 0;
219          }
220          return 1;      
# Line 196 | Line 225 | check_decode_worldpos(DEPTHCODEC *dcp)
225   double
226   decode_depth_next(DEPTHCODEC *dcp)
227   {
228 <        int     c = getint(2, dcp->finp);
228 >        int     c;
229  
230 +        if (dcp->use_last) {
231 +                dcp->use_last = 0;
232 +                return code2depth(dcp->last_dc, dcp->refdepth);
233 +        }
234 +        c = getint(2, dcp->finp);
235 +
236          if (c == EOF && feof(dcp->finp))
237                  return -1.;
238  
239 +        dcp->last_dc = c;
240          dcp->curpos += 2;
241  
242          return code2depth(c, dcp->refdepth);
# Line 252 | Line 288 | seek_dc_pix(DEPTHCODEC *dcp, int x, int y)
288          long    seekpos;
289  
290          if ((dcp->res.xr <= 0) | (dcp->res.yr <= 0)) {
291 <                fputs(progname, stderr);
292 <                fputs(": need map resolution to seek\n", stderr);
291 >                if (dcp->hdrflags & HF_STDERR) {
292 >                        fputs(progname, stderr);
293 >                        fputs(": need map resolution to seek\n", stderr);
294 >                }
295                  return -1;
296          }
297          if ((x < 0) | (y < 0) ||
298                          (x >= scanlen(&dcp->res)) | (y >= numscans(&dcp->res))) {
299 <                fputs(dcp->inpname, stderr);
300 <                fputs(": warning - pixel index off map\n", stderr);
299 >                if (dcp->hdrflags & HF_STDERR) {
300 >                        fputs(dcp->inpname, stderr);
301 >                        fputs(": warning - pixel index off map\n", stderr);
302 >                }
303                  return 0;
304          }
305          seekpos = dcp->dstart + 2*((long)y*scanlen(&dcp->res) + x);
306  
307 +        if (seekpos == dcp->curpos-2) {
308 +                dcp->use_last++;        /* avoids seek/read */
309 +                return 1;
310 +        }
311          if (seekpos != dcp->curpos &&
312                          fseek(dcp->finp, seekpos, SEEK_SET) == EOF) {
313 <                fputs(dcp->inpname, stderr);
314 <                fputs(": seek error\n", stderr);
313 >                if (dcp->hdrflags & HF_STDERR) {
314 >                        fputs(dcp->inpname, stderr);
315 >                        fputs(": seek error\n", stderr);
316 >                }
317                  return -1;
318          }
319          dcp->curpos = seekpos;

Diff Legend

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