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.6 by greg, Thu Mar 3 16:09:31 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);
# 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 <
142 >        if (c == lastc) {                       /* optimization */
143 >                VCOPY(nrm, lastv);
144 >        } else {
145 >                decodedir(nrm, c);
146 >                if (c) {
147 >                        lastc = c;
148 >                        VCOPY(lastv, nrm);
149 >                }
150 >        }
151          return (c != 0);
152   }
153  
# Line 129 | Line 159 | seek_nc_pix(NORMCODEC *ncp, int x, int y)
159          long    seekpos;
160  
161          if ((ncp->res.xr <= 0) | (ncp->res.yr <= 0)) {
162 <                fputs(progname, stderr);
163 <                fputs(": need map resolution to seek\n", stderr);
162 >                if (ncp->hdrflags & HF_STDERR) {
163 >                        fputs(progname, stderr);
164 >                        fputs(": need map resolution to seek\n", stderr);
165 >                }
166                  return -1;
167          }
168          if ((x < 0) | (y < 0) ||
169                          (x >= scanlen(&ncp->res)) | (y >= numscans(&ncp->res))) {
170 <                fputs(ncp->inpname, stderr);
171 <                fputs(": warning - pixel index off map\n", stderr);
170 >                if (ncp->hdrflags & HF_STDERR) {
171 >                        fputs(ncp->inpname, stderr);
172 >                        fputs(": warning - pixel index off map\n", stderr);
173 >                }
174                  return 0;
175          }
176          seekpos = ncp->dstart + 4*((long)y*scanlen(&ncp->res) + x);
177  
178          if (seekpos != ncp->curpos &&
179                          fseek(ncp->finp, seekpos, SEEK_SET) == EOF) {
180 <                fputs(ncp->inpname, stderr);
181 <                fputs(": seek error\n", stderr);
180 >                if (ncp->hdrflags & HF_STDERR) {
181 >                        fputs(ncp->inpname, stderr);
182 >                        fputs(": seek error\n", stderr);
183 >                }
184                  return -1;
185          }
186          ncp->curpos = seekpos;

Diff Legend

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