12 |
|
#include "resolu.h" |
13 |
|
#include "paths.h" |
14 |
|
#include "rmatrix.h" |
15 |
+ |
#if !defined(_WIN32) && !defined(_WIN64) |
16 |
+ |
#include <sys/mman.h> |
17 |
+ |
#endif |
18 |
|
|
19 |
|
static char rmx_mismatch_warn[] = "WARNING: data type mismatch\n"; |
20 |
|
|
21 |
< |
/* Allocate a nr x nc matrix with n components */ |
21 |
> |
#define array_size(rm) (sizeof(double)*(rm)->nrows*(rm)->ncols*(rm)->ncomp) |
22 |
> |
#define mapped_size(rm) ((char *)(rm)->mtx + array_size(rm) - (char *)(rm)->mapped) |
23 |
> |
|
24 |
> |
/* Initialize a RMATRIX struct but don't allocate array space */ |
25 |
|
RMATRIX * |
26 |
+ |
rmx_new(int nr, int nc, int n) |
27 |
+ |
{ |
28 |
+ |
RMATRIX *dnew = (RMATRIX *)calloc(1, sizeof(RMATRIX)); |
29 |
+ |
|
30 |
+ |
if (dnew) { |
31 |
+ |
dnew->dtype = DTdouble; |
32 |
+ |
dnew->nrows = nr; |
33 |
+ |
dnew->ncols = nc; |
34 |
+ |
dnew->ncomp = n; |
35 |
+ |
} |
36 |
+ |
return(dnew); |
37 |
+ |
} |
38 |
+ |
|
39 |
+ |
/* Prepare a RMATRIX for writing (allocate array if needed) */ |
40 |
+ |
int |
41 |
+ |
rmx_prepare(RMATRIX *rm) |
42 |
+ |
{ |
43 |
+ |
if (!rm) return(0); |
44 |
+ |
if (rm->mtx) |
45 |
+ |
return(1); |
46 |
+ |
rm->mtx = (double *)malloc(array_size(rm)); |
47 |
+ |
return(rm->mtx != NULL); |
48 |
+ |
} |
49 |
+ |
|
50 |
+ |
/* Call rmx_new() and rmx_prepare() */ |
51 |
+ |
RMATRIX * |
52 |
|
rmx_alloc(int nr, int nc, int n) |
53 |
|
{ |
54 |
< |
RMATRIX *dnew; |
54 |
> |
RMATRIX *dnew = rmx_new(nr, nc, n); |
55 |
|
|
56 |
< |
if ((nr <= 0) | (nc <= 0) | (n <= 0)) |
57 |
< |
return(NULL); |
58 |
< |
dnew = (RMATRIX *)malloc(sizeof(RMATRIX)-sizeof(dnew->mtx) + |
59 |
< |
sizeof(dnew->mtx[0])*n*nr*nc); |
28 |
< |
if (!dnew) |
29 |
< |
return(NULL); |
30 |
< |
dnew->nrows = nr; dnew->ncols = nc; dnew->ncomp = n; |
31 |
< |
dnew->dtype = DTdouble; |
32 |
< |
dnew->swapin = 0; |
33 |
< |
dnew->info = NULL; |
56 |
> |
if (dnew && !rmx_prepare(dnew)) { |
57 |
> |
rmx_free(dnew); |
58 |
> |
dnew = NULL; |
59 |
> |
} |
60 |
|
return(dnew); |
61 |
|
} |
62 |
|
|
67 |
|
if (!rm) return; |
68 |
|
if (rm->info) |
69 |
|
free(rm->info); |
70 |
+ |
#ifdef MAP_FILE |
71 |
+ |
if (rm->mapped) |
72 |
+ |
munmap(rm->mapped, mapped_size(rm)); |
73 |
+ |
else |
74 |
+ |
#endif |
75 |
+ |
free(rm->mtx); |
76 |
|
free(rm); |
77 |
|
} |
78 |
|
|
93 |
|
int |
94 |
|
rmx_addinfo(RMATRIX *rm, const char *info) |
95 |
|
{ |
96 |
+ |
int oldlen = 0; |
97 |
+ |
|
98 |
|
if (!rm || !info || !*info) |
99 |
|
return(0); |
100 |
|
if (!rm->info) { |
101 |
|
rm->info = (char *)malloc(strlen(info)+1); |
102 |
|
if (rm->info) rm->info[0] = '\0'; |
103 |
< |
} else |
103 |
> |
} else { |
104 |
> |
oldlen = strlen(rm->info); |
105 |
|
rm->info = (char *)realloc(rm->info, |
106 |
< |
strlen(rm->info)+strlen(info)+1); |
106 |
> |
oldlen+strlen(info)+1); |
107 |
> |
} |
108 |
|
if (!rm->info) |
109 |
|
return(0); |
110 |
< |
strcat(rm->info, info); |
110 |
> |
strcpy(rm->info+oldlen, info); |
111 |
|
return(1); |
112 |
|
} |
113 |
|
|
138 |
|
} |
139 |
|
if (isexpos(s)) { |
140 |
|
double d = exposval(s); |
141 |
< |
scalecolor(ip->mtx, d); |
141 |
> |
scalecolor(ip->cexp, d); |
142 |
|
return(0); |
143 |
|
} |
144 |
|
if (iscolcor(s)) { |
145 |
|
COLOR ctmp; |
146 |
|
colcorval(ctmp, s); |
147 |
< |
multcolor(ip->mtx, ctmp); |
147 |
> |
multcolor(ip->cexp, ctmp); |
148 |
|
return(0); |
149 |
|
} |
150 |
|
if (!formatval(fmt, s)) { |
151 |
|
rmx_addinfo(ip, s); |
152 |
|
return(0); |
153 |
< |
} |
153 |
> |
} /* else check format */ |
154 |
|
for (i = 1; i < DTend; i++) |
155 |
|
if (!strcmp(fmt, cm_fmt_id[i])) { |
156 |
|
ip->dtype = i; |
164 |
|
{ |
165 |
|
int i, j, k; |
166 |
|
|
167 |
+ |
if (!rmx_prepare(rm)) |
168 |
+ |
return(0); |
169 |
|
for (i = 0; i < rm->nrows; i++) |
170 |
|
for (j = 0; j < rm->ncols; j++) |
171 |
|
for (k = 0; k < rm->ncomp; k++) |
184 |
|
fputs("Unsupported # components in rmx_load_float()\n", stderr); |
185 |
|
exit(1); |
186 |
|
} |
187 |
+ |
if (!rmx_prepare(rm)) |
188 |
+ |
return(0); |
189 |
|
for (i = 0; i < rm->nrows; i++) |
190 |
|
for (j = 0; j < rm->ncols; j++) { |
191 |
|
if (getbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp) |
202 |
|
rmx_load_double(RMATRIX *rm, FILE *fp) |
203 |
|
{ |
204 |
|
int i; |
205 |
< |
|
206 |
< |
if ((char *)&rmx_lval(rm,1,0,0) - (char *)&rmx_lval(rm,0,0,0) != |
207 |
< |
sizeof(double)*rm->ncols*rm->ncomp) { |
208 |
< |
fputs("Code error in rmx_load_double()\n", stderr); |
209 |
< |
exit(1); |
205 |
> |
#ifdef MAP_FILE |
206 |
> |
long pos; /* map memory to file if possible */ |
207 |
> |
if (!rm->swapin && (pos = ftell(fp)) >= 0 && !(pos % sizeof(double))) { |
208 |
> |
rm->mapped = mmap(NULL, array_size(rm)+pos, PROT_READ|PROT_WRITE, |
209 |
> |
MAP_PRIVATE, fileno(fp), 0); |
210 |
> |
if (rm->mapped != MAP_FAILED) { |
211 |
> |
rm->mtx = (double *)rm->mapped + pos/sizeof(double); |
212 |
> |
return(1); |
213 |
> |
} |
214 |
> |
rm->mapped = NULL; |
215 |
|
} |
216 |
+ |
#endif |
217 |
+ |
if (!rmx_prepare(rm)) |
218 |
+ |
return(0); |
219 |
|
for (i = 0; i < rm->nrows; i++) { |
220 |
|
if (getbinary(&rmx_lval(rm,i,0,0), sizeof(double)*rm->ncomp, |
221 |
|
rm->ncols, fp) != rm->ncols) |
234 |
|
|
235 |
|
if (!scan) |
236 |
|
return(0); |
237 |
+ |
if (!rmx_prepare(rm)) |
238 |
+ |
return(0); |
239 |
|
for (i = 0; i < rm->nrows; i++) { |
240 |
|
if (freadscan(scan, rm->ncols, fp) < 0) { |
241 |
|
free(scan); |
256 |
|
rmx_load(const char *inspec, RMPref rmp) |
257 |
|
{ |
258 |
|
FILE *fp; |
209 |
– |
RMATRIX dinfo; |
259 |
|
RMATRIX *dnew; |
260 |
|
|
261 |
|
if (!inspec) |
291 |
|
#ifdef getc_unlocked |
292 |
|
flockfile(fp); |
293 |
|
#endif |
294 |
< |
dinfo.nrows = dinfo.ncols = dinfo.ncomp = 0; |
246 |
< |
dinfo.dtype = DTascii; /* assumed w/o FORMAT */ |
247 |
< |
dinfo.swapin = 0; |
248 |
< |
dinfo.info = NULL; |
249 |
< |
dinfo.mtx[0] = dinfo.mtx[1] = dinfo.mtx[2] = 1.; |
250 |
< |
if (getheader(fp, get_dminfo, &dinfo) < 0) { |
294 |
> |
if (!(dnew = rmx_new(0,0,3))) { |
295 |
|
fclose(fp); |
296 |
|
return(NULL); |
297 |
|
} |
298 |
< |
if ((dinfo.nrows <= 0) | (dinfo.ncols <= 0)) { |
299 |
< |
if (!fscnresolu(&dinfo.ncols, &dinfo.nrows, fp)) { |
298 |
> |
dnew->dtype = DTascii; /* assumed w/o FORMAT */ |
299 |
> |
dnew->cexp[0] = dnew->cexp[1] = dnew->cexp[2] = 1.f; |
300 |
> |
if (getheader(fp, get_dminfo, dnew) < 0) { |
301 |
> |
fclose(fp); |
302 |
> |
return(NULL); |
303 |
> |
} |
304 |
> |
if ((dnew->nrows <= 0) | (dnew->ncols <= 0)) { |
305 |
> |
if (!fscnresolu(&dnew->ncols, &dnew->nrows, fp)) { |
306 |
|
fclose(fp); |
307 |
|
return(NULL); |
308 |
|
} |
309 |
< |
if (dinfo.ncomp <= 0) |
310 |
< |
dinfo.ncomp = 3; |
261 |
< |
else if ((dinfo.dtype == DTrgbe) | (dinfo.dtype == DTxyze) && |
262 |
< |
dinfo.ncomp != 3) { |
309 |
> |
if ((dnew->dtype == DTrgbe) | (dnew->dtype == DTxyze) && |
310 |
> |
dnew->ncomp != 3) { |
311 |
|
fclose(fp); |
312 |
|
return(NULL); |
313 |
|
} |
314 |
|
} |
315 |
< |
dnew = rmx_alloc(dinfo.nrows, dinfo.ncols, dinfo.ncomp); |
268 |
< |
if (!dnew) { |
269 |
< |
fclose(fp); |
270 |
< |
return(NULL); |
271 |
< |
} |
272 |
< |
dnew->info = dinfo.info; |
273 |
< |
switch (dinfo.dtype) { |
315 |
> |
switch (dnew->dtype) { |
316 |
|
case DTascii: |
317 |
|
SET_FILE_TEXT(fp); |
318 |
|
if (!rmx_load_ascii(dnew, fp)) |
320 |
|
dnew->dtype = DTascii; /* should leave double? */ |
321 |
|
break; |
322 |
|
case DTfloat: |
281 |
– |
dnew->swapin = dinfo.swapin; |
323 |
|
if (!rmx_load_float(dnew, fp)) |
324 |
|
goto loaderr; |
325 |
|
dnew->dtype = DTfloat; |
326 |
|
break; |
327 |
|
case DTdouble: |
287 |
– |
dnew->swapin = dinfo.swapin; |
328 |
|
if (!rmx_load_double(dnew, fp)) |
329 |
|
goto loaderr; |
330 |
|
dnew->dtype = DTdouble; |
333 |
|
case DTxyze: |
334 |
|
if (!rmx_load_rgbe(dnew, fp)) |
335 |
|
goto loaderr; |
336 |
< |
dnew->dtype = dinfo.dtype; /* undo exposure? */ |
337 |
< |
if ((dinfo.mtx[0] != 1.) | (dinfo.mtx[1] != 1.) | |
338 |
< |
(dinfo.mtx[2] != 1.)) { |
339 |
< |
dinfo.mtx[0] = 1./dinfo.mtx[0]; |
340 |
< |
dinfo.mtx[1] = 1./dinfo.mtx[1]; |
341 |
< |
dinfo.mtx[2] = 1./dinfo.mtx[2]; |
342 |
< |
rmx_scale(dnew, dinfo.mtx); |
336 |
> |
/* undo exposure? */ |
337 |
> |
if ((dnew->cexp[0] != 1.f) | (dnew->cexp[1] != 1.f) | |
338 |
> |
(dnew->cexp[2] != 1.f)) { |
339 |
> |
double cmlt[3]; |
340 |
> |
cmlt[0] = 1./dnew->cexp[0]; |
341 |
> |
cmlt[1] = 1./dnew->cexp[1]; |
342 |
> |
cmlt[2] = 1./dnew->cexp[2]; |
343 |
> |
rmx_scale(dnew, cmlt); |
344 |
|
} |
345 |
+ |
dnew->swapin = 0; |
346 |
|
break; |
347 |
|
default: |
348 |
|
goto loaderr; |
440 |
|
return(1); |
441 |
|
} |
442 |
|
|
443 |
+ |
/* Check if CIE XYZ primaries were specified */ |
444 |
+ |
static int |
445 |
+ |
findCIEprims(const char *info) |
446 |
+ |
{ |
447 |
+ |
RGBPRIMS prims; |
448 |
+ |
|
449 |
+ |
if (!info) |
450 |
+ |
return(0); |
451 |
+ |
info = strstr(info, PRIMARYSTR); |
452 |
+ |
if (!info || !primsval(prims, info)) |
453 |
+ |
return(0); |
454 |
+ |
|
455 |
+ |
return((prims[RED][CIEX] > .99) & (prims[RED][CIEY] < .01) && |
456 |
+ |
(prims[GRN][CIEX] < .01) & (prims[GRN][CIEY] > .99) && |
457 |
+ |
(prims[BLU][CIEX] < .01) & (prims[BLU][CIEY] < .01)); |
458 |
+ |
} |
459 |
+ |
|
460 |
|
/* Write matrix to file type indicated by dtype */ |
461 |
|
int |
462 |
|
rmx_write(const RMATRIX *rm, int dtype, FILE *fp) |
474 |
|
fputs(rm->info, fp); |
475 |
|
if (dtype == DTfromHeader) |
476 |
|
dtype = rm->dtype; |
477 |
< |
else if ((dtype == DTrgbe) & (rm->dtype == DTxyze)) |
477 |
> |
else if (dtype == DTrgbe && (rm->dtype == DTxyze || |
478 |
> |
findCIEprims(rm->info))) |
479 |
|
dtype = DTxyze; |
480 |
|
else if ((dtype == DTxyze) & (rm->dtype == DTrgbe)) |
481 |
|
dtype = DTrgbe; |
495 |
|
} |
496 |
|
if ((dtype == DTfloat) | (dtype == DTdouble)) |
497 |
|
fputendian(fp); /* important to record */ |
498 |
< |
fputformat((char *)cm_fmt_id[dtype], fp); |
498 |
> |
fputformat(cm_fmt_id[dtype], fp); |
499 |
|
fputc('\n', fp); |
500 |
|
switch (dtype) { /* write data */ |
501 |
|
case DTascii: |