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

Comparing ray/src/common/header.c (file contents):
Revision 2.33 by greg, Sat May 25 04:00:54 2019 UTC vs.
Revision 2.51 by greg, Sat Jun 7 05:09:45 2025 UTC

# Line 4 | Line 4 | static const char      RCSid[] = "$Id$";
4   /*
5   *  header.c - routines for reading and writing information headers.
6   *
7 < *  Externals declared in resolu.h
7 > *  Externals declared in rtio.h
8   *
9   *  newheader(t,fp)     start new information header identified by string t
10   *  headidval(r,s)      copy header identifier value in s to r
# Line 12 | Line 12 | static const char      RCSid[] = "$Id$";
12   *  gmtval(t,s)         get GMT as UTC
13   *  fputdate(t,fp)      put out the given UTC
14   *  fputnow(fp)         put out the current date and time
15 – *  printargs(ac,av,fp) print an argument list to fp, followed by '\n'
15   *  formatval(r,s)      copy the format value in s to r
16   *  fputformat(s,fp)    write "FORMAT=%s" to fp
17 + *  nativebigendian()   are we native on big-endian machine?
18 + *  isbigendian(s)      header line matches "BigEndian=1" (-1 if irrelevant)
19 + *  fputendian(fp)      write native endianness in BigEndian= line
20   *  getheader(fp,f,p)   read header from fp, calling f(s,p) on each line
21   *  globmatch(pat, str) check for glob match of str against pat
22   *  checkheader(i,p,o)  check header format from i against p and copy to o
# Line 26 | Line 28 | static const char      RCSid[] = "$Id$";
28  
29   #include  <ctype.h>
30  
31 + #include  "tiff.h"      /* for int32 */
32   #include  "rtio.h"
33 + #include  "color.h"
34   #include  "resolu.h"
35  
36   #define  MAXLINE        2048
# Line 40 | Line 44 | const char  FMTSTR[] = "FORMAT=";      /* format identifier
44   const char  TMSTR[] = "CAPDATE=";       /* capture date identifier */
45   const char  GMTSTR[] = "GMT=";          /* GMT identifier */
46  
47 + const char  BIGEND[] = "BigEndian=";    /* big-endian variable */
48 +
49   static gethfunc mycheck;
50  
51  
# Line 51 | Line 57 | newheader(             /* identifying line of information header
57   {
58          fputs(HDRSTR, fp);
59          fputs(s, fp);
60 <        putc('\n', fp);
60 >        fputc('\n', fp);
61   }
62  
63  
# Line 154 | Line 160 | fputnow(                       /* write out the current time */
160   }
161  
162  
157 – void
158 – printargs(              /* print arguments to a file */
159 –        int  ac,
160 –        char  **av,
161 –        FILE  *fp
162 – )
163 – {
164 –        while (ac-- > 0) {
165 –                fputword(*av++, fp);
166 –                fputc(ac ? ' ' : '\n', fp);
167 –        }
168 – }
169 –
170 –
163   int
164   formatval(                      /* get format value (return true if format) */
165          char  fmt[MAXFMTLEN],
# Line 176 | Line 168 | formatval(                     /* get format value (return true if forma
168   {
169          const char  *cp = FMTSTR;
170          char  *r = fmt;
171 <
171 >                                /* check against format string */
172          while (*cp) if (*cp++ != *s++) return(0);
173          while (isspace(*s)) s++;
174          if (!*s) return(0);
175 <        if (r == NULL) return(1);
176 <        do
175 >        if (r == NULL)          /* just checking if format? */
176 >                return(1);
177 >        do                      /* copy format ID */
178                  *r++ = *s++;
179 <        while (*s && !isspace(*s) && r-fmt < MAXFMTLEN-1);
180 <        *r = '\0';
179 >        while (*s && r-fmt < MAXFMTLEN-1);
180 >
181 >        do                      /* remove trailing white space */
182 >                *r-- = '\0';
183 >        while (r > fmt && isspace(*r));
184 >
185          return(1);
186   }
187  
# Line 195 | Line 192 | fputformat(            /* put out a format value */
192          FILE  *fp
193   )
194   {
195 +        int     align = 0;
196 +
197          fputs(FMTSTR, fp);
198          fputs(s, fp);
199 <        putc('\n', fp);
199 >                        /* pad to align binary type for mmap() */
200 >        if (globmatch(PICFMT, s))
201 >                align = 0;      /* not needed for picture data */
202 >        else if (!strncmp("float", s, 5))
203 >                align = sizeof(float);
204 >        else if (!strncmp("double", s, 6))
205 >                align = sizeof(double);
206 >        else if (!strncmp("16-bit", s, 6))
207 >                align = 2;
208 >        else if (!strncmp("32-bit", s, 6))
209 >                align = 4;
210 >        else if (!strncmp("64-bit", s, 6))
211 >                align = 8;
212 >        if (align) {
213 >                long    pos = ftell(fp);
214 >                if (pos >= 0) {
215 >                        pos = (pos + 2) % align;
216 >                        if (pos) align -= pos;
217 >                        else align = 0;
218 >                } else
219 >                        align = 0;
220 >        }
221 >        while (align-- > 0)
222 >                putc(' ', fp);
223 >        fputc('\n', fp);
224   }
225  
226  
227   int
228 + nativebigendian()       /* are we native on a big-endian machine? */
229 + {
230 +        union { int32 i; char c[4]; } u;
231 +
232 +        u.i = 1;
233 +
234 +        return(u.c[0] == 0);
235 + }
236 +
237 +
238 + int
239 + isbigendian(            /* header line says "BigEndian=1" (-1 if irrelevant) */
240 +        const char *s
241 + )
242 + {
243 +        const char      *be = BIGEND;
244 +
245 +        while ((*s != '\0') & (*be != '=') && *s++ == *be)
246 +                ++be;
247 +        if (*be != '=')
248 +                return(-1);     /* irrelevant */
249 +        while (isspace(*s))
250 +                s++;
251 +        if (*s++ != '=')
252 +                return(-1);
253 +        while (isspace(*s))
254 +                s++;
255 +        return(*s == '1');
256 + }
257 +
258 +
259 + void
260 + fputendian(             /* write native endianness in BigEndian= line */
261 +        FILE *fp
262 + )
263 + {
264 +        fputs(BIGEND, fp);
265 +        if (nativebigendian())
266 +                fputs("1\n", fp);
267 +        else
268 +                fputs("0\n", fp);
269 + }
270 +
271 +
272 + int
273   getheader(              /* get header from file */
274          FILE  *fp,
275          gethfunc *f,
# Line 210 | Line 278 | getheader(             /* get header from file */
278   {
279          int   rtotal = 0;
280          char  buf[MAXLINE];
281 +        int   firstc = fgetc(fp);
282  
283 +        if (!isprint(firstc))
284 +                return(-1);                             /* messed up */
285 +        ungetc(firstc, fp);
286          for ( ; ; ) {
287                  int     rval = 0;
288                  buf[MAXLINE-2] = '\n';
289                  if (fgets(buf, MAXLINE, fp) == NULL)
290                          return(-1);
291 <                if (buf[buf[0]=='\r'] == '\n')
291 >                if (buf[buf[0]=='\r'] == '\n')          /* end of header? */
292                          return(rtotal);
293                  if (buf[MAXLINE-2] != '\n') {
294                          ungetc(buf[MAXLINE-2], fp);     /* prevent false end */
# Line 244 | Line 316 | mycheck(                       /* check a header line for format info. */
316          struct check    *scp = (struct check *)cp;
317  
318          if (!formatval(scp->fs, s) && scp->fp != NULL)
319 <                fputs(s, scp->fp);
319 >                return(fputs(s, scp->fp));
320  
321          return(0);
322   }
# Line 273 | Line 345 | globmatch(                     /* check for match of s against pattern p
345                          while (*s++);
346                          return(0);
347                  case '[':                       /* character set */
348 <                        setmatch = *s == *++p;
348 >                        setmatch = (*s == *++p);
349                          if (!*p)
350                                  return(0);
351                          while (*++p != ']') {
352                                  if (!*p)
353                                          return(0);
354                                  if (*p == '-') {
355 <                                        setmatch += (p[-1] <= *s && *s <= p[1]);
355 >                                        setmatch += (p[-1] <= *s) & (*s <= p[1]);
356                                          if (!*++p)
357                                                  break;
358                                  } else
# Line 291 | Line 363 | globmatch(                     /* check for match of s against pattern p
363                          s++;
364                          break;
365                  case '\\':                      /* literal next */
366 <                        p++;
366 >                        if (!*++p)
367 >                                return(0);
368                  /* fall through */
369                  default:                        /* normal character */
370                          if (*p != *s)

Diff Legend

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