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

Comparing ray/src/px/ra_rgbe.c (file contents):
Revision 2.13 by schorsch, Thu Jul 3 22:41:44 2003 UTC vs.
Revision 2.23 by greg, Tue Sep 10 20:24:42 2024 UTC

# Line 5 | Line 5 | static const char      RCSid[] = "$Id$";
5   *  program to convert from RADIANCE RLE to flat format
6   */
7  
8 – #include  <stdio.h>
8   #include  <math.h>
10 – #include  <time.h>
11 – #include  <string.h>
9  
10   #include  "platform.h"
11 + #include  "rtio.h"
12 + #include  "paths.h"
13   #include  "color.h"
14   #include  "resolu.h"
15  
16 < extern int      addhline();
16 > #define dumpheader(fp)  putbinary(headlines, 1, headlen, fp)
17  
19 – #define dumpheader(fp)  fwrite(headlines, 1, headlen, fp)
20 –
18   int  bradj = 0;                         /* brightness adjustment */
22 –
19   int  doflat = 1;                        /* produce flat file */
24 –
20   int  force = 0;                         /* force file overwrite? */
26 –
21   int  findframe = 0;                     /* find a specific frame? */
28 –
22   int  frameno = 0;                       /* current frame number */
23   int  fmterr = 0;                        /* got input format error */
24 < char  *headlines;                       /* current header info. */
25 < int  headlen;                           /* current header length */
24 > char  *headlines = NULL;                /* current header info. */
25 > int  headlen1 = 0;                      /* length of initial frame header */
26 > int  headlen = 0;                       /* current header length */
27 > char  fmt[MAXFMTLEN];                   /* input format */
28  
29   char  *progname;
30  
31 + static gethfunc addhline;
32 + static int transfer(char *ospec);
33 + static int loadheader(FILE *fp);
34  
35 < main(argc, argv)
36 < int  argc;
37 < char  *argv[];
35 >
36 > int
37 > main(int  argc, char  *argv[])
38   {
39          char    *ospec;
40          int  i;
# Line 89 | Line 87 | userr:
87   }
88  
89  
90 < transfer(ospec)                 /* transfer a Radiance picture */
91 < char    *ospec;
90 > static int
91 > transfer(                       /* transfer a Radiance picture */
92 >        char    *ospec
93 > )
94   {
95 <        char    oname[128];
95 >        char    oname[PATH_MAX];
96          FILE    *fp;
97          int     order;
98          int     xmax, ymax;
# Line 109 | Line 109 | char   *ospec;
109          if (findframe && findframe < frameno)
110                  return(0);
111                                          /* allocate scanline */
112 <        scanin = (COLR *)tempbuffer(xmax*sizeof(COLR));
112 >        scanin = (COLR *)malloc(xmax*sizeof(COLR));
113          if (scanin == NULL) {
114                  perror(progname);
115                  exit(1);
116          }
117                                          /* skip frame? */
118          if (findframe > frameno) {
119 <                for (y = ymax; y--; )
119 >                if (NCSAMP > 3) {
120 >                        if (fseek(stdin, ymax*xmax*LSCOLR, SEEK_CUR) < 0) {
121 >                                perror(progname);
122 >                                exit(1);
123 >                        }
124 >                } else
125 >                    for (y = ymax; y--; )
126                          if (freadcolrs(scanin, xmax, stdin) < 0) {
127                                  fprintf(stderr,
128                                          "%s: error reading input picture\n",
129                                                  progname);
130                                  exit(1);
131                          }
132 +                free(scanin);
133                  return(1);
134          }
135                                          /* open output file/command */
# Line 152 | Line 159 | char   *ospec;
159                  }
160          }
161          SET_FILE_BINARY(fp);
162 <        dumpheader(fp);                 /* put out header */
162 >        newheader("RADIANCE", fp);              /* put out header */
163 >        dumpheader(fp);
164          fputs(progname, fp);
165          if (bradj)
166                  fprintf(fp, " -e %+d", bradj);
# Line 161 | Line 169 | char   *ospec;
169          fputc('\n', fp);
170          if (bradj)
171                  fputexpos(pow(2.0, (double)bradj), fp);
172 +        if (frameno)
173 +                fprintf(fp, "FRAME=%d\n", frameno);
174 +        if (fmt[0])
175 +                fputformat(fmt, fp);
176          fputc('\n', fp);
177          fputresolu(order, xmax, ymax, fp);
178                                          /* transfer picture */
179          for (y = ymax; y--; ) {
180 <                if (freadcolrs(scanin, xmax, stdin) < 0) {
180 >                if (fread2colrs(scanin, xmax, stdin, NCSAMP, WLPART) < 0) {
181                          fprintf(stderr, "%s: error reading input picture\n",
182                                          progname);
183                          exit(1);
184                  }
185                  if (bradj)
186                          shiftcolrs(scanin, xmax, bradj);
187 <                if (doflat)
188 <                        fwrite((char *)scanin, sizeof(COLR), xmax, fp);
189 <                else
178 <                        fwritecolrs(scanin, xmax, fp);
179 <                if (ferror(fp)) {
180 <                        fprintf(stderr, "%s: error writing output to \"%s\"\n",
181 <                                        progname, oname);
182 <                        exit(1);
183 <                }
187 >                if (doflat ? (putbinary(scanin, sizeof(COLR), xmax, fp) != xmax) :
188 >                                (fwritecolrs(scanin, xmax, fp) < 0))
189 >                        goto writerr;
190          }
191 <                                        /* clean up */
191 >        free(scanin);                   /* clean up */
192 >        if (fflush(fp) == EOF)
193 >                goto writerr;
194          if (oname[0] == '!')
195                  pclose(fp);
196          else if (ospec != NULL)
197                  fclose(fp);
198          return(1);
199 + writerr:
200 +        fprintf(stderr, "%s: error writing output to \"%s\"\n",
201 +                        progname, oname);
202 +        exit(1);
203   }
204  
205  
206 < int
207 < addhline(s)                     /* add a line to our info. header */
208 < char    *s;
206 > static int
207 > addhline(                       /* add a line to our info. header */
208 >        char    *s,
209 >        void    *p
210 > )
211   {
198 –        char    fmt[32];
212          int     n;
213  
214 <        if (formatval(fmt, s))
215 <                fmterr += !globmatch(PICFMT, fmt);
216 <        else if (!strncmp(s, "FRAME=", 6))
214 >        if (isheadid(s))
215 >                return(0);
216 >        if (!strncmp(s, "FRAME=", 6)) {
217                  frameno = atoi(s+6);
218 +                return(0);
219 +        }
220 +        if (formatval(fmt, s)) {
221 +                if (!strcmp(fmt, SPECFMT))
222 +                        strcpy(fmt, COLRFMT);
223 +                else
224 +                        fmterr += !globmatch(PICFMT, fmt);
225 +                return(0);
226 +        }
227 +        if (isncomp(s)) {
228 +                NCSAMP = ncompval(s);
229 +                return(NCSAMP - 3);
230 +        }
231 +        if (iswlsplit(s)) {
232 +                wlsplitval(WLPART, s);
233 +                return(0);
234 +        }
235          n = strlen(s);
236          if (headlen)
237                  headlines = (char *)realloc((void *)headlines, headlen+n+1);
# Line 217 | Line 247 | char   *s;
247   }
248  
249  
250 < loadheader(fp)                  /* load an info. header into memory */
251 < FILE    *fp;
250 > static int
251 > loadheader(                     /* load an info. header into memory */
252 >        FILE    *fp
253 > )
254   {
255          fmterr = 0; frameno = 0;
256 <        if (headlen) {                  /* free old header */
257 <                free(headlines);
258 <                headlen = 0;
259 <        }
256 >                                /* revert to initial header length */
257 >        if (!headlen1) headlen1 = headlen;
258 >        else headlen = headlen1;
259 >
260          if (getheader(fp, addhline, NULL) < 0)
261                  return(0);
262          if (fmterr)

Diff Legend

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