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.30 by greg, Sun May 7 16:14:19 2017 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  
52   void
53   newheader(              /* identifying line of information header */
54 <        char  *s,
54 >        const char  *s,
55          FILE  *fp
56   )
57   {
58          fputs(HDRSTR, fp);
59          fputs(s, fp);
60 <        putc('\n', fp);
60 >        fputc('\n', fp);
61   }
62  
63  
64   int
65   headidval(                      /* get header id (return true if is id) */
66          char  *r,
67 <        char    *s
67 >        const char      *s
68   )
69   {
70          const char  *cp = HDRSTR;
# Line 74 | Line 80 | headidval(                     /* get header id (return true if is id) *
80   int
81   dateval(                /* convert capture date line to UTC */
82          time_t  *tloc,
83 <        char    *s
83 >        const char      *s
84   )
85   {
86          struct tm       tms;
# Line 100 | Line 106 | dateval(               /* convert capture date line to UTC */
106   int
107   gmtval(                 /* convert GMT date line to UTC */
108          time_t  *tloc,
109 <        char    *s
109 >        const char      *s
110   )
111   {
112          struct tm       tms;
# 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  *r,
166 <        char  *s
165 >        char  fmt[MAXFMTLEN],
166 >        const char  *s
167   )
168   {
169          const char  *cp = FMTSTR;
170 <
170 >        char  *r = fmt;
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));
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  
188  
189   void
190   fputformat(             /* put out a format value */
191 <        char  *s,
191 >        const char  *s,
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 209 | 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 230 | Line 303 | getheader(             /* get header from file */
303  
304   struct check {
305          FILE    *fp;
306 <        char    fs[64];
306 >        char    fs[MAXFMTLEN];
307   };
308  
309  
# Line 240 | Line 313 | mycheck(                       /* check a header line for format info. */
313          void  *cp
314   )
315   {
316 <        if (!formatval(((struct check*)cp)->fs, s)
317 <                        && ((struct check*)cp)->fp != NULL) {
318 <                fputs(s, ((struct check*)cp)->fp);
319 <        }
316 >        struct check    *scp = (struct check *)cp;
317 >
318 >        if (!formatval(scp->fs, s) && scp->fp != NULL)
319 >                return(fputs(s, scp->fp));
320 >
321          return(0);
322   }
323  
324  
325   int
326   globmatch(                      /* check for match of s against pattern p */
327 <        char    *p,
328 <        char    *s
327 >        const char      *p,
328 >        const char      *s
329   )
330   {
331          int     setmatch;
# Line 271 | 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 289 | 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)
# Line 319 | Line 394 | globmatch(                     /* check for match of s against pattern p
394   int
395   checkheader(
396          FILE  *fin,
397 <        char  *fmt,
397 >        char  fmt[MAXFMTLEN],
398          FILE  *fout
399   )
400   {

Diff Legend

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