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

Comparing ray/src/common/normcodec.c (file contents):
Revision 2.1 by greg, Fri Jul 26 16:18:06 2019 UTC vs.
Revision 2.7 by greg, Wed Aug 24 19:55:58 2022 UTC

# Line 30 | Line 30 | static int
30   headline(char *s, void *p)
31   {
32          NORMCODEC       *ncp = (NORMCODEC *)p;
33 +        int             rv;
34  
35          if (formatval(ncp->inpfmt, s))  /* don't pass format */
36                  return 0;
37  
38 +        if ((rv = isbigendian(s)) >= 0) {
39 +                ncp->swapped = (nativebigendian() != rv);
40 +                return 0;
41 +        }
42          if (ncp->hdrflags & HF_HEADOUT)
43                  fputs(s, stdout);       /* copy to standard output */
44          return 1;
# Line 46 | Line 51 | process_nc_header(NORMCODEC *ncp, int ac, char *av[])
51   {
52          if (ncp->hdrflags & HF_HEADIN &&
53                          getheader(ncp->finp, headline, ncp) < 0) {
54 <                fputs(ncp->inpname, stderr);
55 <                fputs(": bad header\n", stderr);
56 <                return 1;
54 >                if (ncp->hdrflags & HF_STDERR) {
55 >                        fputs(ncp->inpname, stderr);
56 >                        fputs(": bad header\n", stderr);
57 >                }
58 >                return 0;
59          }
60 +                                        /* get resolution string? */
61 +        if (ncp->hdrflags & HF_RESIN && !fgetsresolu(&ncp->res, ncp->finp)) {
62 +                if (ncp->hdrflags & HF_STDERR) {
63 +                        fputs(ncp->inpname, stderr);
64 +                        fputs(": bad resolution string\n", stderr);
65 +                }
66 +                return 0;
67 +        }
68          if (ncp->hdrflags & HF_HEADOUT) {       /* finish header */
69                  if (!(ncp->hdrflags & HF_HEADIN))
70                          newheader("RADIANCE", stdout);
# Line 57 | Line 72 | process_nc_header(NORMCODEC *ncp, int ac, char *av[])
72                          printargs(ac, av, stdout);
73                  if (ncp->hdrflags & HF_ENCODE) {
74                          fputformat(NORMAL32FMT, stdout);
75 <                } else
75 >                } else {
76 >                        fputs("NCOMP=3\n", stdout);
77 >                        if ((ncp->hdrflags & (HF_RESIN|HF_RESOUT)) == HF_RESIN)
78 >                                printf("NCOLS=%d\nNROWS=%d\n",
79 >                                                scanlen(&ncp->res),
80 >                                                numscans(&ncp->res));
81                          switch (ncp->format) {
82                          case 'a':
83                                  fputformat("ascii", stdout);
84                                  break;
85                          case 'f':
86 +                                fputendian(stdout);
87                                  fputformat("float", stdout);
88                                  break;
89                          case 'd':
90 +                                fputendian(stdout);
91                                  fputformat("double", stdout);
92                                  break;
93                          }
94 +                }
95                  fputc('\n', stdout);
96          }
97 <                                        /* get/put resolution string */
75 <        if (ncp->hdrflags & HF_RESIN && !fgetsresolu(&ncp->res, ncp->finp)) {
76 <                fputs(ncp->inpname, stderr);
77 <                fputs(": bad resolution string\n", stderr);
78 <                return 1;
79 <        }
80 <        if (ncp->hdrflags & HF_RESOUT)
97 >        if (ncp->hdrflags & HF_RESOUT)  /* put resolution string? */
98                  fputsresolu(&ncp->res, stdout);
99  
100 <        ncp->dstart = ncp->curpos = ftell(ncp->finp);
100 >        ncp->dstart = ftell(ncp->finp);
101          return 1;
102   }
103  
# Line 90 | Line 107 | int
107   check_decode_normals(NORMCODEC *ncp)
108   {
109          if (ncp->hdrflags & HF_ENCODE) {
110 <                fputs(progname, stderr);
111 <                fputs(": wrong header mode for decode\n", stderr);
110 >                if (ncp->hdrflags & HF_STDERR) {
111 >                        fputs(progname, stderr);
112 >                        fputs(": wrong header mode for decode\n", stderr);
113 >                }
114                  return 0;
115          }
116          if (ncp->inpfmt[0] && strcmp(ncp->inpfmt, NORMAL32FMT)) {
117 <                fputs(ncp->inpname, stderr);
118 <                fputs(": unexpected input format: ", stderr);
119 <                fputs(ncp->inpfmt, stderr);
120 <                fputc('\n', stderr);
117 >                if (ncp->hdrflags & HF_STDERR) {
118 >                        fputs(ncp->inpname, stderr);
119 >                        fputs(": unexpected input format: ", stderr);
120 >                        fputs(ncp->inpfmt, stderr);
121 >                        fputc('\n', stderr);
122 >                }
123                  return 0;
124          }
125          return 1;
# Line 109 | Line 130 | check_decode_normals(NORMCODEC *ncp)
130   int
131   decode_normal_next(FVECT nrm, NORMCODEC *ncp)
132   {
133 <        int32   c = getint(4, ncp->finp);
133 >        static int32    lastc;
134 >        static FVECT    lastv;
135 >        int32           c = getint(4, ncp->finp);
136  
137          if (c == EOF && feof(ncp->finp))
138                  return -1;
139  
140 <        ncp->curpos += 4;
141 <
142 <        decodedir(nrm, c);
143 <
140 >        if (c == lastc) {                       /* optimization */
141 >                VCOPY(nrm, lastv);
142 >        } else {
143 >                decodedir(nrm, c);
144 >                if (c) {
145 >                        lastc = c;
146 >                        VCOPY(lastv, nrm);
147 >                }
148 >        }
149          return (c != 0);
150   }
151  
# Line 126 | Line 154 | decode_normal_next(FVECT nrm, NORMCODEC *ncp)
154   int
155   seek_nc_pix(NORMCODEC *ncp, int x, int y)
156   {
129 –        long    seekpos;
130 –
157          if ((ncp->res.xr <= 0) | (ncp->res.yr <= 0)) {
158 <                fputs(progname, stderr);
159 <                fputs(": need map resolution to seek\n", stderr);
158 >                if (ncp->hdrflags & HF_STDERR) {
159 >                        fputs(progname, stderr);
160 >                        fputs(": need map resolution to seek\n", stderr);
161 >                }
162                  return -1;
163          }
164          if ((x < 0) | (y < 0) ||
165                          (x >= scanlen(&ncp->res)) | (y >= numscans(&ncp->res))) {
166 <                fputs(ncp->inpname, stderr);
167 <                fputs(": warning - pixel index off map\n", stderr);
166 >                if (ncp->hdrflags & HF_STDERR) {
167 >                        fputs(ncp->inpname, stderr);
168 >                        fputs(": warning - pixel index off map\n", stderr);
169 >                }
170                  return 0;
171          }
172 <        seekpos = ncp->dstart + 4*((long)y*scanlen(&ncp->res) + x);
173 <
174 <        if (seekpos != ncp->curpos &&
175 <                        fseek(ncp->finp, seekpos, SEEK_SET) == EOF) {
176 <                fputs(ncp->inpname, stderr);
177 <                fputs(": seek error\n", stderr);
172 >        if (fseek(ncp->finp, ncp->dstart + 4*((long)y*scanlen(&ncp->res) + x),
173 >                        SEEK_SET) == EOF) {
174 >                if (ncp->hdrflags & HF_STDERR) {
175 >                        fputs(ncp->inpname, stderr);
176 >                        fputs(": seek error\n", stderr);
177 >                }
178                  return -1;
179          }
150 –        ncp->curpos = seekpos;
180          return 1;
181   }
182  

Diff Legend

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