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.3 by greg, Fri Jul 26 18:52:32 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 83 | Line 85 | headline(char *s, void *p)
85                  *cp = '\0';
86                  dcp->refdepth = atof(dcp->depth_unit);
87                  if (dcp->refdepth <= .0) {
88 <                        fputs(dcp->inpname, stderr);
89 <                        fputs(": bad reference depth in input header\n", stderr);
88 >                        if (dcp->hdrflags & HF_STDERR) {
89 >                                fputs(dcp->inpname, stderr);
90 >                                fputs(": bad reference depth in input header\n",
91 >                                                stderr);
92 >                        }
93                          return -1;
94                  }
95          } else if (isview(s))           /* get view params */
# Line 101 | Line 106 | process_dc_header(DEPTHCODEC *dcp, int ac, char *av[])
106   {
107          if (dcp->hdrflags & HF_HEADIN &&
108                          getheader(dcp->finp, headline, dcp) < 0) {
109 <                fputs(dcp->inpname, stderr);
110 <                fputs(": bad header\n", stderr);
111 <                return 1;
109 >                if (dcp->hdrflags & HF_STDERR) {
110 >                        fputs(dcp->inpname, stderr);
111 >                        fputs(": bad header\n", stderr);
112 >                }
113 >                return 0;
114          }
115          if (dcp->hdrflags & HF_HEADOUT) {       /* finish header */
116                  if (!(dcp->hdrflags & HF_HEADIN))
# Line 131 | Line 138 | process_dc_header(DEPTHCODEC *dcp, int ac, char *av[])
138          }
139                                          /* get/put resolution string */
140          if (dcp->hdrflags & HF_RESIN && !fgetsresolu(&dcp->res, dcp->finp)) {
141 <                fputs(dcp->inpname, stderr);
142 <                fputs(": bad resolution string\n", stderr);
143 <                return 1;
141 >                if (dcp->hdrflags & HF_STDERR) {
142 >                        fputs(dcp->inpname, stderr);
143 >                        fputs(": bad resolution string\n", stderr);
144 >                }
145 >                return 0;
146          }
147          if (dcp->hdrflags & HF_RESOUT)
148                  fputsresolu(&dcp->res, stdout);
# Line 148 | Line 157 | int
157   check_decode_depths(DEPTHCODEC *dcp)
158   {
159          if (dcp->hdrflags & HF_ENCODE) {
160 <                fputs(progname, stderr);
161 <                fputs(": wrong header mode for decode\n", stderr);
160 >                if (dcp->hdrflags & HF_STDERR) {
161 >                        fputs(progname, stderr);
162 >                        fputs(": wrong header mode for decode\n", stderr);
163 >                }
164                  return 0;
165          }
166          if (dcp->inpfmt[0] && strcmp(dcp->inpfmt, DEPTH16FMT)) {
167 <                fputs(dcp->inpname, stderr);
168 <                fputs(": unexpected input format: ", stderr);
169 <                fputs(dcp->inpfmt, stderr);
170 <                fputc('\n', stderr);
167 >                if (dcp->hdrflags & HF_STDERR) {
168 >                        fputs(dcp->inpname, stderr);
169 >                        fputs(": unexpected input format: ", stderr);
170 >                        fputs(dcp->inpfmt, stderr);
171 >                        fputc('\n', stderr);
172 >                }
173                  return 0;
174          }
175          return 1;
# Line 172 | Line 185 | check_decode_worldpos(DEPTHCODEC *dcp)
185          if (!check_decode_depths(dcp))
186                  return 0;
187          if ((dcp->res.xr <= 0) | (dcp->res.yr <= 0)) {
188 <                fputs(progname, stderr);
189 <                fputs(": missing map resolution\n", stderr);
188 >                if (dcp->hdrflags & HF_STDERR) {
189 >                        fputs(progname, stderr);
190 >                        fputs(": missing map resolution\n", stderr);
191 >                }
192                  return 0;
193          }
194          if (!dcp->gotview) {
195 <                fputs(dcp->inpname, stderr);
196 <                fputs(": missing view\n", stderr);
195 >                if (dcp->hdrflags & HF_STDERR) {
196 >                        fputs(dcp->inpname, stderr);
197 >                        fputs(": missing view\n", stderr);
198 >                }
199                  return 0;
200          }
201          if ((err = setview(&dcp->vw)) != NULL) {
202 <                fputs(dcp->inpname, stderr);
203 <                fputs(": input view error: ", stderr);
204 <                fputs(err, stderr);
205 <                fputc('\n', stderr);
202 >                if (dcp->hdrflags & HF_STDERR) {
203 >                        fputs(dcp->inpname, stderr);
204 >                        fputs(": input view error: ", stderr);
205 >                        fputs(err, stderr);
206 >                        fputc('\n', stderr);
207 >                }
208                  return 0;
209          }
210          return 1;      
# Line 252 | Line 271 | seek_dc_pix(DEPTHCODEC *dcp, int x, int y)
271          long    seekpos;
272  
273          if ((dcp->res.xr <= 0) | (dcp->res.yr <= 0)) {
274 <                fputs(progname, stderr);
275 <                fputs(": need map resolution to seek\n", stderr);
274 >                if (dcp->hdrflags & HF_STDERR) {
275 >                        fputs(progname, stderr);
276 >                        fputs(": need map resolution to seek\n", stderr);
277 >                }
278                  return -1;
279          }
280          if ((x < 0) | (y < 0) ||
281                          (x >= scanlen(&dcp->res)) | (y >= numscans(&dcp->res))) {
282 <                fputs(dcp->inpname, stderr);
283 <                fputs(": warning - pixel index off map\n", stderr);
282 >                if (dcp->hdrflags & HF_STDERR) {
283 >                        fputs(dcp->inpname, stderr);
284 >                        fputs(": warning - pixel index off map\n", stderr);
285 >                }
286                  return 0;
287          }
288          seekpos = dcp->dstart + 2*((long)y*scanlen(&dcp->res) + x);
289  
290          if (seekpos != dcp->curpos &&
291                          fseek(dcp->finp, seekpos, SEEK_SET) == EOF) {
292 <                fputs(dcp->inpname, stderr);
293 <                fputs(": seek error\n", stderr);
292 >                if (dcp->hdrflags & HF_STDERR) {
293 >                        fputs(dcp->inpname, stderr);
294 >                        fputs(": seek error\n", stderr);
295 >                }
296                  return -1;
297          }
298          dcp->curpos = seekpos;

Diff Legend

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