ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/rcomb.c
Revision: 2.23
Committed: Fri Jun 7 03:55:59 2024 UTC (10 months, 3 weeks ago) by greg
Content type: text/plain
Branch: MAIN
Changes since 2.22: +56 -55 lines
Log Message:
fix(rcomb: Cleaned up logic and error reporting and fixed bug caused by subtle fclose(3) behavior that moved underlying file pointer shared with parent

File Contents

# User Rev Content
1 greg 2.1 #ifndef lint
2 greg 2.23 static const char RCSid[] = "$Id: rcomb.c,v 2.22 2024/06/04 22:05:23 greg Exp $";
3 greg 2.1 #endif
4     /*
5     * General component matrix combiner, operating on a row at a time.
6 greg 2.18 *
7     * Multi-processing mode under Unix creates children that each work
8 greg 2.19 * on one input row at a time, fed by the original process. Final conversion
9 greg 2.20 * and output to stdout is sorted by last child while its siblings send it
10 greg 2.19 * their record calculations.
11 greg 2.1 */
12    
13     #include <math.h>
14     #include "platform.h"
15 greg 2.10 #include "rtprocess.h"
16 greg 2.1 #include "rtio.h"
17     #include "rmatrix.h"
18     #include "calcomp.h"
19    
20     #ifndef M_PI
21     #define M_PI 3.14159265358979323846
22     #endif
23    
24     #define MAXCOMP MAXCSAMP /* #components we support */
25    
26     /* Unary matrix operation(s) */
27     typedef struct {
28     double cmat[MAXCOMP*MAXCOMP]; /* component transformation */
29     double sca[MAXCOMP]; /* scalar coefficients */
30     const char *csym; /* symbolic coefficients */
31     short clen; /* number of coefficients */
32     short nsf; /* number of scalars */
33     } RUNARYOP;
34    
35     /* Input matrix */
36     typedef struct {
37     const char *inspec; /* input specification */
38     RUNARYOP preop; /* transform operation */
39     RMATRIX imx; /* input matrix header info */
40     RMATRIX *rmp; /* active single-row matrix */
41     FILE *infp; /* open input stream */
42     } ROPMAT;
43    
44     ROPMAT *mop = NULL; /* allocated input array */
45     int nall = 0; /* number allocated */
46     int nmats = 0; /* number of actual inputs */
47    
48     RMATRIX *mcat = NULL; /* final concatenation */
49     int mcat_last = 0; /* goes after trailing ops? */
50    
51 greg 2.2 int in_nrows; /* number of input rows (or 0) */
52     #define in_ncols (mop[0].rmp->ncols) /* number of input columns */
53 greg 2.1 #define in_ncomp (mop[0].rmp->ncomp) /* input #components */
54    
55     extern int nowarn; /* turn off warnings? */
56    
57     int cur_row; /* current input/output row */
58     int cur_col; /* current input/output column */
59     int cur_chan; /* if we're looping channels */
60    
61 greg 2.10 SUBPROC *cproc = NULL; /* child process array */
62     int nchildren = 0; /* # of child processes */
63     int inchild = -1; /* our child ID (-1: parent) */
64    
65 greg 2.22 extern int checksymbolic(ROPMAT *rop);
66 greg 2.1
67 greg 2.22 int
68 greg 2.1 split_input(ROPMAT *rop)
69     {
70     if (rop->rmp == &rop->imx && !(rop->rmp = rmx_copy(&rop->imx))) {
71     fputs("Out of memory in split_input()\n", stderr);
72     return(0);
73     }
74     rmx_reset(rop->rmp);
75     return(1);
76     }
77    
78     /* Check/set transform based on a reference input file */
79 greg 2.22 int
80 greg 2.1 checkreffile(ROPMAT *rop)
81     {
82     static const char *curRF = NULL;
83     static RMATRIX refm;
84     const int nc = rop->imx.ncomp;
85     int i;
86    
87     if (!curRF || strcmp(rop->preop.csym, curRF)) {
88     FILE *fp = fopen(rop->preop.csym, "rb");
89     if (!rmx_load_header(&refm, fp)) {
90     fprintf(stderr, "%s: cannot read info header\n",
91     rop->preop.csym);
92     curRF = NULL;
93     if (fp) fclose(fp);
94     return(0);
95     }
96     fclose(fp);
97     curRF = rop->preop.csym;
98     }
99     if (refm.ncomp == 3) {
100     rop->preop.csym = (refm.dtype == DTxyze) ? "XYZ" : "RGB";
101     return(checksymbolic(rop));
102     }
103     if (refm.ncomp == 2) {
104     fprintf(stderr, "%s: cannot convert to 2 components\n",
105     curRF);
106     return(0);
107     }
108     if (refm.ncomp == 1) {
109     rop->preop.csym = "Y"; /* XXX big assumption */
110     return(checksymbolic(rop));
111     }
112     if (refm.ncomp == nc &&
113     !memcmp(refm.wlpart, rop->imx.wlpart, sizeof(refm.wlpart)))
114     return(1); /* nothing to do */
115    
116     if ((nc <= 3) | (nc > MAXCSAMP) | (refm.ncomp > MAXCSAMP)) {
117     fprintf(stderr, "%s: cannot resample from %d to %d components\n",
118     curRF, nc, refm.ncomp);
119     return(0);
120     }
121     if (!split_input(rop)) /* get our own struct */
122     return(0);
123     rop->preop.clen = refm.ncomp * nc; /* compute spec to ref */
124    
125     for (i = 0; i < nc; i++) {
126     SCOLOR scstim, scresp;
127     int j;
128     memset(scstim, 0, sizeof(COLORV)*nc);
129     scstim[i] = 1.f;
130     convertscolor(scresp, refm.ncomp, refm.wlpart[0], refm.wlpart[3],
131     scstim, nc, rop->imx.wlpart[0], rop->imx.wlpart[3]);
132     for (j = refm.ncomp; j-- > 0; )
133     rop->preop.cmat[j*nc + i] = scresp[j];
134     }
135     /* remember new spectral params */
136     memcpy(rop->rmp->wlpart, refm.wlpart, sizeof(rop->rmp->wlpart));
137     rop->rmp->ncomp = refm.ncomp;
138     return(1);
139     }
140    
141     /* Compute conversion row from spectrum to one channel of RGB */
142 greg 2.22 void
143 greg 2.1 rgbrow(ROPMAT *rop, int r, int p)
144     {
145     const int nc = rop->imx.ncomp;
146     const float * wlp = rop->imx.wlpart;
147     int i;
148    
149     for (i = nc; i--; ) {
150     int nmEnd = wlp[0] + (wlp[3] - wlp[0])*i/nc;
151     int nmStart = wlp[0] + (wlp[3] - wlp[0])*(i+1)/nc;
152     COLOR crgb;
153     spec_rgb(crgb, nmStart, nmEnd);
154     rop->preop.cmat[r*nc+i] = crgb[p];
155     }
156     }
157    
158     /* Compute conversion row from spectrum to one channel of XYZ */
159 greg 2.22 void
160 greg 2.1 xyzrow(ROPMAT *rop, int r, int p)
161     {
162     const int nc = rop->imx.ncomp;
163     const float * wlp = rop->imx.wlpart;
164     int i;
165    
166     for (i = nc; i--; ) {
167     int nmEnd = wlp[0] + (wlp[3] - wlp[0])*i/nc;
168     int nmStart = wlp[0] + (wlp[3] - wlp[0])*(i+1)/nc;
169     COLOR cxyz;
170     spec_cie(cxyz, nmStart, nmEnd);
171     rop->preop.cmat[r*nc+i] = cxyz[p];
172     }
173     }
174    
175     /* Use the spectral sensitivity function to compute matrix coefficients */
176 greg 2.22 void
177 greg 2.1 sensrow(ROPMAT *rop, int r, double (*sf)(SCOLOR sc, int ncs, const float wlpt[4]))
178     {
179     const int nc = rop->imx.ncomp;
180     int i;
181    
182     for (i = nc; i--; ) {
183     SCOLOR sclr;
184     memset(sclr, 0, sizeof(COLORV)*nc);
185     sclr[i] = 1.f;
186     rop->preop.cmat[r*nc+i] = (*sf)(sclr, nc, rop->imx.wlpart);
187     }
188     }
189    
190     /* Check/set symbolic transform */
191 greg 2.22 int
192 greg 2.1 checksymbolic(ROPMAT *rop)
193     {
194     const int nc = rop->imx.ncomp;
195     const int dt = rop->imx.dtype;
196 greg 2.3 double cf = 1;
197 greg 2.1 int i, j;
198     /* check suffix => reference file */
199     if (strchr(rop->preop.csym, '.') > rop->preop.csym)
200     return(checkreffile(rop));
201    
202     if (nc < 3) {
203     fprintf(stderr, "%s: -c '%s' requires at least 3 components\n",
204     rop->inspec, rop->preop.csym);
205     return(0);
206     }
207     rop->preop.clen = strlen(rop->preop.csym) * nc;
208     if (rop->preop.clen > MAXCOMP*MAXCOMP) {
209     fprintf(stderr, "%s: -c '%s' results in too many components\n",
210     rop->inspec, rop->preop.csym);
211     return(0);
212     }
213     for (j = 0; rop->preop.csym[j]; j++) {
214     int comp = 0;
215     switch (rop->preop.csym[j]) {
216     case 'B':
217 greg 2.3 case 'b':
218 greg 2.1 ++comp;
219     /* fall through */
220     case 'G':
221 greg 2.3 case 'g':
222 greg 2.1 ++comp;
223     /* fall through */
224     case 'R':
225 greg 2.3 case 'r':
226     if (rop->preop.csym[j] <= 'Z')
227     cf = 1./WHTEFFICACY;
228 greg 2.1 if (dt == DTxyze) {
229     for (i = 3; i--; )
230 greg 2.3 rop->preop.cmat[j*nc+i] = cf*xyz2rgbmat[comp][i];
231 greg 2.1 } else if (nc == 3)
232     rop->preop.cmat[j*nc+comp] = 1.;
233     else
234     rgbrow(rop, j, comp);
235     break;
236     case 'Z':
237 greg 2.3 case 'z':
238 greg 2.1 ++comp;
239     /* fall through */
240     case 'Y':
241 greg 2.3 case 'y':
242 greg 2.1 ++comp;
243     /* fall through */
244     case 'X':
245 greg 2.3 case 'x':
246     if ((rop->preop.csym[j] <= 'Z') & (dt != DTxyze))
247     cf = WHTEFFICACY;
248 greg 2.1 if (dt == DTxyze) {
249     rop->preop.cmat[j*nc+comp] = 1.;
250     } else if (nc == 3) {
251     for (i = 3; i--; )
252     rop->preop.cmat[j*nc+i] =
253     rgb2xyzmat[comp][i];
254     } else if (comp == CIEY)
255     sensrow(rop, j, scolor2photopic);
256     else
257     xyzrow(rop, j, comp);
258    
259 greg 2.3 for (i = nc*(cf != 1); i--; )
260     rop->preop.cmat[j*nc+i] *= cf;
261 greg 2.1 break;
262     case 'S': /* scotopic (il)luminance */
263 greg 2.3 cf = WHTSCOTOPIC;
264     /* fall through */
265     case 's':
266 greg 2.1 sensrow(rop, j, scolor2scotopic);
267 greg 2.3 for (i = nc*(cf != 1); i--; )
268     rop->preop.cmat[j*nc+i] *= cf;
269 greg 2.1 break;
270     case 'M': /* melanopic (il)luminance */
271 greg 2.3 cf = WHTMELANOPIC;
272     /* fall through */
273     case 'm':
274 greg 2.1 sensrow(rop, j, scolor2melanopic);
275 greg 2.3 for (i = nc*(cf != 1); i--; )
276     rop->preop.cmat[j*nc+i] *= cf;
277 greg 2.1 break;
278     case 'A': /* average component */
279 greg 2.3 case 'a':
280 greg 2.1 for (i = nc; i--; )
281     rop->preop.cmat[j*nc+i] = 1./(double)nc;
282     break;
283     default:
284     fprintf(stderr, "%s: -c '%c' unsupported\n",
285     rop->inspec, rop->preop.csym[j]);
286     return(0);
287     }
288     }
289     if (!split_input(rop)) /* get our own struct */
290     return(0);
291     memcpy(rop->rmp->wlpart, WLPART, sizeof(rop->rmp->wlpart));
292     rop->rmp->ncomp = rop->preop.clen / nc;
293     /* decide on output type */
294 greg 2.4 if (!strcasecmp(rop->preop.csym, "XYZ")) {
295 greg 2.1 if (dt <= DTspec)
296     rop->rmp->dtype = DTxyze;
297 greg 2.4 } else if (!strcasecmp(rop->preop.csym, "RGB")) {
298 greg 2.1 if (dt <= DTspec)
299     rop->rmp->dtype = DTrgbe;
300     } else if (rop->rmp->dtype == DTspec)
301     rop->rmp->dtype = DTfloat;
302     return(1);
303     }
304    
305 greg 2.22 int
306 greg 2.1 get_component_xfm(ROPMAT *rop)
307     {
308     int i, j;
309    
310     if (rop->rmp != &rop->imx) { /* reset destination matrix */
311     rmx_free(rop->rmp);
312     rop->rmp = &rop->imx;
313     }
314     if (rop->preop.csym && /* symbolic transform? */
315     !checksymbolic(rop))
316     return(0);
317     /* undo exposure? */
318     if (fabs(1. - bright(rop->rmp->cexp)) > .025) {
319     if (rop->rmp->ncomp == 1)
320     rop->rmp->cexp[RED] = rop->rmp->cexp[GRN] =
321     rop->rmp->cexp[BLU] = bright(rop->rmp->cexp);
322     if (rop->preop.nsf <= 0) {
323     rop->preop.nsf = i = rop->rmp->ncomp;
324     while (i--)
325     rop->preop.sca[i] = 1.;
326     }
327     if (rop->preop.nsf == 1) {
328     if (rop->rmp->ncomp == 3) {
329     rop->preop.sca[2] = rop->preop.sca[1] =
330     rop->preop.sca[0];
331     rop->preop.nsf = 3;
332     } else
333     rop->preop.sca[0] /= bright(rop->rmp->cexp);
334     }
335     if (rop->preop.nsf == 3) {
336     opcolor(rop->preop.sca, /=, rop->rmp->cexp);
337     } else if (rop->preop.nsf > 3) { /* punt */
338     double mult = 1./bright(rop->rmp->cexp);
339     for (i = rop->preop.nsf; i--; )
340     rop->preop.sca[i] *= mult;
341     }
342     setcolor(rop->rmp->cexp, 1., 1., 1.);
343     }
344     if (rop->preop.clen > 0) { /* use component transform? */
345     if (rop->preop.clen % rop->imx.ncomp) {
346     fprintf(stderr, "%s: -c must have N x %d coefficients\n",
347     rop->inspec, rop->imx.ncomp);
348     return(0);
349     }
350     if (rop->preop.nsf > 0) { /* scale transform, instead */
351     if (rop->preop.nsf == 1) {
352     for (i = rop->preop.clen; i--; )
353     rop->preop.cmat[i] *= rop->preop.sca[0];
354     } else if (rop->preop.nsf*rop->imx.ncomp != rop->preop.clen) {
355     fprintf(stderr, "%s: -s must have one or %d factors\n",
356     rop->inspec,
357     rop->preop.clen/rop->imx.ncomp);
358     return(0);
359     } else {
360     for (i = rop->preop.nsf; i--; )
361     for (j = rop->imx.ncomp; j--; )
362     rop->preop.cmat[i*rop->imx.ncomp+j]
363     *= rop->preop.sca[i];
364     }
365     }
366     rop->preop.nsf = 0; /* now folded in */
367     if (!split_input(rop)) /* get our own struct */
368     return(0);
369     rop->rmp->ncomp = rop->preop.clen / rop->imx.ncomp;
370     if ((rop->rmp->ncomp > 3) & (rop->rmp->dtype <= DTspec)) {
371     rop->rmp->dtype = DTfloat; /* probably not actual spectrum */
372     memcpy(rop->rmp->wlpart, WLPART, sizeof(rop->rmp->wlpart));
373     }
374     } else if (rop->preop.nsf > 0) { /* else use scalar(s)? */
375     if (rop->preop.nsf == 1) {
376     for (i = rop->rmp->ncomp; --i; )
377     rop->preop.sca[i] = rop->preop.sca[0];
378     rop->preop.nsf = rop->rmp->ncomp;
379     } else if (rop->preop.nsf != rop->rmp->ncomp) {
380     fprintf(stderr, "%s: -s must have one or %d factors\n",
381     rop->inspec, rop->rmp->ncomp);
382     return(0);
383     }
384     }
385     return(1);
386     }
387    
388 greg 2.22 int
389 greg 2.1 apply_op(RMATRIX *dst, const RMATRIX *src, const RUNARYOP *ro)
390     {
391     if (ro->clen > 0) {
392     RMATRIX *res = rmx_transform(src, dst->ncomp, ro->cmat);
393     if (!res) {
394     fputs("Error in call to rmx_transform()\n", stderr);
395     return(0);
396     }
397     if (!rmx_transfer_data(dst, res, 0))
398     return(0);
399     rmx_free(res);
400     } else if (dst != src)
401 greg 2.9 memcpy(dst->mtx, src->mtx, rmx_array_size(dst));
402 greg 2.1 if (ro->nsf == dst->ncomp)
403     rmx_scale(dst, ro->sca);
404     return(1);
405     }
406    
407 greg 2.22 int
408 greg 2.1 open_input(ROPMAT *rop)
409     {
410     int outtype;
411    
412     if (!rop || !rop->inspec || !rop->inspec[0])
413     return(0);
414     if (rop->inspec == stdin_name)
415     rop->infp = stdin;
416     else if (rop->inspec[0] == '!')
417     rop->infp = popen(rop->inspec+1, "r");
418     else
419     rop->infp = fopen(rop->inspec, "rb");
420    
421     if (!rmx_load_header(&rop->imx, rop->infp)) {
422     fprintf(stderr, "Bad header from: %s\n", rop->inspec);
423     return(0);
424     }
425     return(get_component_xfm(rop));
426     }
427    
428     /* Return nominal wavelength associated with input component (return nm) */
429 greg 2.22 double
430 greg 2.1 l_wavelength(char *nam)
431     {
432     double comp = argument(1);
433    
434     if ((comp < -.5) | (comp >= in_ncomp+.5)) {
435     errno = EDOM;
436     return(.0);
437     }
438     if (comp < .5) /* asking for #components? */
439     return(in_ncomp);
440    
441     if (in_ncomp == 3) { /* special case for RGB */
442     const int w0 = (int)(comp - .5);
443     return(mop[0].rmp->wlpart[w0] +
444     (comp-.5)*(mop[0].rmp->wlpart[w0+1] -
445     mop[0].rmp->wlpart[w0]));
446     }
447     return(mop[0].rmp->wlpart[0] + /* general case, even div. */
448     (comp-.5)/(double)in_ncomp *
449     (mop[0].rmp->wlpart[3] - mop[0].rmp->wlpart[0]));
450     }
451    
452     /* Return ith input with optional channel selector */
453 greg 2.22 double
454 greg 2.1 l_chanin(char *nam)
455     {
456     double inp = argument(1);
457     int mi, chan;
458    
459     if ((mi = (int)(inp-.5)) < 0 || mi >= nmats) {
460     errno = EDOM;
461     return(.0);
462     }
463     if (inp < .5) /* asking for #inputs? */
464     return(nmats);
465    
466     if (nargum() >= 2) {
467     double cval = argument(2);
468     if (cval < .5 || (chan = (int)(cval-.5)) >= in_ncomp) {
469     errno = EDOM;
470     return(.0);
471     }
472     } else
473     chan = cur_chan;
474    
475     return(mop[mi].rmp->mtx[cur_col*in_ncomp + chan]);
476     }
477    
478 greg 2.22 int
479 greg 2.1 initialize(RMATRIX *imp)
480     {
481     int i;
482     /* XXX struct is zeroed coming in */
483     setcolor(imp->cexp, 1.f, 1.f, 1.f);
484     for (i = 0; i < nmats; i++) { /* open each input */
485     int restype;
486     if (!open_input(&mop[i]))
487     return(0);
488     restype = mop[i].rmp->dtype;
489     if (!imp->dtype || (restype = rmx_newtype(restype, imp->dtype)) > 0)
490     imp->dtype = restype;
491     else
492     fprintf(stderr, "%s: warning - data type mismatch\n",
493     mop[i].inspec);
494     if (!i) {
495     imp->ncols = mop[0].rmp->ncols;
496     imp->ncomp = mop[0].rmp->ncomp;
497     memcpy(imp->wlpart, mop[0].rmp->wlpart, sizeof(imp->wlpart));
498 greg 2.2 } else if ((mop[i].rmp->ncols != imp->ncols) |
499     (mop[i].rmp->ncomp != imp->ncomp) |
500     ((in_nrows > 0) & (mop[i].rmp->nrows > 0) &
501     (mop[i].rmp->nrows != in_nrows))) {
502 greg 2.1 fprintf(stderr, "%s: mismatch in size or #components\n",
503     mop[i].inspec);
504     return(0);
505     } /* XXX should check wlpart? */
506 greg 2.2 if (in_nrows <= 0)
507     in_nrows = imp->nrows = mop[i].rmp->nrows;
508 greg 2.1 } /* set up .cal environment */
509     esupport |= E_VARIABLE|E_FUNCTION|E_RCONST;
510     esupport &= ~(E_OUTCHAN|E_INCHAN);
511     varset("PI", ':', M_PI);
512     varset("nfiles", ':', nmats);
513     varset("nrows", ':', in_nrows);
514     varset("ncols", ':', in_ncols);
515     varset("ncomp", ':', in_ncomp);
516     varset("R", ':', 1.);
517     varset("G", ':', 2.);
518     varset("B", ':', 3.);
519     funset("wl", 1, ':', l_wavelength);
520     funset("ci", 1, '=', l_chanin);
521     scompile("ri(i)=ci(i,R);gi(i)=ci(i,G);bi(i)=ci(i,B)", NULL, 0);
522     return(1);
523     }
524    
525 greg 2.22 void
526 greg 2.1 output_headinfo(FILE *fp)
527     {
528     int i;
529    
530     for (i = 0; i < nmats; i++) {
531     const char *cp = mop[i].imx.info;
532     fputs(mop[i].inspec, fp);
533     fputs(":\n", fp);
534     if (!cp) continue;
535     while (*cp) {
536     if (*cp == '\n') {
537     cp++; /* avoid inadvertant terminus */
538     continue;
539     }
540     fputc('\t', fp); /* indent this input's info */
541     do
542     putc(*cp, fp);
543     while (*cp++ != '\n');
544     }
545     }
546     }
547    
548 greg 2.22 int
549 greg 2.10 spawned_children(int np)
550 greg 2.1 {
551 greg 2.10 int i, rv;
552    
553     #if defined(_WIN32) || defined(_WIN64)
554     if (np > 1) {
555     fputs("Warning: only one process under Windows\n", stderr);
556     np = 1;
557     } else
558     #endif
559 greg 2.18 if ((in_nrows > 0) & (np*4 > in_nrows))
560     np = in_nrows/4;
561 greg 2.10 /* we'll be doing a row at a time */
562 greg 2.1 for (i = 0; i < nmats; i++) {
563 greg 2.10 mop[i].imx.nrows = 1;
564 greg 2.1 if (!rmx_prepare(&mop[i].imx))
565     goto memerror;
566     if (mop[i].rmp != &mop[i].imx) {
567     mop[i].rmp->nrows = 1;
568     if (!rmx_prepare(mop[i].rmp))
569     goto memerror;
570     }
571     }
572 greg 2.20 /* prep output row buffer(s) */
573 greg 2.23 if (mop[nmats].preop.clen > 0) {
574 greg 2.10 if (!split_input(&mop[nmats])) /* need separate buffer */
575 greg 2.23 goto memerror;
576     mop[nmats].rmp->ncomp = mop[nmats].preop.clen /
577     mop[nmats].imx.ncomp;
578 greg 2.1 }
579 greg 2.10 mop[nmats].imx.nrows = 1;
580     if (!rmx_prepare(&mop[nmats].imx))
581     goto memerror;
582 greg 2.20 if (mop[nmats].rmp != &mop[nmats].imx) {
583     mop[nmats].rmp->nrows = 1;
584     if (!rmx_prepare(mop[nmats].rmp))
585     goto memerror;
586     }
587 greg 2.18 if (np <= 1) { /* single process return */
588 greg 2.10 #ifdef getc_unlocked
589     for (i = 0; i < nmats; i++)
590     flockfile(mop[i].infp);
591     flockfile(stdout);
592     #endif
593     return(0);
594     }
595     fflush(stdout); /* flush header & spawn children */
596 greg 2.20 nchildren = np + 1; /* extra child to sequence output */
597 greg 2.19 cproc = (SUBPROC *)malloc(sizeof(SUBPROC)*nchildren);
598 greg 2.10 if (!cproc)
599     goto memerror;
600 greg 2.20 for (i = nchildren; i--; ) cproc[i] = sp_inactive;
601     cproc[nchildren-1].flags |= PF_FILT_OUT;
602 greg 2.23 /* start each child from parent */
603     for (i = 0; i < nchildren; i++)
604     if ((rv = open_process(&cproc[i], NULL)) <= 0)
605     break; /* child breaks here */
606 greg 2.10 if (rv < 0) {
607 greg 2.23 perror("fork"); /* WTH? */
608 greg 2.17 close_processes(cproc, i);
609 greg 2.10 exit(1);
610     }
611 greg 2.23 if (i != nchildren-1) { /* last child is sole reader */
612     int j = i;
613     while (j-- > 0) {
614     close(cproc[j].r);
615     cproc[j].r = -1;
616 greg 2.21 }
617 greg 2.23 }
618     if (rv > 0)
619 greg 2.20 return(1); /* parent return value */
620 greg 2.23
621     inchild = i; /* else set our child index */
622 greg 2.20 while (i-- > 0) /* only parent writes siblings */
623 greg 2.11 close(cproc[i].w);
624 greg 2.20
625 greg 2.23 i = nmats; /* close matrix streams (carefully) */
626     while (i-- > 0) {
627     if (mop[i].infp != stdin) {
628     close(fileno(mop[i].infp)); /* avoid lseek() */
629     fclose(mop[i].infp); /* ! pclose() */
630     }
631     mop[i].infp = NULL;
632     }
633     fpurge(stdin); /* discard previously buffered input */
634    
635 greg 2.22 if (inchild == nchildren-1)
636     return(-1); /* output process return value */
637 greg 2.20
638 greg 2.23 i = nmats; /* get matrix rows from parent */
639 greg 2.20 while (i-- > 0) {
640     mop[i].infp = stdin;
641     mop[i].imx.dtype = DTrmx_native;
642     mop[i].imx.pflags &= ~RMF_SWAPIN;
643     }
644 greg 2.10 #ifdef getc_unlocked
645     flockfile(stdin);
646     #endif
647 greg 2.20 mop[nmats].rmp->dtype = DTrmx_native;
648     return(0); /* worker child return value */
649 greg 2.10 memerror:
650     fputs("Out of memory in spawned_children()\n", stderr);
651     exit(1);
652     }
653    
654 greg 2.22 int
655 greg 2.19 parent_loop(void)
656 greg 2.10 {
657     int i;
658    
659 greg 2.20 rmx_reset(&mop[nmats].imx); /* not touching output side */
660     if (mop[nmats].rmp != &mop[nmats].imx) {
661     rmx_free(mop[nmats].rmp);
662     mop[nmats].rmp = &mop[nmats].imx;
663     }
664 greg 2.10 #ifdef getc_unlocked
665 greg 2.20 for (i = 0; i < nmats; i++) /* we handle matrix inputs */
666 greg 2.10 flockfile(mop[i].infp);
667     #endif
668 greg 2.19 /* load & send rows to kids */
669 greg 2.10 for (cur_row = 0; (in_nrows <= 0) | (cur_row < in_nrows); cur_row++) {
670 greg 2.20 int wfd = cproc[cur_row % (nchildren-1)].w;
671 greg 2.11 for (i = 0; i < nmats; i++)
672 greg 2.10 if (!rmx_load_row(mop[i].imx.mtx, &mop[i].imx, mop[i].infp)) {
673     if (cur_row > in_nrows) /* unknown #input rows? */
674     break;
675 greg 2.23 fprintf(stderr, "%s: parent_loop() load error at row %d\n",
676 greg 2.10 mop[i].inspec, cur_row);
677     return(0);
678     }
679 greg 2.11 if (i < nmats)
680     break;
681     for (i = 0; i < nmats; i++)
682 greg 2.19 if (writebuf(wfd, mop[i].imx.mtx, rmx_array_size(&mop[i].imx))
683 greg 2.23 != rmx_array_size(&mop[i].imx)) {
684     fprintf(stderr, "%s: parent_loop() write error at row %d\n",
685     mop[i].inspec, cur_row);
686 greg 2.19 return(0);
687 greg 2.23 }
688 greg 2.10 }
689 greg 2.23 i = close_processes(cproc, nchildren); /* collect family */
690 greg 2.20 free(cproc); cproc = NULL; nchildren = 0;
691 greg 2.10 if (i < 0) {
692 greg 2.20 fputs("Warning: lost child in parent_loop()\n", stderr);
693 greg 2.10 return(1);
694     }
695     if (i > 0) {
696     fprintf(stderr, "Child exited with status %d\n", i);
697     return(0);
698     }
699 greg 2.20 return(1); /* return success! */
700 greg 2.10 }
701    
702 greg 2.22 int
703 greg 2.19 combine_input(void)
704 greg 2.10 {
705 greg 2.20 const int row0 = (inchild >= 0)*inchild;
706     const int rstep = nchildren ? nchildren-1 : 1;
707 greg 2.10 ROPMAT *res = &mop[nmats];
708     int set_r, set_c;
709     RMATRIX *tmp = NULL;
710     int co_set;
711     int i;
712    
713 greg 2.23 if (mcat_last && !(tmp = rmx_alloc(1, res->imx.ncols, res->rmp->ncomp))) {
714     fputs("Out of buffer space in combine_input()\n", stderr);
715     return(0);
716     }
717 greg 2.1 /* figure out what the user set */
718     co_set = fundefined("co");
719     if (!co_set)
720     co_set = -vardefined("co");
721     if (!co_set & (in_ncomp == 3) && vardefined("ro") &&
722     vardefined("go") && vardefined("bo")) {
723     scompile("co(p)=select(p,ro,go,bo)", NULL, 0);
724     co_set = 1;
725     }
726     if (co_set) { /* set if user wants, didn't set */
727     set_r = varlookup("r") != NULL && !vardefined("r");
728     set_c = varlookup("c") != NULL && !vardefined("c");
729     } else /* save a little time */
730     set_r = set_c = 0;
731 greg 2.16 /* read/process row-by-row */
732 greg 2.10 for (cur_row = row0; (in_nrows <= 0) | (cur_row < in_nrows); cur_row += rstep) {
733 greg 2.1 RMATRIX *mres = NULL;
734 greg 2.14 for (i = 0; i < nmats; i++)
735 greg 2.1 if (!rmx_load_row(mop[i].imx.mtx, &mop[i].imx, mop[i].infp)) {
736 greg 2.5 if (cur_row > in_nrows) /* unknown #input rows? */
737 greg 2.10 break;
738 greg 2.23 fprintf(stderr, "%s: combine_input() load error at row %d\n",
739 greg 2.1 mop[i].inspec, cur_row);
740     return(0);
741     }
742 greg 2.10 if (i < nmats)
743     break;
744     for (i = 0; i < nmats; i++)
745 greg 2.1 if (!apply_op(mop[i].rmp, &mop[i].imx, &mop[i].preop))
746     return(0);
747     if (set_r) varset("r", '=', cur_row);
748     for (cur_col = 0; cur_col < in_ncols; cur_col++) {
749     if (set_c) varset("c", '=', cur_col);
750     for (cur_chan = 0; cur_chan < in_ncomp; cur_chan++) {
751     const int ndx = cur_col*in_ncomp + cur_chan;
752     eclock++;
753     if (!co_set) { /* just summing elements? */
754     res->imx.mtx[ndx] = 0;
755     for (i = nmats; i--; )
756     res->imx.mtx[ndx] += mop[i].rmp->mtx[ndx];
757     } else if (co_set > 0) {
758     double dchan = cur_chan+1;
759     res->imx.mtx[ndx] = funvalue("co", 1, &dchan);
760     } else
761     res->imx.mtx[ndx] = varvalue("co");
762     }
763     } /* final conversions */
764     if (!mcat) {
765     if (!apply_op(res->rmp, &res->imx, &res->preop))
766     return(0);
767     } else if (mcat_last) {
768     if (!apply_op(tmp, &res->imx, &res->preop))
769     return(0);
770     mres = rmx_multiply(tmp, mcat);
771     if (!mres)
772     goto multerror;
773     if (!rmx_transfer_data(res->rmp, mres, 0))
774     return(0);
775     } else /* mcat && !mcat_last */ {
776     mres = rmx_multiply(&res->imx, mcat);
777     if (!mres)
778     goto multerror;
779     if (!apply_op(res->rmp, mres, &res->preop))
780     return(0);
781     }
782     rmx_free(mres); mres = NULL;
783     if (!rmx_write_data(res->rmp->mtx, res->rmp->ncomp,
784 greg 2.23 res->rmp->ncols, res->rmp->dtype, stdout) ||
785     (inchild >= 0 && fflush(stdout) == EOF)) {
786     fprintf(stderr, "Conversion/write error at row %d in combine_input()\n",
787     cur_row);
788 greg 2.16 return(0);
789 greg 2.23 }
790 greg 2.1 }
791 greg 2.20 return(inchild >= 0 || fflush(stdout) != EOF);
792 greg 2.1 multerror:
793     fputs("Unexpected matrix multiply error in combine_input()\n", stderr);
794     return(0);
795     }
796    
797 greg 2.22 int
798     output_loop(void)
799     {
800     const size_t row_size = rmx_array_size(mop[nmats].rmp);
801 greg 2.23 int cur_child = 0;
802 greg 2.22 int i = nmats;
803    
804 greg 2.23 while (i-- > 0) { /* free input buffers */
805 greg 2.22 rmx_reset(&mop[i].imx);
806     if (mop[i].rmp != &mop[i].imx) {
807     rmx_free(mop[i].rmp);
808     mop[i].rmp = &mop[i].imx;
809     }
810     }
811 greg 2.23 if (mop[nmats].rmp != &mop[nmats].imx) /* output is split? */
812     rmx_reset(&mop[nmats].imx);
813 greg 2.22 #ifdef getc_unlocked
814     flockfile(stdout); /* we own this, now */
815     #endif
816     for ( ; ; ) { /* loop until no more */
817     ssize_t rv;
818     rv = readbuf(cproc[cur_child].r, mop[nmats].rmp->mtx, row_size);
819     if (!rv) /* out of rows? */
820     break;
821     if (rv != row_size) {
822 greg 2.23 fputs("Read error in output_loop()\n", stderr);
823 greg 2.22 return(0);
824     } /* do final conversion */
825     if (!rmx_write_data(mop[nmats].rmp->mtx, mop[nmats].rmp->ncomp,
826     mop[nmats].rmp->ncols, mop[nmats].rmp->dtype, stdout)) {
827 greg 2.23 fputs("Conversion/write error in output_loop()\n", stderr);
828 greg 2.22 return(0);
829     }
830     cur_child++;
831 greg 2.23 cur_child *= (cur_child < inchild); /* loop over workers */
832 greg 2.22 }
833     return(fflush(stdout) != EOF);
834     }
835    
836     int
837 greg 2.1 get_factors(double da[], int n, char *av[])
838     {
839     int ac;
840    
841     for (ac = 0; ac < n && isflt(av[ac]); ac++)
842     da[ac] = atof(av[ac]);
843     return(ac);
844     }
845    
846 greg 2.22 void
847 greg 2.1 resize_inparr(int n2alloc)
848     {
849     int i;
850    
851 greg 2.6 if (n2alloc == nall)
852     return;
853     for (i = nall; i > n2alloc; i--) {
854 greg 2.1 rmx_reset(&mop[i].imx);
855     if (mop[i].rmp != &mop[i].imx)
856     rmx_free(mop[i].rmp);
857     }
858     mop = (ROPMAT *)realloc(mop, n2alloc*sizeof(ROPMAT));
859     if (mop == NULL) {
860     fputs("Out of memory in resize_inparr()\n", stderr);
861     exit(1);
862     }
863 greg 2.6 if (n2alloc > nall)
864     memset(mop+nall, 0, (n2alloc-nall)*sizeof(ROPMAT));
865 greg 2.1 nall = n2alloc;
866     }
867    
868     /* Load one or more matrices and operate on them, sending results to stdout */
869     int
870     main(int argc, char *argv[])
871     {
872    
873     int outfmt = DTfromHeader;
874     const char *defCsym = NULL;
875     int echoheader = 1;
876     int stdin_used = 0;
877 greg 2.10 int nproc = 1;
878 greg 2.1 const char *mcat_spec = NULL;
879     int n2comp = 0;
880     uby8 comp_ndx[128];
881     int i;
882     /* get starting input array */
883     mop = (ROPMAT *)calloc(nall=2, sizeof(ROPMAT));
884     /* get options and arguments */
885     for (i = 1; i < argc; i++)
886     if (argv[i][0] != '-' || !argv[i][1]) {
887     if (argv[i][0] == '-') {
888     if (stdin_used++) goto stdin_error;
889     mop[nmats].inspec = stdin_name;
890     } else
891     mop[nmats].inspec = argv[i];
892     if (!mop[nmats].preop.csym)
893     mop[nmats].preop.csym = defCsym;
894     if (++nmats >= nall)
895     resize_inparr(nmats + (nmats>>2) + 2);
896     } else {
897     int n = argc-1 - i;
898     switch (argv[i][1]) { /* get option */
899     case 'w':
900     nowarn = !nowarn;
901     break;
902     case 'h':
903     echoheader = !echoheader;
904     break;
905 greg 2.10 case 'n':
906     nproc = atoi(argv[++i]);
907     if (nproc <= 0)
908     goto userr;
909     break;
910 greg 2.1 case 'e':
911     if (!n) goto userr;
912     comp_ndx[n2comp++] = i++;
913     break;
914     case 'f':
915     switch (argv[i][2]) {
916     case '\0':
917     if (!n) goto userr;
918     comp_ndx[n2comp++] = i++;
919     break;
920     case 'd':
921     outfmt = DTdouble;
922     break;
923     case 'f':
924     outfmt = DTfloat;
925     break;
926     case 'a':
927     outfmt = DTascii;
928     break;
929     case 'c':
930     outfmt = DTrgbe;
931     break;
932     default:
933     goto userr;
934     }
935     break;
936     case 's':
937     if (n > MAXCOMP) n = MAXCOMP;
938     i += mop[nmats].preop.nsf =
939     get_factors(mop[nmats].preop.sca,
940     n, argv+i+1);
941     if (mop[nmats].preop.nsf <= 0) {
942     fprintf(stderr, "%s: -s missing arguments\n",
943     argv[0]);
944     goto userr;
945     }
946     break;
947     case 'C':
948 greg 2.23 mcat_last = 0;
949 greg 2.1 if (!n || isflt(argv[i+1]))
950     goto userr;
951     defCsym = mop[nmats].preop.csym = argv[++i];
952     mop[nmats].preop.clen = 0;
953     break;
954     case 'c':
955 greg 2.23 mcat_last = 0;
956 greg 2.1 if (n && !isflt(argv[i+1])) {
957     mop[nmats].preop.csym = argv[++i];
958     mop[nmats].preop.clen = 0;
959     break;
960     }
961     if (n > MAXCOMP*MAXCOMP) n = MAXCOMP*MAXCOMP;
962     i += mop[nmats].preop.clen =
963     get_factors(mop[nmats].preop.cmat,
964     n, argv+i+1);
965     if (mop[nmats].preop.clen <= 0) {
966     fprintf(stderr, "%s: -c missing arguments\n",
967     argv[0]);
968     goto userr;
969     }
970     mop[nmats].preop.csym = NULL;
971     break;
972     case 'm':
973 greg 2.23 mcat_last = 1;
974 greg 2.1 if (!n) goto userr;
975     if (argv[++i][0] == '-' && !argv[i][1]) {
976     if (stdin_used++) goto stdin_error;
977     mcat_spec = stdin_name;
978     } else
979     mcat_spec = argv[i];
980     break;
981     default:
982     fprintf(stderr, "%s: unknown option '%s'\n",
983     argv[0], argv[i]);
984     goto userr;
985     }
986     }
987     if (!nmats) {
988     fprintf(stderr, "%s: need at least one input matrix\n", argv[0]);
989     goto userr;
990     }
991     resize_inparr(nmats+1); /* extra matrix at end for result */
992     mop[nmats].inspec = "trailing_ops";
993     /* load final concatenation matrix */
994     if (mcat_spec && !(mcat = rmx_load(mcat_spec, RMPnone))) {
995     fprintf(stderr, "%s: error loading concatenation matrix: %s\n",
996     argv[0], mcat_spec);
997     return(1);
998     }
999     /* get/check inputs, set constants */
1000     if (!initialize(&mop[nmats].imx))
1001     return(1);
1002    
1003     for (i = 0; i < n2comp; i++) /* user .cal files and expressions */
1004     if (argv[comp_ndx[i]][1] == 'f') {
1005     char *fpath = getpath(argv[comp_ndx[i]+1],
1006     getrlibpath(), 0);
1007     if (fpath == NULL) {
1008     fprintf(stderr, "%s: cannot find file '%s'\n",
1009     argv[0], argv[comp_ndx[i]+1]);
1010     return(1);
1011     }
1012     fcompile(fpath);
1013     } else /* (argv[comp_ndx[i]][1] == 'e') */
1014     scompile(argv[comp_ndx[i]+1], NULL, 0);
1015    
1016     /* get trailing color transform */
1017     if (!get_component_xfm(&mop[nmats]))
1018     return(1);
1019     /* adjust output dimensions and #components */
1020     if (mcat) {
1021     if (mop[nmats].imx.ncols != mcat->nrows) {
1022     fprintf(stderr,
1023     "%s: number of input columns does not match number of rows in '%s'\n",
1024     argv[0], mcat_spec);
1025     return(1);
1026     }
1027     if (mcat->ncomp != (mcat_last ? mop[nmats].rmp->ncomp : mop[nmats].imx.ncomp)) {
1028     fprintf(stderr,
1029     "%s: number of components does not match those in '%s'\n",
1030     argv[0], mcat_spec);
1031     return(1);
1032     }
1033     if (!split_input(&mop[nmats]))
1034     return(1);
1035     mop[nmats].rmp->ncols = mcat->ncols;
1036     }
1037     newheader("RADIANCE", stdout); /* write output header */
1038     if (echoheader)
1039     output_headinfo(stdout);
1040     printargs(argc, argv, stdout);
1041     fputnow(stdout);
1042     mop[nmats].rmp->dtype = rmx_write_header(mop[nmats].rmp, outfmt, stdout);
1043     if (!mop[nmats].rmp->dtype) {
1044     fprintf(stderr, "%s: unsupported output format\n", argv[0]);
1045     return(1);
1046     }
1047 greg 2.7 doptimize(1); /* optimize definitions */
1048 greg 2.22 i = spawned_children(nproc); /* create multiple processes if requested */
1049     if (i > 0) /* running in parent process? */
1050 greg 2.10 return(parent_loop() ? 0 : 1);
1051 greg 2.22 if (i < 0) /* running in output process? */
1052     return(output_loop() ? 0 : 1);
1053     /* else we are a worker process */
1054 greg 2.10 return(combine_input() ? 0 : 1);
1055 greg 2.1 stdin_error:
1056     fprintf(stderr, "%s: %s used for more than one input\n",
1057     argv[0], stdin_name);
1058     return(1);
1059     userr:
1060     fprintf(stderr,
1061 greg 2.10 "Usage: %s [-h][-f{adfc}][-n nproc][-e expr][-f file][-s sf .. | -c ce ..] m1 .. -m mcat > mres\n",
1062 greg 2.1 argv[0]);
1063     return(1);
1064     }