ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/rcode_ident.c
Revision: 2.6
Committed: Wed Jul 24 00:25:51 2019 UTC (4 years, 8 months ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.5: +12 -12 lines
Log Message:
Cosmetic improvements

File Contents

# User Rev Content
1 greg 2.1 #ifndef lint
2 greg 2.6 static const char RCSid[] = "$Id: rcode_ident.c,v 2.5 2019/07/24 00:17:22 greg Exp $";
3 greg 2.1 #endif
4     /*
5     * Create or read identifier index map
6     *
7     */
8    
9     #include <stdlib.h>
10     #include <ctype.h>
11     #include "rtio.h"
12     #include "platform.h"
13     #include "lookup.h"
14     #include "idmap.h"
15    
16     #ifndef MAXIDLEN
17     #define MAXIDLEN 256 /* longest ID length supported */
18     #endif
19    
20 greg 2.3 #define HF_TABLOUT 0x100 /* output ID table after header */
21    
22 greg 2.1 char *progname; /* global argv[0] */
23    
24     static int unbuffered = 0;
25 greg 2.3 static int numeric = 0;
26 greg 2.1 static int sepc = '\n';
27    
28    
29     /* Report usage error and exit */
30     static void
31     usage_exit(int code)
32     {
33     fputs("Usage: ", stderr);
34     fputs(progname, stderr);
35     fputs(" [-8|-16|-24][-h][-tS][-x xr -y yr] [input.txt [output.idx]]\n",
36     stderr);
37     fputs(" Or: ", stderr);
38     fputs(progname, stderr);
39 greg 2.3 fputs(" -r [-i][-u][-h][-H][-l][-n][-tS] input.idx [output.txt]\n",
40     stderr);
41 greg 2.1 exit(code);
42     }
43    
44    
45     /* read identifier from input, trimming white space on either end */
46     static int
47     scan_ident(char ident[MAXIDLEN], FILE *fp)
48     {
49     char *cp = ident;
50     int c;
51    
52     while ((c = getc(fp)) != EOF) {
53     if (cp == ident && isspace(c))
54     continue;
55     if (c == sepc) {
56     while (cp > ident && isspace(cp[-1]))
57     cp--;
58     *cp = '\0';
59     return cp - ident; /* return string length */
60     }
61     if (cp - ident >= MAXIDLEN-1) {
62     fputs(progname, stderr);
63     fputs(": identifier too long in scan_ident()\n", stderr);
64     return -1;
65     }
66     *cp++ = c;
67     }
68     return -1;
69     }
70    
71    
72     /* elide format from header lines */
73     static int
74     headline(char *s, void *p)
75     {
76     extern const char FMTSTR[];
77    
78     if (strstr(s, FMTSTR) == s)
79     return 0;
80    
81     fputs(s, stdout);
82     return 1;
83     }
84    
85    
86     /* Create an identifier index from the given input file (stdin if NULL) */
87     int
88     create_index(const char *fname, int hdrflags, int ndxbytes, int xres, int yres)
89     {
90     FILE *fp = stdin;
91     char **idmap;
92     int idmlen;
93     int nextID = 0;
94 greg 2.5 LUTAB hashtab;
95 greg 2.1 RESOLU rs;
96     long n;
97     int ndx;
98     /* open file if not stdin */
99 greg 2.2 if (!fname)
100     fname = "<stdin>";
101     else if (!(fp = fopen(fname, "r"))) {
102 greg 2.1 fputs(fname, stderr);
103     fputs(": cannot open for input\n", stderr);
104     return 0;
105     }
106     #ifdef getc_unlocked /* avoid stupid semaphores */
107     flockfile(fp);
108     #endif
109     /* load/copy header */
110     if (hdrflags & HF_HEADOUT && getheader(fp, headline, NULL) < 0) {
111     fputs(fname, stderr);
112     fputs(": bad header or wrong input format\n", stderr);
113     fclose(fp);
114     return 0;
115     }
116     if (!(hdrflags & HF_HEADOUT))
117     newheader("RADIANCE", stdout);
118     /* finish & allocate ID table */
119     switch (ndxbytes) {
120     case 1:
121     fputformat(IDMAP8FMT, stdout);
122     idmap = (char **)malloc((idmlen=256)*sizeof(char *));
123     break;
124     case 2:
125     fputformat(IDMAP16FMT, stdout);
126     idmap = (char **)malloc((idmlen=4096)*sizeof(char *));
127     break;
128     case 3:
129     fputformat(IDMAP24FMT, stdout);
130     idmap = (char **)malloc((idmlen=1L<<17)*sizeof(char *));
131     break;
132     default:
133     fputs(progname, stderr);
134     fputs(": unsupported bits/pixel\n", stderr);
135     return 0;
136     }
137 greg 2.5 memset(&hashtab, 0, sizeof(hashtab));
138     hashtab.hashf = lu_shash;
139     hashtab.keycmp = strcmp;
140     hashtab.freek = free;
141 greg 2.1 if (!idmap || !lu_init(&hashtab, idmlen))
142     goto memerr;
143     fputc('\n', stdout); /* end of info header */
144    
145     rs.rt = PIXSTANDARD; /* get/write map resolution */
146     if (hdrflags & HF_RESOUT) {
147     if (!fgetsresolu(&rs, fp)) {
148     fputs(fname, stderr);
149     fputs(": bad resolution string\n", stderr);
150     return 0;
151     }
152     } else if (((rs.xr = xres) <= 0) | ((rs.yr = yres) <= 0)) {
153     fputs(fname, stderr);
154     fputs(": missing/illegal resolution\n", stderr);
155     return 0;
156     }
157     fputsresolu(&rs, stdout);
158     /* read/assign/write each ID */
159     for (n = (long)rs.xr*rs.yr; n-- > 0; ) {
160     LUENT *lep;
161     char ident[MAXIDLEN];
162     int len = scan_ident(ident, fp);
163     if (len < 0) {
164     if (feof(fp)) {
165     fputs(fname, stderr);
166     fputs(": unexpected EOF\n", stderr);
167     }
168     return 0;
169     }
170     lep = lu_find(&hashtab, ident);
171     if (!lep->key) { /* new entry */
172     if (nextID >= 1<<(ndxbytes<<3)) {
173     fputs(progname, stderr);
174     fputs(
175     ": too many unique identifiers for index size\n",
176     stderr);
177     return 0;
178     }
179     if (nextID >= idmlen) { /* reallocate? */
180     idmlen += idmlen>>2; /* +25% growth */
181     idmap = (char **)realloc(idmap, idmlen);
182     if (!idmap)
183     goto memerr;
184     }
185     lep->key = (char *)malloc(len+1);
186     if (!lep->key)
187     goto memerr;
188     idmap[nextID] = strcpy(lep->key, ident);
189     lep->data = (char *)nextID++;
190     }
191     /* write this id index */
192     putint((int)lep->data, ndxbytes, stdout);
193     }
194     while ((ndx = getc(fp)) != EOF) /* verify we got them all */
195     if (!isspace(ndx)) {
196     fputs(fname, stderr);
197     fputs(": warning - non-white characters past end\n",
198     stderr);
199     break;
200     }
201 greg 2.2 if (fp != stdin) /* done with input */
202     fclose(fp);
203 greg 2.1 for (ndx = 0; ndx < nextID; ndx++) { /* append string table */
204     fputs(idmap[ndx], stdout);
205     putchar('\0'); /* nul-terminated IDs */
206     }
207     free(idmap); /* clean up */
208     lu_done(&hashtab);
209     return 1;
210     memerr:
211     fputs(progname, stderr);
212     fputs(": out of memory!\n", stderr);
213     return 0;
214     }
215    
216    
217 greg 2.6 /* print out ID table */
218 greg 2.3 void
219     print_IDs(IDMAP *idmp)
220     {
221     int i;
222    
223     printf("============ %d IDs ============\n", idmp->nids);
224    
225     for (i = 0; i < idmp->nids; i++)
226     puts(mapID(idmp, i));
227    
228     puts("============= END =============");
229     }
230    
231    
232 greg 2.1 /* Load selected pixels from identifier index file */
233     int
234     decode_select(const char *fname, int hdrflags)
235     {
236     IDMAP *idmp = idmap_ropen(fname, hdrflags);
237 greg 2.6 int i, j;
238 greg 2.1
239     if (!idmp)
240     return 0;
241    
242 greg 2.3 if (hdrflags & HF_TABLOUT)
243     print_IDs(idmp);
244    
245 greg 2.1 if (idmp->res.rt != PIXSTANDARD) {
246     fputs(progname, stderr);
247     fputs(": can only handle standard pixel ordering\n", stderr);
248     idmap_close(idmp);
249     return 0;
250     }
251 greg 2.6 while (scanf("%d %d", &i, &j) == 2) {
252     i = idmap_seek(idmp, i, idmp->res.yr-1 - j);
253     if (!i) {
254 greg 2.1 fputs(progname, stderr);
255     fputs(": warning - pixel index is off map\n", stderr);
256     continue;
257     }
258 greg 2.6 if (i > 0)
259     i = idmap_next_i(idmp);
260     if (i < 0) {
261 greg 2.3 fputs(fname, stderr);
262     fputs(": read/seek error in decode_select()\n", stderr);
263 greg 2.1 idmap_close(idmp);
264     return 0;
265     }
266 greg 2.3 if (numeric) {
267 greg 2.6 printf("%d", i);
268 greg 2.3 } else {
269 greg 2.6 const char *id = mapID(idmp, i);
270 greg 2.3 if (!id) {
271     fputs(fname, stderr);
272     fputs(": bad ID index in file\n", stderr);
273     idmap_close(idmp);
274     return 0;
275     }
276     fputs(id, stdout);
277     }
278 greg 2.1 putchar(sepc);
279     if (unbuffered && fflush(stdout) == EOF) {
280     fputs(progname, stderr);
281     fputs(": write error on output\n", stderr);
282     idmap_close(idmp);
283     return 0;
284     }
285     }
286     idmap_close(idmp);
287    
288     if (!feof(stdin)) {
289     fputs(progname, stderr);
290     fputs(": non-numeric input for pixel index\n", stderr);
291     return 0;
292     }
293     return 1;
294     }
295    
296    
297     /* Load and convert identifier index file to ASCII */
298     int
299     decode_all(const char *fname, int hdrflags)
300     {
301     IDMAP *idmp = idmap_ropen(fname, hdrflags);
302     long n;
303    
304     if (!idmp)
305     return 0;
306    
307 greg 2.3 if (hdrflags & HF_TABLOUT)
308     print_IDs(idmp);
309    
310 greg 2.1 for (n = idmp->res.xr*idmp->res.yr; n-- > 0; ) {
311 greg 2.6 const int ndx = idmap_next_i(idmp);
312 greg 2.3 if (ndx < 0) {
313 greg 2.1 fputs(fname, stderr);
314     fputs(": unexpected EOF\n", stderr);
315     idmap_close(idmp);
316     return 0;
317     }
318 greg 2.3 if (numeric) {
319     printf("%d", ndx);
320     } else {
321 greg 2.4 const char *id = mapID(idmp, ndx);
322 greg 2.3 if (!id) {
323     fputs(fname, stderr);
324     fputs(": bad ID index in file\n", stderr);
325     idmap_close(idmp);
326     return 0;
327     }
328     fputs(id, stdout);
329     }
330 greg 2.1 putchar(sepc);
331     }
332     idmap_close(idmp);
333     return 1;
334     }
335    
336    
337     int
338     main(int argc, char *argv[])
339     {
340     char *inpfname = NULL;
341     int reverse = 0;
342     int bypixel = 0;
343     int hdrflags = HF_HEADOUT|HF_RESOUT;
344     int xres=0, yres=0;
345     int ndxbytes = 2;
346     int a;
347    
348     progname = argv[0];
349     for (a = 1; a < argc && argv[a][0] == '-'; a++)
350     switch (argv[a][1]) {
351     case 'r':
352     reverse++;
353     break;
354     case 'i':
355     bypixel++;
356     break;
357     case 'u':
358     unbuffered++;
359     break;
360 greg 2.3 case 'n':
361     numeric++;
362     break;
363     case 'l':
364     hdrflags |= HF_TABLOUT;
365     break;
366 greg 2.1 case 'h':
367     hdrflags &= ~HF_HEADOUT;
368     break;
369     case 'H':
370     hdrflags &= ~HF_RESOUT;
371     break;
372     case 't':
373     if (!(sepc = argv[a][2]))
374     sepc = '\n';
375     break;
376     case 'x':
377     xres = atoi(argv[++a]);
378     break;
379     case 'y':
380     yres = atoi(argv[++a]);
381     break;
382     case '8':
383     case '1':
384     case '2':
385     switch (atoi(argv[a]+1)) {
386     case 8:
387     ndxbytes = 1;
388     break;
389     case 16:
390     ndxbytes = 2;
391     break;
392     case 24:
393     ndxbytes = 3;
394     break;
395     default:
396     usage_exit(1);
397     }
398     break;
399     default:
400     usage_exit(1);
401     }
402 greg 2.2 if ((xres > 0) & (yres > 0)) /* user specified resolution? */
403     hdrflags &= ~HF_RESOUT;
404 greg 2.1 if (reverse && a >= argc) {
405     fputs(progname, stderr);
406     fputs(": -r option requires named input file\n", stderr);
407     return 1;
408     }
409     if (a < argc-2) {
410     fputs(progname, stderr);
411     fputs(": too many file arguments\n", stderr);
412     return 1;
413     }
414     if (a < argc)
415     inpfname = argv[a];
416     if (a+1 < argc && !freopen(argv[a+1], "w", stdout)) {
417     fputs(argv[a+1], stderr);
418     fputs(": cannot open output\n", stderr);
419     return 1;
420     }
421     if (!reverse)
422     SET_FILE_BINARY(stdout);
423     #ifdef getc_unlocked /* avoid stupid semaphores */
424     flockfile(stdout);
425     #endif
426     if (reverse) {
427     if (!(bypixel ? decode_select(inpfname, hdrflags) :
428     decode_all(inpfname, hdrflags)))
429     return 1;
430     } else if (!create_index(inpfname, hdrflags, ndxbytes, xres, yres))
431     return 1;
432    
433     if (fflush(stdout) == EOF) {
434     fputs(progname, stderr);
435     fputs(": error writing output\n", stderr);
436     return 1;
437     }
438     return 0;
439     }