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.4 by greg, Wed Aug 14 21:00:14 2019 UTC

# Line 16 | Line 16 | static const char RCSid[] = "$Id$";
16   #include "depthcodec.h"
17  
18  
19 < #if 0                   /* defined as macro in depthcodec.h */
19 > #ifndef depth2code
20   /* Encode depth as 16-bit signed integer */
21   int
22   depth2code(double d, double dref)
# Line 25 | Line 25 | depth2code(double d, double dref)
25                  return -32768;
26  
27          if (d > dref)
28 <                return (int)(32768 - 32768*dref/d) - 1;
28 >                return (int)(32768.001 - 32768.*dref/d) - 1;
29  
30 <        return (int)(32767*d/dref - 32768);
30 >        return (int)(32767.*d/dref - 32768.);
31   }
32   #endif
33  
34  
35 + #ifndef code2depth
36   /* Decode depth from 16-bit signed integer */
37   double
38   code2depth(int c, double dref)
# Line 47 | Line 48 | code2depth(int c, double dref)
48          
49          return dref*32768./(32766.5 - c);
50   }
51 + #endif
52  
53  
54   /* Set codec defaults */
# Line 57 | Line 59 | set_dc_defaults(DEPTHCODEC *dcp)
59          dcp->finp = stdin;
60          dcp->inpname = "<stdin>";
61          dcp->format = 'a';
62 +        dcp->swapped = 0;
63          dcp->refdepth = 1.;
64          dcp->depth_unit[0] = '1';
65          dcp->vw = stdview;
# Line 70 | Line 73 | static int
73   headline(char *s, void *p)
74   {
75          DEPTHCODEC      *dcp = (DEPTHCODEC *)p;
76 +        int             rv;
77  
78          if (formatval(dcp->inpfmt, s))  /* don't pass format */
79                  return 0;
80 +
81 +        if ((rv = isbigendian(s)) >= 0) {
82 +                dcp->swapped = (nativebigendian() != rv);
83 +                return 0;
84 +        }
85                                          /* check for reference depth */
86          if (!strncmp(s, DEPTHSTR, LDEPTHSTR)) {
87                  char    *cp;
# Line 83 | Line 92 | headline(char *s, void *p)
92                  *cp = '\0';
93                  dcp->refdepth = atof(dcp->depth_unit);
94                  if (dcp->refdepth <= .0) {
95 <                        fputs(dcp->inpname, stderr);
96 <                        fputs(": bad reference depth in input header\n", stderr);
95 >                        if (dcp->hdrflags & HF_STDERR) {
96 >                                fputs(dcp->inpname, stderr);
97 >                                fputs(": bad reference depth in input header\n",
98 >                                                stderr);
99 >                        }
100                          return -1;
101                  }
102          } else if (isview(s))           /* get view params */
# 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          if (dcp->hdrflags & HF_HEADOUT) {       /* finish header */
123                  if (!(dcp->hdrflags & HF_HEADIN))
# Line 121 | Line 135 | process_dc_header(DEPTHCODEC *dcp, int ac, char *av[])
135                                  fputformat("ascii", stdout);
136                                  break;
137                          case 'f':
138 +                                fputendian(stdout);
139                                  fputformat("float", stdout);
140                                  break;
141                          case 'd':
142 +                                fputendian(stdout);
143                                  fputformat("double", stdout);
144                                  break;
145                          }
# Line 131 | Line 147 | process_dc_header(DEPTHCODEC *dcp, int ac, char *av[])
147          }
148                                          /* get/put resolution string */
149          if (dcp->hdrflags & HF_RESIN && !fgetsresolu(&dcp->res, dcp->finp)) {
150 <                fputs(dcp->inpname, stderr);
151 <                fputs(": bad resolution string\n", stderr);
152 <                return 1;
150 >                if (dcp->hdrflags & HF_STDERR) {
151 >                        fputs(dcp->inpname, stderr);
152 >                        fputs(": bad resolution string\n", stderr);
153 >                }
154 >                return 0;
155          }
156          if (dcp->hdrflags & HF_RESOUT)
157                  fputsresolu(&dcp->res, stdout);
# Line 148 | Line 166 | int
166   check_decode_depths(DEPTHCODEC *dcp)
167   {
168          if (dcp->hdrflags & HF_ENCODE) {
169 <                fputs(progname, stderr);
170 <                fputs(": wrong header mode for decode\n", stderr);
169 >                if (dcp->hdrflags & HF_STDERR) {
170 >                        fputs(progname, stderr);
171 >                        fputs(": wrong header mode for decode\n", stderr);
172 >                }
173                  return 0;
174          }
175          if (dcp->inpfmt[0] && strcmp(dcp->inpfmt, DEPTH16FMT)) {
176 <                fputs(dcp->inpname, stderr);
177 <                fputs(": unexpected input format: ", stderr);
178 <                fputs(dcp->inpfmt, stderr);
179 <                fputc('\n', stderr);
176 >                if (dcp->hdrflags & HF_STDERR) {
177 >                        fputs(dcp->inpname, stderr);
178 >                        fputs(": unexpected input format: ", stderr);
179 >                        fputs(dcp->inpfmt, stderr);
180 >                        fputc('\n', stderr);
181 >                }
182                  return 0;
183          }
184          return 1;
# Line 172 | Line 194 | check_decode_worldpos(DEPTHCODEC *dcp)
194          if (!check_decode_depths(dcp))
195                  return 0;
196          if ((dcp->res.xr <= 0) | (dcp->res.yr <= 0)) {
197 <                fputs(progname, stderr);
198 <                fputs(": missing map resolution\n", stderr);
197 >                if (dcp->hdrflags & HF_STDERR) {
198 >                        fputs(progname, stderr);
199 >                        fputs(": missing map resolution\n", stderr);
200 >                }
201                  return 0;
202          }
203          if (!dcp->gotview) {
204 <                fputs(dcp->inpname, stderr);
205 <                fputs(": missing view\n", stderr);
204 >                if (dcp->hdrflags & HF_STDERR) {
205 >                        fputs(dcp->inpname, stderr);
206 >                        fputs(": missing view\n", stderr);
207 >                }
208                  return 0;
209          }
210          if ((err = setview(&dcp->vw)) != NULL) {
211 <                fputs(dcp->inpname, stderr);
212 <                fputs(": input view error: ", stderr);
213 <                fputs(err, stderr);
214 <                fputc('\n', stderr);
211 >                if (dcp->hdrflags & HF_STDERR) {
212 >                        fputs(dcp->inpname, stderr);
213 >                        fputs(": input view error: ", stderr);
214 >                        fputs(err, stderr);
215 >                        fputc('\n', stderr);
216 >                }
217                  return 0;
218          }
219          return 1;      
# Line 252 | Line 280 | seek_dc_pix(DEPTHCODEC *dcp, int x, int y)
280          long    seekpos;
281  
282          if ((dcp->res.xr <= 0) | (dcp->res.yr <= 0)) {
283 <                fputs(progname, stderr);
284 <                fputs(": need map resolution to seek\n", stderr);
283 >                if (dcp->hdrflags & HF_STDERR) {
284 >                        fputs(progname, stderr);
285 >                        fputs(": need map resolution to seek\n", stderr);
286 >                }
287                  return -1;
288          }
289          if ((x < 0) | (y < 0) ||
290                          (x >= scanlen(&dcp->res)) | (y >= numscans(&dcp->res))) {
291 <                fputs(dcp->inpname, stderr);
292 <                fputs(": warning - pixel index off map\n", stderr);
291 >                if (dcp->hdrflags & HF_STDERR) {
292 >                        fputs(dcp->inpname, stderr);
293 >                        fputs(": warning - pixel index off map\n", stderr);
294 >                }
295                  return 0;
296          }
297          seekpos = dcp->dstart + 2*((long)y*scanlen(&dcp->res) + x);
298  
299          if (seekpos != dcp->curpos &&
300                          fseek(dcp->finp, seekpos, SEEK_SET) == EOF) {
301 <                fputs(dcp->inpname, stderr);
302 <                fputs(": seek error\n", stderr);
301 >                if (dcp->hdrflags & HF_STDERR) {
302 >                        fputs(dcp->inpname, stderr);
303 >                        fputs(": seek error\n", stderr);
304 >                }
305                  return -1;
306          }
307          dcp->curpos = seekpos;

Diff Legend

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