summaryrefslogtreecommitdiff
path: root/.pc/04_CVE-2012-4405.diff/icc/icc.c
diff options
context:
space:
mode:
Diffstat (limited to '.pc/04_CVE-2012-4405.diff/icc/icc.c')
-rw-r--r--.pc/04_CVE-2012-4405.diff/icc/icc.c17833
1 files changed, 17833 insertions, 0 deletions
diff --git a/.pc/04_CVE-2012-4405.diff/icc/icc.c b/.pc/04_CVE-2012-4405.diff/icc/icc.c
new file mode 100644
index 0000000..68668d0
--- /dev/null
+++ b/.pc/04_CVE-2012-4405.diff/icc/icc.c
@@ -0,0 +1,17833 @@
+
+/*
+ * International Color Consortium Format Library (icclib)
+ * For ICC profile version 3.4
+ *
+ * Author: Graeme W. Gill
+ * Date: 2002/04/22
+ * Version: 2.15
+ *
+ * Copyright 1997 - 2012 Graeme W. Gill
+ *
+ * This material is licensed with an "MIT" free use license:-
+ * see the License.txt file in this directory for licensing details.
+ */
+
+/*
+ * TTBD:
+ *
+ * Add a "warning mode" to file reading, in which file format
+ * errors are ignored where possible, rather than generating
+ * a fatal error (see ICM_STRICT #define).
+ *
+ * NameColor Dump doesn't handle device space correctly -
+ * should use appropriate interpretation in case device is Lab etc.
+ *
+ * Should recognise & honour unicode 0xFFFE endian marker.
+ * Should generate it on writing too ?
+ *
+ * Add support for copying tags from one icc to another.
+ *
+ * Should fix all write_number failure errors to indicate failed value.
+ * (Partially implemented - need to check all write_number functions)
+ *
+ * Make write fail error messages be specific on which element failed.
+ *
+ * Should add named color space lookup function support.
+ *
+ * Would be nice to add generic ability to add new tag type handling,
+ * so that the base library doesn't need to be modified (ie. VideoCardGamma) ?
+ *
+ * Need to add DeviceSettings and OutputResponse tags to bring up to
+ * ICC.1:1998-09 [started but not complete]
+ *
+ */
+
+#undef ICM_STRICT /* Not fully implimented - switch off strict checking of file format */
+
+/* Make the default grid points of the Lab clut be symetrical about */
+/* a/b 0.0, and also make L = 100.0 fall on a grid point. */
+#define SYMETRICAL_DEFAULT_LAB_RANGE
+
+#define _ICC_C_ /* Turn on implimentation code */
+
+#undef DEBUG_SETLUT /* Show each value being set in setting lut contents */
+#undef DEBUG_SETLUT_CLIP /* Show clipped values when setting LUT */
+#undef DEBUG_LULUT /* Show each value being looked up from lut contents */
+#undef DEBUG_LLULUT /* Debug individual lookup steps (not fully implemented) */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <string.h>
+#include <ctype.h>
+#include <math.h>
+#include <time.h>
+#ifdef __sun
+#include <unistd.h>
+#endif
+#if defined(__IBMC__) && defined(_M_IX86)
+#include <float.h>
+#endif
+#include "icc.h"
+
+#ifdef _MSC_VER
+#define vsnprintf _vsnprintf
+#define snprintf _snprintf
+#endif
+
+/* ========================================================== */
+/* Default system interface object implementations */
+
+#ifndef SEPARATE_STD
+#define COMBINED_STD
+
+#include "iccstd.c"
+
+#undef COMBINED_STD
+#endif /* SEPARATE_STD */
+
+/* Forced byte alignment for tag table and tags */
+#define ALIGN_SIZE 4
+
+/* =========================================================== */
+
+#ifdef DEBUG_SETLUT
+#undef DBGSL
+#define DBGSL(xxx) printf xxx ;
+#else
+#undef DBGSL
+#define DBGSL(xxx)
+#endif
+
+#if defined(DEBUG_SETLUT) || defined(DEBUG_SETLUT_CLIP)
+#undef DBGSLC
+#define DBGSLC(xxx) printf xxx ;
+#else
+#undef DBGSLC
+#define DBGSLC(xxx)
+#endif
+
+#ifdef DEBUG_LULUT
+#undef DBGLL
+#define DBGLL(xxx) printf xxx ;
+#else
+#undef DBGLL
+#define DBGLL(xxx)
+#endif
+
+#ifdef DEBUG_LLULUT
+#undef DBLLL
+#define DBLLL(xxx) printf xxx ;
+#else
+#undef DBLLL
+#define DBLLL(xxx)
+#endif
+
+/* =========================================================== */
+/* Overflow protected unsigned int arithmatic functions. */
+/* These functions saturate rather than wrapping around. */
+/* (Divide doesn't need protection) */
+/* They return UINT_MAX if there was an overflow */
+
+/* a + b */
+static unsigned int sat_add(unsigned int a, unsigned int b) {
+ if (b > (UINT_MAX - a))
+ return UINT_MAX;
+ return a + b;
+}
+
+/* a - b */
+static unsigned int sat_sub(unsigned int a, unsigned int b) {
+ if (a < b)
+ return UINT_MAX;
+ return a - b;
+}
+
+/* a * b */
+static unsigned int sat_mul(unsigned int a, unsigned int b) {
+ unsigned int c;
+
+ if (a == 0 || b == 0)
+ return 0;
+
+ if (a > (UINT_MAX/b))
+ return UINT_MAX;
+ else
+ return a * b;
+}
+
+/* A + B + C */
+#define sat_addadd(A, B, C) sat_add(A, sat_add(B, C))
+
+/* A + B * C */
+#define sat_addmul(A, B, C) sat_add(A, sat_mul(B, C))
+
+/* A + B + C * D */
+#define sat_addaddmul(A, B, C, D) sat_add(A, sat_add(B, sat_mul(C, D)))
+
+/* A * B * C */
+#define sat_mul3(A, B, C) sat_mul(A, sat_mul(B, C))
+
+/* a ^ b */
+static unsigned int sat_pow(unsigned int a, unsigned int b) {
+ unsigned int c = 1;
+ for (; b > 0; b--) {
+ c = sat_mul(c, a);
+ if (c == UINT_MAX)
+ break;
+ }
+ return c;
+}
+
+/* Alignment */
+static unsigned int sat_align(unsigned int align_size, unsigned int a) {
+ align_size--;
+
+ if (align_size > (UINT_MAX - a))
+ return UINT_MAX;
+
+ return (a + align_size) & ~align_size;
+}
+
+/* These test functions detect whether an overflow would occur */
+
+/* Return nz if add would overflow */
+static int ovr_add(unsigned int a, unsigned int b) {
+
+ if (b > (UINT_MAX - a))
+ return 1;
+ return 0;
+}
+
+/* Return nz if sub would overflow */
+static int ovr_sub(unsigned int a, unsigned int b) {
+ if (a < b)
+ return 1;
+ return 0;
+}
+
+/* Return nz if mult would overflow */
+static int ovr_mul(unsigned int a, unsigned int b) {
+ if (a > (UINT_MAX/b))
+ return 1;
+ return 0;
+}
+
+
+/* size_t versions of saturating arithmatic */
+
+#ifndef SIZE_MAX
+# define SIZE_MAX ((size_t)(-1))
+#endif
+
+/* a + b */
+static size_t ssat_add(size_t a, size_t b) {
+ if (b > (SIZE_MAX - a))
+ return SIZE_MAX;
+ return a + b;
+}
+
+/* a - b */
+static size_t ssat_sub(size_t a, size_t b) {
+ if (a < b)
+ return SIZE_MAX;
+ return a - b;
+}
+
+/* a * b */
+static size_t ssat_mul(size_t a, size_t b) {
+ size_t c;
+
+ if (a == 0 || b == 0)
+ return 0;
+
+ if (a > (SIZE_MAX/b))
+ return SIZE_MAX;
+ else
+ return a * b;
+}
+
+/* ------------------------------------------------- */
+/* Memory image icmFile compatible class */
+/* Buffer is assumed to have been allocated by the given allocator, */
+/* and will be expanded on write. */
+
+/* Get the size of the file */
+static size_t icmFileMem_get_size(icmFile *pp) {
+ icmFileMem *p = (icmFileMem *)pp;
+
+ return p->end - p->start;
+}
+
+/* Set current position to offset. Return 0 on success, nz on failure. */
+static int icmFileMem_seek(
+icmFile *pp,
+unsigned int offset
+) {
+ icmFileMem *p = (icmFileMem *)pp;
+ unsigned char *np;
+
+ np = p->start + offset;
+ if (np < p->start || np >= p->end)
+ return 1;
+ p->cur = np;
+ return 0;
+}
+
+/* Read count items of size length. Return number of items successfully read. */
+static size_t icmFileMem_read(
+icmFile *pp,
+void *buffer,
+size_t size,
+size_t count
+) {
+ icmFileMem *p = (icmFileMem *)pp;
+ size_t len;
+
+ len = ssat_mul(size, count);
+ if (len > (p->end - p->cur)) { /* Too much */
+ if (size > 0)
+ count = (p->end - p->cur)/size;
+ else
+ count = 0;
+ }
+ len = size * count;
+ if (len > 0)
+ memmove(buffer, p->cur, len);
+ p->cur += len;
+ return count;
+}
+
+/* Expand the memory buffer file to hold up to pointer ep */
+/* Don't expand if realloc fails */
+static void icmFileMem_filemem_resize(icmFileMem *p, unsigned char *ep) {
+ size_t na, co, ce;
+ unsigned char *nstart;
+
+ /* No need to realloc */
+ if (ep <= p->aend) {
+ return;
+ }
+
+ co = p->cur - p->start; /* Current offset */
+ ce = p->end - p->start; /* Current end */
+ na = ep - p->start; /* new allocated size */
+
+ /* Round new allocation up */
+ if (na <= 1024)
+ na += 1024;
+ else
+ na += 4096;
+
+ if ((nstart = p->al->realloc(p->al, p->start, na)) != NULL) {
+ p->start = nstart;
+ p->cur = nstart + co;
+ p->end = nstart + ce;
+ p->aend = nstart + na;
+ }
+}
+
+/* write count items of size length. Return number of items successfully written. */
+static size_t icmFileMem_write(
+icmFile *pp,
+void *buffer,
+size_t size,
+size_t count
+) {
+ icmFileMem *p = (icmFileMem *)pp;
+ size_t len;
+
+ len = ssat_mul(size, count);
+ if (len > (size_t)(p->aend - p->cur)) /* Try and expand buffer */
+ icmFileMem_filemem_resize(p, p->start + len);
+
+ if (len > (size_t)(p->aend - p->cur)) {
+ if (size > 0)
+ count = (p->aend - p->cur)/size;
+ else
+ count = 0;
+ }
+ len = size * count;
+ if (len > 0)
+ memmove(p->cur, buffer, len);
+ p->cur += len;
+ if (p->end < p->cur)
+ p->end = p->cur;
+ return count;
+}
+
+/* do a printf */
+static int icmFileMem_printf(
+icmFile *pp,
+const char *format,
+...
+) {
+ int rv;
+ va_list args;
+ icmFileMem *p = (icmFileMem *)pp;
+ int len;
+
+ va_start(args, format);
+
+ rv = 1;
+ len = 100; /* Initial allocation for printf */
+ icmFileMem_filemem_resize(p, p->cur + len);
+
+ /* We have to use the available printf functions to resize the buffer if needed. */
+ for (;rv != 0;) {
+ /* vsnprintf() either returns -1 if it doesn't fit, or */
+ /* returns the size-1 needed in order to fit. */
+ len = vsnprintf((char *)p->cur, (p->aend - p->cur), format, args);
+
+ if (len > -1 && ((p->cur + len +1) <= p->aend)) /* Fitted in current allocation */
+ break;
+
+ if (len > -1) /* vsnprintf returned needed size-1 */
+ len = len+2; /* (In case vsnprintf returned 1 less than it needs) */
+ else
+ len *= 2; /* We just have to guess */
+
+ /* Attempt to resize */
+ icmFileMem_filemem_resize(p, p->cur + len);
+
+ /* If resize failed */
+ if ((p->aend - p->cur) < len) {
+ rv = 0;
+ break;
+ }
+ }
+ if (rv != 0) {
+ /* Figure out where end of printf is */
+ len = strlen((char *)p->cur); /* Length excluding nul */
+ p->cur += len;
+ if (p->cur > p->end)
+ p->end = p->cur;
+ rv = len;
+ }
+ va_end(args);
+ return rv;
+}
+
+/* flush all write data out to secondary storage. Return nz on failure. */
+static int icmFileMem_flush(
+icmFile *pp
+) {
+ return 0;
+}
+
+/* Return the memory buffer. Error if not icmFileMem */
+static int icmFileMem_get_buf(
+icmFile *pp,
+unsigned char **buf,
+size_t *len
+) {
+ icmFileMem *p = (icmFileMem *)pp;
+ if (buf != NULL)
+ *buf = p->start;
+ if (len != NULL)
+ *len = p->end - p->start;
+ return 0;
+}
+
+/* we're done with the file object, return nz on failure */
+static int icmFileMem_delete(
+icmFile *pp
+) {
+ icmFileMem *p = (icmFileMem *)pp;
+ icmAlloc *al = p->al;
+ int del_al = p->del_al;
+
+ if (p->del_buf) /* Free the memory buffer */
+ al->free(al, p->start);
+ al->free(al, p); /* Free object */
+ if (del_al) /* We are responsible for deleting allocator */
+ al->del(al);
+ return 0;
+}
+
+/* Create a memory image file access class with allocator */
+/* Buffer is used as is. */
+icmFile *new_icmFileMem_a(
+void *base, /* Pointer to base of memory buffer */
+size_t length, /* Number of bytes in buffer */
+icmAlloc *al /* heap allocator */
+) {
+ icmFileMem *p;
+
+ if ((p = (icmFileMem *) al->calloc(al, 1, sizeof(icmFileMem))) == NULL) {
+ return NULL;
+ }
+ p->al = al; /* Heap allocator */
+ p->get_size = icmFileMem_get_size;
+ p->seek = icmFileMem_seek;
+ p->read = icmFileMem_read;
+ p->write = icmFileMem_write;
+ p->gprintf = icmFileMem_printf;
+ p->flush = icmFileMem_flush;
+ p->get_buf = icmFileMem_get_buf;
+ p->del = icmFileMem_delete;
+
+ p->start = (unsigned char *)base;
+ p->cur = p->start;
+ p->aend = p->end = p->start + length;
+
+ return (icmFile *)p;
+}
+
+/* Create a memory image file access class with given allocator */
+/* and delete base when icmFile is deleted. */
+icmFile *new_icmFileMem_ad(void *base, size_t length, icmAlloc *al) {
+ icmFile *fp;
+
+ if ((fp = new_icmFileMem_a(base, length, al)) != NULL) {
+ ((icmFileMem *)fp)->del_buf = 1;
+ }
+
+ return fp;
+}
+
+/* ========================================================== */
+/* Conversion support functions */
+/* Convert between ICC storage types and native C types */
+/* Write routine return non-zero if numbers can't be represented */
+
+/* Unsigned */
+static unsigned int read_UInt8Number(char *p) {
+ unsigned int rv;
+ rv = (unsigned int)((ORD8 *)p)[0];
+ return rv;
+}
+
+static int write_UInt8Number(unsigned int d, char *p) {
+ if (d > 255)
+ return 1;
+ ((ORD8 *)p)[0] = (ORD8)d;
+ return 0;
+}
+
+static unsigned int read_UInt16Number(char *p) {
+ unsigned int rv;
+ rv = 256 * (unsigned int)((ORD8 *)p)[0]
+ + (unsigned int)((ORD8 *)p)[1];
+ return rv;
+}
+
+static int write_UInt16Number(unsigned int d, char *p) {
+ if (d > 65535)
+ return 1;
+ ((ORD8 *)p)[0] = (ORD8)(d >> 8);
+ ((ORD8 *)p)[1] = (ORD8)(d);
+ return 0;
+}
+
+static unsigned int read_UInt32Number(char *p) {
+ unsigned int rv;
+ rv = 16777216 * (unsigned int)((ORD8 *)p)[0]
+ + 65536 * (unsigned int)((ORD8 *)p)[1]
+ + 256 * (unsigned int)((ORD8 *)p)[2]
+ + (unsigned int)((ORD8 *)p)[3];
+ return rv;
+}
+
+static int write_UInt32Number(unsigned int d, char *p) {
+ ((ORD8 *)p)[0] = (ORD8)(d >> 24);
+ ((ORD8 *)p)[1] = (ORD8)(d >> 16);
+ ((ORD8 *)p)[2] = (ORD8)(d >> 8);
+ ((ORD8 *)p)[3] = (ORD8)(d);
+ return 0;
+}
+
+static void read_UInt64Number(icmUint64 *d, char *p) {
+ d->h = 16777216 * (unsigned int)((ORD8 *)p)[0]
+ + 65536 * (unsigned int)((ORD8 *)p)[1]
+ + 256 * (unsigned int)((ORD8 *)p)[2]
+ + (unsigned int)((ORD8 *)p)[3];
+ d->l = 16777216 * (unsigned int)((ORD8 *)p)[4]
+ + 65536 * (unsigned int)((ORD8 *)p)[5]
+ + 256 * (unsigned int)((ORD8 *)p)[6]
+ + (unsigned int)((ORD8 *)p)[7];
+}
+
+static int write_UInt64Number(icmUint64 *d, char *p) {
+ ((ORD8 *)p)[0] = (ORD8)(d->h >> 24);
+ ((ORD8 *)p)[1] = (ORD8)(d->h >> 16);
+ ((ORD8 *)p)[2] = (ORD8)(d->h >> 8);
+ ((ORD8 *)p)[3] = (ORD8)(d->h);
+ ((ORD8 *)p)[4] = (ORD8)(d->l >> 24);
+ ((ORD8 *)p)[5] = (ORD8)(d->l >> 16);
+ ((ORD8 *)p)[6] = (ORD8)(d->l >> 8);
+ ((ORD8 *)p)[7] = (ORD8)(d->l);
+ return 0;
+}
+
+static double read_U8Fixed8Number(char *p) {
+ ORD32 o32;
+ o32 = 256 * (ORD32)((ORD8 *)p)[0] /* Read big endian 16 bit unsigned */
+ + (ORD32)((ORD8 *)p)[1];
+ return (double)o32/256.0;
+}
+
+static int write_U8Fixed8Number(double d, char *p) {
+ ORD32 o32;
+ d = d * 256.0 + 0.5;
+ if (d >= 65536.0)
+ return 1;
+ if (d < 0.0)
+ return 1;
+ o32 = (ORD32)d;
+ ((ORD8 *)p)[0] = (ORD8)((o32) >> 8);
+ ((ORD8 *)p)[1] = (ORD8)((o32));
+ return 0;
+}
+
+static double read_U16Fixed16Number(char *p) {
+ ORD32 o32;
+ o32 = 16777216 * (ORD32)((ORD8 *)p)[0] /* Read big endian 32 bit unsigned */
+ + 65536 * (ORD32)((ORD8 *)p)[1]
+ + 256 * (ORD32)((ORD8 *)p)[2]
+ + (ORD32)((ORD8 *)p)[3];
+ return (double)o32/65536.0;
+}
+
+static int write_U16Fixed16Number(double d, char *p) {
+ ORD32 o32;
+ d = d * 65536.0 + 0.5;
+ if (d >= 4294967296.0)
+ return 1;
+ if (d < 0.0)
+ return 1;
+ o32 = (ORD32)d;
+ ((ORD8 *)p)[0] = (ORD8)((o32) >> 24);
+ ((ORD8 *)p)[1] = (ORD8)((o32) >> 16);
+ ((ORD8 *)p)[2] = (ORD8)((o32) >> 8);
+ ((ORD8 *)p)[3] = (ORD8)((o32));
+ return 0;
+}
+
+
+/* Signed numbers */
+static int read_SInt8Number(char *p) {
+ int rv;
+ rv = (int)((INR8 *)p)[0];
+ return rv;
+}
+
+static int write_SInt8Number(int d, char *p) {
+ if (d > 127)
+ return 1;
+ else if (d < -128)
+ return 1;
+ ((INR8 *)p)[0] = (INR8)d;
+ return 0;
+}
+
+static int read_SInt16Number(char *p) {
+ int rv;
+ rv = 256 * (int)((INR8 *)p)[0]
+ + (int)((ORD8 *)p)[1];
+ return rv;
+}
+
+static int write_SInt16Number(int d, char *p) {
+ if (d > 32767)
+ return 1;
+ else if (d < -32768)
+ return 1;
+ ((INR8 *)p)[0] = (INR8)(d >> 8);
+ ((ORD8 *)p)[1] = (ORD8)(d);
+ return 0;
+}
+
+static int read_SInt32Number(char *p) {
+ int rv;
+ rv = 16777216 * (int)((INR8 *)p)[0]
+ + 65536 * (int)((ORD8 *)p)[1]
+ + 256 * (int)((ORD8 *)p)[2]
+ + (int)((ORD8 *)p)[3];
+ return rv;
+}
+
+static int write_SInt32Number(int d, char *p) {
+ ((INR8 *)p)[0] = (INR8)(d >> 24);
+ ((ORD8 *)p)[1] = (ORD8)(d >> 16);
+ ((ORD8 *)p)[2] = (ORD8)(d >> 8);
+ ((ORD8 *)p)[3] = (ORD8)(d);
+ return 0;
+}
+
+static void read_SInt64Number(icmInt64 *d, char *p) {
+ d->h = 16777216 * (int)((INR8 *)p)[0]
+ + 65536 * (int)((ORD8 *)p)[1]
+ + 256 * (int)((ORD8 *)p)[2]
+ + (int)((ORD8 *)p)[3];
+ d->l = 16777216 * (unsigned int)((ORD8 *)p)[4]
+ + 65536 * (unsigned int)((ORD8 *)p)[5]
+ + 256 * (unsigned int)((ORD8 *)p)[6]
+ + (unsigned int)((ORD8 *)p)[7];
+}
+
+static int write_SInt64Number(icmInt64 *d, char *p) {
+ ((INR8 *)p)[0] = (INR8)(d->h >> 24);
+ ((ORD8 *)p)[1] = (ORD8)(d->h >> 16);
+ ((ORD8 *)p)[2] = (ORD8)(d->h >> 8);
+ ((ORD8 *)p)[3] = (ORD8)(d->h);
+ ((ORD8 *)p)[4] = (ORD8)(d->l >> 24);
+ ((ORD8 *)p)[5] = (ORD8)(d->l >> 16);
+ ((ORD8 *)p)[6] = (ORD8)(d->l >> 8);
+ ((ORD8 *)p)[7] = (ORD8)(d->l);
+ return 0;
+}
+
+static double read_S15Fixed16Number(char *p) {
+ INR32 i32;
+ i32 = 16777216 * (INR32)((INR8 *)p)[0] /* Read big endian 32 bit signed */
+ + 65536 * (INR32)((ORD8 *)p)[1]
+ + 256 * (INR32)((ORD8 *)p)[2]
+ + (INR32)((ORD8 *)p)[3];
+ return (double)i32/65536.0;
+}
+
+static int write_S15Fixed16Number(double d, char *p) {
+ INR32 i32;
+ d = floor(d * 65536.0 + 0.5); /* Beware! (int)(d + 0.5) doesn't work! */
+ if (d >= 2147483648.0)
+ return 1;
+ if (d < -2147483648.0)
+ return 1;
+ i32 = (INR32)d;
+ ((INR8 *)p)[0] = (INR8)((i32) >> 24); /* Write big endian 32 bit signed */
+ ((ORD8 *)p)[1] = (ORD8)((i32) >> 16);
+ ((ORD8 *)p)[2] = (ORD8)((i32) >> 8);
+ ((ORD8 *)p)[3] = (ORD8)((i32));
+ return 0;
+}
+
+/* Device coordinate as 8 bit value range 0.0 - 1.0 */
+static double read_DCS8Number(char *p) {
+ unsigned int rv;
+ rv = (unsigned int)((ORD8 *)p)[0];
+ return (double)rv/255.0;
+}
+
+static int write_DCS8Number(double d, char *p) {
+ ORD32 o32;
+ d = d * 255.0 + 0.5;
+ if (d >= 256.0)
+ return 1;
+ if (d < 0.0)
+ return 1;
+ o32 = (ORD32)d;
+ ((ORD8 *)p)[0] = (ORD8)(o32);
+ return 0;
+}
+
+/* Device coordinate as 16 bit value range 0.0 - 1.0 */
+static double read_DCS16Number(char *p) {
+ unsigned int rv;
+ rv = 256 * (unsigned int)((ORD8 *)p)[0]
+ + (unsigned int)((ORD8 *)p)[1];
+ return (double)rv/65535.0;
+}
+
+static int write_DCS16Number(double d, char *p) {
+ ORD32 o32;
+ d = d * 65535.0 + 0.5;
+ if (d >= 65536.0)
+ return 1;
+ if (d < 0.0)
+ return 1;
+ o32 = (ORD32)d;
+ ((ORD8 *)p)[0] = (ORD8)(o32 >> 8);
+ ((ORD8 *)p)[1] = (ORD8)(o32);
+ return 0;
+}
+
+static void Lut_Lut2XYZ(double *out, double *in);
+static void Lut_XYZ2Lut(double *out, double *in);
+static void Lut_Lut2Lab_8(double *out, double *in);
+static void Lut_Lab2Lut_8(double *out, double *in);
+static void Lut_Lut2LabV2_16(double *out, double *in);
+static void Lut_Lab2LutV2_16(double *out, double *in);
+static void Lut_Lut2LabV4_16(double *out, double *in);
+static void Lut_Lab2LutV4_16(double *out, double *in);
+
+static void Lut_Lut2Y(double *out, double *in);
+static void Lut_Y2Lut(double *out, double *in);
+static void Lut_Lut2L_8(double *out, double *in);
+static void Lut_L2Lut_8(double *out, double *in);
+static void Lut_Lut2LV2_16(double *out, double *in);
+static void Lut_L2LutV2_16(double *out, double *in);
+static void Lut_Lut2LV4_16(double *out, double *in);
+static void Lut_L2LutV4_16(double *out, double *in);
+
+//~~~~888888
+/* read a PCS number. PCS can be profile PCS, profile version Lab, */
+/* or a specific type of Lab, depending on the value of csig: */
+/* icmSigPCSData, icSigXYZData, icmSigLab8Data, icSigLabData, */
+/* icmSigLabV2Data or icmSigLabV4Data */
+/* Do nothing if not one of the above. */
+static void read_PCSNumber(icc *icp, icColorSpaceSignature csig, double pcs[3], char *p) {
+
+ if (csig == icmSigPCSData)
+ csig = icp->header->pcs;
+ if (csig == icSigLabData) {
+ if (icp->ver != 0)
+ csig = icmSigLabV4Data;
+ else
+ csig = icmSigLabV2Data;
+ }
+
+ if (csig == icmSigLab8Data) {
+ pcs[0] = read_DCS8Number(p);
+ pcs[1] = read_DCS8Number(p+1);
+ pcs[2] = read_DCS8Number(p+2);
+ } else {
+ pcs[0] = read_DCS16Number(p);
+ pcs[1] = read_DCS16Number(p+2);
+ pcs[2] = read_DCS16Number(p+4);
+ }
+ switch (csig) {
+ case icSigXYZData:
+ Lut_Lut2XYZ(pcs, pcs);
+ break;
+ case icmSigLab8Data:
+ Lut_Lut2Lab_8(pcs, pcs);
+ break;
+ case icmSigLabV2Data:
+ Lut_Lut2LabV2_16(pcs, pcs);
+ break;
+ case icmSigLabV4Data:
+ Lut_Lut2LabV4_16(pcs, pcs);
+ break;
+ default:
+ break;
+ }
+}
+
+/* write a PCS number. PCS can be profile PCS, profile version Lab, */
+/* or a specific type of Lab, depending on the value of csig: */
+/* icmSigPCSData, icSigXYZData, icmSigLab8Data, icSigLabData, */
+/* icmSigLabV2Data or icmSigLabV4Data */
+/* Return 1 if error */
+static int write_PCSNumber(icc *icp, icColorSpaceSignature csig, double pcs[3], char *p) {
+ double v[3];
+ int j;
+
+ if (csig == icmSigPCSData)
+ csig = icp->header->pcs;
+ if (csig == icSigLabData) {
+ if (icp->ver != 0)
+ csig = icmSigLabV4Data;
+ else
+ csig = icmSigLabV2Data;
+ }
+
+ switch (csig) {
+ case icSigXYZData:
+ Lut_XYZ2Lut(v, pcs);
+ break;
+ case icmSigLab8Data:
+ Lut_Lab2Lut_8(v, pcs);
+ break;
+ case icmSigLabV2Data:
+ Lut_Lab2LutV2_16(v, pcs);
+ break;
+ case icmSigLabV4Data:
+ Lut_Lab2LutV4_16(v, pcs);
+ break;
+ default:
+ return 1;
+ }
+ if (csig == icmSigLab8Data) {
+ for (j = 0; j < 3; j++) {
+ if (write_DCS8Number(v[j], p+j))
+ return 1;
+ }
+ } else {
+ for (j = 0; j < 3; j++) {
+ if (write_DCS16Number(v[j], p+(2 * j)))
+ return 1;
+ }
+ }
+
+ return 0;
+}
+
+/* Read a given primitive type. Return non-zero on error */
+/* (Not currently used internaly ?) */
+/* Public: */
+int read_Primitive(icc *icp, icmPrimType ptype, void *prim, char *p) {
+
+ switch(ptype) {
+ case icmUInt8Number:
+ *((unsigned int *)prim) = read_UInt8Number(p);
+ return 0;
+ case icmUInt16Number:
+ *((unsigned int *)prim) = read_UInt16Number(p);
+ return 0;
+ case icmUInt32Number:
+ *((unsigned int *)prim) = read_UInt32Number(p);
+ return 0;
+ case icmUInt64Number:
+ read_UInt64Number((icmUint64 *)prim, p);
+ return 0;
+ case icmU8Fixed8Number:
+ *((double *)prim) = read_U8Fixed8Number(p);
+ return 0;
+ case icmU16Fixed16Number:
+ *((double *)prim) = read_U16Fixed16Number(p);
+ return 0;
+ case icmSInt8Number:
+ *((int *)prim) = read_SInt8Number(p);
+ return 0;
+ case icmSInt16Number:
+ *((int *)prim) = read_SInt16Number(p);
+ return 0;
+ case icmSInt32Number:
+ *((int *)prim) = read_SInt32Number(p);
+ return 0;
+ case icmSInt64Number:
+ read_SInt64Number((icmInt64 *)prim, p);
+ return 0;
+ case icmS15Fixed16Number:
+ *((double *)prim) = read_S15Fixed16Number(p);
+ return 0;
+ case icmDCS8Number:
+ *((double *)prim) = read_DCS8Number(p);
+ return 0;
+ case icmDCS16Number:
+ *((double *)prim) = read_DCS16Number(p);
+ return 0;
+ case icmPCSNumber:
+ read_PCSNumber(icp, icmSigPCSData, ((double *)prim), p);
+ return 0;
+ case icmPCSXYZNumber:
+ read_PCSNumber(icp, icSigXYZData, ((double *)prim), p);
+ return 0;
+ case icmPCSLab8Number:
+ read_PCSNumber(icp, icmSigLab8Data, ((double *)prim), p);
+ return 0;
+ case icmPCSLabNumber:
+ read_PCSNumber(icp, icSigLabData, ((double *)prim), p);
+ return 0;
+ case icmPCSLabV2Number:
+ read_PCSNumber(icp, icmSigLabV2Data, ((double *)prim), p);
+ return 0;
+ case icmPCSLabV4Number:
+ read_PCSNumber(icp, icmSigLabV4Data, ((double *)prim), p);
+ return 0;
+ }
+
+ return 2;
+}
+
+/* Write a given primitive type. Return non-zero on error */
+/* (Not currently used internaly ?) */
+/* Public: */
+int write_Primitive(icc *icp, icmPrimType ptype, char *p, void *prim) {
+
+ switch(ptype) {
+ case icmUInt8Number:
+ return write_UInt8Number(*((unsigned int *)prim), p);
+ case icmUInt16Number:
+ return write_UInt16Number(*((unsigned int *)prim), p);
+ case icmUInt32Number:
+ return write_UInt32Number(*((unsigned int *)prim), p);
+ case icmUInt64Number:
+ return write_UInt64Number((icmUint64 *)prim, p);
+ case icmU8Fixed8Number:
+ return write_U8Fixed8Number(*((double *)prim), p);
+ case icmU16Fixed16Number:
+ return write_U16Fixed16Number(*((double *)prim), p);
+ case icmSInt8Number:
+ return write_SInt8Number(*((int *)prim), p);
+ case icmSInt16Number:
+ return write_SInt16Number(*((int *)prim), p);
+ case icmSInt32Number:
+ return write_SInt32Number(*((int *)prim), p);
+ case icmSInt64Number:
+ return write_SInt64Number((icmInt64 *)prim, p);
+ case icmS15Fixed16Number:
+ return write_S15Fixed16Number(*((double *)prim), p);
+ case icmDCS8Number:
+ return write_DCS8Number(*((double *)prim), p);
+ case icmDCS16Number:
+ return write_DCS16Number(*((double *)prim), p);
+ case icmPCSNumber:
+ return write_PCSNumber(icp, icmSigPCSData, ((double *)prim), p);
+ case icmPCSXYZNumber:
+ return write_PCSNumber(icp, icSigXYZData, ((double *)prim), p);
+ case icmPCSLab8Number:
+ return write_PCSNumber(icp, icmSigLab8Data, ((double *)prim), p);
+ case icmPCSLabNumber:
+ return write_PCSNumber(icp, icSigLabData, ((double *)prim), p);
+ case icmPCSLabV2Number:
+ return write_PCSNumber(icp, icmSigLabV2Data, ((double *)prim), p);
+ case icmPCSLabV4Number:
+ return write_PCSNumber(icp, icmSigLabV4Data, ((double *)prim), p);
+ }
+
+ return 2;
+}
+
+/* ---------------------------------------------------------- */
+/* Auiliary function - return a string that represents a tag */
+/* Note - returned buffers are static, can only be used 5 */
+/* times before buffers get reused. */
+char *tag2str(
+ int tag
+) {
+ int i;
+ static int si = 0; /* String buffer index */
+ static char buf[5][20]; /* String buffers */
+ char *bp;
+ unsigned char c[4];
+
+ bp = buf[si++];
+ si %= 5; /* Rotate through buffers */
+
+ c[0] = 0xff & (tag >> 24);
+ c[1] = 0xff & (tag >> 16);
+ c[2] = 0xff & (tag >> 8);
+ c[3] = 0xff & (tag >> 0);
+ for (i = 0; i < 4; i++) { /* Can we represent it as a string ? */
+ if (!isprint(c[i]))
+ break;
+ }
+ if (i < 4) { /* Not printable - use hex */
+ sprintf(bp,"0x%x",tag);
+ } else { /* Printable */
+ sprintf(bp,"'%c%c%c%c'",c[0],c[1],c[2],c[3]);
+ }
+ return bp;
+}
+
+/* Auiliary function - return a tag created from a string */
+/* Note there is also the icmMakeTag() macro */
+unsigned int str2tag(
+ const char *str
+) {
+ unsigned int tag;
+ tag = (((unsigned int)str[0]) << 24)
+ + (((unsigned int)str[1]) << 16)
+ + (((unsigned int)str[2]) << 8)
+ + (((unsigned int)str[3]));
+ return tag;
+}
+
+/* helper - return 1 if the string doesn't have a */
+/* null terminator within len, return 0 has null at exactly len, */
+/* and 2 if it has null before len. */
+/* Note: will return 1 if len == 0 */
+static int check_null_string(char *cp, int len) {
+ for (; len > 0; len--) {
+ if (cp[0] == '\000')
+ break;
+ cp++;
+ }
+ if (len == 0)
+ return 1;
+ if (len > 1)
+ return 2;
+ return 0;
+}
+
+/* helper - return 1 if the string doesn't have a */
+/* null terminator within len, return 0 has null at exactly len, */
+/* and 2 if it has null before len. */
+/* Note: will return 1 if len == 0 */
+/* Unicode version */
+static int check_null_string16(char *cp, int len) {
+ for (; len > 0; len--) { /* Length is in characters */
+ if (cp[0] == 0 && cp[1] == 0)
+ break;
+ cp += 2;
+ }
+ if (len == 0)
+ return 1;
+ if (len > 1)
+ return 2;
+ return 0;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Color Space to number of component conversion */
+/* Return 0 on error */
+static unsigned int number_ColorSpaceSignature(icColorSpaceSignature sig) {
+ switch(sig) {
+ case icSigXYZData:
+ return 3;
+ case icSigLabData:
+ return 3;
+ case icSigLuvData:
+ return 3;
+ case icSigYCbCrData:
+ return 3;
+ case icSigYxyData:
+ return 3;
+ case icSigRgbData:
+ return 3;
+ case icSigGrayData:
+ return 1;
+ case icSigHsvData:
+ return 3;
+ case icSigHlsData:
+ return 3;
+ case icSigCmykData:
+ return 4;
+ case icSigCmyData:
+ return 3;
+ case icSig2colorData:
+ return 2;
+ case icSig3colorData:
+ return 3;
+ case icSig4colorData:
+ return 4;
+ case icSig5colorData:
+ case icSigMch5Data:
+ return 5;
+ case icSig6colorData:
+ case icSigMch6Data:
+ return 6;
+ case icSig7colorData:
+ case icSigMch7Data:
+ return 7;
+ case icSig8colorData:
+ case icSigMch8Data:
+ return 8;
+ case icSig9colorData:
+ return 9;
+ case icSig10colorData:
+ return 10;
+ case icSig11colorData:
+ return 11;
+ case icSig12colorData:
+ return 12;
+ case icSig13colorData:
+ return 13;
+ case icSig14colorData:
+ return 14;
+ case icSig15colorData:
+ return 15;
+
+ /* Non-standard and Pseudo spaces */
+ case icmSigYData:
+ return 1;
+ case icmSigLData:
+ return 1;
+ case icmSigL8Data:
+ return 1;
+ case icmSigLV2Data:
+ return 1;
+ case icmSigLV4Data:
+ return 1;
+ case icmSigPCSData:
+ return 3;
+ case icmSigLab8Data:
+ return 3;
+ case icmSigLabV2Data:
+ return 3;
+ case icmSigLabV4Data:
+ return 3;
+
+ default:
+ break;
+ }
+ return 0;
+}
+
+/* Public version of above */
+
+/* Return the number of channels for the given color space. Return 0 if unknown. */
+ICCLIB_API unsigned int icmCSSig2nchan(icColorSpaceSignature sig) {
+ return number_ColorSpaceSignature(sig);
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Return the individual channel names and number of channels give a colorspace signature. */
+/* Return 0 if it is not a colorspace that itself defines particular channels, */
+/* 1 if it is a colorant based colorspace, and 2 if it is not a colorant based space */
+static int chnames_ColorSpaceSignature(
+icColorSpaceSignature sig,
+char *cvals[] /* Pointers to return for each channel */
+) {
+ switch (sig) {
+ case icSigXYZData:
+ cvals[0] = "CIE X";
+ cvals[1] = "CIE Y";
+ cvals[2] = "CIE Z";
+ return 2;
+
+ case icSigLabData:
+ cvals[0] = "CIE L*";
+ cvals[1] = "CIE a*";
+ cvals[2] = "CIE b*";
+ return 2;
+
+ case icSigLuvData:
+ cvals[0] = "CIE L*";
+ cvals[1] = "CIE u*";
+ cvals[2] = "CIE v*";
+ return 2;
+
+ /* Usually ITU-R BT.601 (was CCIR 601) */
+ case icSigYCbCrData:
+ cvals[0] = "ITU Y";
+ cvals[1] = "ITU Cb";
+ cvals[2] = "ITU Cr";
+ return 2;
+
+ case icSigYxyData:
+ cvals[0] = "CIE Y";
+ cvals[1] = "CIE x";
+ cvals[2] = "CIE y";
+ return 2;
+
+ /* Alvy Ray Smith ? */
+ case icSigHsvData:
+ cvals[0] = "RGB Hue";
+ cvals[1] = "RGB Saturation";
+ cvals[2] = "RGB Value";
+ return 2;
+
+ /* GSPC ? */
+ case icSigHlsData:
+ cvals[0] = "RGB Hue";
+ cvals[1] = "RGB Lightness";
+ cvals[2] = "RGB Saturation";
+ return 2;
+
+ case icSigCmyData:
+ cvals[0] = "Cyan";
+ cvals[1] = "Magenta";
+ cvals[2] = "Yellow";
+ return 1;
+
+ case icSigRgbData:
+ cvals[0] = "Red";
+ cvals[1] = "Green";
+ cvals[2] = "Blue";
+ return 1;
+
+ case icSigCmykData:
+ cvals[0] = "Cyan";
+ cvals[1] = "Magenta";
+ cvals[2] = "Yellow";
+ cvals[3] = "Black";
+ return 1;
+
+
+ /* Non-standard and Pseudo spaces */
+ case icmSigYData:
+ cvals[0] = "CIE Y";
+ return 2;
+
+ case icmSigLData:
+ cvals[0] = "CIE L*";
+ return 2;
+
+ default:
+ break;
+
+ }
+ return 0;
+}
+
+/* Public version of above */
+
+/* Return the individual channel names and number of channels give a colorspace signature. */
+/* Return 0 if it is not a colorspace that itself defines particular channels, */
+/* 1 if it is a colorant based colorspace, and 2 if it is not a colorant based space */
+ICCLIB_API unsigned int icmCSSig2chanNames(icColorSpaceSignature sig, char *cvals[]) {
+
+ return chnames_ColorSpaceSignature(sig, cvals);
+}
+
+/* ------------------------------------------------------- */
+/* Flag dump functions */
+/* Note - returned buffers are static, can only be used 5 */
+/* times before buffers get reused. */
+
+/* Screening Encodings */
+static char *string_ScreenEncodings(unsigned int flags) {
+ static int si = 0; /* String buffer index */
+ static char buf[5][80]; /* String buffers */
+ char *bp, *cp;
+
+ cp = bp = buf[si++];
+ si %= 5; /* Rotate through buffers */
+
+ if (flags & icPrtrDefaultScreensTrue) {
+ sprintf(cp,"Default Screen");
+ } else {
+ sprintf(cp,"No Default Screen");
+ }
+ cp = cp + strlen(cp);
+ if (flags & icLinesPerInch) {
+ sprintf(cp,", Lines Per Inch");
+ } else {
+ sprintf(cp,", Lines Per cm");
+ }
+ cp = cp + strlen(cp);
+
+ return bp;
+}
+
+/* Device attributes */
+static char *string_DeviceAttributes(unsigned int flags) {
+ static int si = 0; /* String buffer index */
+ static char buf[5][80]; /* String buffers */
+ char *bp, *cp;
+
+ cp = bp = buf[si++];
+ si %= 5; /* Rotate through buffers */
+
+ if (flags & icTransparency) {
+ sprintf(cp,"Transparency");
+ } else {
+ sprintf(cp,"Reflective");
+ }
+ cp = cp + strlen(cp);
+ if (flags & icMatte) {
+ sprintf(cp,", Matte");
+ } else {
+ sprintf(cp,", Glossy");
+ }
+ cp = cp + strlen(cp);
+ if (flags & icNegative) {
+ sprintf(cp,", Negative");
+ } else {
+ sprintf(cp,", Positive");
+ }
+ cp = cp + strlen(cp);
+ if (flags & icBlackAndWhite) {
+ sprintf(cp,", BlackAndWhite");
+ } else {
+ sprintf(cp,", Color");
+ }
+ cp = cp + strlen(cp);
+
+ return bp;
+}
+
+/* Profile header flags */
+static char *string_ProfileHeaderFlags(unsigned int flags) {
+ static int si = 0; /* String buffer index */
+ static char buf[5][80]; /* String buffers */
+ char *bp, *cp;
+
+ cp = bp = buf[si++];
+ si %= 5; /* Rotate through buffers */
+
+ if (flags & icEmbeddedProfileTrue) {
+ sprintf(cp,"Embedded Profile");
+ } else {
+ sprintf(cp,"Not Embedded Profile");
+ }
+ cp = cp + strlen(cp);
+ if (flags & icUseWithEmbeddedDataOnly) {
+ sprintf(cp,", Use with embedded data only");
+ } else {
+ sprintf(cp,", Use anywhere");
+ }
+ cp = cp + strlen(cp);
+
+ return bp;
+}
+
+
+static char *string_AsciiOrBinaryData(unsigned int flags) {
+ static int si = 0; /* String buffer index */
+ static char buf[5][80]; /* String buffers */
+ char *bp, *cp;
+
+ cp = bp = buf[si++];
+ si %= 5; /* Rotate through buffers */
+
+ if (flags & icBinaryData) {
+ sprintf(cp,"Binary");
+ } else {
+ sprintf(cp,"Ascii");
+ }
+ cp = cp + strlen(cp);
+
+ return bp;
+}
+
+/* ------------------------------------------------------------ */
+/* Enumeration dump functions */
+/* Note - returned buffers are static, can only be used once */
+/* before buffers get reused if type is unknown. */
+
+/* public tags and sizes */
+static const char *string_TagSignature(icTagSignature sig) {
+ static char buf[80];
+ switch(sig) {
+ case icSigAToB0Tag:
+ return "AToB0 Multidimentional Transform";
+ case icSigAToB1Tag:
+ return "AToB1 Multidimentional Transform";
+ case icSigAToB2Tag:
+ return "AToB2 Multidimentional Transform";
+ case icSigBlueColorantTag:
+ return "Blue Colorant";
+ case icSigBlueTRCTag:
+ return "Blue Tone Reproduction Curve";
+ case icSigBToA0Tag:
+ return "BToA0 Multidimentional Transform";
+ case icSigBToA1Tag:
+ return "BToA1 Multidimentional Transform";
+ case icSigBToA2Tag:
+ return "BToA2 Multidimentional Transform";
+ case icSigCalibrationDateTimeTag:
+ return "Calibration Date & Time";
+ case icSigCharTargetTag:
+ return "Characterization Target";
+ case icSigCopyrightTag:
+ return "Copyright";
+ case icSigCrdInfoTag:
+ return "CRD Info";
+ case icSigDeviceMfgDescTag:
+ return "Device Manufacturer Description";
+ case icSigDeviceModelDescTag:
+ return "Device Model Description";
+ case icSigGamutTag:
+ return "Gamut";
+ case icSigGrayTRCTag:
+ return "Gray Tone Reproduction Curve";
+ case icSigGreenColorantTag:
+ return "Green Colorant";
+ case icSigGreenTRCTag:
+ return "Green Tone Reproduction Curve";
+ case icSigLuminanceTag:
+ return "Luminance";
+ case icSigMeasurementTag:
+ return "Measurement";
+ case icSigMediaBlackPointTag:
+ return "Media Black Point";
+ case icSigMediaWhitePointTag:
+ return "Media White Point";
+ case icSigNamedColorTag:
+ return "Named Color";
+ case icSigNamedColor2Tag:
+ return "Named Color 2";
+ case icSigPreview0Tag:
+ return "Preview0";
+ case icSigPreview1Tag:
+ return "Preview1";
+ case icSigPreview2Tag:
+ return "Preview2";
+ case icSigProfileDescriptionTag:
+ return "Profile Description";
+ case icSigProfileSequenceDescTag:
+ return "Profile Sequence";
+ case icSigPs2CRD0Tag:
+ return "PS Level 2 CRD perceptual";
+ case icSigPs2CRD1Tag:
+ return "PS Level 2 CRD colorimetric";
+ case icSigPs2CRD2Tag:
+ return "PS Level 2 CRD saturation";
+ case icSigPs2CRD3Tag:
+ return "PS Level 2 CRD absolute";
+ case icSigPs2CSATag:
+ return "PS Level 2 color space array";
+ case icSigPs2RenderingIntentTag:
+ return "PS Level 2 Rendering Intent";
+ case icSigRedColorantTag:
+ return "Red Colorant";
+ case icSigRedTRCTag:
+ return "Red Tone Reproduction Curve";
+ case icSigScreeningDescTag:
+ return "Screening Description";
+ case icSigScreeningTag:
+ return "Screening Attributes";
+ case icSigTechnologyTag:
+ return "Device Technology";
+ case icSigUcrBgTag:
+ return "Under Color Removal & Black Generation";
+ case icSigVideoCardGammaTag:
+ return "Video Card Gamma Curve";
+ case icSigViewingCondDescTag:
+ return "Viewing Condition Description";
+ case icSigViewingConditionsTag:
+ return "Viewing Condition Paramaters";
+ default:
+ sprintf(buf,"Unrecognized - %s",tag2str(sig));
+ return buf;
+ }
+}
+
+/* technology signature descriptions */
+static const char *string_TechnologySignature(icTechnologySignature sig) {
+ static char buf[80];
+ switch(sig) {
+ case icSigDigitalCamera:
+ return "Digital Camera";
+ case icSigFilmScanner:
+ return "Film Scanner";
+ case icSigReflectiveScanner:
+ return "Reflective Scanner";
+ case icSigInkJetPrinter:
+ return "InkJet Printer";
+ case icSigThermalWaxPrinter:
+ return "Thermal WaxPrinter";
+ case icSigElectrophotographicPrinter:
+ return "Electrophotographic Printer";
+ case icSigElectrostaticPrinter:
+ return "Electrostatic Printer";
+ case icSigDyeSublimationPrinter:
+ return "DyeSublimation Printer";
+ case icSigPhotographicPaperPrinter:
+ return "Photographic Paper Printer";
+ case icSigFilmWriter:
+ return "Film Writer";
+ case icSigVideoMonitor:
+ return "Video Monitor";
+ case icSigVideoCamera:
+ return "Video Camera";
+ case icSigProjectionTelevision:
+ return "Projection Television";
+ case icSigCRTDisplay:
+ return "Cathode Ray Tube Display";
+ case icSigPMDisplay:
+ return "Passive Matrix Display";
+ case icSigAMDisplay:
+ return "Active Matrix Display";
+ case icSigPhotoCD:
+ return "Photo CD";
+ case icSigPhotoImageSetter:
+ return "Photo ImageSetter";
+ case icSigGravure:
+ return "Gravure";
+ case icSigOffsetLithography:
+ return "Offset Lithography";
+ case icSigSilkscreen:
+ return "Silkscreen";
+ case icSigFlexography:
+ return "Flexography";
+ default:
+ sprintf(buf,"Unrecognized - %s",tag2str(sig));
+ return buf;
+ }
+}
+
+/* type signatures */
+static const char *string_TypeSignature(icTagTypeSignature sig) {
+ static char buf[80];
+ switch(sig) {
+ case icSigCurveType:
+ return "Curve";
+ case icSigDataType:
+ return "Data";
+ case icSigDateTimeType:
+ return "DateTime";
+ case icSigLut16Type:
+ return "Lut16";
+ case icSigLut8Type:
+ return "Lut8";
+ case icSigMeasurementType:
+ return "Measurement";
+ case icSigNamedColorType:
+ return "Named Color";
+ case icSigProfileSequenceDescType:
+ return "Profile Sequence Desc";
+ case icSigS15Fixed16ArrayType:
+ return "S15Fixed16 Array";
+ case icSigScreeningType:
+ return "Screening";
+ case icSigSignatureType:
+ return "Signature";
+ case icSigTextType:
+ return "Text";
+ case icSigTextDescriptionType:
+ return "Text Description";
+ case icSigU16Fixed16ArrayType:
+ return "U16Fixed16 Array";
+ case icSigUcrBgType:
+ return "Under Color Removal & Black Generation";
+ case icSigUInt16ArrayType:
+ return "UInt16 Array";
+ case icSigUInt32ArrayType:
+ return "UInt32 Array";
+ case icSigUInt64ArrayType:
+ return "UInt64 Array";
+ case icSigUInt8ArrayType:
+ return "UInt8 Array";
+ case icSigVideoCardGammaType:
+ return "Video Card Gamma";
+ case icSigViewingConditionsType:
+ return "Viewing Conditions";
+ case icSigXYZType:
+ return "XYZ (Array?)";
+ case icSigNamedColor2Type:
+ return "Named Color 2";
+ case icSigCrdInfoType:
+ return "CRD Info";
+ default:
+ sprintf(buf,"Unrecognized - %s",tag2str(sig));
+ return buf;
+ }
+}
+
+/* Color Space Signatures */
+static const char *string_ColorSpaceSignature(icColorSpaceSignature sig) {
+ static char buf[80];
+ switch(sig) {
+ case icSigXYZData:
+ return "XYZ";
+ case icSigLabData:
+ return "Lab";
+ case icSigLuvData:
+ return "Luv";
+ case icSigYCbCrData:
+ return "YCbCr";
+ case icSigYxyData:
+ return "Yxy";
+ case icSigRgbData:
+ return "RGB";
+ case icSigGrayData:
+ return "Gray";
+ case icSigHsvData:
+ return "HSV";
+ case icSigHlsData:
+ return "HLS";
+ case icSigCmykData:
+ return "CMYK";
+ case icSigCmyData:
+ return "CMY";
+ case icSig2colorData:
+ return "2 Color";
+ case icSig3colorData:
+ return "3 Color";
+ case icSig4colorData:
+ return "4 Color";
+ case icSig5colorData:
+ case icSigMch5Data:
+ return "5 Color";
+ case icSig6colorData:
+ case icSigMch6Data:
+ return "6 Color";
+ case icSig7colorData:
+ case icSigMch7Data:
+ return "7 Color";
+ case icSig8colorData:
+ case icSigMch8Data:
+ return "8 Color";
+ case icSig9colorData:
+ return "9 Color";
+ case icSig10colorData:
+ return "10 Color";
+ case icSig11colorData:
+ return "11 Color";
+ case icSig12colorData:
+ return "12 Color";
+ case icSig13colorData:
+ return "13 Color";
+ case icSig14colorData:
+ return "14 Color";
+ case icSig15colorData:
+ return "15 Color";
+
+ /* Non-standard and Pseudo spaces */
+ case icmSigYData:
+ return "Y";
+ case icmSigLData:
+ return "L";
+ case icmSigL8Data:
+ return "L";
+ case icmSigLV2Data:
+ return "L";
+ case icmSigLV4Data:
+ return "L";
+ case icmSigPCSData:
+ return "PCS";
+ case icmSigLab8Data:
+ return "Lab";
+ case icmSigLabV2Data:
+ return "Lab";
+ case icmSigLabV4Data:
+ return "Lab";
+
+ default:
+ sprintf(buf,"Unrecognized - %s",tag2str(sig));
+ return buf;
+ }
+}
+
+#ifdef NEVER
+/* Public version of above */
+char *ColorSpaceSignature2str(icColorSpaceSignature sig) {
+ return string_ColorSpaceSignature(sig);
+}
+#endif
+
+
+/* profileClass enumerations */
+static const char *string_ProfileClassSignature(icProfileClassSignature sig) {
+ static char buf[80];
+ switch(sig) {
+ case icSigInputClass:
+ return "Input";
+ case icSigDisplayClass:
+ return "Display";
+ case icSigOutputClass:
+ return "Output";
+ case icSigLinkClass:
+ return "Link";
+ case icSigAbstractClass:
+ return "Abstract";
+ case icSigColorSpaceClass:
+ return "Color Space";
+ case icSigNamedColorClass:
+ return "Named Color";
+ default:
+ sprintf(buf,"Unrecognized - %s",tag2str(sig));
+ return buf;
+ }
+}
+
+/* Platform Signatures */
+static const char *string_PlatformSignature(icPlatformSignature sig) {
+ static char buf[80];
+ switch(sig) {
+ case icSigMacintosh:
+ return "Macintosh";
+ case icSigMicrosoft:
+ return "Microsoft";
+ case icSigSolaris:
+ return "Solaris";
+ case icSigSGI:
+ return "SGI";
+ case icSigTaligent:
+ return "Taligent";
+ case icmSig_nix:
+ return "*nix";
+ default:
+ sprintf(buf,"Unrecognized - %s",tag2str(sig));
+ return buf;
+ }
+}
+
+/* Measurement Geometry, used in the measurmentType tag */
+static const char *string_MeasurementGeometry(icMeasurementGeometry sig) {
+ static char buf[30];
+ switch(sig) {
+ case icGeometryUnknown:
+ return "Unknown";
+ case icGeometry045or450:
+ return "0/45 or 45/0";
+ case icGeometry0dord0:
+ return "0/d or d/0";
+ default:
+ sprintf(buf,"Unrecognized - 0x%x",sig);
+ return buf;
+ }
+}
+
+/* Rendering Intents, used in the profile header */
+static const char *string_RenderingIntent(icRenderingIntent sig) {
+ static char buf[30];
+ switch(sig) {
+ case icPerceptual:
+ return "Perceptual";
+ case icRelativeColorimetric:
+ return "Relative Colorimetric";
+ case icSaturation:
+ return "Saturation";
+ case icAbsoluteColorimetric:
+ return "Absolute Colorimetric";
+ case icmAbsolutePerceptual: /* icclib specials */
+ return "Absolute Perceptual";
+ case icmAbsoluteSaturation: /* icclib specials */
+ return "Absolute Saturation";
+ case icmDefaultIntent: /* icclib specials */
+ return "Default Intent";
+ default:
+ sprintf(buf,"Unrecognized - 0x%x",sig);
+ return buf;
+ }
+}
+
+/* Transform Lookup function */
+static const char *string_LookupFunc(icmLookupFunc sig) {
+ static char buf[30];
+ switch(sig) {
+ case icmFwd:
+ return "Forward";
+ case icmBwd:
+ return "Backward";
+ case icmGamut:
+ return "Gamut";
+ case icmPreview:
+ return "Preview";
+ default:
+ sprintf(buf,"Unrecognized - 0x%x",sig);
+ return buf;
+ }
+}
+
+
+/* Different Spot Shapes currently defined, used for screeningType */
+static const char *string_SpotShape(icSpotShape sig) {
+ static char buf[30];
+ switch(sig) {
+ case icSpotShapeUnknown:
+ return "Unknown";
+ case icSpotShapePrinterDefault:
+ return "Printer Default";
+ case icSpotShapeRound:
+ return "Round";
+ case icSpotShapeDiamond:
+ return "Diamond";
+ case icSpotShapeEllipse:
+ return "Ellipse";
+ case icSpotShapeLine:
+ return "Line";
+ case icSpotShapeSquare:
+ return "Square";
+ case icSpotShapeCross:
+ return "Cross";
+ default:
+ sprintf(buf,"Unrecognized - 0x%x",sig);
+ return buf;
+ }
+}
+
+/* Standard Observer, used in the measurmentType tag */
+static const char *string_StandardObserver(icStandardObserver sig) {
+ static char buf[30];
+ switch(sig) {
+ case icStdObsUnknown:
+ return "Unknown";
+ case icStdObs1931TwoDegrees:
+ return "1931 Two Degrees";
+ case icStdObs1964TenDegrees:
+ return "1964 Ten Degrees";
+ default:
+ sprintf(buf,"Unrecognized - 0x%x",sig);
+ return buf;
+ }
+}
+
+/* Pre-defined illuminants, used in measurement and viewing conditions type */
+static const char *string_Illuminant(icIlluminant sig) {
+ static char buf[30];
+ switch(sig) {
+ case icIlluminantUnknown:
+ return "Unknown";
+ case icIlluminantD50:
+ return "D50";
+ case icIlluminantD65:
+ return "D65";
+ case icIlluminantD93:
+ return "D93";
+ case icIlluminantF2:
+ return "F2";
+ case icIlluminantD55:
+ return "D55";
+ case icIlluminantA:
+ return "A";
+ case icIlluminantEquiPowerE:
+ return "Equi-Power(E)";
+ case icIlluminantF8:
+ return "F8";
+ default:
+ sprintf(buf,"Unrecognized - 0x%x",sig);
+ return buf;
+ }
+}
+
+/* Return a text abreviation of a color lookup algorithm */
+static const char *string_LuAlg(icmLuAlgType alg) {
+ static char buf[80];
+
+ switch(alg) {
+ case icmMonoFwdType:
+ return "MonoFwd";
+ case icmMonoBwdType:
+ return "MonoBwd";
+ case icmMatrixFwdType:
+ return "MatrixFwd";
+ case icmMatrixBwdType:
+ return "MatrixBwd";
+ case icmLutType:
+ return "Lut";
+ default:
+ sprintf(buf,"Unrecognized - %d",alg);
+ return buf;
+ }
+}
+
+/* Return a string description of the given enumeration value */
+/* Public: */
+const char *icm2str(icmEnumType etype, int enumval) {
+
+ switch(etype) {
+ case icmScreenEncodings:
+ return string_ScreenEncodings((unsigned int) enumval);
+ case icmDeviceAttributes:
+ return string_DeviceAttributes((unsigned int) enumval);
+ case icmProfileHeaderFlags:
+ return string_ProfileHeaderFlags((unsigned int) enumval);
+ case icmAsciiOrBinaryData:
+ return string_AsciiOrBinaryData((unsigned int) enumval);
+ case icmTagSignature:
+ return string_TagSignature((icTagSignature) enumval);
+ case icmTechnologySignature:
+ return string_TechnologySignature((icTechnologySignature) enumval);
+ case icmTypeSignature:
+ return string_TypeSignature((icTagTypeSignature) enumval);
+ case icmColorSpaceSignature:
+ return string_ColorSpaceSignature((icColorSpaceSignature) enumval);
+ case icmProfileClassSignature:
+ return string_ProfileClassSignature((icProfileClassSignature) enumval);
+ case icmPlatformSignature:
+ return string_PlatformSignature((icPlatformSignature) enumval);
+ case icmMeasurementGeometry:
+ return string_MeasurementGeometry((icMeasurementGeometry) enumval);
+ case icmRenderingIntent:
+ return string_RenderingIntent((icRenderingIntent) enumval);
+ case icmTransformLookupFunc:
+ return string_LookupFunc((icmLookupFunc) enumval);
+ case icmSpotShape:
+ return string_SpotShape((icSpotShape) enumval);
+ case icmStandardObserver:
+ return string_StandardObserver((icStandardObserver) enumval);
+ case icmIlluminant:
+ return string_Illuminant((icIlluminant) enumval);
+ case icmLuAlg:
+ return string_LuAlg((icmLuAlgType) enumval);
+ default:
+ return "enum2str got unknown type";
+ }
+}
+
+/* ========================================================== */
+/* Object I/O routines */
+/* ========================================================== */
+/* icmUnknown object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmUnknown_get_size(
+ icmBase *pp
+) {
+ icmUnknown *p = (icmUnknown *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addmul(len, p->size, 1); /* 1 byte for each unknown data */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmUnknown_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmUnknown *p = (icmUnknown *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i, size;
+ char *bp, *buf;
+
+ if (len < 8) {
+ sprintf(icp->err,"icmUnknown_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUnknown_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmUnknown_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = size = (len - 8)/1; /* Number of elements in the array */
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read type descriptor from the buffer */
+ p->uttype = (icTagTypeSignature)read_SInt32Number(bp);
+ bp += 8; /* Skip padding */
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < size; i++, bp += 1) {
+ p->data[i] = read_UInt8Number(bp);
+ }
+ icp->al->free(p->icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmUnknown_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmUnknown *p = (icmUnknown *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmUnknown_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUnknown_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->uttype,bp)) != 0) {
+ sprintf(icp->err,"icmUnknown_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+ bp += 8; /* Skip padding */
+
+ /* Write all the data to the buffer */
+ for (i = 0; i < p->size; i++, bp += 1) {
+ if ((rv = write_UInt8Number(p->data[i],bp)) != 0) {
+ sprintf(icp->err,"icmUnknown_write: write_UInt8umber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmUnknown_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmUnknown_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmUnknown *p = (icmUnknown *)pp;
+ unsigned int i, ii, r, ph;
+
+ if (verb <= 1)
+ return;
+
+ op->gprintf(op,"Unknown:\n");
+ op->gprintf(op," Payload size in bytes = %u\n",p->size);
+
+ /* Print one row of binary and ASCII interpretation if verb == 2, All if == 3 */
+ /* else print all of it. */
+ ii = i = ph = 0;
+ for (r = 1;; r++) { /* count rows */
+ int c = 1; /* Character location */
+
+ c = 1;
+ if (ph != 0) { /* Print ASCII under binary */
+ op->gprintf(op," ");
+ i = ii; /* Swap */
+ c += 12;
+ } else {
+ op->gprintf(op," 0x%04lx: ",i);
+ ii = i; /* Swap */
+ c += 12;
+ }
+ while (i < p->size && c < 60) {
+ if (ph == 0)
+ op->gprintf(op,"%02x ",p->data[i]);
+ else {
+ if (isprint(p->data[i]))
+ op->gprintf(op,"%c ",p->data[i]);
+ else
+ op->gprintf(op," ",p->data[i]);
+ }
+ c += 3;
+ i++;
+ }
+ if (ph == 0 || i < p->size)
+ op->gprintf(op,"\n");
+
+ if (ph == 1 && i >= p->size) {
+ op->gprintf(op,"\n");
+ break;
+ }
+ if (ph == 1 && r > 1 && verb < 3) {
+ op->gprintf(op," ...\n");
+ break; /* Print 1 row if not verbose */
+ }
+
+ if (ph == 0)
+ ph = 1;
+ else
+ ph = 0;
+
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmUnknown_allocate(
+ icmBase *pp
+) {
+ icmUnknown *p = (icmUnknown *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(unsigned char))) {
+ sprintf(icp->err,"icmUnknown_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (unsigned char *) icp->al->calloc(icp->al, p->size, sizeof(unsigned char)))
+ == NULL) {
+ sprintf(icp->err,"icmUnknown_alloc: malloc() of icmUnknown data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmUnknown_delete(
+ icmBase *pp
+) {
+ icmUnknown *p = (icmUnknown *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmUnknown(
+ icc *icp
+) {
+ icmUnknown *p;
+ if ((p = (icmUnknown *) icp->al->calloc(icp->al,1,sizeof(icmUnknown))) == NULL)
+ return NULL;
+ p->ttype = icmSigUnknownType;
+ p->uttype = icmSigUnknownType;
+ p->refcount = 1;
+ p->get_size = icmUnknown_get_size;
+ p->read = icmUnknown_read;
+ p->write = icmUnknown_write;
+ p->dump = icmUnknown_dump;
+ p->allocate = icmUnknown_allocate;
+ p->del = icmUnknown_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmUInt8Array object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmUInt8Array_get_size(
+ icmBase *pp
+) {
+ icmUInt8Array *p = (icmUInt8Array *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addmul(len, p->size, 1); /* 1 byte for each UInt8 */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmUInt8Array_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmUInt8Array *p = (icmUInt8Array *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i, size;
+ char *bp, *buf;
+
+ if (len < 8) {
+ sprintf(icp->err,"icmUInt8Array_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUInt8Array_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmUInt8Array_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = size = (len - 8)/1; /* Number of elements in the array */
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ icp->al->free(icp->al, buf);
+ sprintf(icp->err,"icmUInt8Array_read: Wrong tag type for icmUInt8Array");
+ return icp->errc = 1;
+ }
+ bp += 8; /* Skip padding */
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < size; i++, bp += 1) {
+ p->data[i] = read_UInt8Number(bp);
+ }
+ icp->al->free(p->icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmUInt8Array_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmUInt8Array *p = (icmUInt8Array *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmUInt8Array_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUInt8Array_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmUInt8Array_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+ bp += 8; /* Skip padding */
+
+ /* Write all the data to the buffer */
+ for (i = 0; i < p->size; i++, bp += 1) {
+ if ((rv = write_UInt8Number(p->data[i],bp)) != 0) {
+ sprintf(icp->err,"icmUInt8Array_write: write_UInt8umber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmUInt8Array_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmUInt8Array_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmUInt8Array *p = (icmUInt8Array *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"UInt8Array:\n");
+ op->gprintf(op," No. elements = %lu\n",p->size);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->size; i++)
+ op->gprintf(op," %lu: %u\n",i,p->data[i]);
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmUInt8Array_allocate(
+ icmBase *pp
+) {
+ icmUInt8Array *p = (icmUInt8Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(unsigned int))) {
+ sprintf(icp->err,"icmUInt8Array_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (unsigned int *) icp->al->calloc(icp->al, p->size, sizeof(unsigned int)))
+ == NULL) {
+ sprintf(icp->err,"icmUInt8Array_alloc: malloc() of icmUInt8Array data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmUInt8Array_delete(
+ icmBase *pp
+) {
+ icmUInt8Array *p = (icmUInt8Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmUInt8Array(
+ icc *icp
+) {
+ icmUInt8Array *p;
+ if ((p = (icmUInt8Array *) icp->al->calloc(icp->al,1,sizeof(icmUInt8Array))) == NULL)
+ return NULL;
+ p->ttype = icSigUInt8ArrayType;
+ p->refcount = 1;
+ p->get_size = icmUInt8Array_get_size;
+ p->read = icmUInt8Array_read;
+ p->write = icmUInt8Array_write;
+ p->dump = icmUInt8Array_dump;
+ p->allocate = icmUInt8Array_allocate;
+ p->del = icmUInt8Array_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmUInt16Array object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmUInt16Array_get_size(
+ icmBase *pp
+) {
+ icmUInt16Array *p = (icmUInt16Array *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addmul(len, p->size, 2); /* 2 bytes for each UInt16 */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmUInt16Array_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmUInt16Array *p = (icmUInt16Array *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i, size;
+ char *bp, *buf;
+
+ if (len < 8) {
+ sprintf(icp->err,"icmUInt16Array_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUInt16Array_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmUInt16Array_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = size = (len - 8)/2; /* Number of elements in the array */
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmUInt16Array_read: Wrong tag type for icmUInt16Array");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp += 8; /* Skip padding */
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < size; i++, bp += 2) {
+ p->data[i] = read_UInt16Number(bp);
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmUInt16Array_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmUInt16Array *p = (icmUInt16Array *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmUInt16Array_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUInt16Array_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmUInt16Array_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write all the data to the buffer */
+ bp += 8; /* Skip padding */
+ for (i = 0; i < p->size; i++, bp += 2) {
+ if ((rv = write_UInt16Number(p->data[i],bp)) != 0) {
+ sprintf(icp->err,"icmUInt16Array_write: write_UInt16umber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmUInt16Array_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmUInt16Array_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmUInt16Array *p = (icmUInt16Array *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"UInt16Array:\n");
+ op->gprintf(op," No. elements = %lu\n",p->size);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->size; i++)
+ op->gprintf(op," %lu: %u\n",i,p->data[i]);
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmUInt16Array_allocate(
+ icmBase *pp
+) {
+ icmUInt16Array *p = (icmUInt16Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(unsigned int))) {
+ sprintf(icp->err,"icmUInt16Array_alloc:: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (unsigned int *) icp->al->calloc(icp->al, p->size, sizeof(unsigned int)))
+ == NULL) {
+ sprintf(icp->err,"icmUInt16Array_alloc: malloc() of icmUInt16Array data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmUInt16Array_delete(
+ icmBase *pp
+) {
+ icmUInt16Array *p = (icmUInt16Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmUInt16Array(
+ icc *icp
+) {
+ icmUInt16Array *p;
+ if ((p = (icmUInt16Array *) icp->al->calloc(icp->al,1,sizeof(icmUInt16Array))) == NULL)
+ return NULL;
+ p->ttype = icSigUInt16ArrayType;
+ p->refcount = 1;
+ p->get_size = icmUInt16Array_get_size;
+ p->read = icmUInt16Array_read;
+ p->write = icmUInt16Array_write;
+ p->dump = icmUInt16Array_dump;
+ p->allocate = icmUInt16Array_allocate;
+ p->del = icmUInt16Array_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmUInt32Array object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmUInt32Array_get_size(
+ icmBase *pp
+) {
+ icmUInt32Array *p = (icmUInt32Array *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addmul(len, p->size, 4); /* 4 bytes for each UInt32 */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmUInt32Array_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmUInt32Array *p = (icmUInt32Array *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i, size;
+ char *bp, *buf;
+
+ if (len < 8) {
+ sprintf(icp->err,"icmUInt32Array_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUInt32Array_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmUInt32Array_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = size = (len - 8)/4; /* Number of elements in the array */
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmUInt32Array_read: Wrong tag type for icmUInt32Array");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp += 8; /* Skip padding */
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < size; i++, bp += 4) {
+ p->data[i] = read_UInt32Number(bp);
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmUInt32Array_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmUInt32Array *p = (icmUInt32Array *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmUInt32Array_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUInt32Array_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmUInt32Array_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write all the data to the buffer */
+ bp += 8; /* Skip padding */
+ for (i = 0; i < p->size; i++, bp += 4) {
+ if ((rv = write_UInt32Number(p->data[i],bp)) != 0) {
+ sprintf(icp->err,"icmUInt32Array_write: write_UInt32umber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmUInt32Array_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmUInt32Array_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmUInt32Array *p = (icmUInt32Array *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"UInt32Array:\n");
+ op->gprintf(op," No. elements = %lu\n",p->size);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->size; i++)
+ op->gprintf(op," %lu: %u\n",i,p->data[i]);
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmUInt32Array_allocate(
+ icmBase *pp
+) {
+ icmUInt32Array *p = (icmUInt32Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(unsigned int))) {
+ sprintf(icp->err,"icmUInt32Array_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (unsigned int *) icp->al->calloc(icp->al, p->size, sizeof(unsigned int)))
+ == NULL) {
+ sprintf(icp->err,"icmUInt32Array_alloc: malloc() of icmUInt32Array data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmUInt32Array_delete(
+ icmBase *pp
+) {
+ icmUInt32Array *p = (icmUInt32Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmUInt32Array(
+ icc *icp
+) {
+ icmUInt32Array *p;
+ if ((p = (icmUInt32Array *) icp->al->calloc(icp->al,1,sizeof(icmUInt32Array))) == NULL)
+ return NULL;
+ p->ttype = icSigUInt32ArrayType;
+ p->refcount = 1;
+ p->get_size = icmUInt32Array_get_size;
+ p->read = icmUInt32Array_read;
+ p->write = icmUInt32Array_write;
+ p->dump = icmUInt32Array_dump;
+ p->allocate = icmUInt32Array_allocate;
+ p->del = icmUInt32Array_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmUInt64Array object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmUInt64Array_get_size(
+ icmBase *pp
+) {
+ icmUInt64Array *p = (icmUInt64Array *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addmul(len, p->size, 8); /* 8 bytes for each UInt64 */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmUInt64Array_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmUInt64Array *p = (icmUInt64Array *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i, size;
+ char *bp, *buf;
+
+ if (len < 8) {
+ sprintf(icp->err,"icmUInt64Array_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUInt64Array_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmUInt64Array_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = size = (len - 8)/8; /* Number of elements in the array */
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmUInt64Array_read: Wrong tag type for icmUInt64Array");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp += 8; /* Skip padding */
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < size; i++, bp += 8) {
+ read_UInt64Number(&p->data[i], bp);
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmUInt64Array_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmUInt64Array *p = (icmUInt64Array *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmUInt64Array_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUInt64Array_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmUInt64Array_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write all the data to the buffer */
+ bp += 8; /* Skip padding */
+ for (i = 0; i < p->size; i++, bp += 8) {
+ if ((rv = write_UInt64Number(&p->data[i],bp)) != 0) {
+ sprintf(icp->err,"icmUInt64Array_write: write_UInt64umber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmUInt64Array_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmUInt64Array_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmUInt64Array *p = (icmUInt64Array *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"UInt64Array:\n");
+ op->gprintf(op," No. elements = %lu\n",p->size);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->size; i++)
+ op->gprintf(op," %lu: h=%lu, l=%lu\n",i,p->data[i].h,p->data[i].l);
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmUInt64Array_allocate(
+ icmBase *pp
+) {
+ icmUInt64Array *p = (icmUInt64Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(icmUint64))) {
+ sprintf(icp->err,"icmUInt64Array_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (icmUint64 *) icp->al->calloc(icp->al, p->size, sizeof(icmUint64)))
+ == NULL) {
+ sprintf(icp->err,"icmUInt64Array_alloc: malloc() of icmUInt64Array data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmUInt64Array_delete(
+ icmBase *pp
+) {
+ icmUInt64Array *p = (icmUInt64Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmUInt64Array(
+ icc *icp
+) {
+ icmUInt64Array *p;
+ if ((p = (icmUInt64Array *) icp->al->calloc(icp->al,1,sizeof(icmUInt64Array))) == NULL)
+ return NULL;
+ p->ttype = icSigUInt64ArrayType;
+ p->refcount = 1;
+ p->get_size = icmUInt64Array_get_size;
+ p->read = icmUInt64Array_read;
+ p->write = icmUInt64Array_write;
+ p->dump = icmUInt64Array_dump;
+ p->allocate = icmUInt64Array_allocate;
+ p->del = icmUInt64Array_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmU16Fixed16Array object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmU16Fixed16Array_get_size(
+ icmBase *pp
+) {
+ icmU16Fixed16Array *p = (icmU16Fixed16Array *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addmul(len, p->size, 4); /* 4 byte for each U16Fixed16 */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmU16Fixed16Array_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmU16Fixed16Array *p = (icmU16Fixed16Array *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i, size;
+ char *bp, *buf;
+
+ if (len < 8) {
+ sprintf(icp->err,"icmU16Fixed16Array_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmU16Fixed16Array_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmU16Fixed16Array_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = size = (len - 8)/4; /* Number of elements in the array */
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmU16Fixed16Array_read: Wrong tag type for icmU16Fixed16Array");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp += 8; /* Skip padding */
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < size; i++, bp += 4) {
+ p->data[i] = read_U16Fixed16Number(bp);
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmU16Fixed16Array_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmU16Fixed16Array *p = (icmU16Fixed16Array *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmU16Fixed16Array_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmU16Fixed16Array_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmU16Fixed16Array_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write all the data to the buffer */
+ bp += 8; /* Skip padding */
+ for (i = 0; i < p->size; i++, bp += 4) {
+ if ((rv = write_U16Fixed16Number(p->data[i],bp)) != 0) {
+ sprintf(icp->err,"icmU16Fixed16Array_write: write_U16Fixed16umber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmU16Fixed16Array_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmU16Fixed16Array_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmU16Fixed16Array *p = (icmU16Fixed16Array *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"U16Fixed16Array:\n");
+ op->gprintf(op," No. elements = %lu\n",p->size);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->size; i++)
+ op->gprintf(op," %lu: %f\n",i,p->data[i]);
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmU16Fixed16Array_allocate(
+ icmBase *pp
+) {
+ icmU16Fixed16Array *p = (icmU16Fixed16Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(double))) {
+ sprintf(icp->err,"icmU16Fixed16Array_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (double *) icp->al->calloc(icp->al, p->size, sizeof(double))) == NULL) {
+ sprintf(icp->err,"icmU16Fixed16Array_alloc: malloc() of icmU16Fixed16Array data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmU16Fixed16Array_delete(
+ icmBase *pp
+) {
+ icmU16Fixed16Array *p = (icmU16Fixed16Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmU16Fixed16Array(
+ icc *icp
+) {
+ icmU16Fixed16Array *p;
+ if ((p = (icmU16Fixed16Array *) icp->al->calloc(icp->al,1,sizeof(icmU16Fixed16Array))) == NULL)
+ return NULL;
+ p->ttype = icSigU16Fixed16ArrayType;
+ p->refcount = 1;
+ p->get_size = icmU16Fixed16Array_get_size;
+ p->read = icmU16Fixed16Array_read;
+ p->write = icmU16Fixed16Array_write;
+ p->dump = icmU16Fixed16Array_dump;
+ p->allocate = icmU16Fixed16Array_allocate;
+ p->del = icmU16Fixed16Array_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmS15Fixed16Array object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmS15Fixed16Array_get_size(
+ icmBase *pp
+) {
+ icmS15Fixed16Array *p = (icmS15Fixed16Array *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addmul(len, p->size, 4); /* 4 byte for each S15Fixed16 */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmS15Fixed16Array_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmS15Fixed16Array *p = (icmS15Fixed16Array *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i, size;
+ char *bp, *buf;
+
+ if (len < 8) {
+ sprintf(icp->err,"icmS15Fixed16Array_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmS15Fixed16Array_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmS15Fixed16Array_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = size = (len - 8)/4; /* Number of elements in the array */
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmS15Fixed16Array_read: Wrong tag type for icmS15Fixed16Array");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp += 8; /* Skip padding */
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < size; i++, bp += 4) {
+ p->data[i] = read_S15Fixed16Number(bp);
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmS15Fixed16Array_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmS15Fixed16Array *p = (icmS15Fixed16Array *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmS15Fixed16Array_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmS15Fixed16Array_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmS15Fixed16Array_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write all the data to the buffer */
+ bp += 8; /* Skip padding */
+ for (i = 0; i < p->size; i++, bp += 4) {
+ if ((rv = write_S15Fixed16Number(p->data[i],bp)) != 0) {
+ sprintf(icp->err,"icmS15Fixed16Array_write: write_S15Fixed16umber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmS15Fixed16Array_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmS15Fixed16Array_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmS15Fixed16Array *p = (icmS15Fixed16Array *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"S15Fixed16Array:\n");
+ op->gprintf(op," No. elements = %lu\n",p->size);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->size; i++)
+ op->gprintf(op," %lu: %f\n",i,p->data[i]);
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmS15Fixed16Array_allocate(
+ icmBase *pp
+) {
+ icmS15Fixed16Array *p = (icmS15Fixed16Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(double))) {
+ sprintf(icp->err,"icmS15Fixed16Array_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (double *) icp->al->calloc(icp->al, p->size, sizeof(double))) == NULL) {
+ sprintf(icp->err,"icmS15Fixed16Array_alloc: malloc() of icmS15Fixed16Array data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmS15Fixed16Array_delete(
+ icmBase *pp
+) {
+ icmS15Fixed16Array *p = (icmS15Fixed16Array *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmS15Fixed16Array(
+ icc *icp
+) {
+ icmS15Fixed16Array *p;
+ if ((p = (icmS15Fixed16Array *) icp->al->calloc(icp->al,1,sizeof(icmS15Fixed16Array))) == NULL)
+ return NULL;
+ p->ttype = icSigS15Fixed16ArrayType;
+ p->refcount = 1;
+ p->get_size = icmS15Fixed16Array_get_size;
+ p->read = icmS15Fixed16Array_read;
+ p->write = icmS15Fixed16Array_write;
+ p->dump = icmS15Fixed16Array_dump;
+ p->allocate = icmS15Fixed16Array_allocate;
+ p->del = icmS15Fixed16Array_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+
+/* Data conversion support functions */
+static int write_XYZNumber(icmXYZNumber *p, char *d) {
+ int rv;
+ if ((rv = write_S15Fixed16Number(p->X, d + 0)) != 0)
+ return rv;
+ if ((rv = write_S15Fixed16Number(p->Y, d + 4)) != 0)
+ return rv;
+ if ((rv = write_S15Fixed16Number(p->Z, d + 8)) != 0)
+ return rv;
+ return 0;
+}
+
+static int read_XYZNumber(icmXYZNumber *p, char *d) {
+ p->X = read_S15Fixed16Number(d + 0);
+ p->Y = read_S15Fixed16Number(d + 4);
+ p->Z = read_S15Fixed16Number(d + 8);
+ return 0;
+}
+
+
+/* Helper: Return a string that shows the XYZ number value */
+static char *string_XYZNumber(icmXYZNumber *p) {
+ static char buf[40];
+
+ sprintf(buf,"%f, %f, %f", p->X, p->Y, p->Z);
+ return buf;
+}
+
+/* Helper: Return a string that shows the XYZ number value, */
+/* and the Lab D50 number in paren. Note the buffer will be re-used on every call. */
+static char *string_XYZNumber_and_Lab(icmXYZNumber *p) {
+ static char buf[100];
+ double lab[3];
+ lab[0] = p->X;
+ lab[1] = p->Y;
+ lab[2] = p->Z;
+ icmXYZ2Lab(&icmD50, lab, lab);
+ snprintf(buf,sizeof(buf),"%f, %f, %f [Lab %f, %f, %f]", p->X, p->Y, p->Z, lab[0], lab[1], lab[2]);
+ return buf;
+}
+
+/* icmXYZArray object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmXYZArray_get_size(
+ icmBase *pp
+) {
+ icmXYZArray *p = (icmXYZArray *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addmul(len, p->size, 12); /* 12 bytes for each XYZ */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmXYZArray_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmXYZArray *p = (icmXYZArray *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i, size;
+ char *bp, *buf;
+
+ if (len < 8) {
+ sprintf(icp->err,"icmXYZArray_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmXYZArray_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmXYZArray_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = size = (len - 8)/12; /* Number of elements in the array */
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmXYZArray_read: Wrong tag type for icmXYZArray");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp += 8; /* Skip padding */
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < size; i++, bp += 12) {
+ read_XYZNumber(&p->data[i], bp);
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmXYZArray_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmXYZArray *p = (icmXYZArray *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmXYZArray_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmXYZArray_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmXYZArray_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write all the data to the buffer */
+ bp += 8; /* Skip padding */
+ for (i = 0; i < p->size; i++, bp += 12) {
+ if ((rv = write_XYZNumber(&p->data[i],bp)) != 0) {
+ sprintf(icp->err,"icmXYZArray_write: write_XYZumber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmXYZArray_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmXYZArray_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmXYZArray *p = (icmXYZArray *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"XYZArray:\n");
+ op->gprintf(op," No. elements = %lu\n",p->size);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->size; i++) {
+ op->gprintf(op," %lu: %s\n",i,string_XYZNumber_and_Lab(&p->data[i]));
+
+ }
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmXYZArray_allocate(
+ icmBase *pp
+) {
+ icmXYZArray *p = (icmXYZArray *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(icmXYZNumber))) {
+ sprintf(icp->err,"icmXYZArray_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (icmXYZNumber *) icp->al->malloc(icp->al, sat_mul(p->size, sizeof(icmXYZNumber)))) == NULL) {
+ sprintf(icp->err,"icmXYZArray_alloc: malloc() of icmXYZArray data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmXYZArray_delete(
+ icmBase *pp
+) {
+ icmXYZArray *p = (icmXYZArray *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmXYZArray(
+ icc *icp
+) {
+ icmXYZArray *p;
+ if ((p = (icmXYZArray *) icp->al->calloc(icp->al,1,sizeof(icmXYZArray))) == NULL)
+ return NULL;
+ p->ttype = icSigXYZArrayType;
+ p->refcount = 1;
+ p->get_size = icmXYZArray_get_size;
+ p->read = icmXYZArray_read;
+ p->write = icmXYZArray_write;
+ p->dump = icmXYZArray_dump;
+ p->allocate = icmXYZArray_allocate;
+ p->del = icmXYZArray_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmCurve object */
+
+/* Do a forward lookup through the curve */
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+static int icmCurve_lookup_fwd(
+ icmCurve *p,
+ double *out,
+ double *in
+) {
+ int rv = 0;
+ if (p->flag == icmCurveLin) {
+ *out = *in;
+ } else if (p->flag == icmCurveGamma) {
+ double val = *in;
+ if (val <= 0.0)
+ *out = 0.0;
+ else
+ *out = pow(val, p->data[0]);
+ } else if (p->size == 0) { /* Table of 0 size */
+ *out = *in;
+ } else { /* Use linear interpolation */
+ unsigned int ix;
+ double val, w;
+ double inputEnt_1 = (double)(p->size-1);
+
+ val = *in * inputEnt_1;
+ if (val < 0.0) {
+ val = 0.0;
+ rv |= 1;
+ } else if (val > inputEnt_1) {
+ val = inputEnt_1;
+ rv |= 1;
+ }
+ ix = (unsigned int)floor(val); /* Coordinate */
+ if (ix > (p->size-2))
+ ix = (p->size-2);
+ w = val - (double)ix; /* weight */
+ val = p->data[ix];
+ *out = val + w * (p->data[ix+1] - val);
+ }
+ return rv;
+}
+
+/* - - - - - - - - - - - - */
+/* Support for reverse interpolation of 1D lookup tables */
+
+/* Create a reverse curve lookup acceleration table */
+/* return non-zero on error, 2 = malloc error. */
+static int icmTable_setup_bwd(
+ icc *icp, /* Base icc object */
+ icmRevTable *rt, /* Reverse table data to setup */
+ unsigned int size, /* Size of fwd table */
+ double *data /* Table */
+) {
+ unsigned int i;
+
+ rt->size = size; /* Stash pointers to these away */
+ rt->data = data;
+
+ /* Find range of output values */
+ rt->rmin = 1e300;
+ rt->rmax = -1e300;
+ for (i = 0; i < rt->size; i++) {
+ if (rt->data[i] > rt->rmax)
+ rt->rmax = rt->data[i];
+ if (rt->data[i] < rt->rmin)
+ rt->rmin = rt->data[i];
+ }
+
+ /* Decide on reverse granularity */
+ rt->rsize = sat_add(rt->size,2)/2;
+ rt->qscale = (double)rt->rsize/(rt->rmax - rt->rmin); /* Scale factor to quantize to */
+
+ if (ovr_mul(rt->size, sizeof(unsigned int *))) {
+ return 2;
+ }
+ /* Initialize the reverse lookup structures, and get overall min/max */
+ if ((rt->rlists = (unsigned int **) icp->al->calloc(icp->al, rt->rsize, sizeof(unsigned int *))) == NULL) {
+ return 2;
+ }
+
+ /* Assign each output value range bucket lists it intersects */
+ for (i = 0; i < (rt->size-1); i++) {
+ unsigned int s, e, j; /* Start and end indexes (inclusive) */
+ s = (unsigned int)((rt->data[i] - rt->rmin) * rt->qscale);
+ e = (unsigned int)((rt->data[i+1] - rt->rmin) * rt->qscale);
+ if (s >= rt->rsize)
+ s = rt->rsize-1;
+ if (e >= rt->rsize)
+ e = rt->rsize-1;
+ if (s > e) { /* swap */
+ unsigned int t;
+ t = s; s = e; e = t;
+ }
+
+ /* For all buckets that may contain this output range, add index of this output */
+ for (j = s; j <= e; j++) {
+ unsigned int as; /* Allocation size */
+ unsigned int nf; /* Next free slot */
+ if (rt->rlists[j] == NULL) { /* No allocation */
+ as = 5; /* Start with space for 5 */
+ if ((rt->rlists[j] = (unsigned int *) icp->al->calloc(icp->al, as, sizeof(unsigned int))) == NULL) {
+ return 2;
+ }
+ rt->rlists[j][0] = as;
+ nf = rt->rlists[j][1] = 2;
+ } else {
+ as = rt->rlists[j][0]; /* Allocate space for this list */
+ nf = rt->rlists[j][1]; /* Next free location in list */
+ if (nf >= as) { /* need to expand space */
+ if ((as = sat_mul(as, 2)) == UINT_MAX
+ || ovr_mul(as, sizeof(unsigned int))) {
+ return 2;
+ }
+ rt->rlists[j] = (unsigned int *) icp->al->realloc(icp->al,rt->rlists[j], as * sizeof(unsigned int));
+ if (rt->rlists[j] == NULL) {
+ return 2;
+ }
+ rt->rlists[j][0] = as;
+ }
+ }
+ rt->rlists[j][nf++] = i;
+ rt->rlists[j][1] = nf;
+ }
+ }
+ rt->inited = 1;
+ return 0;
+}
+
+/* Free up any data */
+static void icmTable_delete_bwd(
+ icc *icp, /* Base icc */
+ icmRevTable *rt /* Reverse table data to setup */
+) {
+ if (rt->inited != 0) {
+ while (rt->rsize > 0)
+ icp->al->free(icp->al, rt->rlists[--rt->rsize]);
+ icp->al->free(icp->al, rt->rlists);
+ rt->size = 0; /* Don't keep these */
+ rt->data = NULL;
+ }
+}
+
+/* Do a reverse lookup through the curve */
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+static int icmTable_lookup_bwd(
+ icmRevTable *rt,
+ double *out,
+ double *in
+) {
+ int rv = 0;
+ unsigned int ix, k, i;
+ double oval, ival = *in, val;
+ double rsize_1;
+
+ /* Find appropriate reverse list */
+ rsize_1 = (double)(rt->rsize-1);
+ val = ((ival - rt->rmin) * rt->qscale);
+ if (val < 0.0)
+ val = 0.0;
+ else if (val > rsize_1)
+ val = rsize_1;
+ ix = (unsigned int)floor(val); /* Coordinate */
+
+ if (ix > (rt->size-2))
+ ix = (rt->size-2);
+ if (rt->rlists[ix] != NULL) { /* There is a list of fwd candidates */
+ /* For each candidate forward range */
+ for (i = 2; i < rt->rlists[ix][1]; i++) { /* For all fwd indexes */
+ double lv,hv;
+ k = rt->rlists[ix][i]; /* Base index */
+ lv = rt->data[k];
+ hv = rt->data[k+1];
+ if ((ival >= lv && ival <= hv) /* If this slot contains output value */
+ || (ival >= hv && ival <= lv)) {
+ /* Reverse linear interpolation */
+ if (hv == lv) { /* Technically non-monotonic - due to quantization ? */
+ oval = (k + 0.5)/(rt->size-1.0);
+ } else
+ oval = (k + ((ival - lv)/(hv - lv)))/(rt->size-1.0);
+ /* If we kept looking, we would find multiple */
+ /* solution for non-monotonic curve */
+ *out = oval;
+ return rv;
+ }
+ }
+ }
+
+ /* We have failed to find an exact value, so return the nearest value */
+ /* (This is slow !) */
+ val = fabs(ival - rt->data[0]);
+ for (k = 0, i = 1; i < rt->size; i++) {
+ double er;
+ er = fabs(ival - rt->data[i]);
+ if (er < val) { /* new best */
+ val = er;
+ k = i;
+ }
+ }
+ *out = k/(rt->size-1.0);
+ rv |= 1;
+ return rv;
+}
+
+
+/* - - - - - - - - - - - - */
+
+/* Do a reverse lookup through the curve */
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+static int icmCurve_lookup_bwd(
+ icmCurve *p,
+ double *out,
+ double *in
+) {
+ icc *icp = p->icp;
+ int rv = 0;
+ if (p->flag == icmCurveLin) {
+ *out = *in;
+ } else if (p->flag == icmCurveGamma) {
+ double val = *in;
+ if (val <= 0.0)
+ *out = 0.0;
+ else
+ *out = pow(val, 1.0/p->data[0]);
+ } else if (p->size == 0) { /* Table of 0 size */
+ *out = *in;
+ } else { /* Use linear interpolation */
+ if (p->rt.inited == 0) {
+ rv = icmTable_setup_bwd(icp, &p->rt, p->size, p->data);
+ if (rv != 0) {
+ sprintf(icp->err,"icmCurve_lookup: Malloc failure in reverse lookup init.");
+ return icp->errc = rv;
+ }
+ }
+ rv = icmTable_lookup_bwd(&p->rt, out, in);
+ }
+ return rv;
+}
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmCurve_get_size(
+ icmBase *pp
+) {
+ icmCurve *p = (icmCurve *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 12); /* 12 bytes for tag, padding and count */
+ len = sat_addmul(len, p->size, 2); /* 2 bytes for each UInt16 */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmCurve_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmCurve *p = (icmCurve *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i;
+ char *bp, *buf, *end;
+
+ if (len < 12) {
+ sprintf(icp->err,"icmCurve_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmCurve_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+ end = buf + len;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmCurve_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmCurve_read: Wrong tag type for icmCurve");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ p->size = read_UInt32Number(bp+8);
+ bp = bp + 12;
+
+ /* Set flag up before allocating */
+ if (p->size == 0) { /* Linear curve */
+ p->flag = icmCurveLin;
+ } else if (p->size == 1) { /* Gamma curve */
+ p->flag = icmCurveGamma;
+ } else {
+ p->flag = icmCurveSpec;
+ if (p->size > (len - 12)/2) {
+ sprintf(icp->err,"icmCurve_read: size overflow");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ }
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ if (p->flag == icmCurveGamma) { /* Gamma curve */
+ if (bp > end || 1 > (end - bp)) {
+ sprintf(icp->err,"icmCurve_read: Data too short for curve gamma");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->data[0] = read_U8Fixed8Number(bp);
+ } else if (p->flag == icmCurveSpec) {
+ /* Read all the data from the buffer */
+ for (i = 0; i < p->size; i++, bp += 2) {
+ if (bp > end || 2 > (end - bp)) {
+ sprintf(icp->err,"icmCurve_read: Data too short for curve value");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->data[i] = read_DCS16Number(bp);
+ }
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmCurve_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmCurve *p = (icmCurve *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmCurve_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmCurve_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmCurve_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write count */
+ if ((rv = write_UInt32Number(p->size,bp+8)) != 0) {
+ sprintf(icp->err,"icmCurve_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write all the data to the buffer */
+ bp += 12; /* Skip padding */
+ if (p->flag == icmCurveLin) {
+ if (p->size != 0) {
+ sprintf(icp->err,"icmCurve_write: Must be exactly 0 entry for Linear");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ } else if (p->flag == icmCurveGamma) {
+ if (p->size != 1) {
+ sprintf(icp->err,"icmCurve_write: Must be exactly 1 entry for Gamma");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ if ((rv = write_U8Fixed8Number(p->data[0],bp)) != 0) {
+ sprintf(icp->err,"icmCurve_write: write_U8Fixed8umber(%f) failed",p->data[0]);
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ } else if (p->flag == icmCurveSpec) {
+ if (p->size < 2) {
+ sprintf(icp->err,"icmCurve_write: Must be 2 or more entries for Specified curve");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ for (i = 0; i < p->size; i++, bp += 2) {
+ if ((rv = write_DCS16Number(p->data[i],bp)) != 0) {
+ sprintf(icp->err,"icmCurve_write: write_UInt16umber(%f) failed",p->data[i]);
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmCurve_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmCurve_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmCurve *p = (icmCurve *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"Curve:\n");
+
+ if (p->flag == icmCurveLin) {
+ op->gprintf(op," Curve is linear\n");
+ } else if (p->flag == icmCurveGamma) {
+ op->gprintf(op," Curve is gamma of %f\n",p->data[0]);
+ } else {
+ op->gprintf(op," No. elements = %lu\n",p->size);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->size; i++)
+ op->gprintf(op," %3lu: %f\n",i,p->data[i]);
+ }
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmCurve_allocate(
+ icmBase *pp
+) {
+ icmCurve *p = (icmCurve *)pp;
+ icc *icp = p->icp;
+
+ if (p->flag == icmCurveUndef) {
+ sprintf(icp->err,"icmCurve_alloc: flag not set");
+ return icp->errc = 1;
+ } else if (p->flag == icmCurveLin) {
+ p->size = 0;
+ } else if (p->flag == icmCurveGamma) {
+ p->size = 1;
+ }
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(double))) {
+ sprintf(icp->err,"icmCurve_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (double *) icp->al->calloc(icp->al, p->size, sizeof(double))) == NULL) {
+ sprintf(icp->err,"icmCurve_alloc: malloc() of icmCurve data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmCurve_delete(
+ icmBase *pp
+) {
+ icmCurve *p = (icmCurve *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icmTable_delete_bwd(icp, &p->rt); /* Free reverse table info */
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmCurve(
+ icc *icp
+) {
+ icmCurve *p;
+ if ((p = (icmCurve *) icp->al->calloc(icp->al,1,sizeof(icmCurve))) == NULL)
+ return NULL;
+ p->ttype = icSigCurveType;
+ p->refcount = 1;
+ p->get_size = icmCurve_get_size;
+ p->read = icmCurve_read;
+ p->write = icmCurve_write;
+ p->dump = icmCurve_dump;
+ p->allocate = icmCurve_allocate;
+ p->del = icmCurve_delete;
+ p->icp = icp;
+
+ p->lookup_fwd = icmCurve_lookup_fwd;
+ p->lookup_bwd = icmCurve_lookup_bwd;
+
+ p->rt.inited = 0;
+
+ p->flag = icmCurveUndef;
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmData object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmData_get_size(
+ icmBase *pp
+) {
+ icmData *p = (icmData *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 12); /* 12 bytes for tag and padding */
+ len = sat_addmul(len, p->size, 1); /* 1 byte for each data element */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmData_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmData *p = (icmData *)pp;
+ icc *icp = p->icp;
+ int rv;
+ unsigned size, f;
+ char *bp, *buf;
+
+ if (len < 12) {
+ sprintf(icp->err,"icmData_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmData_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmData_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = size = (len - 12)/1; /* Number of elements in the array */
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmData_read: Wrong tag type for icmData");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Read the data type flag */
+ f = read_UInt32Number(bp+8);
+ if (f == 0) {
+ p->flag = icmDataASCII;
+ } else if (f == 1) {
+ p->flag = icmDataBin;
+#ifndef ICM_STRICT /* Profile maker sometimes has a problem */
+ } else if (f == 0x01000000) {
+ p->flag = icmDataBin;
+#endif
+ } else {
+ sprintf(icp->err,"icmData_read: Unknown flag value 0x%x",f);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp += 12; /* Skip padding and flag */
+
+ if (p->size > 0) {
+ if (p->flag == icmDataASCII) {
+ if ((rv = check_null_string(bp,p->size)) == 1) {
+ sprintf(icp->err,"icmData_read: ACSII is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+ }
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ memmove((void *)p->data, (void *)bp, p->size);
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmData_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmData *p = (icmData *)pp;
+ icc *icp = p->icp;
+ unsigned int len, f;
+ char *bp, *buf; /* Buffer to write from */
+ int rv;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmData_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmData_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmData_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+ switch(p->flag) {
+ case icmDataASCII:
+ f = 0;
+ break;
+ case icmDataBin:
+ f = 1;
+ break;
+ default:
+ sprintf(icp->err,"icmData_write: Unknown Data Flag value");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Write data flag descriptor to the buffer */
+ if ((rv = write_UInt32Number(f,bp+8)) != 0) {
+ sprintf(icp->err,"icmData_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ bp += 12; /* Skip padding */
+
+ if (p->data != NULL) {
+ if (p->flag == icmDataASCII) {
+ if ((rv = check_null_string((char *)p->data, p->size)) == 1) {
+ sprintf(icp->err,"icmData_write: ASCII is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+ }
+ memmove((void *)bp, (void *)p->data, p->size);
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmData_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmData_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmData *p = (icmData *)pp;
+ unsigned int i, r, c, ii, size = 0;
+ int ph = 0; /* Phase */
+
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"Data:\n");
+ switch(p->flag) {
+ case icmDataASCII:
+ op->gprintf(op," ASCII data\n");
+ size = p->size > 0 ? p->size-1 : 0;
+ break;
+ case icmDataBin:
+ op->gprintf(op," Binary data\n");
+ size = p->size;
+ break;
+ case icmDataUndef:
+ op->gprintf(op," Undefined data\n");
+ size = p->size;
+ break;
+ }
+ op->gprintf(op," No. elements = %lu\n",p->size);
+
+ ii = i = 0;
+ for (r = 1;; r++) { /* count rows */
+ if (i >= size) {
+ op->gprintf(op,"\n");
+ break;
+ }
+ if (r > 1 && verb < 2) {
+ op->gprintf(op,"...\n");
+ break; /* Print 1 row if not verbose */
+ }
+
+ c = 1;
+ if (ph != 0) { /* Print ASCII under binary */
+ op->gprintf(op," ");
+ i = ii;
+ c += 11;
+ } else {
+ op->gprintf(op," 0x%04lx: ",i);
+ ii = i;
+ c += 10;
+ }
+ while (i < size && c < 75) {
+ if (p->flag == icmDataASCII) {
+ if (isprint(p->data[i])) {
+ op->gprintf(op,"%c",p->data[i]);
+ c++;
+ } else {
+ op->gprintf(op,"\\%03o",p->data[i]);
+ c += 4;
+ }
+ } else {
+ if (ph == 0)
+ op->gprintf(op,"%02x ",p->data[i]);
+ else {
+ if (isprint(p->data[i]))
+ op->gprintf(op," %c ",p->data[i]);
+ else
+ op->gprintf(op," ",p->data[i]);
+ }
+ c += 3;
+ }
+ i++;
+ }
+ if (i < size)
+ op->gprintf(op,"\n");
+ if (verb > 2 && p->flag != icmDataASCII && ph == 0)
+ ph = 1;
+ else
+ ph = 0;
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmData_allocate(
+ icmBase *pp
+) {
+ icmData *p = (icmData *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(unsigned char))) {
+ sprintf(icp->err,"icmData_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (unsigned char *) icp->al->calloc(icp->al, p->size, sizeof(unsigned char))) == NULL) {
+ sprintf(icp->err,"icmData_alloc: malloc() of icmData data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmData_delete(
+ icmBase *pp
+) {
+ icmData *p = (icmData *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmData(
+ icc *icp
+) {
+ icmData *p;
+ if ((p = (icmData *) icp->al->calloc(icp->al,1,sizeof(icmData))) == NULL)
+ return NULL;
+ p->ttype = icSigDataType;
+ p->refcount = 1;
+ p->get_size = icmData_get_size;
+ p->read = icmData_read;
+ p->write = icmData_write;
+ p->dump = icmData_dump;
+ p->allocate = icmData_allocate;
+ p->del = icmData_delete;
+ p->icp = icp;
+
+ p->flag = icmDataUndef;
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmText object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmText_get_size(
+ icmBase *pp
+) {
+ icmText *p = (icmText *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addmul(len, p->size, 1); /* 1 byte for each character element (inc. null) */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmText_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmText *p = (icmText *)pp;
+ icc *icp = p->icp;
+ int rv;
+ char *bp, *buf;
+
+ if (len < 8) {
+ sprintf(icp->err,"icmText_read: Tag too short to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmText_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmText_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = (len - 8)/1; /* Number of elements in the array */
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmText_read: Wrong tag type for icmText");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp = bp + 8;
+
+ if (p->size > 0) {
+ if ((rv = check_null_string(bp,p->size)) == 1) {
+ sprintf(icp->err,"icmText_read: text is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ memmove((void *)p->data, (void *)bp, p->size);
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmText_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmText *p = (icmText *)pp;
+ icc *icp = p->icp;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmText_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmText_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmText_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+ bp = bp + 8;
+
+ if (p->data != NULL) {
+ if ((rv = check_null_string(p->data, p->size)) == 1) {
+ sprintf(icp->err,"icmText_write: text is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+ memmove((void *)bp, (void *)p->data, p->size);
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmText_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmText_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmText *p = (icmText *)pp;
+ unsigned int i, r, c, size;
+
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"Text:\n");
+ op->gprintf(op," No. chars = %lu\n",p->size);
+
+ size = p->size > 0 ? p->size-1 : 0;
+ i = 0;
+ for (r = 1;; r++) { /* count rows */
+ if (i >= size) {
+ op->gprintf(op,"\n");
+ break;
+ }
+ if (r > 1 && verb < 2) {
+ op->gprintf(op,"...\n");
+ break; /* Print 1 row if not verbose */
+ }
+ c = 1;
+ op->gprintf(op," 0x%04lx: ",i);
+ c += 10;
+ while (i < size && c < 75) {
+ if (isprint(p->data[i])) {
+ op->gprintf(op,"%c",p->data[i]);
+ c++;
+ } else {
+ op->gprintf(op,"\\%03o",p->data[i]);
+ c += 4;
+ }
+ i++;
+ }
+ if (i < size)
+ op->gprintf(op,"\n");
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmText_allocate(
+ icmBase *pp
+) {
+ icmText *p = (icmText *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(char))) {
+ sprintf(icp->err,"icmText_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (char *) icp->al->calloc(icp->al, p->size, sizeof(char))) == NULL) {
+ sprintf(icp->err,"icmText_alloc: malloc() of icmText data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmText_delete(
+ icmBase *pp
+) {
+ icmText *p = (icmText *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmText(
+ icc *icp
+) {
+ icmText *p;
+ if ((p = (icmText *) icp->al->calloc(icp->al,1,sizeof(icmText))) == NULL)
+ return NULL;
+ p->ttype = icSigTextType;
+ p->refcount = 1;
+ p->get_size = icmText_get_size;
+ p->read = icmText_read;
+ p->write = icmText_write;
+ p->dump = icmText_dump;
+ p->allocate = icmText_allocate;
+ p->del = icmText_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+
+/* Data conversion support functions */
+static int write_DateTimeNumber(icmDateTimeNumber *p, char *d) {
+ int rv;
+ if (p->year < 1900 || p->year > 3000
+ || p->month == 0 || p->month > 12
+ || p->day == 0 || p->day > 31
+ || p->hours > 23
+ || p->minutes > 59
+ || p->seconds > 59)
+ return 1;
+
+ if ((rv = write_UInt16Number(p->year, d + 0)) != 0)
+ return rv;
+ if ((rv = write_UInt16Number(p->month, d + 2)) != 0)
+ return rv;
+ if ((rv = write_UInt16Number(p->day, d + 4)) != 0)
+ return rv;
+ if ((rv = write_UInt16Number(p->hours, d + 6)) != 0)
+ return rv;
+ if ((rv = write_UInt16Number(p->minutes, d + 8)) != 0)
+ return rv;
+ if ((rv = write_UInt16Number(p->seconds, d + 10)) != 0)
+ return rv;
+ return 0;
+}
+
+static int read_DateTimeNumber(icmDateTimeNumber *p, char *d) {
+
+ p->year = read_UInt16Number(d + 0);
+ p->month = read_UInt16Number(d + 2);
+ p->day = read_UInt16Number(d + 4);
+ p->hours = read_UInt16Number(d + 6);
+ p->minutes = read_UInt16Number(d + 8);
+ p->seconds = read_UInt16Number(d + 10);
+
+ /* Sanity check the date and time */
+ if (p->year >= 1900 && p->year <= 3000
+ && p->month != 0 && p->month <= 12
+ && p->day != 0 && p->day <= 31
+ && p->hours <= 23
+ && p->minutes <= 59
+ && p->seconds <= 59)
+ return 0;
+
+#ifdef NEVER
+ printf("Raw year = %d, month = %d, day = %d\n",p->year, p->month, p->day);
+ printf("Raw hour = %d, minutes = %d, seconds = %d\n", p->hours, p->minutes, p->seconds);
+#endif /* NEVER */
+
+#ifdef ICM_STRICT
+ return 1; /* Not legal */
+
+#else
+ /* Be more forgiving */
+
+ /* Check for Adobe problem */
+ if (p->month >= 1900 && p->month <= 3000
+ && p->year != 0 && p->year <= 12
+ && p->hours != 0 && p->hours <= 31
+ && p->day <= 23
+ && p->seconds <= 59
+ && p->minutes <= 59) {
+ unsigned int tt;
+
+ /* Correct Adobe's faulty profile */
+ tt = p->month; p->month = p->year; p->year = tt;
+ tt = p->hours; p->hours = p->day; p->day = tt;
+ tt = p->seconds; p->seconds = p->minutes; p->minutes = tt;
+
+ return 0;
+ }
+
+ /* Hmm. some other sort of corruption. Limit values to sane */
+ if (p->year < 1900) {
+ if (p->year < 100) /* Hmm. didn't use 4 digit year, guess it's 19xx ? */
+ p->year += 1900;
+ else
+ p->year = 1900;
+ } else if (p->year > 3000)
+ p->year = 3000;
+
+ if (p->month == 0)
+ p->month = 1;
+ else if (p->month > 12)
+ p->month = 12;
+
+ if (p->day == 0)
+ p->day = 1;
+ else if (p->day > 31)
+ p->day = 31;
+
+ if (p->hours > 23)
+ p->hours = 23;
+
+ if (p->minutes > 59)
+ p->minutes = 59;
+
+ if (p->seconds > 59)
+ p->seconds = 59;
+
+ return 0;
+#endif
+}
+
+/* Return a string that shows the given date and time */
+static char *string_DateTimeNumber(icmDateTimeNumber *p) {
+ static const char *mstring[13] = {"Bad", "Jan","Feb","Mar","Apr","May","Jun",
+ "Jul","Aug","Sep","Oct","Nov","Dec"};
+ static char buf[80];
+
+ sprintf(buf,"%d %s %4d, %d:%02d:%02d",
+ p->day, mstring[p->month > 12 ? 0 : p->month], p->year,
+ p->hours, p->minutes, p->seconds);
+ return buf;
+}
+
+/* Set the DateTime structure to the current date and time */
+static void setcur_DateTimeNumber(icmDateTimeNumber *p) {
+ time_t cclk;
+ struct tm *ctm;
+
+ cclk = time(NULL);
+ ctm = localtime(&cclk);
+
+ p->year = ctm->tm_year + 1900;
+ p->month = ctm->tm_mon + 1;
+ p->day = ctm->tm_mday;
+ p->hours = ctm->tm_hour;
+ p->minutes = ctm->tm_min;
+ p->seconds = ctm->tm_sec;
+}
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmDateTimeNumber_get_size(
+ icmBase *pp
+) {
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_add(len, 12); /* 12 bytes for Date & Time */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmDateTimeNumber_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmDateTimeNumber *p = (icmDateTimeNumber *)pp;
+ icc *icp = p->icp;
+ int rv;
+ char *bp, *buf;
+
+ if (len < 20) {
+ sprintf(icp->err,"icmDateTimeNumber_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmDateTimeNumber_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmDateTimeNumber_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmDateTimeNumber_read: Wrong tag type for icmDateTimeNumber");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp += 8; /* Skip padding */
+
+ /* Read the time and date from buffer */
+ if((rv = read_DateTimeNumber(p, bp)) != 0) {
+ sprintf(icp->err,"icmDateTimeNumber_read: Corrupted DateTime");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmDateTimeNumber_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmDateTimeNumber *p = (icmDateTimeNumber *)pp;
+ icc *icp = p->icp;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmDateTimeNumber_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmDateTimeNumber_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmDateTimeNumber_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write all the data to the buffer */
+ bp += 8; /* Skip padding */
+ if ((rv = write_DateTimeNumber(p, bp)) != 0) {
+ sprintf(icp->err,"icmDateTimeNumber_write: write_DateTimeNumber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmDateTimeNumber_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmDateTimeNumber_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmDateTimeNumber *p = (icmDateTimeNumber *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"DateTimeNumber:\n");
+ op->gprintf(op," Date = %s\n", string_DateTimeNumber(p));
+}
+
+/* Allocate variable sized data elements */
+static int icmDateTimeNumber_allocate(
+ icmBase *pp
+) {
+ /* Nothing to do */
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmDateTimeNumber_delete(
+ icmBase *pp
+) {
+ icmDateTimeNumber *p = (icmDateTimeNumber *)pp;
+ icc *icp = p->icp;
+
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmDateTimeNumber(
+ icc *icp
+) {
+ icmDateTimeNumber *p;
+ if ((p = (icmDateTimeNumber *) icp->al->calloc(icp->al,1,sizeof(icmDateTimeNumber))) == NULL)
+ return NULL;
+ p->ttype = icSigDateTimeType;
+ p->refcount = 1;
+ p->get_size = icmDateTimeNumber_get_size;
+ p->read = icmDateTimeNumber_read;
+ p->write = icmDateTimeNumber_write;
+ p->dump = icmDateTimeNumber_dump;
+ p->allocate = icmDateTimeNumber_allocate;
+ p->del = icmDateTimeNumber_delete;
+ p->icp = icp;
+
+ setcur_DateTimeNumber(p); /* Default to current date and time */
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmLut object */
+
+/* Check if the matrix is non-zero */
+static int icmLut_nu_matrix(
+ icmLut *p /* Pointer to Lut object */
+) {
+ int i, j;
+
+ for (j = 0; j < 3; j++) { /* Rows */
+ for (i = 0; i < 3; i++) { /* Columns */
+ if ( (i == j && p->e[j][i] != 1.0)
+ || (i != j && p->e[j][i] != 0.0))
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* return the locations of the minimum and */
+/* maximum values of the given channel, in the clut */
+static void icmLut_min_max(
+ icmLut *p, /* Pointer to Lut object */
+ double *minp, /* Return position of min/max */
+ double *maxp,
+ int chan /* Channel, -1 for average of all */
+) {
+ double *tp;
+ double minv, maxv; /* Values */
+ unsigned int e, ee, f;
+ int gc[MAX_CHAN]; /* Grid coordinate */
+
+ minv = 1e6;
+ maxv = -1e6;
+
+ for (e = 0; e < p->inputChan; e++)
+ gc[e] = 0; /* init coords */
+
+ /* Search the whole table */
+ for (tp = p->clutTable, e = 0; e < p->inputChan; tp += p->outputChan) {
+ double v;
+ if (chan == -1) {
+ for (v = 0.0, f = 0; f < p->outputChan; f++)
+ v += tp[f];
+ } else {
+ v = tp[chan];
+ }
+ if (v < minv) {
+ minv = v;
+ for (ee = 0; ee < p->inputChan; ee++)
+ minp[ee] = gc[ee]/(p->clutPoints-1.0);
+ }
+ if (v > maxv) {
+ maxv = v;
+ for (ee = 0; ee < p->inputChan; ee++)
+ maxp[ee] = gc[ee]/(p->clutPoints-1.0);
+ }
+
+ /* Increment coord */
+ for (e = 0; e < p->inputChan; e++) {
+ if (++gc[e] < p->clutPoints)
+ break; /* No carry */
+ gc[e] = 0;
+ }
+ }
+}
+
+/* Convert XYZ throught Luts matrix */
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+static int icmLut_lookup_matrix(
+icmLut *p, /* Pointer to Lut object */
+double *out, /* Output array[outputChan] in ICC order - see Table 39 in 6.5.5 */
+double *in /* Input array[inputChan] */
+) {
+ double t0,t1; /* Take care if out == in */
+ t0 = p->e[0][0] * in[0] + p->e[0][1] * in[1] + p->e[0][2] * in[2];
+ t1 = p->e[1][0] * in[0] + p->e[1][1] * in[1] + p->e[1][2] * in[2];
+ out[2] = p->e[2][0] * in[0] + p->e[2][1] * in[1] + p->e[2][2] * in[2];
+ out[0] = t0;
+ out[1] = t1;
+
+ return 0;
+}
+
+/* Convert normalized numbers though this Luts input tables. */
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+static int icmLut_lookup_input(
+icmLut *p, /* Pointer to Lut object */
+double *out, /* Output array[inputChan] */
+double *in /* Input array[inputChan] */
+) {
+ int rv = 0;
+ unsigned int ix, n;
+ double inputEnt_1 = (double)(p->inputEnt-1);
+ double *table = p->inputTable;
+
+ if (p->inputEnt == 0) { /* Hmm. */
+ for (n = 0; n < p->inputChan; n++)
+ out[n] = in[n];
+ } else {
+ /* Use linear interpolation */
+ for (n = 0; n < p->inputChan; n++, table += p->inputEnt) {
+ double val, w;
+ val = in[n] * inputEnt_1;
+ if (val < 0.0) {
+ val = 0.0;
+ rv |= 1;
+ } else if (val > inputEnt_1) {
+ val = inputEnt_1;
+ rv |= 1;
+ }
+ ix = (unsigned int)floor(val); /* Grid coordinate */
+ if (ix > (p->inputEnt-2))
+ ix = (p->inputEnt-2);
+ w = val - (double)ix; /* weight */
+ val = table[ix];
+ out[n] = val + w * (table[ix+1] - val);
+ }
+ }
+ return rv;
+}
+
+/* Convert normalized numbers though this Luts multi-dimensional table. */
+/* using multi-linear interpolation. */
+static int icmLut_lookup_clut_nl(
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+icmLut *p, /* Pointer to Lut object */
+double *out, /* Output array[inputChan] */
+double *in /* Input array[outputChan] */
+) {
+ icc *icp = p->icp;
+ int rv = 0;
+ double *gp; /* Pointer to grid cube base */
+ double co[MAX_CHAN]; /* Coordinate offset with the grid cell */
+ double *gw, GW[1 << 8]; /* weight for each grid cube corner */
+
+ if (p->inputChan <= 8) {
+ gw = GW; /* Use stack allocation */
+ } else {
+ if ((gw = (double *) icp->al->malloc(icp->al, sat_mul((1 << p->inputChan), sizeof(double)))) == NULL) {
+ sprintf(icp->err,"icmLut_lookup_clut: malloc() failed");
+ return icp->errc = 2;
+ }
+ }
+
+ /* We are using an multi-linear (ie. Trilinear for 3D input) interpolation. */
+ /* The implementation here uses more multiplies that some other schemes, */
+ /* (for instance, see "Tri-Linear Interpolation" by Steve Hill, */
+ /* Graphics Gems IV, page 521), but has less involved bookeeping, */
+ /* needs less local storage for intermediate output values, does fewer */
+ /* output and intermediate value reads, and fp multiplies are fast on */
+ /* todays processors! */
+
+ /* Compute base index into grid and coordinate offsets */
+ {
+ unsigned int e;
+ double clutPoints_1 = (double)(p->clutPoints-1);
+ int clutPoints_2 = p->clutPoints-2;
+ gp = p->clutTable; /* Base of grid array */
+
+ for (e = 0; e < p->inputChan; e++) {
+ unsigned int x;
+ double val;
+ val = in[e] * clutPoints_1;
+ if (val < 0.0) {
+ val = 0.0;
+ rv |= 1;
+ } else if (val > clutPoints_1) {
+ val = clutPoints_1;
+ rv |= 1;
+ }
+ x = (unsigned int)floor(val); /* Grid coordinate */
+ if (x > clutPoints_2)
+ x = clutPoints_2;
+ co[e] = val - (double)x; /* 1.0 - weight */
+ gp += x * p->dinc[e]; /* Add index offset for base of cube */
+ }
+ }
+ /* Compute corner weights needed for interpolation */
+ {
+ unsigned int e;
+ int i, g = 1;
+ gw[0] = 1.0;
+ for (e = 0; e < p->inputChan; e++) {
+ for (i = 0; i < g; i++) {
+ gw[g+i] = gw[i] * co[e];
+ gw[i] *= (1.0 - co[e]);
+ }
+ g *= 2;
+ }
+ }
+ /* Now compute the output values */
+ {
+ int i;
+ unsigned int f;
+ double w = gw[0];
+ double *d = gp + p->dcube[0];
+ for (f = 0; f < p->outputChan; f++) /* Base of cube */
+ out[f] = w * d[f];
+ for (i = 1; i < (1 << p->inputChan); i++) { /* For all other corners of cube */
+ w = gw[i]; /* Strength reduce */
+ d = gp + p->dcube[i];
+ for (f = 0; f < p->outputChan; f++)
+ out[f] += w * d[f];
+ }
+ }
+ if (gw != GW)
+ icp->al->free(icp->al, (void *)gw);
+ return rv;
+}
+
+/* Convert normalized numbers though this Luts multi-dimensional table */
+/* using simplex interpolation. */
+static int icmLut_lookup_clut_sx(
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+icmLut *p, /* Pointer to Lut object */
+double *out, /* Output array[inputChan] */
+double *in /* Input array[outputChan] */
+) {
+ int rv = 0;
+ double *gp; /* Pointer to grid cube base */
+ double co[MAX_CHAN]; /* Coordinate offset with the grid cell */
+ int si[MAX_CHAN]; /* co[] Sort index, [0] = smalest */
+
+ /* We are using a simplex (ie. tetrahedral for 3D input) interpolation. */
+ /* This method is more appropriate for XYZ/RGB/CMYK input spaces, */
+
+ /* Compute base index into grid and coordinate offsets */
+ {
+ unsigned int e;
+ double clutPoints_1 = (double)(p->clutPoints-1);
+ int clutPoints_2 = p->clutPoints-2;
+ gp = p->clutTable; /* Base of grid array */
+
+ for (e = 0; e < p->inputChan; e++) {
+ unsigned int x;
+ double val;
+ val = in[e] * clutPoints_1;
+ if (val < 0.0) {
+ val = 0.0;
+ rv |= 1;
+ } else if (val > clutPoints_1) {
+ val = clutPoints_1;
+ rv |= 1;
+ }
+ x = (unsigned int)floor(val); /* Grid coordinate */
+ if (x > clutPoints_2)
+ x = clutPoints_2;
+ co[e] = val - (double)x; /* 1.0 - weight */
+ gp += x * p->dinc[e]; /* Add index offset for base of cube */
+ }
+ }
+#ifdef NEVER
+ /* Do selection sort on coordinates, smallest to largest. */
+ {
+ int e, f;
+ for (e = 0; e < p->inputChan; e++)
+ si[e] = e; /* Initial unsorted indexes */
+ for (e = 0; e < (p->inputChan-1); e++) {
+ double cosn;
+ cosn = co[si[e]]; /* Current smallest value */
+ for (f = e+1; f < p->inputChan; f++) { /* Check against rest */
+ int tt;
+ tt = si[f];
+ if (cosn > co[tt]) {
+ si[f] = si[e]; /* Exchange */
+ si[e] = tt;
+ cosn = co[tt];
+ }
+ }
+ }
+ }
+#else
+ /* Do insertion sort on coordinates, smallest to largest. */
+ {
+ int f, vf;
+ unsigned int e;
+ double v;
+ for (e = 0; e < p->inputChan; e++)
+ si[e] = e; /* Initial unsorted indexes */
+
+ for (e = 1; e < p->inputChan; e++) {
+ f = e;
+ v = co[si[f]];
+ vf = f;
+ while (f > 0 && co[si[f-1]] > v) {
+ si[f] = si[f-1];
+ f--;
+ }
+ si[f] = vf;
+ }
+ }
+#endif
+ /* Now compute the weightings, simplex vertices and output values */
+ {
+ unsigned int e, f;
+ double w; /* Current vertex weight */
+
+ w = 1.0 - co[si[p->inputChan-1]]; /* Vertex at base of cell */
+ for (f = 0; f < p->outputChan; f++)
+ out[f] = w * gp[f];
+
+ for (e = p->inputChan-1; e > 0; e--) { /* Middle verticies */
+ w = co[si[e]] - co[si[e-1]];
+ gp += p->dinc[si[e]]; /* Move to top of cell in next largest dimension */
+ for (f = 0; f < p->outputChan; f++)
+ out[f] += w * gp[f];
+ }
+
+ w = co[si[0]];
+ gp += p->dinc[si[0]]; /* Far corner from base of cell */
+ for (f = 0; f < p->outputChan; f++)
+ out[f] += w * gp[f];
+ }
+ return rv;
+}
+
+#ifdef NEVER // ~~~99 development code
+
+/* Convert normalized numbers though this Luts multi-dimensional table */
+/* using optimised simplex interpolation. */
+/* This version optimses the simplex split axis depending on the input */
+/* colorspace. */
+static int icmLut_lookup_clut_osx(
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+icmLut *p, /* Pointer to Lut object */
+double *out, /* Output array[inputChan] */
+double *in /* Input array[outputChan] */
+) {
+ int rv = 0;
+ double *gp; /* Pointer to grid cube base */
+ double co[MAX_CHAN]; /* Coordinate offset with the grid cell */
+ int si[MAX_CHAN]; /* co[] Sort index, [0] = smalest */
+ char xflip[MAX_CHAN]; /* Optimised simplex axis flip flags */
+
+ /* Compute base index into grid and coordinate offsets */
+ {
+ unsigned int e;
+ double clutPoints_1 = (double)(p->clutPoints-1);
+ int clutPoints_2 = p->clutPoints-2;
+ gp = p->clutTable; /* Base of grid array */
+
+ for (e = 0; e < p->inputChan; e++) {
+ unsigned int x;
+ double val;
+// ~~~999
+#ifdef NEVER
+ xflip[e] = p->finfo[e].bthff;
+ if (in[e] >= p->finfo[e].fth)
+ xflip[e] = p->finfo[e].athff;
+#else
+
+ xflip[e] = 0;
+ if (e == 0)
+ xflip[e] = 1;
+#endif
+ val = in[e] * clutPoints_1;
+ if (val < 0.0) {
+ val = 0.0;
+ rv |= 1;
+ } else if (val > clutPoints_1) {
+ val = clutPoints_1;
+ rv |= 1;
+ }
+ x = (unsigned int)floor(val); /* Grid coordinate */
+ if (x > clutPoints_2)
+ x = clutPoints_2;
+ co[e] = val - (double)x; /* 1.0 - weight */
+ gp += x * p->dinc[e]; /* Add index offset for base of cube */
+ if (xflip[e]) { /* Reverse sense of direction for this axis */
+ co[e] = 1.0 - co[e];
+ gp += p->dinc[e];
+ }
+ }
+ }
+//printf("*");fflush(stdout);
+#ifdef NEVER
+ /* Do selection sort on coordinates, smallest to largest. */
+ {
+ int e, f;
+ for (e = 0; e < p->inputChan; e++)
+ si[e] = e; /* Initial unsorted indexes */
+ for (e = 0; e < (p->inputChan-1); e++) {
+ double cosn;
+ cosn = co[si[e]]; /* Current smallest value */
+ for (f = e+1; f < p->inputChan; f++) { /* Check against rest */
+ int tt;
+ tt = si[f];
+ if (cosn > co[tt]) {
+ si[f] = si[e]; /* Exchange */
+ si[e] = tt;
+ cosn = co[tt];
+ }
+ }
+ }
+ }
+#else
+ /* Do insertion sort on coordinates, smallest to largest. */
+ {
+ int f, vf;
+ unsigned int e;
+ double v;
+ for (e = 0; e < p->inputChan; e++)
+ si[e] = e; /* Initial unsorted indexes */
+
+ for (e = 1; e < p->inputChan; e++) {
+ f = e;
+ v = co[si[f]];
+ vf = f;
+ while (f > 0 && co[si[f-1]] > v) {
+ si[f] = si[f-1];
+ f--;
+ }
+ si[f] = vf;
+ }
+ }
+#endif
+ /* Now compute the weightings, simplex vertices and output values */
+ {
+ unsigned int e, f;
+ double w; /* Current vertex weight */
+
+ w = 1.0 - co[si[p->inputChan-1]]; /* Vertex at base of cell */
+ for (f = 0; f < p->outputChan; f++)
+ out[f] = w * gp[f];
+
+ for (e = p->inputChan-1; e > 0; e--) { /* Middle verticies */
+ w = co[si[e]] - co[si[e-1]];
+ if (xflip[e])
+ gp -= p->dinc[si[e]]; /* Move to top of cell in next largest dimension */
+ else
+ gp += p->dinc[si[e]]; /* Move to top of cell in next largest dimension */
+ for (f = 0; f < p->outputChan; f++)
+ out[f] += w * gp[f];
+ }
+
+ w = co[si[0]];
+ if (xflip[0])
+ gp -= p->dinc[si[0]]; /* Far corner from base of cell */
+ else
+ gp += p->dinc[si[0]]; /* Far corner from base of cell */
+ for (f = 0; f < p->outputChan; f++)
+ out[f] += w * gp[f];
+ }
+ return rv;
+}
+
+#endif /* NEVER */ // ~~~99 development code
+
+
+/* Convert normalized numbers though this Luts output tables. */
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+static int icmLut_lookup_output(
+icmLut *p, /* Pointer to Lut object */
+double *out, /* Output array[outputChan] */
+double *in /* Input array[outputChan] */
+) {
+ int rv = 0;
+ unsigned int ix, n;
+ double outputEnt_1 = (double)(p->outputEnt-1);
+ double *table = p->outputTable;
+
+ if (p->outputEnt == 0) { /* Hmm. */
+ for (n = 0; n < p->outputChan; n++)
+ out[n] = in[n];
+ } else {
+ /* Use linear interpolation */
+ for (n = 0; n < p->outputChan; n++, table += p->outputEnt) {
+ double val, w;
+ val = in[n] * outputEnt_1;
+ if (val < 0.0) {
+ val = 0.0;
+ rv |= 1;
+ } else if (val > outputEnt_1) {
+ val = outputEnt_1;
+ rv |= 1;
+ }
+ ix = (unsigned int)floor(val); /* Grid coordinate */
+ if (ix > (p->outputEnt-2))
+ ix = (p->outputEnt-2);
+ w = val - (double)ix; /* weight */
+ val = table[ix];
+ out[n] = val + w * (table[ix+1] - val);
+ }
+ }
+ return rv;
+}
+
+/* ----------------------------------------------- */
+/* Pseudo - Hilbert count sequencer */
+
+/* This multi-dimensional count sequence is a distributed */
+/* Gray code sequence, with direction reversal on every */
+/* alternate power of 2 scale. */
+/* It is intended to aid cache coherence in multi-dimensional */
+/* regular sampling. It approximates the Hilbert curve sequence. */
+
+/* Initialise, returns total usable count */
+unsigned
+psh_init(
+psh *p, /* Pointer to structure to initialise */
+int di, /* Dimensionality */
+unsigned int res, /* Size per coordinate */
+int co[] /* Coordinates to initialise (May be NULL) */
+) {
+ int e;
+
+ p->di = di;
+ p->res = res;
+
+ /* Compute bits */
+ for (p->bits = 0; (1u << p->bits) < res; p->bits++)
+ ;
+
+ /* Compute the total count mask */
+ p->tmask = ((((unsigned)1) << (p->bits * di))-1);
+
+ /* Compute usable count */
+ p->count = 1;
+ for (e = 0; e < di; e++)
+ p->count *= res;
+
+ p->ix = 0;
+
+ if (co != NULL) {
+ for (e = 0; e < di; e++)
+ co[e] = 0;
+ }
+
+ return p->count;
+}
+
+/* Reset the counter */
+void
+psh_reset(
+psh *p /* Pointer to structure */
+) {
+ p->ix = 0;
+}
+
+/* Increment pseudo-hilbert coordinates */
+/* Return non-zero if count rolls over to 0 */
+int
+psh_inc(
+psh *p, /* Pointer to structure */
+int co[] /* Coordinates to return */
+) {
+ int di = p->di;
+ unsigned int res = p->res;
+ unsigned int bits = p->bits;
+ int e;
+
+ do {
+ unsigned int b;
+ int gix; /* Gray code index */
+
+ p->ix = (p->ix + 1) & p->tmask;
+
+ gix = p->ix ^ (p->ix >> 1); /* Convert to gray code index */
+
+ for (e = 0; e < di; e++)
+ co[e] = 0;
+
+ for (b = 0; b < bits; b++) { /* Distribute bits */
+ if (b & 1) {
+ for (e = di-1; e >= 0; e--) { /* In reverse order */
+ co[e] |= (gix & 1) << b;
+ gix >>= 1;
+ }
+ } else {
+ for (e = 0; e < di; e++) { /* In normal order */
+ co[e] |= (gix & 1) << b;
+ gix >>= 1;
+ }
+ }
+ }
+
+ /* Convert from Gray to binary coordinates */
+ for (e = 0; e < di; e++) {
+ unsigned int sh, tv;
+
+ for(sh = 1, tv = co[e];; sh <<= 1) {
+ unsigned ptv = tv;
+ tv ^= (tv >> sh);
+ if (ptv <= 1 || sh == 16)
+ break;
+ }
+ if (tv >= res) /* Dumbo filter - increment again if outside cube range */
+ break;
+ co[e] = tv;
+ }
+
+ } while (e < di);
+
+ return (p->ix == 0);
+}
+
+/* ------------------------------------------------------- */
+
+#ifndef COUNTERS_H
+
+/* Macros for a multi-dimensional counter. */
+
+/* Declare the counter name nn, maximum di mxdi, dimensions di, & count */
+/* This counter can have each dimension range clipped */
+
+#define FCOUNT(nn, mxdi, di) \
+ int nn[mxdi]; /* counter value */ \
+ int nn##_di = (di); /* Number of dimensions */ \
+ int nn##_stt[mxdi]; /* start count value */ \
+ int nn##_res[mxdi]; /* last count +1 */ \
+ int nn##_e /* dimension index */
+
+#define FRECONF(nn, start, endp1) \
+ for (nn##_e = 0; nn##_e < nn##_di; nn##_e++) { \
+ nn##_stt[nn##_e] = (start); /* start count value */ \
+ nn##_res[nn##_e] = (endp1); /* last count +1 */ \
+ }
+
+/* Set the counter value to 0 */
+#define FC_INIT(nn) \
+{ \
+ for (nn##_e = 0; nn##_e < nn##_di; nn##_e++) \
+ nn[nn##_e] = nn##_stt[nn##_e]; \
+ nn##_e = 0; \
+}
+
+/* Increment the counter value */
+#define FC_INC(nn) \
+{ \
+ for (nn##_e = 0; nn##_e < nn##_di; nn##_e++) { \
+ nn[nn##_e]++; \
+ if (nn[nn##_e] < nn##_res[nn##_e]) \
+ break; /* No carry */ \
+ nn[nn##_e] = nn##_stt[nn##_e]; \
+ } \
+}
+
+/* After increment, expression is TRUE if counter is done */
+#define FC_DONE(nn) \
+ (nn##_e >= nn##_di)
+
+#endif /* COUNTERS_H */
+
+/* Parameter to getNormFunc function */
+typedef enum {
+ icmFromLuti = 0, /* return "fromo Lut normalized index" conversion function */
+ icmToLuti = 1, /* return "to Lut normalized index" conversion function */
+ icmFromLutv = 2, /* return "from Lut normalized value" conversion function */
+ icmToLutv = 3 /* return "to Lut normalized value" conversion function */
+} icmNormFlag;
+
+/* Return an appropriate color space normalization function, */
+/* given the color space and Lut type */
+/* Return 0 on success, 1 on match failure */
+static int getNormFunc(
+ icc *icp,
+ icColorSpaceSignature csig,
+ icTagTypeSignature tagSig,
+ icmNormFlag flag,
+ void (**nfunc)(double *out, double *in)
+);
+
+#define CLIP_MARGIN 0.005 /* Margine to allow before reporting clipping = 0.5% */
+
+/* Helper function to set multiple Lut tables simultaneously. */
+/* Note that these tables all have to be compatible in */
+/* having the same configuration and resolution. */
+/* Set errc and return error number in underlying icc */
+/* Set warnc if there is clipping in the output values */
+/* 1 = input table, 2 = main clut, 3 = clut midpoin, 4 = midpoint interp, 5 = output table */
+int icmSetMultiLutTables(
+ int ntables, /* Number of tables to be set, 1..n */
+ icmLut **pp, /* Pointer to array of Lut objects */
+ int flags, /* Setting flags */
+ void *cbctx, /* Opaque callback context pointer value */
+ icColorSpaceSignature insig, /* Input color space */
+ icColorSpaceSignature outsig, /* Output color space */
+ void (*infunc)(void *cbctx, double *out, double *in),
+ /* Input transfer function, inspace->inspace' (NULL = default) */
+ /* Will be called ntables times for each input grid value */
+ double *inmin, double *inmax, /* Maximum range of inspace' values */
+ /* (NULL = default) */
+ void (*clutfunc)(void *cbntx, double *out, double *in),
+ /* inspace' -> outspace[ntables]' transfer function */
+ /* will be called once for each input' grid value, and */
+ /* ntables output values should be written consecutively */
+ /* to out[]. */
+ double *clutmin, double *clutmax, /* Maximum range of outspace' values */
+ /* (NULL = default) */
+ void (*outfunc)(void *cbntx, double *out, double *in))
+ /* Output transfer function, outspace'->outspace (NULL = deflt) */
+ /* Will be called ntables times on each output value */
+{
+ icmLut *p, *pn; /* Pointer to 0'th nd tn'th Lut object */
+ icc *icp; /* Pointer to common icc */
+ int tn;
+ unsigned int e, f, i, n;
+ double **clutTable2 = NULL; /* Cell center values for ICM_CLUT_SET_APXLS */
+ double *clutTable3 = NULL; /* Vertex smoothing radius values [ntables] per entry */
+ int dinc3[MAX_CHAN]; /* Dimensional increment through clut3 (in doubles) */
+ int dcube3[1 << MAX_CHAN]; /* Hyper cube offsets throught clut3 (in doubles) */
+ int ii[MAX_CHAN]; /* Index value */
+ psh counter; /* Pseudo-Hilbert counter */
+// double _iv[4 * MAX_CHAN], *iv = &_iv[MAX_CHAN], *ivn; /* Real index value/table value */
+ int maxchan; /* Actual max of input and output */
+ double *_iv, *iv, *ivn; /* Real index value/table value */
+ double imin[MAX_CHAN], imax[MAX_CHAN];
+ double omin[MAX_CHAN], omax[MAX_CHAN];
+ void (*ifromindex)(double *out, double *in); /* Index to input color space function */
+ void (*itoentry)(double *out, double *in); /* Input color space to entry function */
+ void (*ifromentry)(double *out, double *in); /* Entry to input color space function */
+ void (*otoentry)(double *out, double *in); /* Output colorspace to table value function */
+ void (*ofromentry)(double *out, double *in); /* Table value to output color space function */
+ int clip = 0;
+
+ /* Check that everything is OK to proceed */
+ if (ntables < 1 || ntables > MAX_CHAN) {
+ if (ntables >= 1) {
+ icp = pp[0]->icp;
+ sprintf(icp->err,"icmSetMultiLutTables has illegal number of tables %d",ntables);
+ return icp->errc = 1;
+ } else {
+ /* Can't write error message anywhere */
+ return 1;
+ }
+ }
+
+ p = pp[0];
+ icp = p->icp;
+
+ for (tn = 1; tn < ntables; tn++) {
+ if (pp[tn]->icp != icp) {
+ sprintf(icp->err,"icmSetMultiLutTables Tables base icc is different");
+ return icp->errc = 1;
+ }
+ if (pp[tn]->ttype != p->ttype) {
+ sprintf(icp->err,"icmSetMultiLutTables Tables have different Tage Type");
+ return icp->errc = 1;
+ }
+
+ if (pp[tn]->inputChan != p->inputChan) {
+ sprintf(icp->err,"icmSetMultiLutTables Tables have different inputChan");
+ return icp->errc = 1;
+ }
+ if (pp[tn]->outputChan != p->outputChan) {
+ sprintf(icp->err,"icmSetMultiLutTables Tables have different outputChan");
+ return icp->errc = 1;
+ }
+ if (pp[tn]->clutPoints != p->clutPoints) {
+ sprintf(icp->err,"icmSetMultiLutTables Tables have different clutPoints");
+ return icp->errc = 1;
+ }
+ }
+
+ if (getNormFunc(icp, insig, p->ttype, icmFromLuti, &ifromindex) != 0) {
+ sprintf(icp->err,"icmLut_set_tables index to input colorspace function lookup failed");
+ return icp->errc = 1;
+ }
+ if (getNormFunc(icp, insig, p->ttype, icmToLutv, &itoentry) != 0) {
+ sprintf(icp->err,"icmLut_set_tables input colorspace to table entry function lookup failed");
+ return icp->errc = 1;
+ }
+ if (getNormFunc(icp, insig, p->ttype, icmFromLutv, &ifromentry) != 0) {
+ sprintf(icp->err,"icmLut_set_tables table entry to input colorspace function lookup failed");
+ return icp->errc = 1;
+ }
+
+ if (getNormFunc(icp, outsig, p->ttype, icmToLutv, &otoentry) != 0) {
+ sprintf(icp->err,"icmLut_set_tables output colorspace to table entry function lookup failed");
+ return icp->errc = 1;
+ }
+ if (getNormFunc(icp, outsig, p->ttype, icmFromLutv, &ofromentry) != 0) {
+ sprintf(icp->err,"icmLut_set_tables table entry to output colorspace function lookup failed");
+ return icp->errc = 1;
+ }
+
+ /* Allocate an array to hold the input and output values. */
+ /* It needs to be able to hold di "index under valus as in[], */
+ /* and ntables ICM_CLUT_SET_FILTER values as out[], so we assume maxchan >= di */
+ maxchan = p->inputChan > p->outputChan ? p->inputChan : p->outputChan;
+ if ((_iv = (double *) icp->al->malloc(icp->al, sizeof(double) * maxchan * (ntables+1)))
+ == NULL) {
+ sprintf(icp->err,"icmLut_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ iv = _iv + maxchan; /* Allow for "index under" and smoothing radius values */
+
+ /* Setup input table value min-max */
+ if (inmin == NULL || imax == NULL) {
+#ifdef SYMETRICAL_DEFAULT_LAB_RANGE /* Symetrical default range. */
+ /* We are assuming V2 Lab16 encoding, since this is a lut16type that always uses */
+ /* this encoding */
+ if (insig == icSigLabData) { /* Special case Lab */
+ double mn[3], mx[3];
+ /* This is to ensure that Lab 100,0,0 maps exactly to a clut grid point. */
+ /* This should work well if there is an odd grid resolution, */
+ /* and icclib is being used, as input lookup will */
+ /* be computed using floating point, so that the CLUT input value */
+ /* 0.5 can be represented exactly. */
+ /* Because the symetric range will cause slight clipping, */
+ /* only do it if the input table has sufficient resolution */
+ /* to represent the clipping faithfuly. */
+ if (p->inputEnt >= 64) {
+ if (p->ttype == icSigLut8Type) {
+ mn[0] = 0.0, mn[1] = mn[2] = -127.0;
+ mx[0] = 100.0, mx[1] = mx[2] = 127.0;
+ } else {
+ mn[0] = 0.0, mn[1] = mn[2] = -127.0 - 255.0/256.0;
+ mx[0] = 100.0, mx[1] = mx[2] = 127.0 + 255.0/256.0;
+ }
+ itoentry(imin, mn); /* Convert from input color space to table representation */
+ itoentry(imax, mx);
+ } else {
+ for (e = 0; e < p->inputChan; e++) {
+ imin[e] = 0.0;
+ imax[e] = 1.0;
+ }
+ }
+ } else
+#endif
+ {
+ for (e = 0; e < p->inputChan; e++) {
+ imin[e] = 0.0; /* We are assuming this is true for all other color spaces. */
+ imax[e] = 1.0;
+ }
+ }
+ } else {
+ itoentry(imin, inmin); /* Convert from input color space to table representation */
+ itoentry(imax, inmax);
+ }
+
+ /* Setup output table value min-max */
+ if (clutmin == NULL || clutmax == NULL) {
+#ifdef SYMETRICAL_DEFAULT_LAB_RANGE
+ /* This really isn't doing much, since the full range encoding doesn't need */
+ /* any adjustment to map a*b* 0 to an integer value. */
+ /* We are tweaking the 16 bit L* = 100 to the last index into */
+ /* the output table, which may help its accuracy slightly. */
+ /* We are assuming V2 Lab16 encoding, since this is a lut16type that always uses */
+ /* this encoding */
+ if (outsig == icSigLabData) { /* Special case Lab */
+ double mn[3], mx[3];
+ /* The output of the CLUT will be an 8 or 16 bit value, and we want to */
+ /* adjust the range so that the input grid point holding the white */
+ /* point can encode 0.0 exactly. */
+ /* Note that in the case of the a & b values, the range equates to */
+ /* normalised 0.0 .. 1.0, since 0 can be represented exactly in it. */
+ if (p->outputEnt >= 64) {
+ if (p->ttype == icSigLut8Type) {
+ mn[0] = 0.0, mn[1] = mn[2] = -128.0;
+ mx[0] = 100.0, mx[1] = mx[2] = 127.0;
+ } else {
+ mn[0] = 0.0, mn[1] = mn[2] = -128.0;
+ mx[0] = 100.0, mx[1] = mx[2] = (65535.0 * 255.0)/65280.0 - 128.0;
+ }
+ otoentry(omin, mn);/* Convert from output color space to table representation */
+ otoentry(omax, mx);
+ } else {
+ for (e = 0; e < p->inputChan; e++) {
+ omin[e] = 0.0;
+ omax[e] = 1.0;
+ }
+ }
+ } else
+#endif
+ {
+ for (f = 0; f < p->outputChan; f++) {
+ omin[f] = 0.0; /* We are assuming this is true for all other color spaces. */
+ omax[f] = 1.0;
+ }
+ }
+ } else {
+ otoentry(omin, clutmin);/* Convert from output color space to table representation */
+ otoentry(omax, clutmax);
+ }
+
+ /* Create the input table entry values */
+ for (tn = 0; tn < ntables; tn++) {
+ pn = pp[tn];
+ for (n = 0; n < pn->inputEnt; n++) {
+ double fv;
+ fv = n/(pn->inputEnt-1.0);
+ for (e = 0; e < pn->inputChan; e++)
+ iv[e] = fv;
+
+ ifromindex(iv,iv); /* Convert from index value to input color space value */
+
+ if (infunc != NULL)
+ infunc(cbctx, iv, iv); /* In colorspace -> input table -> In colorspace. */
+
+ itoentry(iv,iv); /* Convert from input color space value to table value */
+
+ /* Expand used range to 0.0 - 1.0, and clip to legal values */
+ /* Note that if the range is reduced, and clipping occurs, */
+ /* then there should be enough resolution within the input */
+ /* table, to represent the sharp edges of the clipping. */
+ for (e = 0; e < pn->inputChan; e++) {
+ double tt;
+ tt = (iv[e] - imin[e])/(imax[e] - imin[e]);
+ if (tt < 0.0) {
+ DBGSLC(("iclip: tt = %f, iv = %f, omin = %f, omax = %f\n",tt,iv[e],omin[e],omax[e]));
+ if (tt < -CLIP_MARGIN)
+ clip = 1;
+ tt = 0.0;
+ } else if (tt > 1.0) {
+ DBGSLC(("iclip: tt = %f, iv = %f, omin = %f, omax = %f\n",tt,iv[e],omin[e],omax[e]));
+ if (tt > (1.0 + CLIP_MARGIN))
+ clip = 1;
+ tt = 1.0;
+ }
+ iv[e] = tt;
+ }
+
+ for (e = 0; e < pn->inputChan; e++) /* Input tables */
+ pn->inputTable[e * pn->inputEnt + n] = iv[e];
+ }
+ }
+
+ /* Allocate space for cell center value lookup */
+ if (flags & ICM_CLUT_SET_APXLS) {
+ if ((clutTable2 = (double **) icp->al->calloc(icp->al,sizeof(double *), ntables)) == NULL) {
+ sprintf(icp->err,"icmLut_set_tables malloc of cube center array failed");
+ icp->al->free(icp->al, _iv);
+ return icp->errc = 1;
+ }
+ for (tn = 0; tn < ntables; tn++) {
+ if ((clutTable2[tn] = (double *) icp->al->calloc(icp->al,sizeof(double),
+ p->clutTable_size)) == NULL) {
+ for (--tn; tn >= 0; tn--)
+ icp->al->free(icp->al, clutTable2[tn]);
+ icp->al->free(icp->al, _iv);
+ icp->al->free(icp->al, clutTable2);
+ sprintf(icp->err,"icmLut_set_tables malloc of cube center array failed");
+ return icp->errc = 1;
+ }
+ }
+ }
+
+ /* Allocate space for smoothing radius values */
+ if (flags & ICM_CLUT_SET_FILTER) {
+ unsigned int j, g, size;
+
+ /* Private: compute dimensional increment though clut3 */
+ i = p->inputChan-1;
+ dinc3[i--] = ntables;
+ for (; i < p->inputChan; i--)
+ dinc3[i] = dinc3[i+1] * p->clutPoints;
+
+ /* Private: compute offsets from base of cube to other corners */
+ for (dcube3[0] = 0, g = 1, j = 0; j < p->inputChan; j++) {
+ for (i = 0; i < g; i++)
+ dcube3[g+i] = dcube3[i] + dinc3[j];
+ g *= 2;
+ }
+
+ if ((size = sat_mul(ntables, sat_pow(p->clutPoints,p->inputChan))) == UINT_MAX) {
+ sprintf(icp->err,"icmLut_alloc size overflow");
+ if (flags & ICM_CLUT_SET_APXLS) {
+ for (tn = 0; tn < ntables; tn++)
+ icp->al->free(icp->al, clutTable2[tn]);
+ }
+ icp->al->free(icp->al, clutTable2);
+ icp->al->free(icp->al, _iv);
+ return icp->errc = 1;
+ }
+
+ if ((clutTable3 = (double *) icp->al->calloc(icp->al,sizeof(double),
+ size)) == NULL) {
+ if (flags & ICM_CLUT_SET_APXLS) {
+ for (tn = 0; tn < ntables; tn++)
+ icp->al->free(icp->al, clutTable2[tn]);
+ }
+ icp->al->free(icp->al, clutTable2);
+ icp->al->free(icp->al, _iv);
+ sprintf(icp->err,"icmLut_set_tables malloc of vertex smoothing value array failed");
+ return icp->errc = 1;
+ }
+ }
+
+ /* Create the multi-dimensional lookup table values */
+
+ /* To make this clut function cache friendly, we use the pseudo-hilbert */
+ /* count sequence. This keeps each point close to the last in the */
+ /* multi-dimensional space. This is the point of setting multiple Luts at */
+ /* once too - the assumption is that these tables are all related (different */
+ /* gamut compressions for instance), and hence calling the clutfunc() with */
+ /* close values will maximise reverse lookup cache hit rate. */
+
+ psh_init(&counter, p->inputChan, p->clutPoints, ii); /* Initialise counter */
+
+ /* Itterate through all verticies in the grid */
+ for (;;) {
+ int ti, ti3; /* Table indexes */
+
+ for (ti = e = 0; e < p->inputChan; e++) { /* Input tables */
+ ti += ii[e] * p->dinc[e]; /* Clut index */
+ iv[e] = ii[e]/(p->clutPoints-1.0); /* Vertex coordinates */
+ iv[e] = iv[e] * (imax[e] - imin[e]) + imin[e]; /* Undo expansion to 0.0 - 1.0 */
+ *((int *)&iv[-((int)e)-1]) = ii[e]; /* Trick to supply grid index in iv[] */
+ }
+
+ if (flags & ICM_CLUT_SET_FILTER) {
+ for (ti3 = e = 0; e < p->inputChan; e++) /* Input tables */
+ ti3 += ii[e] * dinc3[e]; /* Clut3 index */
+ }
+
+ DBGSL(("\nix %s\n",icmPiv(p->inputChan, ii)));
+ DBGSL(("raw itv %s to iv'",icmPdv(p->inputChan, iv)));
+ ifromentry(iv,iv); /* Convert from table value to input color space */
+ DBGSL((" %s\n",icmPdv(p->inputChan, iv)));
+
+ /* Apply incolor -> outcolor function we want to represent for all tables */
+ DBGSL(("iv: %s to ov'",icmPdv(p->inputChan, iv)));
+ clutfunc(cbctx, iv, iv);
+ DBGSL((" %s\n",icmPdv(p->outputChan, iv)));
+
+ /* Save the results to the output tables */
+ for (tn = 0, ivn = iv; tn < ntables; ivn += p->outputChan, tn++) {
+ pn = pp[tn];
+
+ DBGSL(("tn %d, ov' %s -> otv",tn,icmPdv(p->outputChan, ivn)));
+ otoentry(ivn,ivn); /* Convert from output color space value to table value */
+ DBGSL((" %s\n -> oval",icmPdv(p->outputChan, ivn)));
+
+ /* Expand used range to 0.0 - 1.0, and clip to legal values */
+ for (f = 0; f < pn->outputChan; f++) {
+ double tt;
+ tt = (ivn[f] - omin[f])/(omax[f] - omin[f]);
+ if (tt < 0.0) {
+ DBGSLC(("lclip: tt = %f, ivn= %f, omin = %f, omax = %f\n",tt,ivn[f],omin[f],omax[f]));
+ if (tt < -CLIP_MARGIN)
+ clip = 2;
+ tt = 0.0;
+ } else if (tt > 1.0) {
+ DBGSLC(("lclip: tt = %f, ivn= %f, omin = %f, omax = %f\n",tt,ivn[f],omin[f],omax[f]));
+ if (tt > (1.0 + CLIP_MARGIN))
+ clip = 2;
+ tt = 1.0;
+ }
+ ivn[f] = tt;
+ }
+
+ for (f = 0; f < pn->outputChan; f++) /* Output chans */
+ pn->clutTable[ti + f] = ivn[f];
+ DBGSL((" %s\n",icmPdv(pn->outputChan, ivn)));
+
+ if (flags & ICM_CLUT_SET_FILTER) {
+ clutTable3[ti3 + tn] = iv[-1 -tn]; /* Filter radiuses */
+ }
+ }
+
+ /* Lookup cell center value if ICM_CLUT_SET_APXLS */
+ if (clutTable2 != NULL) {
+
+ for (e = 0; e < p->inputChan; e++) {
+ if (ii[e] >= (p->clutPoints-1))
+ break; /* Don't lookup beyond last */
+ iv[e] = (ii[e] + 0.5)/(p->clutPoints-1.0); /* Vertex coordinates + 0.5 */
+ iv[e] = iv[e] * (imax[e] - imin[e]) + imin[e]; /* Undo expansion to 0.0 - 1.0 */
+ *((int *)&iv[-((int)e)-1]) = ii[e]; /* Trick to supply grid index in iv[] */
+ /* (Not this is only the base for +0.5) */
+ }
+
+ if (e >= p->inputChan) { /* We're not on the last row */
+
+ ifromentry(iv,iv); /* Convert from table value to input color space */
+
+ /* Apply incolor -> outcolor function we want to represent */
+ clutfunc(cbctx, iv, iv);
+
+ /* Save the results to the output tables */
+ for (tn = 0, ivn = iv; tn < ntables; ivn += p->outputChan, tn++) {
+ pn = pp[tn];
+
+ otoentry(ivn,ivn); /* Convert from output color space value to table value */
+
+ /* Expand used range to 0.0 - 1.0, and clip to legal values */
+ for (f = 0; f < pn->outputChan; f++) {
+ double tt;
+ tt = (ivn[f] - omin[f])/(omax[f] - omin[f]);
+ if (tt < 0.0) {
+ DBGSLC(("lclip: tt = %f, ivn= %f, omin = %f, omax = %f\n",tt,ivn[f],omin[f],omax[f]));
+ if (tt < -CLIP_MARGIN)
+ clip = 3;
+ tt = 0.0;
+ } else if (tt > 1.0) {
+ DBGSLC(("lclip: tt = %f, ivn= %f, omin = %f, omax = %f\n",tt,ivn[f],omin[f],omax[f]));
+ if (tt > (1.0 + CLIP_MARGIN))
+ clip = 3;
+ tt = 1.0;
+ }
+ ivn[f] = tt;
+ }
+
+ for (f = 0; f < pn->outputChan; f++) /* Output chans */
+ clutTable2[tn][ti + f] = ivn[f];
+ }
+ }
+ }
+
+ /* Increment index within block (Reverse index significancd) */
+ if (psh_inc(&counter, ii))
+ break;
+ }
+
+#define APXLS_WHT 0.5
+#define APXLS_DIFF_THRHESH 0.2
+ /* Deal with cell center value, aproximate least squares adjustment. */
+ /* Subtract some of the mean of the surrounding center values from each grid value. */
+ /* Skip the edges so that things like the white point are not changed. */
+ /* Avoid modifying the value if the difference between the */
+ /* interpolated value and the current value is too great, */
+ /* and there is the possibility of different color aliases. */
+ if (clutTable2 != NULL) {
+ int ti; /* cube vertex table index */
+ int ti2; /* cube center table2 index */
+ int ee;
+ double cw = 1.0/(double)(1 << p->inputChan); /* Weight for each cube corner */
+
+ /* For each cell center point except last row */
+ for (e = 0; e < p->inputChan; e++)
+ ii[e] = 0; /* init coords */
+
+ /* Compute linear interpolated value from center values */
+ for (ee = 0; ee < p->inputChan;) {
+
+ /* Compute base index for table2 */
+ for (ti2 = e = 0; e < p->inputChan; e++) /* Input tables */
+ ti2 += ii[e] * p->dinc[e]; /* Clut index */
+
+ ti = ti2 + p->dcube[(1 << p->inputChan)-1]; /* +1 to each coord for vertex index */
+
+ for (tn = 0; tn < ntables; tn++) {
+ double mval[MAX_CHAN], vv;
+ double maxd = 0.0;
+
+ pn = pp[tn];
+
+ /* Compute mean of center values */
+ for (f = 0; f < pn->outputChan; f++) { /* Output chans */
+
+ mval[f] = 0.0;
+ for (i = 0; i < (1 << p->inputChan); i++) { /* For surrounding center values */
+ mval[f] += clutTable2[tn][ti2 + p->dcube[i] + f];
+ }
+ mval[f] = pn->clutTable[ti + f] - mval[f] * cw; /* Diff to mean */
+ vv = fabs(mval[f]);
+ if (vv > maxd)
+ maxd = vv;
+ }
+
+ if (pn->outputChan <= 3 || maxd < APXLS_DIFF_THRHESH) {
+ for (f = 0; f < pn->outputChan; f++) { /* Output chans */
+
+ vv = pn->clutTable[ti + f] + APXLS_WHT * mval[f];
+
+ /* Hmm. This is a bit crude. How do we know valid range is 0-1 ? */
+ /* What about an ink limit ? */
+ if (vv < 0.0) {
+ vv = 0.0;
+ } else if (vv > 1.0) {
+ vv = 1.0;
+ }
+ pn->clutTable[ti + f] = vv;
+ }
+ }
+ }
+
+ /* Increment coord */
+ for (ee = 0; ee < p->inputChan; ee++) {
+ if (++ii[ee] < (p->clutPoints-2)) /* Don't go through upper edge */
+ break; /* No carry */
+ ii[ee] = 0;
+ }
+ }
+
+ /* Done with center values */
+ for (tn = 0; tn < ntables; tn++)
+ icp->al->free(icp->al, clutTable2[tn]);
+ icp->al->free(icp->al, clutTable2);
+ }
+
+ /* Apply any smoothing in the clipped region to the resulting clutTable */
+ if (clutTable3 != NULL) {
+ double *clutTable1; /* Copy of current unfilted values */
+ FCOUNT(cc, MAX_CHAN, p->inputChan); /* Surrounding counter */
+
+ if ((clutTable1 = (double *) icp->al->calloc(icp->al,sizeof(double),
+ p->clutTable_size)) == NULL) {
+ icp->al->free(icp->al, clutTable3);
+ icp->al->free(icp->al, _iv);
+ sprintf(icp->err,"icmLut_set_tables malloc of grid copy failed");
+ return icp->errc = 1;
+ }
+
+ for (tn = 0; tn < ntables; tn++) {
+ int aa;
+ int ee;
+ int ti, ti3; /* Table indexes */
+
+ pn = pp[tn];
+
+ /* For each pass */
+ for (aa = 0; aa < 2; aa++) {
+
+ /* Copy current values */
+ memcpy(clutTable1, pn->clutTable, sizeof(double) * pn->clutTable_size);
+
+ /* Filter each point */
+ for (e = 0; e < pn->inputChan; e++)
+ ii[e] = 0; /* init coords */
+
+ /* Compute linear interpolated error to actual cell center value */
+ for (ee = 0; ee < pn->inputChan;) {
+ double rr; /* Filter radius */
+ int ir; /* Integer radius */
+ double tw; /* Total weight */
+
+ /* Compute base index for this cell */
+ for (ti3 = ti = e = 0; e < pn->inputChan; e++) { /* Input tables */
+ ti += ii[e] * pn->dinc[e]; /* Clut index */
+ ti3 += ii[e] * dinc3[e]; /* Clut3 index */
+ }
+ rr = clutTable3[ti3 + tn] * (pn->clutPoints-1.0);
+ ir = (int)floor(rr + 0.5); /* Don't bother unless 1/2 over vertex */
+
+ if (ir < 1)
+ goto next_vert;
+
+ //FRECONF(cc, -ir, ir + 1); /* Set size of surroundign grid */
+
+ /* Clip scanning cube to be within grid */
+ for (e = 0; e < pn->inputChan; e++) {
+ int cr = ir;
+ if ((ii[e] - ir) < 0)
+ cr = ii[e];
+ if ((ii[e] + ir) >= pn->clutPoints)
+ cr = pn->clutPoints -1 -ii[e];
+
+ cc_stt[e] = -cr;
+ cc_res[e] = cr + 1;
+ }
+
+ for (f = 0; f < pn->outputChan; f++)
+ pn->clutTable[ti + f] = 0.0;
+ tw = 0.0;
+
+ FC_INIT(cc)
+ for (tw = 0.0; !FC_DONE(cc);) {
+ double r;
+ int tti;
+
+ /* Radius of this cell */
+ for (r = 0.0, tti = e = 0; e < pn->inputChan; e++) {
+ int ix;
+ r += cc[e] * cc[e];
+ tti += (ii[e] + cc[e]) * p->dinc[e];
+ }
+ r = sqrt(r);
+
+ if (r <= rr && e >= pn->inputChan) {
+ double w = (rr - r)/rr; /* Triangle weighting */
+ w = sqrt(w);
+ for (f = 0; f < pn->outputChan; f++)
+ pn->clutTable[ti+f] += w * clutTable1[tti + f];
+ tw += w;
+ }
+ FC_INC(cc);
+ }
+ for (f = 0; f < pn->outputChan; f++) {
+ double vv = pn->clutTable[ti+f] / tw;
+ if (vv < 0.0) {
+ vv = 0.0;
+ } else if (vv > 1.0) {
+ vv = 1.0;
+ }
+ pn->clutTable[ti+f] = vv;
+ }
+
+ /* Increment coord */
+ next_vert:;
+ for (ee = 0; ee < pn->inputChan; ee++) {
+ if (++ii[ee] < (pn->clutPoints-1)) /* Don't go through upper edge */
+ break; /* No carry */
+ ii[ee] = 0;
+ }
+ } /* Next grid point to filter */
+ } /* Next pass */
+ } /* Next table */
+
+ free(clutTable1);
+ free(clutTable3);
+ }
+
+ /* Create the output table entry values */
+ for (tn = 0; tn < ntables; tn++) {
+ pn = pp[tn];
+ for (n = 0; n < pn->outputEnt; n++) {
+ double fv;
+ fv = n/(pn->outputEnt-1.0);
+ for (f = 0; f < pn->outputChan; f++)
+ iv[f] = fv;
+
+ /* Undo expansion to 0.0 - 1.0 */
+ for (f = 0; f < pn->outputChan; f++) /* Output tables */
+ iv[f] = iv[f] * (omax[f] - omin[f]) + omin[f];
+
+ ofromentry(iv,iv); /* Convert from table value to output color space value */
+
+ if (outfunc != NULL)
+ outfunc(cbctx, iv, iv); /* Out colorspace -> output table -> out colorspace. */
+
+ otoentry(iv,iv); /* Convert from output color space value to table value */
+
+ /* Clip to legal values */
+ for (f = 0; f < pn->outputChan; f++) {
+ double tt;
+ tt = iv[f];
+ if (tt < 0.0) {
+ DBGSLC(("oclip: tt = %f\n",tt));
+ if (tt < -CLIP_MARGIN)
+ clip = 5;
+ tt = 0.0;
+ } else if (tt > 1.0) {
+ DBGSLC(("oclip: tt = %f\n",tt));
+ if (tt > (1.0 + CLIP_MARGIN))
+ clip = 5;
+ tt = 1.0;
+ }
+ iv[f] = tt;
+ }
+
+ for (f = 0; f < pn->outputChan; f++) /* Input tables */
+ pn->outputTable[f * pn->outputEnt + n] = iv[f];
+ }
+ }
+
+ icp->al->free(icp->al, _iv);
+
+ icp->warnc = 0;
+ if (clip) {
+ DBGSLC(("Returning clip status = %d\n",clip));
+ icp->warnc = clip;
+ }
+
+ return 0;
+}
+
+/* Helper function to initialize a Lut tables contents */
+/* from supplied transfer functions. */
+/* Set errc and return error number */
+/* Set warnc if there is clipping in the output values */
+static int icmLut_set_tables (
+icmLut *p, /* Pointer to Lut object */
+int flags, /* Setting flags */
+void *cbctx, /* Opaque callback context pointer value */
+icColorSpaceSignature insig, /* Input color space */
+icColorSpaceSignature outsig, /* Output color space */
+void (*infunc)(void *cbcntx, double *out, double *in),
+ /* Input transfer function, inspace->inspace' (NULL = default) */
+double *inmin, double *inmax, /* Maximum range of inspace' values (NULL = default) */
+void (*clutfunc)(void *cbctx, double *out, double *in),
+ /* inspace' -> outspace' transfer function */
+double *clutmin, double *clutmax, /* Maximum range of outspace' values (NULL = default) */
+void (*outfunc)(void *cbctx, double *out, double *in)
+ /* Output transfer function, outspace'->outspace (NULL = deflt) */
+) {
+ struct _icmLut *pp[3];
+
+ /* Simply call the multiple table function with one table */
+ pp[0] = p;
+ return icmSetMultiLutTables(1, pp, flags,
+ cbctx, insig, outsig,
+ infunc,
+ inmin, inmax,
+ clutfunc,
+ clutmin, clutmax,
+ outfunc);
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmLut_get_size(
+ icmBase *pp
+) {
+ icmLut *p = (icmLut *)pp;
+ unsigned int len = 0;
+
+ if (p->ttype == icSigLut8Type) {
+ len = sat_add(len, 48); /* tag and header */
+ len = sat_add(len, sat_mul3(1, p->inputChan, p->inputEnt));
+ len = sat_add(len, sat_mul3(1, p->outputChan, sat_pow(p->clutPoints,p->inputChan)));
+ len = sat_add(len, sat_mul3(1, p->outputChan, p->outputEnt));
+ } else {
+ len = sat_add(len, 52); /* tag and header */
+ len = sat_add(len, sat_mul3(2, p->inputChan, p->inputEnt));
+ len = sat_add(len, sat_mul3(2, p->outputChan, sat_pow(p->clutPoints,p->inputChan)));
+ len = sat_add(len, sat_mul3(2, p->outputChan, p->outputEnt));
+ }
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmLut_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmLut *p = (icmLut *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i, j, g, size;
+ char *bp, *buf;
+
+ if (len < 4) {
+ sprintf(icp->err,"icmLut_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmLut_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmLut_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ p->ttype = (icTagTypeSignature)read_SInt32Number(bp);
+ if (p->ttype != icSigLut8Type && p->ttype != icSigLut16Type) {
+ sprintf(icp->err,"icmLut_read: Wrong tag type for icmLut");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ if (p->ttype == icSigLut8Type) {
+ if (len < 48) {
+ sprintf(icp->err,"icmLut_read: Tag too small to be legal");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ } else {
+ if (len < 52) {
+ sprintf(icp->err,"icmLut_read: Tag too small to be legal");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ }
+
+ /* Read in the info common to 8 and 16 bit Lut */
+ p->inputChan = read_UInt8Number(bp+8);
+ p->outputChan = read_UInt8Number(bp+9);
+ p->clutPoints = read_UInt8Number(bp+10);
+
+ /* Sanity check */
+ if (p->inputChan > MAX_CHAN) {
+ sprintf(icp->err,"icmLut_read: Can't handle > %d input channels\n",MAX_CHAN);
+ return icp->errc = 1;
+ }
+
+ if (p->outputChan > MAX_CHAN) {
+ sprintf(icp->err,"icmLut_read: Can't handle > %d output channels\n",MAX_CHAN);
+ return icp->errc = 1;
+ }
+
+ /* Read 3x3 transform matrix */
+ for (j = 0; j < 3; j++) { /* Rows */
+ for (i = 0; i < 3; i++) { /* Columns */
+ p->e[j][i] = read_S15Fixed16Number(bp + 12 + ((j * 3 + i) * 4));
+ }
+ }
+ /* Read 16 bit specific stuff */
+ if (p->ttype == icSigLut8Type) {
+ p->inputEnt = 256; /* By definition */
+ p->outputEnt = 256; /* By definition */
+ bp = buf+48;
+ } else {
+ p->inputEnt = read_UInt16Number(bp+48);
+ p->outputEnt = read_UInt16Number(bp+50);
+ bp = buf+52;
+ }
+
+ /* Sanity check dimensions. This protects against */
+ /* subsequent integer overflows involving the dimensions. */
+ if ((size = icmLut_get_size((icmBase *)p)) == UINT_MAX
+ || size > len) {
+ sprintf(icp->err,"icmLut_read: Tag wrong size for contents");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read the input tables */
+ size = (p->inputChan * p->inputEnt);
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ if (p->ttype == icSigLut8Type) {
+ for (i = 0; i < size; i++, bp += 1)
+ p->inputTable[i] = read_DCS8Number(bp);
+ } else {
+ for (i = 0; i < size; i++, bp += 2)
+ p->inputTable[i] = read_DCS16Number(bp);
+ }
+
+ /* Read the clut table */
+ size = (p->outputChan * sat_pow(p->clutPoints,p->inputChan));
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ if (p->ttype == icSigLut8Type) {
+ for (i = 0; i < size; i++, bp += 1)
+ p->clutTable[i] = read_DCS8Number(bp);
+ } else {
+ for (i = 0; i < size; i++, bp += 2)
+ p->clutTable[i] = read_DCS16Number(bp);
+ }
+
+ /* Read the output tables */
+ size = (p->outputChan * p->outputEnt);
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ if (p->ttype == icSigLut8Type) {
+ for (i = 0; i < size; i++, bp += 1)
+ p->outputTable[i] = read_DCS8Number(bp);
+ } else {
+ for (i = 0; i < size; i++, bp += 2)
+ p->outputTable[i] = read_DCS16Number(bp);
+ }
+
+ /* Private: compute dimensional increment though clut */
+ /* Note that first channel varies least rapidly. */
+ i = p->inputChan-1;
+ p->dinc[i--] = p->outputChan;
+ for (; i < p->inputChan; i--)
+ p->dinc[i] = p->dinc[i+1] * p->clutPoints;
+
+ /* Private: compute offsets from base of cube to other corners */
+ for (p->dcube[0] = 0, g = 1, j = 0; j < p->inputChan; j++) {
+ for (i = 0; i < g; i++)
+ p->dcube[g+i] = p->dcube[i] + p->dinc[j];
+ g *= 2;
+ }
+
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmLut_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmLut *p = (icmLut *)pp;
+ icc *icp = p->icp;
+ unsigned int i,j;
+ unsigned int len, size;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmLut_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmLut_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmLut_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write the info common to 8 and 16 bit Lut */
+ if ((rv = write_UInt8Number(p->inputChan, bp+8)) != 0) {
+ sprintf(icp->err,"icmLut_write: write_UInt8Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt8Number(p->outputChan, bp+9)) != 0) {
+ sprintf(icp->err,"icmLut_write: write_UInt8Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt8Number(p->clutPoints, bp+10)) != 0) {
+ sprintf(icp->err,"icmLut_write: write_UInt8Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ write_UInt8Number(0, bp+11); /* Set padding to 0 */
+
+ /* Write 3x3 transform matrix */
+ for (j = 0; j < 3; j++) { /* Rows */
+ for (i = 0; i < 3; i++) { /* Columns */
+ if ((rv = write_S15Fixed16Number(p->e[j][i],bp + 12 + ((j * 3 + i) * 4))) != 0) {
+ sprintf(icp->err,"icmLut_write: write_S15Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ }
+
+ /* Write 16 bit specific stuff */
+ if (p->ttype == icSigLut8Type) {
+ if (p->inputEnt != 256 || p->outputEnt != 256) {
+ sprintf(icp->err,"icmLut_write: 8 bit Input and Output tables must be 256 entries");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp = buf+48;
+ } else {
+ if (p->inputEnt > 4096 || p->outputEnt > 4096) {
+ sprintf(icp->err,"icmLut_write: 16 bit Input and Output tables must each be less than 4096 entries");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ if ((rv = write_UInt16Number(p->inputEnt, bp+48)) != 0) {
+ sprintf(icp->err,"icmLut_write: write_UInt16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt16Number(p->outputEnt, bp+50)) != 0) {
+ sprintf(icp->err,"icmLut_write: write_UInt16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ bp = buf+52;
+ }
+
+ /* Write the input tables */
+ size = (p->inputChan * p->inputEnt);
+ if (p->ttype == icSigLut8Type) {
+ for (i = 0; i < size; i++, bp += 1) {
+ if ((rv = write_DCS8Number(p->inputTable[i], bp)) != 0) {
+ sprintf(icp->err,"icmLut_write: inputTable write_DCS8Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ } else {
+ for (i = 0; i < size; i++, bp += 2) {
+ if ((rv = write_DCS16Number(p->inputTable[i], bp)) != 0) {
+ sprintf(icp->err,"icmLut_write: inputTable write_DCS16Number(%f) failed",p->inputTable[i]);
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ }
+
+ /* Write the clut table */
+ size = (p->outputChan * sat_pow(p->clutPoints,p->inputChan));
+ if (p->ttype == icSigLut8Type) {
+ for (i = 0; i < size; i++, bp += 1) {
+ if ((rv = write_DCS8Number(p->clutTable[i], bp)) != 0) {
+ sprintf(icp->err,"icmLut_write: clutTable write_DCS8Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ } else {
+ for (i = 0; i < size; i++, bp += 2) {
+ if ((rv = write_DCS16Number(p->clutTable[i], bp)) != 0) {
+ sprintf(icp->err,"icmLut_write: clutTable write_DCS16Number(%f) failed",p->clutTable[i]);
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ }
+
+ /* Write the output tables */
+ size = (p->outputChan * p->outputEnt);
+ if (p->ttype == icSigLut8Type) {
+ for (i = 0; i < size; i++, bp += 1) {
+ if ((rv = write_DCS8Number(p->outputTable[i], bp)) != 0) {
+ sprintf(icp->err,"icmLut_write: outputTable write_DCS8Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ } else {
+ for (i = 0; i < size; i++, bp += 2) {
+ if ((rv = write_DCS16Number(p->outputTable[i], bp)) != 0) {
+ sprintf(icp->err,"icmLut_write: outputTable write_DCS16Number(%f) failed",p->outputTable[i]);
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ }
+
+ /* Write buffer to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmLut_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmLut_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmLut *p = (icmLut *)pp;
+ if (verb <= 0)
+ return;
+
+ if (p->ttype == icSigLut8Type) {
+ op->gprintf(op,"Lut8:\n");
+ } else {
+ op->gprintf(op,"Lut16:\n");
+ }
+ op->gprintf(op," Input Channels = %u\n",p->inputChan);
+ op->gprintf(op," Output Channels = %u\n",p->outputChan);
+ op->gprintf(op," CLUT resolution = %u\n",p->clutPoints);
+ op->gprintf(op," Input Table entries = %u\n",p->inputEnt);
+ op->gprintf(op," Output Table entries = %u\n",p->outputEnt);
+ op->gprintf(op," XYZ matrix = %f, %f, %f\n",p->e[0][0],p->e[0][1],p->e[0][2]);
+ op->gprintf(op," %f, %f, %f\n",p->e[1][0],p->e[1][1],p->e[1][2]);
+ op->gprintf(op," %f, %f, %f\n",p->e[2][0],p->e[2][1],p->e[2][2]);
+
+ if (verb >= 2) {
+ unsigned int i, j, size;
+ unsigned int ii[MAX_CHAN]; /* maximum no of input channels */
+
+ op->gprintf(op," Input table:\n");
+ for (i = 0; i < p->inputEnt; i++) {
+ op->gprintf(op," %3u: ",i);
+ for (j = 0; j < p->inputChan; j++)
+ op->gprintf(op," %1.10f",p->inputTable[j * p->inputEnt + i]);
+ op->gprintf(op,"\n");
+ }
+
+ op->gprintf(op,"\n CLUT table:\n");
+ if (p->inputChan > MAX_CHAN) {
+ op->gprintf(op," !!Can't dump > %d input channel CLUT table!!\n",MAX_CHAN);
+ } else {
+ size = (p->outputChan * sat_pow(p->clutPoints,p->inputChan));
+ for (j = 0; j < p->inputChan; j++)
+ ii[j] = 0;
+ for (i = 0; i < size;) {
+ unsigned int k;
+ /* Print table entry index */
+ op->gprintf(op," ");
+ for (j = p->inputChan-1; j < p->inputChan; j--)
+ op->gprintf(op," %2u",ii[j]);
+ op->gprintf(op,":");
+ /* Print table entry contents */
+ for (k = 0; k < p->outputChan; k++, i++)
+ op->gprintf(op," %1.10f",p->clutTable[i]);
+ op->gprintf(op,"\n");
+
+ for (j = 0; j < p->inputChan; j++) { /* Increment index */
+ ii[j]++;
+ if (ii[j] < p->clutPoints)
+ break; /* No carry */
+ ii[j] = 0;
+ }
+ }
+ }
+
+ op->gprintf(op,"\n Output table:\n");
+ for (i = 0; i < p->outputEnt; i++) {
+ op->gprintf(op," %3u: ",i);
+ for (j = 0; j < p->outputChan; j++)
+ op->gprintf(op," %1.10f",p->outputTable[j * p->outputEnt + i]);
+ op->gprintf(op,"\n");
+ }
+
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmLut_allocate(
+ icmBase *pp
+) {
+ unsigned int i, j, g, size;
+ icmLut *p = (icmLut *)pp;
+ icc *icp = p->icp;
+
+ /* Sanity check */
+ if (p->inputChan < 1) {
+ sprintf(icp->err,"icmLut_alloc: Can't handle %d input channels\n",p->inputChan);
+ return icp->errc = 1;
+ }
+
+ if (p->inputChan > MAX_CHAN) {
+ sprintf(icp->err,"icmLut_alloc: Can't handle > %d input channels\n",MAX_CHAN);
+ return icp->errc = 1;
+ }
+
+ if (p->outputChan > MAX_CHAN) {
+ sprintf(icp->err,"icmLut_alloc: Can't handle > %d output channels\n",MAX_CHAN);
+ return icp->errc = 1;
+ }
+
+ if ((size = sat_mul(p->inputChan, p->inputEnt)) == UINT_MAX) {
+ sprintf(icp->err,"icmLut_alloc size overflow");
+ return icp->errc = 1;
+ }
+ if (size != p->inputTable_size) {
+ if (ovr_mul(size, sizeof(double))) {
+ sprintf(icp->err,"icmLut_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->inputTable != NULL)
+ icp->al->free(icp->al, p->inputTable);
+ if ((p->inputTable = (double *) icp->al->calloc(icp->al,size, sizeof(double))) == NULL) {
+ sprintf(icp->err,"icmLut_alloc: calloc() of Lut inputTable data failed");
+ return icp->errc = 2;
+ }
+ p->inputTable_size = size;
+ }
+ if ((size = sat_mul(p->outputChan, sat_pow(p->clutPoints,p->inputChan))) == UINT_MAX) {
+ sprintf(icp->err,"icmLut_alloc size overflow");
+ return icp->errc = 1;
+ }
+ if (size != p->clutTable_size) {
+ if (ovr_mul(size, sizeof(double))) {
+ sprintf(icp->err,"icmLut_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->clutTable != NULL)
+ icp->al->free(icp->al, p->clutTable);
+ if ((p->clutTable = (double *) icp->al->calloc(icp->al,size, sizeof(double))) == NULL) {
+ sprintf(icp->err,"icmLut_alloc: calloc() of Lut clutTable data failed");
+ return icp->errc = 2;
+ }
+ p->clutTable_size = size;
+ }
+ if ((size = sat_mul(p->outputChan, p->outputEnt)) == UINT_MAX) {
+ sprintf(icp->err,"icmLut_alloc size overflow");
+ return icp->errc = 1;
+ }
+ if (size != p->outputTable_size) {
+ if (ovr_mul(size, sizeof(double))) {
+ sprintf(icp->err,"icmLut_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->outputTable != NULL)
+ icp->al->free(icp->al, p->outputTable);
+ if ((p->outputTable = (double *) icp->al->calloc(icp->al,size, sizeof(double))) == NULL) {
+ sprintf(icp->err,"icmLut_alloc: calloc() of Lut outputTable data failed");
+ return icp->errc = 2;
+ }
+ p->outputTable_size = size;
+ }
+
+ /* Private: compute dimensional increment though clut */
+ /* Note that first channel varies least rapidly. */
+ i = p->inputChan-1;
+ p->dinc[i--] = p->outputChan;
+ for (; i < p->inputChan; i--)
+ p->dinc[i] = p->dinc[i+1] * p->clutPoints;
+
+ /* Private: compute offsets from base of cube to other corners */
+ for (p->dcube[0] = 0, g = 1, j = 0; j < p->inputChan; j++) {
+ for (i = 0; i < g; i++)
+ p->dcube[g+i] = p->dcube[i] + p->dinc[j];
+ g *= 2;
+ }
+
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmLut_delete(
+ icmBase *pp
+) {
+ icmLut *p = (icmLut *)pp;
+ icc *icp = p->icp;
+ int i;
+
+ if (p->inputTable != NULL)
+ icp->al->free(icp->al, p->inputTable);
+ if (p->clutTable != NULL)
+ icp->al->free(icp->al, p->clutTable);
+ if (p->outputTable != NULL)
+ icp->al->free(icp->al, p->outputTable);
+ for (i = 0; i < p->inputChan; i++)
+ icmTable_delete_bwd(icp, &p->rit[i]);
+ for (i = 0; i < p->outputChan; i++)
+ icmTable_delete_bwd(icp, &p->rot[i]);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmLut(
+ icc *icp
+) {
+ int i,j;
+ icmLut *p;
+ if ((p = (icmLut *) icp->al->calloc(icp->al,1,sizeof(icmLut))) == NULL)
+ return NULL;
+ p->ttype = icSigLut16Type;
+ p->refcount = 1;
+ p->get_size = icmLut_get_size;
+ p->read = icmLut_read;
+ p->write = icmLut_write;
+ p->dump = icmLut_dump;
+ p->allocate = icmLut_allocate;
+ p->del = icmLut_delete;
+
+ /* Lookup methods */
+ p->nu_matrix = icmLut_nu_matrix;
+ p->min_max = icmLut_min_max;
+ p->lookup_matrix = icmLut_lookup_matrix;
+ p->lookup_input = icmLut_lookup_input;
+ p->lookup_clut_nl = icmLut_lookup_clut_nl;
+ p->lookup_clut_sx = icmLut_lookup_clut_sx;
+ p->lookup_output = icmLut_lookup_output;
+
+ /* Set method */
+ p->set_tables = icmLut_set_tables;
+
+ p->icp = icp;
+
+ /* Set matrix to reasonable default */
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 3; j++) {
+ if (i == j)
+ p->e[i][j] = 1.0;
+ else
+ p->e[i][j] = 0.0;
+ }
+
+ /* Init lookups to non-dangerous values */
+ for (i = 0; i < MAX_CHAN; i++)
+ p->dinc[i] = 0;
+
+ for (i = 0; i < (1 << MAX_CHAN); i++)
+ p->dcube[i] = 0;
+
+ for (i = 0; i < MAX_CHAN; i++) {
+ p->rit[i].inited = 0;
+ p->rot[i].inited = 0;
+ }
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* Measurement */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmMeasurement_get_size(
+ icmBase *pp
+) {
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_add(len, 4); /* 4 for standard observer */
+ len = sat_add(len, 12); /* 12 for XYZ of measurement backing */
+ len = sat_add(len, 4); /* 4 for measurement geometry */
+ len = sat_add(len, 4); /* 4 for measurement flare */
+ len = sat_add(len, 4); /* 4 for standard illuminant */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmMeasurement_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmMeasurement *p = (icmMeasurement *)pp;
+ icc *icp = p->icp;
+ int rv;
+ char *bp, *buf;
+
+ if (len < 36) {
+ sprintf(icp->err,"icmMeasurement_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmMeasurement_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmMeasurement_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmMeasurement_read: Wrong tag type for icmMeasurement");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read the encoded standard observer */
+ p->observer = (icStandardObserver)read_SInt32Number(bp + 8);
+
+ /* Read the XYZ values for measurement backing */
+ if ((rv = read_XYZNumber(&p->backing, bp+12)) != 0) {
+ sprintf(icp->err,"icmMeasurement: read_XYZNumber error");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Read the encoded measurement geometry */
+ p->geometry = (icMeasurementGeometry)read_SInt32Number(bp + 24);
+
+ /* Read the proportion of flare */
+ p->flare = read_U16Fixed16Number(bp + 28);
+
+ /* Read the encoded standard illuminant */
+ p->illuminant = (icIlluminant)read_SInt32Number(bp + 32);
+
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmMeasurement_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmMeasurement *p = (icmMeasurement *)pp;
+ icc *icp = p->icp;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmMeasurement_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmMeasurement_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmMeasurement_write, type: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write the encoded standard observer */
+ if ((rv = write_SInt32Number((int)p->observer, bp + 8)) != 0) {
+ sprintf(icp->err,"icmMeasurementa_write, observer: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write the XYZ values for measurement backing */
+ if ((rv = write_XYZNumber(&p->backing, bp+12)) != 0) {
+ sprintf(icp->err,"icmMeasurement, backing: write_XYZNumber error");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write the encoded measurement geometry */
+ if ((rv = write_SInt32Number((int)p->geometry, bp + 24)) != 0) {
+ sprintf(icp->err,"icmMeasurementa_write, geometry: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write the proportion of flare */
+ if ((rv = write_U16Fixed16Number(p->flare, bp + 28)) != 0) {
+ sprintf(icp->err,"icmMeasurementa_write, flare: write_U16Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write the encoded standard illuminant */
+ if ((rv = write_SInt32Number((int)p->illuminant, bp + 32)) != 0) {
+ sprintf(icp->err,"icmMeasurementa_write, illuminant: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmMeasurement_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmMeasurement_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmMeasurement *p = (icmMeasurement *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"Measurement:\n");
+ op->gprintf(op," Standard Observer = %s\n", string_StandardObserver(p->observer));
+ op->gprintf(op," XYZ for Measurement Backing = %s\n", string_XYZNumber_and_Lab(&p->backing));
+ op->gprintf(op," Measurement Geometry = %s\n", string_MeasurementGeometry(p->geometry));
+ op->gprintf(op," Measurement Flare = %5.1f%%\n", p->flare * 100.0);
+ op->gprintf(op," Standard Illuminant = %s\n", string_Illuminant(p->illuminant));
+}
+
+/* Allocate variable sized data elements */
+static int icmMeasurement_allocate(
+ icmBase *pp
+) {
+ /* Nothing to do */
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmMeasurement_delete(
+ icmBase *pp
+) {
+ icmMeasurement *p = (icmMeasurement *)pp;
+ icc *icp = p->icp;
+
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmMeasurement(
+ icc *icp
+) {
+ icmMeasurement *p;
+ if ((p = (icmMeasurement *) icp->al->calloc(icp->al,1,sizeof(icmMeasurement))) == NULL)
+ return NULL;
+ p->ttype = icSigMeasurementType;
+ p->refcount = 1;
+ p->get_size = icmMeasurement_get_size;
+ p->read = icmMeasurement_read;
+ p->write = icmMeasurement_write;
+ p->dump = icmMeasurement_dump;
+ p->allocate = icmMeasurement_allocate;
+ p->del = icmMeasurement_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+
+/* Named color structure read/write support */
+static int read_NamedColorVal(
+ icmNamedColorVal *p,
+ char *bp,
+ char *end,
+ icColorSpaceSignature pcs, /* Header Profile Connection Space */
+ unsigned int ndc /* Number of device corrds */
+) {
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int mxl; /* Max possible string length */
+ int rv;
+
+ if (bp > end) {
+ sprintf(icp->err,"icmNamedColorVal_read: Data too short to read");
+ return icp->errc = 1;
+ }
+ mxl = (end - bp) < 32 ? (end - bp) : 32;
+ if ((rv = check_null_string(bp,mxl)) == 1) {
+ sprintf(icp->err,"icmNamedColorVal_read: Root name string not terminated");
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+ strcpy(p->root, bp);
+ bp += strlen(p->root) + 1;
+ if (bp > end || ndc > (end - bp)) {
+ sprintf(icp->err,"icmNamedColorVal_read: Data too short to read device coords");
+ return icp->errc = 1;
+ }
+ for (i = 0; i < ndc; i++) {
+ p->deviceCoords[i] = read_DCS8Number(bp);
+ bp += 1;
+ }
+ return 0;
+}
+
+static int read_NamedColorVal2(
+ icmNamedColorVal *p,
+ char *bp,
+ char *end,
+ icColorSpaceSignature pcs, /* Header Profile Connection Space */
+ unsigned int ndc /* Number of device coords */
+) {
+ int rv;
+ icc *icp = p->icp;
+ unsigned int i;
+
+ if (bp > end
+ || (32 + 6) > (end - bp)
+ || ndc > (end - bp - 32 - 6)/2) {
+ sprintf(icp->err,"icmNamedColorVal2_read: Data too short to read");
+ return icp->errc = 1;
+ }
+ if ((rv = check_null_string(bp,32)) == 1) {
+ sprintf(icp->err,"icmNamedColorVal2_read: Root name string not terminated");
+ return icp->errc = 1;
+ }
+ memmove((void *)p->root,(void *)(bp + 0),32);
+ switch(pcs) {
+ case icSigXYZData:
+ read_PCSNumber(icp, icSigXYZData, p->pcsCoords, bp+32);
+ break;
+ case icSigLabData:
+ /* namedColor2Type retains legacy Lab encoding */
+ read_PCSNumber(icp, icmSigLabV2Data, p->pcsCoords, bp+32);
+ break;
+ default:
+ return 1; /* Unknown PCS */
+ }
+ for (i = 0; i < ndc; i++)
+ p->deviceCoords[i] = read_DCS16Number(bp + 32 + 6 + 2 * i);
+ return 0;
+}
+
+static int write_NamedColorVal(
+ icmNamedColorVal *p,
+ char *d,
+ icColorSpaceSignature pcs, /* Header Profile Connection Space */
+ unsigned int ndc /* Number of device corrds */
+) {
+ icc *icp = p->icp;
+ unsigned int i;
+ int rv;
+
+ if ((rv = check_null_string(p->root,32)) == 1) {
+ sprintf(icp->err,"icmNamedColorVal_write: Root string names is unterminated");
+ return icp->errc = 1;
+ }
+ strcpy(d, p->root);
+ d += strlen(p->root) + 1;
+ for (i = 0; i < ndc; i++) {
+ if ((rv = write_DCS8Number(p->deviceCoords[i], d)) != 0) {
+ sprintf(icp->err,"icmNamedColorVal_write: write of device coord failed");
+ return icp->errc = 1;
+ }
+ d += 1;
+ }
+ return 0;
+}
+
+static int write_NamedColorVal2(
+ icmNamedColorVal *p,
+ char *bp,
+ icColorSpaceSignature pcs, /* Header Profile Connection Space */
+ unsigned int ndc /* Number of device coords */
+) {
+ icc *icp = p->icp;
+ unsigned int i;
+ int rv;
+
+ if ((rv = check_null_string(p->root,32)) == 1) {
+ sprintf(icp->err,"icmNamedColorVal2_write: Root string names is unterminated");
+ return icp->errc = 1;
+ }
+ rv = 0;
+ memmove((void *)(bp + 0),(void *)p->root,32);
+ switch(pcs) {
+ case icSigXYZData:
+ rv |= write_PCSNumber(icp, icSigXYZData, p->pcsCoords, bp+32);
+ break;
+ case icSigLabData:
+ /* namedColor2Type retains legacy Lab encoding */
+ rv |= write_PCSNumber(icp, icmSigLabV2Data, p->pcsCoords, bp+32);
+ break;
+ default:
+ sprintf(icp->err,"icmNamedColorVal2_write: Unknown PCS");
+ return icp->errc = 1;
+ }
+ if (rv) {
+ sprintf(icp->err,"icmNamedColorVal2_write: write of PCS coord failed");
+ return icp->errc = 1;
+ }
+ for (i = 0; i < ndc; i++) {
+ if ((rv = write_DCS16Number(p->deviceCoords[i], bp + 32 + 6 + 2 * i)) != 0) {
+ sprintf(icp->err,"icmNamedColorVal2_write: write of device coord failed");
+ return icp->errc = 1;
+ }
+ }
+ return 0;
+}
+
+/* - - - - - - - - - - - */
+/* icmNamedColor object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmNamedColor_get_size(
+ icmBase *pp
+) {
+ icmNamedColor *p = (icmNamedColor *)pp;
+ unsigned int len = 0;
+ if (p->ttype == icSigNamedColorType) {
+ unsigned int i;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_add(len, 4); /* 4 for vendor specific flags */
+ len = sat_add(len, 4); /* 4 for count of named colors */
+ len = sat_add(len, strlen(p->prefix) + 1); /* prefix of color names */
+ len = sat_add(len, strlen(p->suffix) + 1); /* suffix of color names */
+ for (i = 0; i < p->count; i++) {
+ len = sat_add(len, strlen(p->data[i].root) + 1); /* color names */
+ len = sat_add(len, p->nDeviceCoords * 1); /* bytes for each named color */
+ }
+ } else { /* Named Color 2 */
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_add(len, 4); /* 4 for vendor specific flags */
+ len = sat_add(len, 4); /* 4 for count of named colors */
+ len = sat_add(len, 4); /* 4 for number of device coords */
+ len = sat_add(len, 32); /* 32 for prefix of color names */
+ len = sat_add(len, 32); /* 32 for suffix of color names */
+ len = sat_add(len, sat_mul(p->count, (32 + 6 + p->nDeviceCoords * 2)));
+ /* bytes for each named color */
+ }
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmNamedColor_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmNamedColor *p = (icmNamedColor *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ char *bp, *buf, *end;
+ int rv;
+
+ if (len < 4) {
+ sprintf(icp->err,"icmNamedColor_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmNamedColor_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+ end = buf + len;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmNamedColor_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ p->ttype = (icTagTypeSignature)read_SInt32Number(bp);
+ if (p->ttype != icSigNamedColorType && p->ttype != icSigNamedColor2Type) {
+ sprintf(icp->err,"icmNamedColor_read: Wrong tag type for icmNamedColor");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ if (p->ttype == icSigNamedColorType) {
+ if (len < 16) {
+ sprintf(icp->err,"icmNamedColor_read: Tag too small to be legal");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Make sure that the number of device coords in known */
+ p->nDeviceCoords = number_ColorSpaceSignature(icp->header->colorSpace);
+ if (p->nDeviceCoords > MAX_CHAN) {
+ sprintf(icp->err,"icmNamedColor_read: Can't handle more than %d device channels",MAX_CHAN);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ } else { /* icmNC2 */
+ if (len < 84) {
+ sprintf(icp->err,"icmNamedColor_read: Tag too small to be legal");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ }
+
+ /* Read vendor specific flag */
+ p->vendorFlag = read_UInt32Number(bp+8);
+
+ /* Read count of named colors */
+ p->count = read_UInt32Number(bp+12);
+
+ if (p->ttype == icSigNamedColorType) {
+ unsigned int mxl; /* Max possible string length */
+ bp = bp + 16;
+
+ /* Prefix for each color name */
+ if (bp > end) {
+ sprintf(icp->err,"icmNamedColor_read: Data too short to read");
+ return icp->errc = 1;
+ }
+ mxl = (end - bp) < 32 ? (end - bp) : 32;
+ if ((rv = check_null_string(bp,mxl)) == 1) {
+ sprintf(icp->err,"icmNamedColor_read: Color prefix is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+ strcpy(p->prefix, bp);
+ bp += strlen(p->prefix) + 1;
+
+ /* Suffix for each color name */
+ if (bp > end) {
+ sprintf(icp->err,"icmNamedColor_read: Data too short to read");
+ return icp->errc = 1;
+ }
+ mxl = (end - bp) < 32 ? (end - bp) : 32;
+ if ((rv = check_null_string(bp,mxl)) == 1) {
+ sprintf(icp->err,"icmNamedColor_read: Color suffix is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+ strcpy(p->suffix, bp);
+ bp += strlen(p->suffix) + 1;
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < p->count; i++) {
+ if ((rv = read_NamedColorVal(p->data+i, bp, end, icp->header->pcs, p->nDeviceCoords)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ bp += strlen(p->data[i].root) + 1;
+ bp += p->nDeviceCoords * 1;
+ }
+ } else { /* icmNC2 */
+ /* Number of device coords per color */
+ p->nDeviceCoords = read_UInt32Number(bp+16);
+ if (p->nDeviceCoords > MAX_CHAN) {
+ sprintf(icp->err,"icmNamedColor_read: Can't handle more than %d device channels",MAX_CHAN);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Prefix for each color name */
+ memmove((void *)p->prefix, (void *)(bp + 20), 32);
+ if ((rv = check_null_string(p->prefix,32)) == 1) {
+ sprintf(icp->err,"icmNamedColor_read: Color prefix is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Suffix for each color name */
+ memmove((void *)p->suffix, (void *)(bp + 52), 32);
+ if ((rv = check_null_string(p->suffix,32)) == 1) {
+ sprintf(icp->err,"icmNamedColor_read: Color suffix is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read all the data from the buffer */
+ bp = bp + 84;
+ for (i = 0; i < p->count; i++) {
+ if ((rv = read_NamedColorVal2(p->data+i, bp, end, icp->header->pcs, p->nDeviceCoords)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ bp += 32 + 6 + p->nDeviceCoords * 2;
+ }
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmNamedColor_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmNamedColor *p = (icmNamedColor *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmNamedColor_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmNamedColor_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmNamedColor_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write vendor specific flag */
+ if ((rv = write_UInt32Number(p->vendorFlag, bp+8)) != 0) {
+ sprintf(icp->err,"icmNamedColor_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write count of named colors */
+ if ((rv = write_UInt32Number(p->count, bp+12)) != 0) {
+ sprintf(icp->err,"icmNamedColor_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ if (p->ttype == icSigNamedColorType) {
+ bp = bp + 16;
+
+ /* Prefix for each color name */
+ if ((rv = check_null_string(p->prefix,32)) == 1) {
+ sprintf(icp->err,"icmNamedColor_write: Color prefix is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ strcpy(bp, p->prefix);
+ bp += strlen(p->prefix) + 1;
+
+ /* Suffix for each color name */
+ if ((rv = check_null_string(p->suffix,32)) == 1) {
+ sprintf(icp->err,"icmNamedColor_write: Color sufix is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ strcpy(bp, p->suffix);
+ bp += strlen(p->suffix) + 1;
+
+ /* Write all the data to the buffer */
+
+ for (i = 0; i < p->count; i++) {
+ if ((rv = write_NamedColorVal(p->data+i, bp, icp->header->pcs, p->nDeviceCoords)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ bp += strlen(p->data[i].root) + 1;
+ bp += p->nDeviceCoords * 1;
+ }
+ } else { /* icmNC2 */
+ /* Number of device coords per color */
+ if ((rv = write_UInt32Number(p->nDeviceCoords, bp+16)) != 0) {
+ sprintf(icp->err,"icmNamedColor_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Prefix for each color name */
+ if ((rv = check_null_string(p->prefix,32)) == 1) {
+ sprintf(icp->err,"icmNamedColor_write: Color prefix is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ memmove((void *)(bp + 20), (void *)p->prefix, 32);
+
+ /* Suffix for each color name */
+ if ((rv = check_null_string(p->suffix,32)) == 1) {
+ sprintf(icp->err,"icmNamedColor_write: Color sufix is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ memmove((void *)(bp + 52), (void *)p->suffix, 32);
+
+ /* Write all the data to the buffer */
+ bp = bp + 84;
+ for (i = 0; i < p->count; i++, bp += (32 + 6 + p->nDeviceCoords * 2)) {
+ if ((rv = write_NamedColorVal2(p->data+i, bp, icp->header->pcs, p->nDeviceCoords)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmNamedColor_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmNamedColor_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmNamedColor *p = (icmNamedColor *)pp;
+ icc *icp = p->icp;
+ if (verb <= 0)
+ return;
+
+ if (p->ttype == icSigNamedColorType)
+ op->gprintf(op,"NamedColor:\n");
+ else
+ op->gprintf(op,"NamedColor2:\n");
+ op->gprintf(op," Vendor Flag = 0x%x\n",p->vendorFlag);
+ op->gprintf(op," No. colors = %u\n",p->count);
+ op->gprintf(op," No. dev. coords = %u\n",p->nDeviceCoords);
+ op->gprintf(op," Name prefix = '%s'\n",p->prefix);
+ op->gprintf(op," Name suffix = '%s'\n",p->suffix);
+ if (verb >= 2) {
+ unsigned int i, n;
+ icmNamedColorVal *vp;
+ for (i = 0; i < p->count; i++) {
+ vp = p->data + i;
+ op->gprintf(op," Color %lu:\n",i);
+ op->gprintf(op," Name root = '%s'\n",vp->root);
+
+ if (p->ttype == icSigNamedColor2Type) {
+ switch(icp->header->pcs) {
+ case icSigXYZData:
+ op->gprintf(op," XYZ = %f, %f, %f\n",
+ vp->pcsCoords[0],vp->pcsCoords[1],vp->pcsCoords[2]);
+ break;
+ case icSigLabData:
+ op->gprintf(op," Lab = %f, %f, %f\n",
+ vp->pcsCoords[0],vp->pcsCoords[1],vp->pcsCoords[2]);
+ break;
+ default:
+ op->gprintf(op," Unexpected PCS\n");
+ break;
+ }
+ }
+ if (p->nDeviceCoords > 0) {
+ op->gprintf(op," Device Coords = ");
+ for (n = 0; n < p->nDeviceCoords; n++) {
+ if (n > 0)
+ op->gprintf(op,", ");
+ op->gprintf(op,"%f",vp->deviceCoords[n]);
+ }
+ op->gprintf(op,"\n");
+ }
+ }
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmNamedColor_allocate(
+ icmBase *pp
+) {
+ icmNamedColor *p = (icmNamedColor *)pp;
+ icc *icp = p->icp;
+
+ if (p->count != p->_count) {
+ unsigned int i;
+ if (ovr_mul(p->count, sizeof(icmNamedColorVal))) {
+ sprintf(icp->err,"icmNamedColor_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (icmNamedColorVal *) icp->al->calloc(icp->al,p->count, sizeof(icmNamedColorVal))) == NULL) {
+ sprintf(icp->err,"icmNamedColor_alloc: malloc() of icmNamedColor data failed");
+ return icp->errc = 2;
+ }
+ for (i = 0; i < p->count; i++) {
+ p->data[i].icp = icp; /* Do init */
+ }
+ p->_count = p->count;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmNamedColor_delete(
+ icmBase *pp
+) {
+ icmNamedColor *p = (icmNamedColor *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmNamedColor(
+ icc *icp
+) {
+ icmNamedColor *p;
+ if ((p = (icmNamedColor *) icp->al->calloc(icp->al,1,sizeof(icmNamedColor))) == NULL)
+ return NULL;
+ p->ttype = icSigNamedColor2Type;
+ p->refcount = 1;
+ p->get_size = icmNamedColor_get_size;
+ p->read = icmNamedColor_read;
+ p->write = icmNamedColor_write;
+ p->dump = icmNamedColor_dump;
+ p->allocate = icmNamedColor_allocate;
+ p->del = icmNamedColor_delete;
+ p->icp = icp;
+
+ /* Default the the number of device coords appropriately for NamedColorType */
+ p->nDeviceCoords = number_ColorSpaceSignature(icp->header->colorSpace);
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* Colorant table structure read/write support */
+/* (Contribution from Piet Vandenborre) */
+
+static int read_ColorantTableVal(
+ icmColorantTableVal *p,
+ char *bp,
+ char *end,
+ icColorSpaceSignature pcs /* Header Profile Connection Space */
+) {
+ int rv;
+ icc *icp = p->icp;
+ if (bp > end || (32 + 6) > (end - bp)) {
+ sprintf(icp->err,"icmColorantTableVal_read: Data too short to read");
+ return icp->errc = 1;
+ }
+ if ((rv = check_null_string(bp,32)) == 1) {
+ sprintf(icp->err,"icmColorantTableVal_read: Name string not terminated");
+ return icp->errc = 1;
+ }
+ memmove((void *)p->name,(void *)(bp + 0),32);
+ switch(pcs) {
+ case icSigXYZData:
+ case icSigLabData:
+ read_PCSNumber(icp, pcs, p->pcsCoords, bp+32);
+ break;
+ default:
+ return 1; /* Unknown PCS */
+ }
+ return 0;
+}
+
+static int write_ColorantTableVal(
+ icmColorantTableVal *p,
+ char *bp,
+ icColorSpaceSignature pcs /* Header Profile Connection Space */
+) {
+ int rv;
+ icc *icp = p->icp;
+
+ if ((rv = check_null_string(p->name,32)) == 1) {
+ sprintf(icp->err,"icmColorantTableVal_write: Name string is unterminated");
+ return icp->errc = 1;
+ }
+ memmove((void *)(bp + 0),(void *)p->name,32);
+ rv = 0;
+ switch(pcs) {
+ case icSigXYZData:
+ case icSigLabData:
+ rv |= write_PCSNumber(icp, pcs, p->pcsCoords, bp+32);
+ break;
+ default:
+ sprintf(icp->err,"icmColorantTableVal_write: Unknown PCS");
+ return icp->errc = 1;
+ }
+ if (rv) {
+ sprintf(icp->err,"icmColorantTableVal_write: write of PCS coord failed");
+ return icp->errc = 1;
+ }
+ return 0;
+}
+
+/* - - - - - - - - - - - */
+/* icmColorantTable object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmColorantTable_get_size(
+ icmBase *pp
+) {
+ icmColorantTable *p = (icmColorantTable *)pp;
+ unsigned int len = 0;
+ if (p->ttype == icSigColorantTableType
+ || p->ttype == icmSigAltColorantTableType) {
+ unsigned int i;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_add(len, 4); /* 4 for count of colorants */
+ for (i = 0; i < p->count; i++) {
+ len = sat_add(len, 32); /* colorant names - 32 bytes*/
+ len = sat_add(len, 6); /* colorant pcs value - 3 x 16bit number*/
+ }
+ }
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmColorantTable_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmColorantTable *p = (icmColorantTable *)pp;
+ icc *icp = p->icp;
+ icColorSpaceSignature pcs;
+ unsigned int i;
+ char *bp, *buf, *end;
+ int rv = 0;
+
+ if (icp->header->deviceClass != icSigLinkClass)
+ pcs = icp->header->pcs;
+ else
+ pcs = icSigLabData;
+
+ if (len < 4) {
+ sprintf(icp->err,"icmColorantTable_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmColorantTable_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+ end = buf + len;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmColorantTable_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ p->ttype = (icTagTypeSignature)read_SInt32Number(bp);
+ if (p->ttype != icSigColorantTableType
+ && p->ttype != icmSigAltColorantTableType) {
+ sprintf(icp->err,"icmColorantTable_read: Wrong tag type for icmColorantTable");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ if (len < 12) {
+ sprintf(icp->err,"icmColorantTable_read: Tag too small to be legal");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read count of colorants */
+ if (p->ttype == icmSigAltColorantTableType)
+ p->count = read_UInt8Number(bp+8); /* Hmm. This is Little Endian */
+ else
+ p->count = read_UInt32Number(bp+8);
+
+ if (p->count > ((len - 12) / (32 + 6))) {
+ sprintf(icp->err,"icmColorantTable_read count overflow, count %x, len %d",p->count,len);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ bp = bp + 12;
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < p->count; i++, bp += (32 + 6)) {
+ if (p->ttype == icmSigAltColorantTableType /* Hack to reverse little endian */
+ && (end - bp) >= 38) {
+ int tt;
+ tt = *(bp + 32);
+ *(bp+32) = *(bp+33);
+ *(bp+33) = tt;
+ tt = *(bp + 34);
+ *(bp+34) = *(bp+35);
+ *(bp+35) = tt;
+ tt = *(bp + 36);
+ *(bp+36) = *(bp+37);
+ *(bp+37) = tt;
+ }
+ if ((rv = read_ColorantTableVal(p->data+i, bp, end, pcs)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ }
+
+ icp->al->free(icp->al, buf);
+ return rv;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmColorantTable_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmColorantTable *p = (icmColorantTable *)pp;
+ icc *icp = p->icp;
+ icColorSpaceSignature pcs;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ if (icp->header->deviceClass != icSigLinkClass)
+ pcs = icp->header->pcs;
+ else
+ pcs = icSigLabData;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmColorantTable_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmColorantTable_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmColorantTable_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write count of colorants */
+ if ((rv = write_UInt32Number(p->count, bp+8)) != 0) {
+ sprintf(icp->err,"icmColorantTable_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ bp = bp + 12;
+
+ /* Write all the data to the buffer */
+ for (i = 0; i < p->count; i++, bp += (32 + 6)) {
+ if ((rv = write_ColorantTableVal(p->data+i, bp, pcs)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmColorantTable_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmColorantTable_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmColorantTable *p = (icmColorantTable *)pp;
+ icc *icp = p->icp;
+ icColorSpaceSignature pcs;
+
+ if (icp->header->deviceClass != icSigLinkClass)
+ pcs = icp->header->pcs;
+ else
+ pcs = icSigLabData;
+
+ if (verb <= 0)
+ return;
+
+ if (p->ttype == icSigColorantTableType
+ || p->ttype == icmSigAltColorantTableType)
+ op->gprintf(op,"ColorantTable:\n");
+ op->gprintf(op," No. colorants = %u\n",p->count);
+ if (verb >= 2) {
+ unsigned int i;
+ icmColorantTableVal *vp;
+ for (i = 0; i < p->count; i++) {
+ vp = p->data + i;
+ op->gprintf(op," Colorant %lu:\n",i);
+ op->gprintf(op," Name = '%s'\n",vp->name);
+
+ if (p->ttype == icSigColorantTableType
+ || p->ttype == icmSigAltColorantTableType) {
+
+ switch(pcs) {
+ case icSigXYZData:
+ op->gprintf(op," XYZ = %f, %f, %f\n",
+ vp->pcsCoords[0],vp->pcsCoords[1],vp->pcsCoords[2]);
+ break;
+ case icSigLabData:
+ op->gprintf(op," Lab = %f, %f, %f\n",
+ vp->pcsCoords[0],vp->pcsCoords[1],vp->pcsCoords[2]);
+ break;
+ default:
+ op->gprintf(op," Unexpected PCS\n");
+ break;
+ }
+ }
+ }
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmColorantTable_allocate(
+ icmBase *pp
+) {
+ icmColorantTable *p = (icmColorantTable *)pp;
+ icc *icp = p->icp;
+
+ if (p->count != p->_count) {
+ unsigned int i;
+ if (ovr_mul(p->count, sizeof(icmColorantTableVal))) {
+ sprintf(icp->err,"icmColorantTable_alloc: count overflow (%d of %ld bytes)",p->count,sizeof(icmColorantTableVal));
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (icmColorantTableVal *) icp->al->calloc(icp->al,p->count, sizeof(icmColorantTableVal))) == NULL) {
+ sprintf(icp->err,"icmColorantTable_alloc: malloc() of icmColorantTable data failed");
+ return icp->errc = 2;
+ }
+ for (i = 0; i < p->count; i++) {
+ p->data[i].icp = icp; /* Do init */
+ }
+ p->_count = p->count;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmColorantTable_delete(
+ icmBase *pp
+) {
+ icmColorantTable *p = (icmColorantTable *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmColorantTable(
+ icc *icp
+) {
+ icmColorantTable *p;
+ if ((p = (icmColorantTable *) icp->al->calloc(icp->al,1,sizeof(icmColorantTable))) == NULL)
+ return NULL;
+ p->ttype = icSigColorantTableType;
+ p->refcount = 1;
+ p->get_size = icmColorantTable_get_size;
+ p->read = icmColorantTable_read;
+ p->write = icmColorantTable_write;
+ p->dump = icmColorantTable_dump;
+ p->allocate = icmColorantTable_allocate;
+ p->del = icmColorantTable_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* textDescription */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmTextDescription_get_size(
+ icmBase *pp
+) {
+ icmTextDescription *p = (icmTextDescription *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addadd(len, 4, p->size); /* Ascii string length + ascii string */
+ len = sat_addaddmul(len, 8, 2, p->ucSize); /* Unicode language code + length + string */
+ len = sat_addadd(len, 3, 67); /* ScriptCode code, length string */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmTextDescription_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmTextDescription *p = (icmTextDescription *)pp;
+ icc *icp = p->icp;
+ int rv;
+ char *bp, *buf, *end;
+
+#ifdef ICM_STRICT
+ if (len < (8 + 4 + 8 + 3 /* + 67 */)) {
+#else
+ if (len < (8 + 4 + 8 + 3)) {
+#endif
+ sprintf(icp->err,"icmTextDescription_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmTextDescription_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+ end = buf + len;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmTextDescription_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read from the buffer into the structure */
+ if ((rv = p->core_read(p, &bp, end)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* core read the object, return 0 on success, error code on fail */
+static int icmTextDescription_core_read(
+ icmTextDescription *p,
+ char **bpp, /* Pointer to buffer pointer, returns next after read */
+ char *end /* Pointer to past end of read buffer */
+) {
+ icc *icp = p->icp;
+ int rv;
+ char *bp = *bpp;
+
+ if (bp > end || 8 > (end - bp)) {
+ sprintf(icp->err,"icmTextDescription_read: Data too short to type descriptor");
+ *bpp = bp;
+ return icp->errc = 1;
+ }
+
+ p->size = read_UInt32Number(bp);
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: Wrong tag type ('%s') for icmTextDescription",
+ tag2str((icTagTypeSignature)read_SInt32Number(bp)));
+ return icp->errc = 1;
+ }
+ bp = bp + 8;
+
+ /* Read the Ascii string */
+ if (bp > end || 4 > (end - bp)) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: Data too short to read Ascii header");
+ return icp->errc = 1;
+ }
+ p->size = read_UInt32Number(bp);
+ bp += 4;
+ if (p->size > 0) {
+ if (bp > end || p->size > (end - bp)) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: Data too short to read Ascii string");
+ return icp->errc = 1;
+ }
+ if ((rv = check_null_string(bp,p->size)) == 1) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: ascii string is not terminated");
+ return icp->errc = 1;
+ }
+#ifdef ICM_STRICT
+ if (rv == 2) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: ascii string is shorter than count");
+ return icp->errc = 1;
+ }
+#endif
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ return rv;
+ }
+ strcpy(p->desc, bp);
+ bp += p->size;
+ }
+
+ /* Read the Unicode string */
+ if (bp > end || 8 > (end - bp)) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: Data too short to read Unicode string");
+ return icp->errc = 1;
+ }
+ p->ucLangCode = read_UInt32Number(bp);
+ bp += 4;
+ p->ucSize = read_UInt32Number(bp);
+ bp += 4;
+ if (p->ucSize > 0) {
+ ORD16 *up;
+ char *tbp;
+ if (bp > end || p->ucSize > (end - bp)/2) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: Data too short to read Unicode string");
+ return icp->errc = 1;
+ }
+ if ((rv = check_null_string16(bp,p->ucSize)) == 1) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: Unicode string is not terminated");
+ return icp->errc = 1;
+ }
+#ifdef ICM_STRICT
+ if (rv == 2) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: Unicode string is shorter than count");
+ return icp->errc = 1;
+ }
+#endif
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ return rv;
+ }
+ for (up = p->ucDesc, tbp = bp; tbp[0] != 0 || tbp[1] != 0; up++, tbp += 2)
+ *up = read_UInt16Number(tbp);
+ *up = 0; /* Unicode null */
+ bp += p->ucSize * 2;
+ }
+
+ /* Read the ScriptCode string */
+ if (bp > end || 3 > (end - bp)) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: Data too short to read ScriptCode header");
+ return icp->errc = 1;
+ }
+ p->scCode = read_UInt16Number(bp);
+ bp += 2;
+ p->scSize = read_UInt8Number(bp);
+ bp += 1;
+ if (p->scSize > 0) {
+ if (p->scSize > 67) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: ScriptCode string too long");
+ return icp->errc = 1;
+ }
+ if (bp > end || p->scSize > (end - bp)) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: Data too short to read ScriptCode string");
+ return icp->errc = 1;
+ }
+ if ((rv = check_null_string(bp,p->scSize)) == 1) {
+#ifdef ICM_STRICT
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_read: ScriptCode string is not terminated");
+ return icp->errc = 1;
+#else
+ /* Patch it up */
+ bp[p->scSize-1] = '\000';
+#endif
+ }
+ memmove((void *)p->scDesc, (void *)bp, p->scSize);
+ } else {
+ memset((void *)p->scDesc, 0, 67);
+ }
+ bp += 67;
+
+ *bpp = bp;
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmTextDescription_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmTextDescription *p = (icmTextDescription *)pp;
+ icc *icp = p->icp;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmTextDescription_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmTextDescription_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write to the buffer from the structure */
+ if ((rv = p->core_write(p, &bp)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmTextDescription_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Core write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmTextDescription_core_write(
+ icmTextDescription *p,
+ char **bpp /* Pointer to buffer pointer, returns next after read */
+) {
+ icc *icp = p->icp;
+ char *bp = *bpp;
+ int rv;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmTextDescription_write: write_SInt32Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+ bp = bp + 8;
+
+ /* Write the Ascii string */
+ if ((rv = write_UInt32Number(p->size,bp)) != 0) {
+ sprintf(icp->err,"icmTextDescription_write: write_UInt32Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ bp += 4;
+ if (p->size > 0) {
+ if ((rv = check_null_string(p->desc,p->size)) == 1) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_write: ascii string is not terminated");
+ return icp->errc = 1;
+ }
+ if (rv == 2) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_write: ascii string is shorter than length");
+ return icp->errc = 1;
+ }
+ strcpy(bp, p->desc);
+ bp += strlen(p->desc) + 1;
+ }
+
+ /* Write the Unicode string */
+ if ((rv = write_UInt32Number(p->ucLangCode, bp)) != 0) {
+ sprintf(icp->err,"icmTextDescription_write: write_UInt32Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ bp += 4;
+ if ((rv = write_UInt32Number(p->ucSize, bp)) != 0) {
+ sprintf(icp->err,"icmTextDescription_write: write_UInt32Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ bp += 4;
+ if (p->ucSize > 0) {
+ ORD16 *up;
+ if ((rv = check_null_string16((char *)p->ucDesc,p->ucSize)) == 1) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_write: Unicode string is not terminated");
+ return icp->errc = 1;
+ }
+ if (rv == 2) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_write: Unicode string is shorter than length");
+ return icp->errc = 1;
+ }
+ for(up = p->ucDesc; *up != 0; up++, bp += 2) {
+ if ((rv = write_UInt16Number(((unsigned int)*up), bp)) != 0) {
+ sprintf(icp->err,"icmTextDescription_write: write_UInt16Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ }
+ bp[0] = 0; /* null */
+ bp[1] = 0;
+ bp += 2;
+ }
+
+ /* Write the ScriptCode string */
+ if ((rv = write_UInt16Number(p->scCode, bp)) != 0) {
+ sprintf(icp->err,"icmTextDescription_write: write_UInt16Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ bp += 2;
+ if ((rv = write_UInt8Number(p->scSize, bp)) != 0) {
+ sprintf(icp->err,"icmTextDescription_write: write_UInt8Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ bp += 1;
+ if (p->scSize > 0) {
+ if (p->scSize > 67) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_write: ScriptCode string too long");
+ return icp->errc = 1;
+ }
+ if ((rv = check_null_string((char *)p->scDesc,p->scSize)) == 1) {
+ *bpp = bp;
+ sprintf(icp->err,"icmTextDescription_write: ScriptCode string is not terminated");
+ return icp->errc = 1;
+ }
+ memmove((void *)bp, (void *)p->scDesc, 67);
+ } else {
+ memset((void *)bp, 0, 67);
+ }
+ bp += 67;
+
+ *bpp = bp;
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmTextDescription_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmTextDescription *p = (icmTextDescription *)pp;
+ unsigned int i, r, c;
+
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"TextDescription:\n");
+
+ if (p->size > 0) {
+ unsigned int size = p->size > 0 ? p->size-1 : 0;
+ op->gprintf(op," ASCII data, length %lu chars:\n",p->size);
+
+ i = 0;
+ for (r = 1;; r++) { /* count rows */
+ if (i >= size) {
+ op->gprintf(op,"\n");
+ break;
+ }
+ if (r > 1 && verb < 2) {
+ op->gprintf(op,"...\n");
+ break; /* Print 1 row if not verbose */
+ }
+ c = 1;
+ op->gprintf(op," 0x%04lx: ",i);
+ c += 10;
+ while (i < size && c < 75) {
+ if (isprint(p->desc[i])) {
+ op->gprintf(op,"%c",p->desc[i]);
+ c++;
+ } else {
+ op->gprintf(op,"\\%03o",p->desc[i]);
+ c += 4;
+ }
+ i++;
+ }
+ if (i < size)
+ op->gprintf(op,"\n");
+ }
+ } else {
+ op->gprintf(op," No ASCII data\n");
+ }
+
+ /* Can't dump Unicode or ScriptCode as text with portable code */
+ if (p->ucSize > 0) {
+ unsigned int size = p->ucSize;
+ op->gprintf(op," Unicode Data, Language code 0x%x, length %lu chars\n",
+ p->ucLangCode, p->ucSize);
+ i = 0;
+ for (r = 1;; r++) { /* count rows */
+ if (i >= size) {
+ op->gprintf(op,"\n");
+ break;
+ }
+ if (r > 1 && verb < 2) {
+ op->gprintf(op,"...\n");
+ break; /* Print 1 row if not verbose */
+ }
+ c = 1;
+ op->gprintf(op," 0x%04lx: ",i);
+ c += 10;
+ while (i < size && c < 75) {
+ op->gprintf(op,"%04x ",p->ucDesc[i]);
+ c += 5;
+ i++;
+ }
+ if (i < size)
+ op->gprintf(op,"\n");
+ }
+ } else {
+ op->gprintf(op," No Unicode data\n");
+ }
+ if (p->scSize > 0) {
+ unsigned int size = p->scSize;
+ op->gprintf(op," ScriptCode Data, Code 0x%x, length %lu chars\n",
+ p->scCode, p->scSize);
+ i = 0;
+ for (r = 1;; r++) { /* count rows */
+ if (i >= size) {
+ op->gprintf(op,"\n");
+ break;
+ }
+ if (r > 1 && verb < 2) {
+ op->gprintf(op,"...\n");
+ break; /* Print 1 row if not verbose */
+ }
+ c = 1;
+ op->gprintf(op," 0x%04lx: ",i);
+ c += 10;
+ while (i < size && c < 75) {
+ op->gprintf(op,"%02x ",p->scDesc[i]);
+ c += 3;
+ i++;
+ }
+ if (i < size)
+ op->gprintf(op,"\n");
+ }
+ } else {
+ op->gprintf(op," No ScriptCode data\n");
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmTextDescription_allocate(
+ icmBase *pp
+) {
+ icmTextDescription *p = (icmTextDescription *)pp;
+ icc *icp = p->icp;
+
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(char))) {
+ sprintf(icp->err,"icmTextDescription_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->desc != NULL)
+ icp->al->free(icp->al, p->desc);
+ if ((p->desc = (char *) icp->al->calloc(icp->al, p->size, sizeof(char))) == NULL) {
+ sprintf(icp->err,"icmTextDescription_alloc: malloc() of Ascii description failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ if (p->ucSize != p->uc_size) {
+ if (ovr_mul(p->ucSize, sizeof(ORD16))) {
+ sprintf(icp->err,"icmTextDescription_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->ucDesc != NULL)
+ icp->al->free(icp->al, p->ucDesc);
+ if ((p->ucDesc = (ORD16 *) icp->al->calloc(icp->al, p->ucSize, sizeof(ORD16))) == NULL) {
+ sprintf(icp->err,"icmTextDescription_alloc: malloc() of Unicode description failed");
+ return icp->errc = 2;
+ }
+ p->uc_size = p->ucSize;
+ }
+ return 0;
+}
+
+/* Free all variable sized elements */
+static void icmTextDescription_unallocate(
+ icmTextDescription *p
+) {
+ icc *icp = p->icp;
+
+ if (p->desc != NULL)
+ icp->al->free(icp->al, p->desc);
+ if (p->ucDesc != NULL)
+ icp->al->free(icp->al, p->ucDesc);
+}
+
+/* Free all storage in the object */
+static void icmTextDescription_delete(
+ icmBase *pp
+) {
+ icmTextDescription *p = (icmTextDescription *)pp;
+ icc *icp = p->icp;
+
+ icmTextDescription_unallocate(p);
+ icp->al->free(icp->al, p);
+}
+
+/* Initialze a named object */
+static void icmTextDescription_init(
+ icmTextDescription *p,
+ icc *icp
+) {
+ memset((void *)p, 0, sizeof(icmTextDescription)); /* Imitate calloc */
+
+ p->ttype = icSigTextDescriptionType;
+ p->refcount = 1;
+ p->get_size = icmTextDescription_get_size;
+ p->read = icmTextDescription_read;
+ p->write = icmTextDescription_write;
+ p->dump = icmTextDescription_dump;
+ p->allocate = icmTextDescription_allocate;
+ p->del = icmTextDescription_delete;
+ p->icp = icp;
+
+ p->core_read = icmTextDescription_core_read;
+ p->core_write = icmTextDescription_core_write;
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmTextDescription(
+ icc *icp
+) {
+ icmTextDescription *p;
+ if ((p = (icmTextDescription *) icp->al->calloc(icp->al,1,sizeof(icmTextDescription))) == NULL)
+ return NULL;
+
+ icmTextDescription_init(p,icp);
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+
+/* Support for icmDescStruct */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmDescStruct_get_size(
+ icmDescStruct *p
+) {
+ unsigned int len = 0;
+ len = sat_add(len, 20); /* 20 bytes for header info */
+ len = sat_add(len, p->device.get_size((icmBase *)&p->device));
+ if (p->device.size == 0)
+ len = sat_add(len, 1); /* Extra 1 because of zero length desciption */
+ len = sat_add(len, p->model.get_size((icmBase *)&p->model));
+ if (p->model.size == 0)
+ len = sat_add(len, 1); /* Extra 1 because of zero length desciption */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmDescStruct_read(
+ icmDescStruct *p,
+ char **bpp, /* Pointer to buffer pointer, returns next after read */
+ char *end /* Pointer to past end of read buffer */
+) {
+ icc *icp = p->icp;
+ char *bp = *bpp;
+ int rv = 0;
+
+ if (bp > end || 20 > (end - bp)) {
+ sprintf(icp->err,"icmDescStruct_read: Data too short read header");
+ *bpp = bp;
+ return icp->errc = 1;
+ }
+
+ p->deviceMfg = read_SInt32Number(bp + 0);
+ p->deviceModel = read_UInt32Number(bp + 4);
+ read_UInt64Number(&p->attributes, bp + 8);
+ p->technology = (icTechnologySignature) read_UInt32Number(bp + 16);
+ *bpp = bp += 20;
+
+ /* Read the device text description */
+ if ((rv = p->device.core_read(&p->device, bpp, end)) != 0) {
+ return rv;
+ }
+
+ /* Read the model text description */
+ if ((rv = p->model.core_read(&p->model, bpp, end)) != 0) {
+ return rv;
+ }
+
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmDescStruct_write(
+ icmDescStruct *p,
+ char **bpp /* Pointer to buffer pointer, returns next after read */
+) {
+ icc *icp = p->icp;
+ char *bp = *bpp;
+ int rv = 0;
+ char *ttd = NULL;
+ unsigned int tts = 0;
+
+ if ((rv = write_SInt32Number(p->deviceMfg, bp + 0)) != 0) {
+ sprintf(icp->err,"icmDescStruct_write: write_SInt32Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt32Number(p->deviceModel, bp + 4)) != 0) {
+ sprintf(icp->err,"icmDescStruct_write: write_UInt32Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt64Number(&p->attributes, bp + 8)) != 0) {
+ sprintf(icp->err,"icmDescStruct_write: write_UInt64Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt32Number(p->technology, bp + 16)) != 0) {
+ sprintf(icp->err,"icmDescStruct_write: write_UInt32Number() failed");
+ *bpp = bp;
+ return icp->errc = rv;
+ }
+ *bpp = bp += 20;
+
+ /* Make sure the ASCII device text is a minimum size of 1, as per the spec. */
+ ttd = p->device.desc;
+ tts = p->device.size;
+
+ if (p->device.size == 0) {
+ p->device.desc = "";
+ p->device.size = 1;
+ }
+
+ /* Write the device text description */
+ if ((rv = p->device.core_write(&p->device, bpp)) != 0) {
+ return rv;
+ }
+
+ p->device.desc = ttd;
+ p->device.size = tts;
+
+ /* Make sure the ASCII model text is a minimum size of 1, as per the spec. */
+ ttd = p->model.desc;
+ tts = p->model.size;
+
+ if (p->model.size == 0) {
+ p->model.desc = "";
+ p->model.size = 1;
+ }
+
+ /* Write the model text description */
+ if ((rv = p->model.core_write(&p->model, bpp)) != 0) {
+ return rv;
+ }
+
+ p->model.desc = ttd;
+ p->model.size = tts;
+
+ /* Make sure the ASCII model text is a minimum size of 1, as per the spec. */
+ ttd = p->device.desc;
+ tts = p->device.size;
+
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmDescStruct_dump(
+ icmDescStruct *p,
+ icmFile *op, /* Output to dump to */
+ int verb, /* Verbosity level */
+ int index /* Description index */
+) {
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"DescStruct %u:\n",index);
+ if (verb >= 1) {
+ op->gprintf(op," Dev. Mnfctr. = %s\n",tag2str(p->deviceMfg)); /* ~~~ */
+ op->gprintf(op," Dev. Model = %s\n",tag2str(p->deviceModel)); /* ~~~ */
+ op->gprintf(op," Dev. Attrbts = %s\n", string_DeviceAttributes(p->attributes.l));
+ op->gprintf(op," Dev. Technology = %s\n", string_TechnologySignature(p->technology));
+ p->device.dump((icmBase *)&p->device, op,verb);
+ p->model.dump((icmBase *)&p->model, op,verb);
+ op->gprintf(op,"\n");
+ }
+}
+
+/* Allocate variable sized data elements (ie. descriptions) */
+static int icmDescStruct_allocate(
+ icmDescStruct *p
+) {
+ int rv;
+
+ if ((rv = p->device.allocate((icmBase *)&p->device)) != 0) {
+ return rv;
+ }
+ if ((rv = p->model.allocate((icmBase *)&p->model)) != 0) {
+ return rv;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmDescStruct_delete(
+ icmDescStruct *p
+) {
+ icmTextDescription_unallocate(&p->device);
+ icmTextDescription_unallocate(&p->model);
+}
+
+/* Init a DescStruct object */
+static void icmDescStruct_init(
+ icmDescStruct *p,
+ icc *icp
+) {
+
+ p->allocate = icmDescStruct_allocate;
+ p->icp = icp;
+
+ icmTextDescription_init(&p->device, icp);
+ icmTextDescription_init(&p->model, icp);
+}
+
+/* - - - - - - - - - - - - - - - */
+/* icmProfileSequenceDesc object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmProfileSequenceDesc_get_size(
+ icmBase *pp
+) {
+ icmProfileSequenceDesc *p = (icmProfileSequenceDesc *)pp;
+ unsigned int len = 0;
+ unsigned int i;
+ len = sat_add(len, 12); /* 12 bytes for tag, padding and count */
+ for (i = 0; i < p->count; i++) { /* All the description structures */
+ len = sat_add(len, icmDescStruct_get_size(&p->data[i]));
+ }
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmProfileSequenceDesc_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmProfileSequenceDesc *p = (icmProfileSequenceDesc *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ char *bp, *buf, *end;
+ int rv = 0;
+
+ if (len < 12) {
+ sprintf(icp->err,"icmProfileSequenceDesc_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmProfileSequenceDesc_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+ end = buf + len;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmProfileSequenceDesc_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmProfileSequenceDesc_read: Wrong tag type for icmProfileSequenceDesc");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp += 8; /* Skip padding */
+
+ p->count = read_UInt32Number(bp); /* Number of sequence descriptions */
+ bp += 4;
+
+ /* Read all the sequence descriptions */
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ for (i = 0; i < p->count; i++) {
+ if ((rv = icmDescStruct_read(&p->data[i], &bp, end)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ }
+
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmProfileSequenceDesc_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmProfileSequenceDesc *p = (icmProfileSequenceDesc *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmProfileSequenceDesc_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmProfileSequenceDesc_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmProfileSequenceDesc_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ if ((rv = write_UInt32Number(p->count,bp+8)) != 0) {
+ sprintf(icp->err,"icmProfileSequenceDesc_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ bp = bp + 12;
+
+ /* Write all the description structures */
+ for (i = 0; i < p->count; i++) {
+ if ((rv = icmDescStruct_write(&p->data[i], &bp)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmProfileSequenceDesc_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmProfileSequenceDesc_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmProfileSequenceDesc *p = (icmProfileSequenceDesc *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"ProfileSequenceDesc:\n");
+ op->gprintf(op," No. elements = %u\n",p->count);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->count; i++)
+ icmDescStruct_dump(&p->data[i], op, verb-1, i);
+ }
+}
+
+/* Allocate variable sized data elements (ie. count of profile descriptions) */
+static int icmProfileSequenceDesc_allocate(
+ icmBase *pp
+) {
+ icmProfileSequenceDesc *p = (icmProfileSequenceDesc *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+
+ if (p->count != p->_count) {
+ if (ovr_mul(p->count, sizeof(icmDescStruct))) {
+ sprintf(icp->err,"icmProfileSequenceDesc_allocate: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (icmDescStruct *) icp->al->calloc(icp->al, p->count, sizeof(icmDescStruct))) == NULL) {
+ sprintf(icp->err,"icmProfileSequenceDesc_allocate Allocation of DescStruct array failed");
+ return icp->errc = 2;
+ }
+ /* Now init the DescStructs */
+ for (i = 0; i < p->count; i++) {
+ icmDescStruct_init(&p->data[i], icp);
+ }
+ p->_count = p->count;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmProfileSequenceDesc_delete(
+ icmBase *pp
+) {
+ icmProfileSequenceDesc *p = (icmProfileSequenceDesc *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+
+ for (i = 0; i < p->count; i++) {
+ icmDescStruct_delete(&p->data[i]); /* Free allocated contents */
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmProfileSequenceDesc(
+ icc *icp
+) {
+ icmProfileSequenceDesc *p;
+ if ((p = (icmProfileSequenceDesc *) icp->al->calloc(icp->al,1,sizeof(icmProfileSequenceDesc))) == NULL)
+ return NULL;
+ p->ttype = icSigProfileSequenceDescType;
+ p->refcount = 1;
+ p->get_size = icmProfileSequenceDesc_get_size;
+ p->read = icmProfileSequenceDesc_read;
+ p->write = icmProfileSequenceDesc_write;
+ p->dump = icmProfileSequenceDesc_dump;
+ p->allocate = icmProfileSequenceDesc_allocate;
+ p->del = icmProfileSequenceDesc_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* Signature */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmSignature_get_size(
+ icmBase *pp
+) {
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_add(len, 4); /* 4 for signature */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmSignature_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmSignature *p = (icmSignature *)pp;
+ icc *icp = p->icp;
+ char *bp, *buf;
+
+ if (len < 12) {
+ sprintf(icp->err,"icmSignature_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmSignature_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmSignature_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmSignaturSignatureng tag type for icmSignature");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read the encoded measurement geometry */
+ p->sig = (icTechnologySignature)read_SInt32Number(bp + 8);
+
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmSignature_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmSignature *p = (icmSignature *)pp;
+ icc *icp = p->icp;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmSignature_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmSignature_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmSignature_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write the signature */
+ if ((rv = write_SInt32Number((int)p->sig, bp + 8)) != 0) {
+ sprintf(icp->err,"icmSignaturea_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmSignature_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmSignature_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmSignature *p = (icmSignature *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"Signature\n");
+ op->gprintf(op," Technology = %s\n", string_TechnologySignature(p->sig));
+}
+
+/* Allocate variable sized data elements */
+static int icmSignature_allocate(
+ icmBase *pp
+) {
+ /* Nothing to do */
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmSignature_delete(
+ icmBase *pp
+) {
+ icmSignature *p = (icmSignature *)pp;
+ icc *icp = p->icp;
+
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmSignature(
+ icc *icp
+) {
+ icmSignature *p;
+ if ((p = (icmSignature *) icp->al->calloc(icp->al,1,sizeof(icmSignature))) == NULL)
+ return NULL;
+ p->ttype = icSigSignatureType;
+ p->refcount = 1;
+ p->get_size = icmSignature_get_size;
+ p->read = icmSignature_read;
+ p->write = icmSignature_write;
+ p->dump = icmSignature_dump;
+ p->allocate = icmSignature_allocate;
+ p->del = icmSignature_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+
+/* Data conversion support functions */
+static int read_ScreeningData(icmScreeningData *p, char *d) {
+ p->frequency = read_S15Fixed16Number(d + 0);
+ p->angle = read_S15Fixed16Number(d + 4);
+ p->spotShape = (icSpotShape)read_SInt32Number(d + 8);
+ return 0;
+}
+
+static int write_ScreeningData(icmScreeningData *p, char *d) {
+ int rv;
+ if ((rv = write_S15Fixed16Number(p->frequency, d + 0)) != 0)
+ return rv;
+ if ((rv = write_S15Fixed16Number(p->angle, d + 4)) != 0)
+ return rv;
+ if ((rv = write_SInt32Number((int)p->spotShape, d + 8)) != 0)
+ return rv;
+ return 0;
+}
+
+
+/* icmScreening object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmScreening_get_size(
+ icmBase *pp
+) {
+ icmScreening *p = (icmScreening *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 16); /* 16 bytes for tag, padding, flag & channeles */
+ len = sat_addmul(len, p->channels, 12); /* 12 bytes for each channel */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmScreening_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmScreening *p = (icmScreening *)pp;
+ icc *icp = p->icp;
+ int rv = 0;
+ unsigned int i;
+ char *bp, *buf, *end;
+
+ if (len < 12) {
+ sprintf(icp->err,"icmScreening_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmScreening_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+ end = buf + len;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmScreening_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmScreening_read: Wrong tag type for icmScreening");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->screeningFlag = read_UInt32Number(bp+8); /* Flags */
+ p->channels = read_UInt32Number(bp+12); /* Number of channels */
+ bp = bp + 16;
+
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+
+ /* Read all the data from the buffer */
+ for (i = 0; i < p->channels; i++, bp += 12) {
+ if (bp > end || 12 > (end - bp)) {
+ sprintf(icp->err,"icmScreening_read: Data too short to read Screening Data");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ read_ScreeningData(&p->data[i], bp);
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmScreening_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmScreening *p = (icmScreening *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmScreening_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmScreening_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmScreening_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ if ((rv = write_UInt32Number(p->screeningFlag,bp+8)) != 0) {
+ sprintf(icp->err,"icmScreening_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt32Number(p->channels,bp+12)) != 0) {
+ sprintf(icp->err,"icmScreening_write: write_UInt32NumberXYZumber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ bp = bp + 16;
+
+ /* Write all the data to the buffer */
+ for (i = 0; i < p->channels; i++, bp += 12) {
+ if ((rv = write_ScreeningData(&p->data[i],bp)) != 0) {
+ sprintf(icp->err,"icmScreening_write: write_ScreeningData() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmScreening_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmScreening_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmScreening *p = (icmScreening *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"Screening:\n");
+ op->gprintf(op," Flags = %s\n", string_ScreenEncodings(p->screeningFlag));
+ op->gprintf(op," No. channels = %u\n",p->channels);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->channels; i++) {
+ op->gprintf(op," %lu:\n",i);
+ op->gprintf(op," Frequency: %f\n",p->data[i].frequency);
+ op->gprintf(op," Angle: %f\n",p->data[i].angle);
+ op->gprintf(op," Spot shape: %s\n", string_SpotShape(p->data[i].spotShape));
+ }
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmScreening_allocate(
+ icmBase *pp
+) {
+ icmScreening *p = (icmScreening *)pp;
+ icc *icp = p->icp;
+
+ if (p->channels != p->_channels) {
+ if (ovr_mul(p->channels, sizeof(icmScreeningData))) {
+ sprintf(icp->err,"icmScreening_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ if ((p->data = (icmScreeningData *) icp->al->malloc(icp->al, p->channels * sizeof(icmScreeningData))) == NULL) {
+ sprintf(icp->err,"icmScreening_alloc: malloc() of icmScreening data failed");
+ return icp->errc = 2;
+ }
+ p->_channels = p->channels;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmScreening_delete(
+ icmBase *pp
+) {
+ icmScreening *p = (icmScreening *)pp;
+ icc *icp = p->icp;
+
+ if (p->data != NULL)
+ icp->al->free(icp->al, p->data);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmScreening(
+ icc *icp
+) {
+ icmScreening *p;
+ if ((p = (icmScreening *) icp->al->calloc(icp->al,1,sizeof(icmScreening))) == NULL)
+ return NULL;
+ p->ttype = icSigScreeningType;
+ p->refcount = 1;
+ p->get_size = icmScreening_get_size;
+ p->read = icmScreening_read;
+ p->write = icmScreening_write;
+ p->dump = icmScreening_dump;
+ p->allocate = icmScreening_allocate;
+ p->del = icmScreening_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmUcrBg object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmUcrBg_get_size(
+ icmBase *pp
+) {
+ icmUcrBg *p = (icmUcrBg *)pp;
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addaddmul(len, 4, p->UCRcount, 2); /* Undercolor Removal */
+ len = sat_addaddmul(len, 4, p->BGcount, 2); /* Black Generation */
+ len = sat_add(len, p->size); /* Description string */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmUcrBg_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmUcrBg *p = (icmUcrBg *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ int rv;
+ char *bp, *buf, *end;
+
+ if (len < 16) {
+ sprintf(icp->err,"icmUcrBg_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUcrBg_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+ end = buf + len;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmUcrBg_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmUcrBg_read: Wrong tag type for icmUcrBg");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->UCRcount = read_UInt32Number(bp+8); /* First curve count */
+ bp = bp + 12;
+
+ if (p->UCRcount > 0) {
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ for (i = 0; i < p->UCRcount; i++, bp += 2) {
+ if (bp > end || 2 > (end - bp)) {
+ sprintf(icp->err,"icmUcrBg_read: Data too short to read UCR Data");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ if (p->UCRcount == 1) /* % */
+ p->UCRcurve[i] = (double)read_UInt16Number(bp);
+ else /* 0.0 - 1.0 */
+ p->UCRcurve[i] = read_DCS16Number(bp);
+ }
+ } else {
+ p->UCRcurve = NULL;
+ }
+
+ if (bp > end || 4 > (end - bp)) {
+ sprintf(icp->err,"icmData_read: Data too short to read Black Gen count");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->BGcount = read_UInt32Number(bp); /* First curve count */
+ bp += 4;
+
+ if (p->BGcount > 0) {
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ for (i = 0; i < p->BGcount; i++, bp += 2) {
+ if (bp > end || 2 > (end - bp)) {
+ sprintf(icp->err,"icmUcrBg_read: Data too short to read BG Data");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ if (p->BGcount == 1) /* % */
+ p->BGcurve[i] = (double)read_UInt16Number(bp);
+ else /* 0.0 - 1.0 */
+ p->BGcurve[i] = read_DCS16Number(bp);
+ }
+ } else {
+ p->BGcurve = NULL;
+ }
+
+ p->size = end - bp; /* Nominal string length */
+ if (p->size > 0) {
+ if ((rv = check_null_string(bp, p->size)) == 1) {
+ sprintf(icp->err,"icmUcrBg_read: string is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->size = strlen(bp) + 1;
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ memmove((void *)p->string, (void *)bp, p->size);
+ bp += p->size;
+ } else {
+ p->string = NULL;
+ }
+
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmUcrBg_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmUcrBg *p = (icmUcrBg *)pp;
+ icc *icp = p->icp;
+ unsigned int i;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmUcrBg_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmUcrBg_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmUcrBg_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+ bp = bp + 8;
+
+ /* Write UCR curve */
+ if ((rv = write_UInt32Number(p->UCRcount,bp)) != 0) {
+ sprintf(icp->err,"icmUcrBg_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ bp += 4;
+
+ for (i = 0; i < p->UCRcount; i++, bp += 2) {
+ if (p->UCRcount == 1) { /* % */
+ if ((rv = write_UInt16Number((unsigned int)(p->UCRcurve[i]+0.5),bp)) != 0) {
+ sprintf(icp->err,"icmUcrBg_write: write_UInt16umber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ } else {
+ if ((rv = write_DCS16Number(p->UCRcurve[i],bp)) != 0) {
+ sprintf(icp->err,"icmUcrBg_write: write_DCS16umber(%f) failed",p->UCRcurve[i]);
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ }
+
+ /* Write BG curve */
+ if ((rv = write_UInt32Number(p->BGcount,bp)) != 0) {
+ sprintf(icp->err,"icmUcrBg_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ bp += 4;
+
+ for (i = 0; i < p->BGcount; i++, bp += 2) {
+ if (p->BGcount == 1) { /* % */
+ if ((rv = write_UInt16Number((unsigned int)(p->BGcurve[i]+0.5),bp)) != 0) {
+ sprintf(icp->err,"icmUcrBg_write: write_UInt16umber() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ } else {
+ if ((rv = write_DCS16Number(p->BGcurve[i],bp)) != 0) {
+ sprintf(icp->err,"icmUcrBg_write: write_DCS16umber(%f) failed",p->BGcurve[i]);
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ }
+
+ if (p->string != NULL) {
+ if ((rv = check_null_string(p->string,p->size)) == 1) {
+ sprintf(icp->err,"icmUcrBg_write: text is not null terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ if (rv == 2) {
+ sprintf(icp->err,"icmUcrBg_write: text is shorter than length");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ memmove((void *)bp, (void *)p->string, p->size);
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmUcrBg_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmUcrBg_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmUcrBg *p = (icmUcrBg *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"Undercolor Removal Curve & Black Generation:\n");
+
+ if (p->UCRcount == 0) {
+ op->gprintf(op," UCR: Not specified\n");
+ } else if (p->UCRcount == 1) {
+ op->gprintf(op," UCR: %f%%\n",p->UCRcurve[0]);
+ } else {
+ op->gprintf(op," UCR curve no. elements = %u\n",p->UCRcount);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->UCRcount; i++)
+ op->gprintf(op," %3lu: %f\n",i,p->UCRcurve[i]);
+ }
+ }
+ if (p->BGcount == 0) {
+ op->gprintf(op," BG: Not specified\n");
+ } else if (p->BGcount == 1) {
+ op->gprintf(op," BG: %f%%\n",p->BGcurve[0]);
+ } else {
+ op->gprintf(op," BG curve no. elements = %u\n",p->BGcount);
+ if (verb >= 2) {
+ unsigned int i;
+ for (i = 0; i < p->BGcount; i++)
+ op->gprintf(op," %3lu: %f\n",i,p->BGcurve[i]);
+ }
+ }
+
+ {
+ unsigned int i, r, c, size;
+ op->gprintf(op," Description:\n");
+ op->gprintf(op," No. chars = %lu\n",p->size);
+
+ size = p->size > 0 ? p->size-1 : 0;
+ i = 0;
+ for (r = 1;; r++) { /* count rows */
+ if (i >= size) {
+ op->gprintf(op,"\n");
+ break;
+ }
+ if (r > 1 && verb < 2) {
+ op->gprintf(op,"...\n");
+ break; /* Print 1 row if not verbose */
+ }
+ c = 1;
+ op->gprintf(op," 0x%04lx: ",i);
+ c += 10;
+ while (i < size && c < 73) {
+ if (isprint(p->string[i])) {
+ op->gprintf(op,"%c",p->string[i]);
+ c++;
+ } else {
+ op->gprintf(op,"\\%03o",p->string[i]);
+ c += 4;
+ }
+ i++;
+ }
+ if (i < size)
+ op->gprintf(op,"\n");
+ }
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmUcrBg_allocate(
+ icmBase *pp
+) {
+ icmUcrBg *p = (icmUcrBg *)pp;
+ icc *icp = p->icp;
+
+ if (p->UCRcount != p->UCR_count) {
+ if (ovr_mul(p->UCRcount, sizeof(double))) {
+ sprintf(icp->err,"icmUcrBg_allocate: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->UCRcurve != NULL)
+ icp->al->free(icp->al, p->UCRcurve);
+ if ((p->UCRcurve = (double *) icp->al->calloc(icp->al, p->UCRcount, sizeof(double))) == NULL) {
+ sprintf(icp->err,"icmUcrBg_allocate: malloc() of UCR curve data failed");
+ return icp->errc = 2;
+ }
+ p->UCR_count = p->UCRcount;
+ }
+ if (p->BGcount != p->BG_count) {
+ if (ovr_mul(p->BGcount, sizeof(double))) {
+ sprintf(icp->err,"icmUcrBg_allocate: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->BGcurve != NULL)
+ icp->al->free(icp->al, p->BGcurve);
+ if ((p->BGcurve = (double *) icp->al->calloc(icp->al, p->BGcount, sizeof(double))) == NULL) {
+ sprintf(icp->err,"icmUcrBg_allocate: malloc() of BG curve data failed");
+ return icp->errc = 2;
+ }
+ p->BG_count = p->BGcount;
+ }
+ if (p->size != p->_size) {
+ if (ovr_mul(p->size, sizeof(char))) {
+ sprintf(icp->err,"icmUcrBg_allocate: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->string != NULL)
+ icp->al->free(icp->al, p->string);
+ if ((p->string = (char *) icp->al->calloc(icp->al, p->size, sizeof(char))) == NULL) {
+ sprintf(icp->err,"icmUcrBg_allocate: malloc() of string data failed");
+ return icp->errc = 2;
+ }
+ p->_size = p->size;
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmUcrBg_delete(
+ icmBase *pp
+) {
+ icmUcrBg *p = (icmUcrBg *)pp;
+ icc *icp = p->icp;
+
+ if (p->UCRcurve != NULL)
+ icp->al->free(icp->al, p->UCRcurve);
+ if (p->BGcurve != NULL)
+ icp->al->free(icp->al, p->BGcurve);
+ if (p->string != NULL)
+ icp->al->free(icp->al, p->string);
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmUcrBg(
+ icc *icp
+) {
+ icmUcrBg *p;
+ if ((p = (icmUcrBg *) icp->al->calloc(icp->al,1,sizeof(icmUcrBg))) == NULL)
+ return NULL;
+ p->ttype = icSigUcrBgType;
+ p->refcount = 1;
+ p->get_size = icmUcrBg_get_size;
+ p->read = icmUcrBg_read;
+ p->write = icmUcrBg_write;
+ p->dump = icmUcrBg_dump;
+ p->allocate = icmUcrBg_allocate;
+ p->del = icmUcrBg_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* VideoCardGamma (ColorSync 2.5 specific - c/o Neil Okamoto) */
+/* 'vcgt' */
+
+static unsigned int icmVideoCardGamma_get_size(
+ icmBase *pp
+) {
+ icmVideoCardGamma *p = (icmVideoCardGamma *)pp;
+ unsigned int len = 0;
+
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_add(len, 4); /* 4 for gamma type */
+
+ /* compute size of remainder */
+ if (p->tagType == icmVideoCardGammaTableType) {
+ len = sat_add(len, 2); /* 2 bytes for channels */
+ len = sat_add(len, 2); /* 2 for entry count */
+ len = sat_add(len, 2); /* 2 for entry size */
+ len = sat_add(len, sat_mul3(p->u.table.channels, /* compute table size */
+ p->u.table.entryCount, p->u.table.entrySize));
+ }
+ else if (p->tagType == icmVideoCardGammaFormulaType) {
+ len = sat_add(len, 12); /* 4 bytes each for red gamma, min, & max */
+ len = sat_add(len, 12); /* 4 bytes each for green gamma, min & max */
+ len = sat_add(len, 12); /* 4 bytes each for blue gamma, min & max */
+ }
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmVideoCardGamma_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmVideoCardGamma *p = (icmVideoCardGamma *)pp;
+ icc *icp = p->icp;
+ int rv, c;
+ char *bp, *buf;
+ ORD8 *pchar;
+ ORD16 *pshort;
+
+ if (len < 18) {
+ sprintf(icp->err,"icmVideoCardGamma_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmVideoCardGamma_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmVideoCardGamma_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmVideoCardGamma_read: Wrong tag type for icmVideoCardGamma");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read gamma format (eg. table or formula) from the buffer */
+ p->tagType = (icmVideoCardGammaTagType)read_UInt32Number(bp+8);
+
+ /* Read remaining gamma data based on format */
+ if (p->tagType == icmVideoCardGammaTableType) {
+ p->u.table.channels = read_UInt16Number(bp+12);
+ p->u.table.entryCount = read_UInt16Number(bp+14);
+ p->u.table.entrySize = read_UInt16Number(bp+16);
+ if ((len-18) < sat_mul3(p->u.table.channels, p->u.table.entryCount,
+ p->u.table.entrySize)) {
+ sprintf(icp->err,"icmVideoCardGamma_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+ if ((rv = pp->allocate(pp)) != 0) { /* make space for table */
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ /* ~~~~ This should be a table of doubles like the rest of icclib ! ~~~~ */
+ pchar = (ORD8 *)p->u.table.data;
+ pshort = (ORD16 *)p->u.table.data;
+ for (c=0, bp=bp+18; c<p->u.table.channels*p->u.table.entryCount; c++) {
+ switch (p->u.table.entrySize) {
+ case 1:
+ *pchar++ = read_UInt8Number(bp);
+ bp++;
+ break;
+ case 2:
+ *pshort++ = read_UInt16Number(bp);
+ bp+=2;
+ break;
+ default:
+ sprintf(icp->err,"icmVideoCardGamma_read: unsupported table entry size");
+ pp->del(pp);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ }
+ } else if (p->tagType == icmVideoCardGammaFormulaType) {
+ if (len < 48) {
+ sprintf(icp->err,"icmVideoCardGamma_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+ p->u.table.channels = 3; /* Always 3 for formula */
+ p->u.formula.redGamma = read_S15Fixed16Number(bp+12);
+ p->u.formula.redMin = read_S15Fixed16Number(bp+16);
+ p->u.formula.redMax = read_S15Fixed16Number(bp+20);
+ p->u.formula.greenGamma = read_S15Fixed16Number(bp+24);
+ p->u.formula.greenMin = read_S15Fixed16Number(bp+28);
+ p->u.formula.greenMax = read_S15Fixed16Number(bp+32);
+ p->u.formula.blueGamma = read_S15Fixed16Number(bp+36);
+ p->u.formula.blueMin = read_S15Fixed16Number(bp+40);
+ p->u.formula.blueMax = read_S15Fixed16Number(bp+44);
+ } else {
+ sprintf(icp->err,"icmVideoCardGammaTable_read: Unknown gamma format for icmVideoCardGamma");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmVideoCardGamma_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmVideoCardGamma *p = (icmVideoCardGamma *)pp;
+ icc *icp = p->icp;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0, c;
+ ORD8 *pchar;
+ ORD16 *pshort;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmViewingConditions_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmViewingConditions_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write gamma format (eg. table of formula) */
+ if ((rv = write_UInt32Number(p->tagType,bp+8)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write remaining gamma data based on format */
+ if (p->tagType == icmVideoCardGammaTableType) {
+ if ((rv = write_UInt16Number(p->u.table.channels,bp+12)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_UInt16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt16Number(p->u.table.entryCount,bp+14)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_UInt16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt16Number(p->u.table.entrySize,bp+16)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_UInt16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ pchar = (ORD8 *)p->u.table.data;
+ pshort = (ORD16 *)p->u.table.data;
+ for (c=0, bp=bp+18; c<p->u.table.channels*p->u.table.entryCount; c++) {
+ switch (p->u.table.entrySize) {
+ case 1:
+ write_UInt8Number(*pchar++,bp);
+ bp++;
+ break;
+ case 2:
+ write_UInt16Number(*pshort++,bp);
+ bp+=2;
+ break;
+ default:
+ sprintf(icp->err,"icmVideoCardGamma_write: unsupported table entry size");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ }
+ } else if (p->tagType == icmVideoCardGammaFormulaType) {
+ if ((rv = write_S15Fixed16Number(p->u.formula.redGamma,bp+12)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_S15Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_S15Fixed16Number(p->u.formula.redMin,bp+16)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_S15Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_S15Fixed16Number(p->u.formula.redMax,bp+20)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_S15Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_S15Fixed16Number(p->u.formula.greenGamma,bp+24)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_S15Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_S15Fixed16Number(p->u.formula.greenMin,bp+28)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_S15Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_S15Fixed16Number(p->u.formula.greenMax,bp+32)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_S15Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_S15Fixed16Number(p->u.formula.blueGamma,bp+36)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_S15Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_S15Fixed16Number(p->u.formula.blueMin,bp+40)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_S15Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_S15Fixed16Number(p->u.formula.blueMax,bp+44)) != 0) {
+ sprintf(icp->err,"icmVideoCardGamma_write: write_S15Fixed16Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ } else {
+ sprintf(icp->err,"icmVideoCardGammaTable_write: Unknown gamma format for icmVideoCardGamma");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmViewingConditions_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmVideoCardGamma_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmVideoCardGamma *p = (icmVideoCardGamma *)pp;
+ int c,i;
+
+ if (verb <= 0)
+ return;
+
+ if (p->tagType == icmVideoCardGammaTableType) {
+ op->gprintf(op,"VideoCardGammaTable:\n");
+ op->gprintf(op," channels = %d\n", p->u.table.channels);
+ op->gprintf(op," entries = %d\n", p->u.table.entryCount);
+ op->gprintf(op," entrysize = %d\n", p->u.table.entrySize);
+ if (verb >= 2) {
+ /* dump array contents also */
+ for (c=0; c<p->u.table.channels; c++) {
+ op->gprintf(op," channel #%d\n",c);
+ for (i=0; i<p->u.table.entryCount; i++) {
+ if (p->u.table.entrySize == 1) {
+ op->gprintf(op," %d: %d\n",i,((ORD8 *)p->u.table.data)[c*p->u.table.entryCount+i]);
+ }
+ else if (p->u.table.entrySize == 2) {
+ op->gprintf(op," %d: %d\n",i,((ORD16 *)p->u.table.data)[c*p->u.table.entryCount+i]);
+ }
+ }
+ }
+ }
+ } else if (p->tagType == icmVideoCardGammaFormulaType) {
+ op->gprintf(op,"VideoCardGammaFormula:\n");
+ op->gprintf(op," red gamma = %f\n", p->u.formula.redGamma);
+ op->gprintf(op," red min = %f\n", p->u.formula.redMin);
+ op->gprintf(op," red max = %f\n", p->u.formula.redMax);
+ op->gprintf(op," green gamma = %f\n", p->u.formula.greenGamma);
+ op->gprintf(op," green min = %f\n", p->u.formula.greenMin);
+ op->gprintf(op," green max = %f\n", p->u.formula.greenMax);
+ op->gprintf(op," blue gamma = %f\n", p->u.formula.blueGamma);
+ op->gprintf(op," blue min = %f\n", p->u.formula.blueMin);
+ op->gprintf(op," blue max = %f\n", p->u.formula.blueMax);
+ } else {
+ op->gprintf(op," Unknown tag format\n");
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmVideoCardGamma_allocate(
+ icmBase *pp
+) {
+ icmVideoCardGamma *p = (icmVideoCardGamma *)pp;
+ icc *icp = p->icp;
+ unsigned int size;
+
+ /* note: allocation is only relevant for table type
+ * and in that case the channels, entryCount, and entrySize
+ * fields must all be set prior to getting here
+ */
+
+ if (p->tagType == icmVideoCardGammaTableType) {
+ size = sat_mul(p->u.table.channels, p->u.table.entryCount);
+ switch (p->u.table.entrySize) {
+ case 1:
+ size = sat_mul(size, sizeof(ORD8));
+ break;
+ case 2:
+ size = sat_mul(size, sizeof(unsigned short));
+ break;
+ default:
+ sprintf(icp->err,"icmVideoCardGamma_alloc: unsupported table entry size");
+ return icp->errc = 1;
+ }
+ if (size == UINT_MAX) {
+ sprintf(icp->err,"icmVideoCardGamma_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->u.table.data != NULL)
+ icp->al->free(icp->al, p->u.table.data);
+ if ((p->u.table.data = (void*) icp->al->malloc(icp->al, size)) == NULL) {
+ sprintf(icp->err,"icmVideoCardGamma_alloc: malloc() of table data failed");
+ return icp->errc = 2;
+ }
+ }
+
+ return 0;
+}
+
+/* Read a value */
+static double icmVideoCardGamma_lookup(
+ icmVideoCardGamma *p,
+ int chan, /* Channel, 0, 1 or 2 */
+ double iv /* Input value 0.0 - 1.0 */
+) {
+ double ov = 0.0;
+
+ if (chan < 0 || chan > (p->u.table.channels-1)
+ || iv < 0.0 || iv > 1.0)
+ return iv;
+
+ if (p->tagType == icmVideoCardGammaTableType && p->u.table.entryCount == 0) {
+ /* Deal with siliness */
+ ov = iv;
+ } else if (p->tagType == icmVideoCardGammaTableType) {
+ /* Use linear interpolation */
+ unsigned int ix;
+ double val0, val1, w;
+ double inputEnt_1 = (double)(p->u.table.entryCount-1);
+
+ val0 = iv * inputEnt_1;
+ if (val0 < 0.0)
+ val0 = 0.0;
+ else if (val0 > inputEnt_1)
+ val0 = inputEnt_1;
+ ix = (unsigned int)floor(val0); /* Coordinate */
+ if (ix > (p->u.table.entryCount-2))
+ ix = (p->u.table.entryCount-2);
+ w = val0 - (double)ix; /* weight */
+ if (p->u.table.entrySize == 1) {
+ val0 = ((ORD8 *)p->u.table.data)[chan * p->u.table.entryCount + ix]/255.0;
+ val1 = ((ORD8 *)p->u.table.data)[chan * p->u.table.entryCount + ix + 1]/255.0;
+ } else if (p->u.table.entrySize == 2) {
+ val0 = ((ORD16 *)p->u.table.data)[chan * p->u.table.entryCount + ix]/65535.0;
+ val1 = ((ORD16 *)p->u.table.data)[chan * p->u.table.entryCount + ix + 1]/65535.0;
+ } else {
+ val0 = val1 = iv;
+ }
+ ov = val0 + w * (val1 - val0);
+
+ } else if (p->tagType == icmVideoCardGammaFormulaType) {
+ double min, max, gam;
+
+ if (iv == 0) {
+ min = p->u.formula.redMin;
+ max = p->u.formula.redMax;
+ gam = p->u.formula.redGamma;
+ } else if (iv == 1) {
+ min = p->u.formula.greenMin;
+ max = p->u.formula.greenMax;
+ gam = p->u.formula.greenGamma;
+ } else {
+ min = p->u.formula.blueMin;
+ max = p->u.formula.blueMax;
+ gam = p->u.formula.blueGamma;
+ }
+
+ /* The Apple OSX doco confirms this is the formula */
+ ov = min + (max - min) * pow(iv, gam);
+ }
+ return ov;
+}
+
+/* Free all storage in the object */
+static void icmVideoCardGamma_delete(
+ icmBase *pp
+) {
+ icmVideoCardGamma *p = (icmVideoCardGamma *)pp;
+ icc *icp = p->icp;
+
+ if (p->tagType == icmVideoCardGammaTableType && p->u.table.data != NULL)
+ icp->al->free(icp->al, p->u.table.data);
+
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmVideoCardGamma(
+ icc *icp
+) {
+ icmVideoCardGamma *p;
+ if ((p = (icmVideoCardGamma *) icp->al->calloc(icp->al,1,sizeof(icmVideoCardGamma))) == NULL)
+ return NULL;
+ p->ttype = icSigVideoCardGammaType;
+ p->refcount = 1;
+ p->get_size = icmVideoCardGamma_get_size;
+ p->read = icmVideoCardGamma_read;
+ p->write = icmVideoCardGamma_write;
+ p->lookup = icmVideoCardGamma_lookup;
+ p->dump = icmVideoCardGamma_dump;
+ p->allocate = icmVideoCardGamma_allocate;
+ p->del = icmVideoCardGamma_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* ViewingConditions */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmViewingConditions_get_size(
+ icmBase *pp
+) {
+ unsigned int len = 0;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_add(len, 12); /* 12 for XYZ of illuminant */
+ len = sat_add(len, 12); /* 12 for XYZ of surround */
+ len = sat_add(len, 4); /* 4 for illuminant type */
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmViewingConditions_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmViewingConditions *p = (icmViewingConditions *)pp;
+ icc *icp = p->icp;
+ int rv;
+ char *bp, *buf;
+
+ if (len < 36) {
+ sprintf(icp->err,"icmViewingConditions_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmViewingConditions_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmViewingConditions_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmViewingConditions_read: Wrong tag type for icmViewingConditions");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read the XYZ values for the illuminant */
+ if ((rv = read_XYZNumber(&p->illuminant, bp+8)) != 0) {
+ sprintf(icp->err,"icmViewingConditions: read_XYZNumber error");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Read the XYZ values for the surround */
+ if ((rv = read_XYZNumber(&p->surround, bp+20)) != 0) {
+ sprintf(icp->err,"icmViewingConditions: read_XYZNumber error");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Read the encoded standard illuminant */
+ p->stdIlluminant = (icIlluminant)read_SInt32Number(bp + 32);
+
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmViewingConditions_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmViewingConditions *p = (icmViewingConditions *)pp;
+ icc *icp = p->icp;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmViewingConditions_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmViewingConditions_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmViewingConditions_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+
+ /* Write the XYZ values for the illuminant */
+ if ((rv = write_XYZNumber(&p->illuminant, bp+8)) != 0) {
+ sprintf(icp->err,"icmViewingConditions: write_XYZNumber error");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write the XYZ values for the surround */
+ if ((rv = write_XYZNumber(&p->surround, bp+20)) != 0) {
+ sprintf(icp->err,"icmViewingConditions: write_XYZNumber error");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write the encoded standard illuminant */
+ if ((rv = write_SInt32Number((int)p->stdIlluminant, bp + 32)) != 0) {
+ sprintf(icp->err,"icmViewingConditionsa_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmViewingConditions_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmViewingConditions_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmViewingConditions *p = (icmViewingConditions *)pp;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"Viewing Conditions:\n");
+ op->gprintf(op," XYZ value of illuminant in cd/m^2 = %s\n", string_XYZNumber(&p->illuminant));
+ op->gprintf(op," XYZ value of surround in cd/m^2 = %s\n", string_XYZNumber(&p->surround));
+ op->gprintf(op," Illuminant type = %s\n", string_Illuminant(p->stdIlluminant));
+}
+
+/* Allocate variable sized data elements */
+static int icmViewingConditions_allocate(
+ icmBase *pp
+) {
+ /* Nothing to do */
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmViewingConditions_delete(
+ icmBase *pp
+) {
+ icmViewingConditions *p = (icmViewingConditions *)pp;
+ icc *icp = p->icp;
+
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmViewingConditions(
+ icc *icp
+) {
+ icmViewingConditions *p;
+ if ((p = (icmViewingConditions *) icp->al->calloc(icp->al,1,sizeof(icmViewingConditions))) == NULL)
+ return NULL;
+ p->ttype = icSigViewingConditionsType;
+ p->refcount = 1;
+ p->get_size = icmViewingConditions_get_size;
+ p->read = icmViewingConditions_read;
+ p->write = icmViewingConditions_write;
+ p->dump = icmViewingConditions_dump;
+ p->allocate = icmViewingConditions_allocate;
+ p->del = icmViewingConditions_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ---------------------------------------------------------- */
+/* icmCrdInfo object */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmCrdInfo_get_size(
+ icmBase *pp
+) {
+ icmCrdInfo *p = (icmCrdInfo *)pp;
+ unsigned int len = 0, t;
+ len = sat_add(len, 8); /* 8 bytes for tag and padding */
+ len = sat_addadd(len, 4, p->ppsize); /* Postscript product name */
+ for (t = 0; t < 4; t++) { /* For all 4 intents */
+ len = sat_addadd(len, 4, p->crdsize[t]); /* crd names */
+ }
+ return len;
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmCrdInfo_read(
+ icmBase *pp,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icmCrdInfo *p = (icmCrdInfo *)pp;
+ icc *icp = p->icp;
+ unsigned int t;
+ int rv;
+ char *bp, *buf, *end;
+
+ if (len < 28) {
+ sprintf(icp->err,"icmCrdInfo_read: Tag too small to be legal");
+ return icp->errc = 1;
+ }
+
+ /* Allocate a file read buffer */
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmCrdInfo_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+ end = buf + len;
+
+ /* Read portion of file into buffer */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, bp, 1, len) != len) {
+ sprintf(icp->err,"icmCrdInfo_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Read type descriptor from the buffer */
+ if (((icTagTypeSignature)read_SInt32Number(bp)) != p->ttype) {
+ sprintf(icp->err,"icmCrdInfo_read: Wrong tag type for icmCrdInfo");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ bp = bp + 8;
+
+ /* Postscript product name */
+ if (bp > end || 4 > (end - bp)) {
+ sprintf(icp->err,"icmCrdInfo_read: Data too short to read Postscript product name");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->ppsize = read_UInt32Number(bp);
+ bp += 4;
+ if (p->ppsize > 0) {
+ if (p->ppsize > (end - bp)) {
+ sprintf(icp->err,"icmCrdInfo_read: Data to short to read Postscript product string");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ if ((rv = check_null_string(bp,p->ppsize)) == 1) {
+ sprintf(icp->err,"icmCrdInfo_read: Postscript product name is not terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ memmove((void *)p->ppname, (void *)bp, p->ppsize);
+ bp += p->ppsize;
+ }
+
+ /* CRD names for the four rendering intents */
+ for (t = 0; t < 4; t++) { /* For all 4 intents */
+ if (bp > end || 4 > (end - bp)) {
+ sprintf(icp->err,"icmCrdInfo_read: Data too short to read CRD%d name",t);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->crdsize[t] = read_UInt32Number(bp);
+ bp += 4;
+ if (p->crdsize[t] > 0) {
+ if (p->crdsize[t] > (end - bp)) {
+ sprintf(icp->err,"icmCrdInfo_read: Data to short to read CRD%d string",t);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ if ((rv = check_null_string(bp,p->crdsize[t])) == 1) {
+ sprintf(icp->err,"icmCrdInfo_read: CRD%d name is not terminated",t);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+ if ((rv = p->allocate((icmBase *)p)) != 0) {
+ icp->al->free(icp->al, buf);
+ return rv;
+ }
+ memmove((void *)p->crdname[t], (void *)bp, p->crdsize[t]);
+ bp += p->crdsize[t];
+ }
+ }
+
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmCrdInfo_write(
+ icmBase *pp,
+ unsigned int of /* File offset to write from */
+) {
+ icmCrdInfo *p = (icmCrdInfo *)pp;
+ icc *icp = p->icp;
+ unsigned int t;
+ unsigned int len;
+ char *bp, *buf; /* Buffer to write from */
+ int rv;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size((icmBase *)p)) == UINT_MAX) {
+ sprintf(icp->err,"icmCrdInfo_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmCrdInfo_write malloc() failed");
+ return icp->errc = 2;
+ }
+ bp = buf;
+
+ /* Write type descriptor to the buffer */
+ if ((rv = write_SInt32Number((int)p->ttype,bp)) != 0) {
+ sprintf(icp->err,"icmCrdInfo_write: write_SInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ write_SInt32Number(0,bp+4); /* Set padding to 0 */
+ bp = bp + 8;
+
+ /* Postscript product name */
+ if ((rv = write_UInt32Number(p->ppsize,bp)) != 0) {
+ sprintf(icp->err,"icmCrdInfo_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ bp += 4;
+ if (p->ppsize > 0) {
+ if ((rv = check_null_string(p->ppname,p->ppsize)) == 1) {
+ sprintf(icp->err,"icmCrdInfo_write: Postscript product name is not terminated");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+ memmove((void *)bp, (void *)p->ppname, p->ppsize);
+ bp += p->ppsize;
+ }
+
+ /* CRD names for the four rendering intents */
+ for (t = 0; t < 4; t++) { /* For all 4 intents */
+ if ((rv = write_UInt32Number(p->crdsize[t],bp)) != 0) {
+ sprintf(icp->err,"icmCrdInfo_write: write_UInt32Number() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ bp += 4;
+ if (p->ppsize > 0) {
+ if ((rv = check_null_string(p->crdname[t],p->crdsize[t])) == 1) {
+ sprintf(icp->err,"icmCrdInfo_write: CRD%d name is not terminated",t);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ /* Haven't checked if rv == 2 is legal or not */
+ memmove((void *)bp, (void *)p->crdname[t], p->crdsize[t]);
+ bp += p->crdsize[t];
+ }
+ }
+
+ /* Write to the file */
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmCrdInfo_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+ icp->al->free(icp->al, buf);
+ return 0;
+}
+
+/* Dump a text description of the object */
+static void icmCrdInfo_dump(
+ icmBase *pp,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ icmCrdInfo *p = (icmCrdInfo *)pp;
+ unsigned int i, r, c, size, t;
+
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"PostScript Product name and CRD names:\n");
+
+ op->gprintf(op," Product name:\n");
+ op->gprintf(op," No. chars = %lu\n",p->ppsize);
+
+ size = p->ppsize > 0 ? p->ppsize-1 : 0;
+ i = 0;
+ for (r = 1;; r++) { /* count rows */
+ if (i >= size) {
+ op->gprintf(op,"\n");
+ break;
+ }
+ if (r > 1 && verb < 2) {
+ op->gprintf(op,"...\n");
+ break; /* Print 1 row if not verbose */
+ }
+ c = 1;
+ op->gprintf(op," 0x%04lx: ",i);
+ c += 10;
+ while (i < size && c < 73) {
+ if (isprint(p->ppname[i])) {
+ op->gprintf(op,"%c",p->ppname[i]);
+ c++;
+ } else {
+ op->gprintf(op,"\\%03o",p->ppname[i]);
+ c += 4;
+ }
+ i++;
+ }
+ if (i < size)
+ op->gprintf(op,"\n");
+ }
+
+ for (t = 0; t < 4; t++) { /* For all 4 intents */
+ op->gprintf(op," CRD%ld name:\n",t);
+ op->gprintf(op," No. chars = %lu\n",p->crdsize[t]);
+
+ size = p->crdsize[t] > 0 ? p->crdsize[t]-1 : 0;
+ i = 0;
+ for (r = 1;; r++) { /* count rows */
+ if (i >= size) {
+ op->gprintf(op,"\n");
+ break;
+ }
+ if (r > 1 && verb < 2) {
+ op->gprintf(op,"...\n");
+ break; /* Print 1 row if not verbose */
+ }
+ c = 1;
+ op->gprintf(op," 0x%04lx: ",i);
+ c += 10;
+ while (i < size && c < 73) {
+ if (isprint(p->crdname[t][i])) {
+ op->gprintf(op,"%c",p->crdname[t][i]);
+ c++;
+ } else {
+ op->gprintf(op,"\\%03o",p->crdname[t][i]);
+ c += 4;
+ }
+ i++;
+ }
+ if (i < size)
+ op->gprintf(op,"\n");
+ }
+ }
+}
+
+/* Allocate variable sized data elements */
+static int icmCrdInfo_allocate(
+ icmBase *pp
+) {
+ icmCrdInfo *p = (icmCrdInfo *)pp;
+ icc *icp = p->icp;
+ unsigned int t;
+
+ if (p->ppsize != p->_ppsize) {
+ if (ovr_mul(p->ppsize, sizeof(char))) {
+ sprintf(icp->err,"icmCrdInfo_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->ppname != NULL)
+ icp->al->free(icp->al, p->ppname);
+ if ((p->ppname = (char *) icp->al->calloc(icp->al, p->ppsize, sizeof(char))) == NULL) {
+ sprintf(icp->err,"icmCrdInfo_alloc: malloc() of string data failed");
+ return icp->errc = 2;
+ }
+ p->_ppsize = p->ppsize;
+ }
+ for (t = 0; t < 4; t++) { /* For all 4 intents */
+ if (p->crdsize[t] != p->_crdsize[t]) {
+ if (ovr_mul(p->crdsize[t], sizeof(char))) {
+ sprintf(icp->err,"icmCrdInfo_alloc: size overflow");
+ return icp->errc = 1;
+ }
+ if (p->crdname[t] != NULL)
+ icp->al->free(icp->al, p->crdname[t]);
+ if ((p->crdname[t] = (char *) icp->al->calloc(icp->al, p->crdsize[t], sizeof(char))) == NULL) {
+ sprintf(icp->err,"icmCrdInfo_alloc: malloc() of CRD%d name string failed",t);
+ return icp->errc = 2;
+ }
+ p->_crdsize[t] = p->crdsize[t];
+ }
+ }
+ return 0;
+}
+
+/* Free all storage in the object */
+static void icmCrdInfo_delete(
+ icmBase *pp
+) {
+ icmCrdInfo *p = (icmCrdInfo *)pp;
+ icc *icp = p->icp;
+ unsigned int t;
+
+ if (p->ppname != NULL)
+ icp->al->free(icp->al, p->ppname);
+ for (t = 0; t < 4; t++) { /* For all 4 intents */
+ if (p->crdname[t] != NULL)
+ icp->al->free(icp->al, p->crdname[t]);
+ }
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmBase *new_icmCrdInfo(
+ icc *icp
+) {
+ icmCrdInfo *p;
+ if ((p = (icmCrdInfo *) icp->al->calloc(icp->al,1,sizeof(icmCrdInfo))) == NULL)
+ return NULL;
+ p->ttype = icSigCrdInfoType;
+ p->refcount = 1;
+ p->get_size = icmCrdInfo_get_size;
+ p->read = icmCrdInfo_read;
+ p->write = icmCrdInfo_write;
+ p->dump = icmCrdInfo_dump;
+ p->allocate = icmCrdInfo_allocate;
+ p->del = icmCrdInfo_delete;
+ p->icp = icp;
+
+ return (icmBase *)p;
+}
+
+/* ========================================================== */
+/* icmHeader object */
+/* ========================================================== */
+
+/* Return the number of bytes needed to write this tag */
+static unsigned int icmHeader_get_size(
+ icmHeader *p
+) {
+ return 128; /* By definition */
+}
+
+/* read the object, return 0 on success, error code on fail */
+static int icmHeader_read(
+ icmHeader *p,
+ unsigned int len, /* tag length */
+ unsigned int of /* start offset within file */
+) {
+ icc *icp = p->icp;
+ char *buf;
+ unsigned int tt;
+ int rv = 0;
+
+ if (len != 128) {
+ sprintf(icp->err,"icmHeader_read: Length expected to be 128");
+ return icp->errc = 1;
+ }
+
+ if ((buf = (char *) icp->al->malloc(icp->al, len)) == NULL) {
+ sprintf(icp->err,"icmHeader_read: malloc() failed");
+ return icp->errc = 2;
+ }
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->read(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmHeader_read: fseek() or fread() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Check that the magic number is right */
+ tt = read_SInt32Number(buf+36);
+ if (tt != icMagicNumber) { /* Check magic number */
+ sprintf(icp->err,"icmHeader_read: wrong magic number 0x%x",tt);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+
+ /* Fill in the in-memory structure */
+ p->size = read_UInt32Number(buf + 0); /* Profile size in bytes */
+ if (p->size < (128 + 4)) {
+ sprintf(icp->err,"icmHeader_read: file size %d too small to be legal",p->size);
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ p->cmmId = read_SInt32Number(buf + 4); /* CMM for profile */
+ tt = read_UInt8Number(buf + 8); /* Raw major version number */
+ p->majv = (tt >> 4) * 10 + (tt & 0xf); /* Integer major version number */
+ icp->ver = p->majv > 3 ? 1 : 0; /* Set major version flag in icc */
+ tt = read_UInt8Number(buf + 9); /* Raw minor/bug fix version numbers */
+ p->minv = (tt >> 4); /* Integer minor version number */
+ p->bfv = (tt & 0xf); /* Integer bug fix version number */
+ p->deviceClass = (icProfileClassSignature)
+ read_SInt32Number(buf + 12); /* Type of profile */
+ p->colorSpace = (icColorSpaceSignature)
+ read_SInt32Number(buf + 16); /* Color space of data */
+ p->pcs = (icColorSpaceSignature)
+ read_SInt32Number(buf + 20); /* PCS: XYZ or Lab */
+ if ((rv = read_DateTimeNumber(&p->date, buf + 24)) != 0) { /* Creation Date */
+ sprintf(icp->err,"icmHeader_read: read_DateTimeNumber corrupted");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ p->platform = (icPlatformSignature)
+ read_SInt32Number(buf + 40); /* Primary platform */
+ p->flags = read_UInt32Number(buf + 44); /* Various bits */
+ p->manufacturer = read_SInt32Number(buf + 48); /* Dev manufacturer */
+ p->model = read_SInt32Number(buf + 52); /* Dev model */
+ read_UInt64Number(&p->attributes, buf + 56); /* Device attributes */
+ p->renderingIntent = (icRenderingIntent)
+ read_SInt32Number(buf + 64); /* Rendering intent */
+ if ((rv = read_XYZNumber(&p->illuminant, buf + 68)) != 0) { /* Profile illuminant */
+ sprintf(icp->err,"icmHeader_read: read_XYZNumber error");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ p->creator = read_SInt32Number(buf + 80); /* Profile creator */
+
+ for (tt = 0; tt < 16; tt++)
+ p->id[tt] = icp->ver ? read_UInt8Number(buf + 84 + tt) : 0; /* Profile ID */
+
+ icp->al->free(icp->al, buf);
+
+#ifndef ENABLE_V4
+ if (icp->ver) {
+ sprintf(icp->err,"icmHeader_read: ICC V4 not supported!");
+ return icp->errc = 1;
+ }
+#endif
+ return 0;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+static int icmHeader_write(
+ icmHeader *p,
+ unsigned int of, /* File offset to write from */
+ int doid /* Flag, nz = writing to compute ID */
+) {
+ icc *icp = p->icp;
+ char *buf; /* Buffer to write from */
+ unsigned int len;
+ unsigned int tt;
+ int rv = 0;
+
+ /* Allocate a file write buffer */
+ if ((len = p->get_size(p)) == UINT_MAX) {
+ sprintf(icp->err,"icmHeader_write get_size overflow");
+ return icp->errc = 1;
+ }
+ if ((buf = (char *) icp->al->calloc(icp->al,1,len)) == NULL) { /* Zero it - some CMS are fussy */
+ sprintf(icp->err,"icmHeader_write calloc() failed");
+ return icp->errc = 2;
+ }
+
+ /* Fill in the write buffer */
+ if ((rv = write_UInt32Number(p->size, buf + 0)) != 0) { /* Profile size in bytes */
+ sprintf(icp->err,"icmHeader_write: profile size");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+
+ if ((rv = write_SInt32Number(p->cmmId, buf + 4)) != 0) { /* CMM for profile */
+ sprintf(icp->err,"icmHeader_write: cmmId");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if (p->majv < 0 || p->majv > 99 /* Sanity check version numbers */
+ || p->minv < 0 || p->minv > 9
+ || p->bfv < 0 || p->bfv > 9) {
+ sprintf(icp->err,"icmHeader_write: version number");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 1;
+ }
+ tt = ((p->majv/10) << 4) + (p->majv % 10);
+ if ((rv = write_UInt8Number(tt, buf + 8)) != 0) { /* Raw major version number */
+ sprintf(icp->err,"icmHeader_write: Uint8Number major version");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ tt = (p->minv << 4) + p->bfv;
+ if ((rv = write_UInt8Number(tt, buf + 9)) != 0) { /* Raw minor/bug fix version numbers */
+ sprintf(icp->err,"icmHeader_write: Uint8Number minor/bug fix");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_SInt32Number((int)p->deviceClass, buf + 12)) != 0) { /* Type of profile */
+ sprintf(icp->err,"icmHeader_write: SInt32Number deviceClass");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_SInt32Number((int)p->colorSpace, buf + 16)) != 0) { /* Color space of data */
+ sprintf(icp->err,"icmHeader_write: SInt32Number data color space");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_SInt32Number((int)p->pcs, buf + 20)) != 0) { /* PCS: XYZ or Lab */
+ sprintf(icp->err,"icmHeader_write: SInt32Number PCS");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_DateTimeNumber(&p->date, buf + 24)) != 0) { /* Creation Date */
+ sprintf(icp->err,"icmHeader_write: DateTimeNumber creation");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_SInt32Number(icMagicNumber, buf+36)) != 0) { /* Magic number */
+ sprintf(icp->err,"icmHeader_write: SInt32Number magic");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_SInt32Number((int)p->platform, buf + 40)) != 0) { /* Primary platform */
+ sprintf(icp->err,"icmHeader_write: SInt32Number platform");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt32Number(doid ? 0 : p->flags, buf + 44)) != 0) { /* Various flag bits */
+ sprintf(icp->err,"icmHeader_write: UInt32Number flags");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_SInt32Number(p->manufacturer, buf + 48)) != 0) { /* Dev manufacturer */
+ sprintf(icp->err,"icmHeader_write: SInt32Number manufaturer");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((write_SInt32Number(p->model, buf + 52)) != 0) { /* Dev model */
+ sprintf(icp->err,"icmHeader_write: SInt32Number model");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_UInt64Number(&p->attributes, buf + 56)) != 0) { /* Device attributes */
+ sprintf(icp->err,"icmHeader_write: UInt64Number attributes");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_SInt32Number(doid ? 0 : (int)p->renderingIntent, buf + 64)) != 0) { /* Rendering intent */
+ sprintf(icp->err,"icmHeader_write: SInt32Number rendering intent");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_XYZNumber(&p->illuminant, buf + 68)) != 0) { /* Profile illuminant */
+ sprintf(icp->err,"icmHeader_write: XYZNumber illuminant");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if ((rv = write_SInt32Number(p->creator, buf + 80)) != 0) { /* Profile creator */
+ sprintf(icp->err,"icmHeader_write: SInt32Number creator");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ if (doid == 0 && icp->ver) { /* ID is V4.0+ feature */
+ for (tt = 0; tt < 16; tt++) {
+ if ((rv = write_UInt8Number(p->id[tt], buf + 84 + tt)) != 0) { /* Profile ID */
+ sprintf(icp->err,"icmHeader_write: UInt8Number creator");
+ icp->al->free(icp->al, buf);
+ return icp->errc = rv;
+ }
+ }
+ }
+
+ if ( icp->fp->seek(icp->fp, of) != 0
+ || icp->fp->write(icp->fp, buf, 1, len) != len) {
+ sprintf(icp->err,"icmHeader_write fseek() or fwrite() failed");
+ icp->al->free(icp->al, buf);
+ return icp->errc = 2;
+ }
+
+ icp->al->free(icp->al, buf);
+ return rv;
+}
+
+static void icmHeader_dump(
+ icmHeader *p,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ int i;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"Header:\n");
+ op->gprintf(op," size = %d bytes\n",p->size);
+ op->gprintf(op," CMM = %s\n",tag2str(p->cmmId));
+ op->gprintf(op," Version = %d.%d.%d\n",p->majv, p->minv, p->bfv);
+ op->gprintf(op," Device Class = %s\n", string_ProfileClassSignature(p->deviceClass));
+ op->gprintf(op," Color Space = %s\n", string_ColorSpaceSignature(p->colorSpace));
+ op->gprintf(op," Conn. Space = %s\n", string_ColorSpaceSignature(p->pcs));
+ op->gprintf(op," Date, Time = %s\n", string_DateTimeNumber(&p->date));
+ op->gprintf(op," Platform = %s\n", string_PlatformSignature(p->platform));
+ op->gprintf(op," Flags = %s\n", string_ProfileHeaderFlags(p->flags));
+ op->gprintf(op," Dev. Mnfctr. = %s\n", tag2str(p->manufacturer)); /* ~~~ */
+ op->gprintf(op," Dev. Model = %s\n", tag2str(p->model)); /* ~~~ */
+ op->gprintf(op," Dev. Attrbts = %s\n", string_DeviceAttributes(p->attributes.l));
+ op->gprintf(op," Rndrng Intnt = %s\n", string_RenderingIntent(p->renderingIntent));
+ op->gprintf(op," Illuminant = %s\n", string_XYZNumber_and_Lab(&p->illuminant));
+ op->gprintf(op," Creator = %s\n", tag2str(p->creator)); /* ~~~ */
+ if (p->icp->ver) { /* V4.0+ feature */
+ for (i = 0; i < 16; i++) { /* Check if ID has been set */
+ if (p->id[i] != 0)
+ break;
+ }
+ if (i < 16)
+ op->gprintf(op," ID = %02X%02X%02X%02X%02X%02X%02X%02X"
+ "%02X%02X%02X%02X%02X%02X%02X%02X\n",
+ p->id[0], p->id[1], p->id[2], p->id[3], p->id[4], p->id[5], p->id[6], p->id[7],
+ p->id[8], p->id[9], p->id[10], p->id[11], p->id[12], p->id[13], p->id[14], p->id[15]);
+ else
+ op->gprintf(op," ID = <Not set>\n");
+ }
+ op->gprintf(op,"\n");
+}
+
+static void icmHeader_delete(
+ icmHeader *p
+) {
+ icc *icp = p->icp;
+
+ icp->al->free(icp->al, p);
+}
+
+/* Create an empty object. Return null on error */
+static icmHeader *new_icmHeader(
+ icc *icp
+) {
+ icmHeader *p;
+ if ((p = (icmHeader *) icp->al->calloc(icp->al,1,sizeof(icmHeader))) == NULL)
+ return NULL;
+ p->icp = icp;
+ p->get_size = icmHeader_get_size;
+ p->read = icmHeader_read;
+ p->write = icmHeader_write;
+ p->dump = icmHeader_dump;
+ p->del = icmHeader_delete;
+
+ return p;
+}
+
+/* ---------------------------------------------------------- */
+/* Type vector table. Match the Tag type against the object creator */
+static struct {
+ icTagTypeSignature ttype; /* The tag type signature */
+ icmBase * (*new_obj)(icc *icp);
+} typetable[] = {
+ {icSigColorantTableType, new_icmColorantTable},
+ {icmSigAltColorantTableType, new_icmColorantTable},
+ {icSigCrdInfoType, new_icmCrdInfo},
+ {icSigCurveType, new_icmCurve},
+ {icSigDataType, new_icmData},
+ {icSigDateTimeType, new_icmDateTimeNumber},
+ {icSigLut16Type, new_icmLut},
+ {icSigLut8Type, new_icmLut},
+ {icSigMeasurementType, new_icmMeasurement},
+ {icSigNamedColorType, new_icmNamedColor},
+ {icSigNamedColor2Type, new_icmNamedColor},
+ {icSigProfileSequenceDescType, new_icmProfileSequenceDesc},
+ {icSigS15Fixed16ArrayType, new_icmS15Fixed16Array},
+ {icSigScreeningType, new_icmScreening},
+ {icSigSignatureType, new_icmSignature},
+ {icSigTextDescriptionType, new_icmTextDescription},
+ {icSigTextType, new_icmText},
+ {icSigU16Fixed16ArrayType, new_icmU16Fixed16Array},
+ {icSigUcrBgType, new_icmUcrBg},
+ {icSigVideoCardGammaType, new_icmVideoCardGamma},
+ {icSigUInt16ArrayType, new_icmUInt16Array},
+ {icSigUInt32ArrayType, new_icmUInt32Array},
+ {icSigUInt64ArrayType, new_icmUInt64Array},
+ {icSigUInt8ArrayType, new_icmUInt8Array},
+ {icSigViewingConditionsType, new_icmViewingConditions},
+ {icSigXYZArrayType, new_icmXYZArray},
+ {icMaxEnumType, NULL}
+};
+
+/* Table that lists the legal Types for each Tag Signature */
+static struct {
+ icTagSignature sig;
+ icTagTypeSignature ttypes[4]; /* Arbitrary max of 4 */
+} sigtypetable[] = {
+ {icSigAToB0Tag, {icSigLut8Type,icSigLut16Type,icMaxEnumType}},
+ {icSigAToB1Tag, {icSigLut8Type,icSigLut16Type,icMaxEnumType}},
+ {icSigAToB2Tag, {icSigLut8Type,icSigLut16Type,icMaxEnumType}},
+ {icSigBlueColorantTag, {icSigXYZType,icMaxEnumType}},
+ {icSigBlueTRCTag, {icSigCurveType,icMaxEnumType}},
+ {icSigBToA0Tag, {icSigLut8Type,icSigLut16Type,icMaxEnumType}},
+ {icSigBToA1Tag, {icSigLut8Type,icSigLut16Type,icMaxEnumType}},
+ {icSigBToA2Tag, {icSigLut8Type,icSigLut16Type,icMaxEnumType}},
+ {icSigCalibrationDateTimeTag, {icSigDateTimeType,icMaxEnumType}},
+ {icSigCharTargetTag, {icSigTextType,icMaxEnumType}},
+ {icSigColorantTableTag, {icSigColorantTableType,icmSigAltColorantTableType,
+ icMaxEnumType}},
+ {icSigColorantTableOutTag, {icSigColorantTableType,icmSigAltColorantTableType,
+ icMaxEnumType}},
+ {icSigCopyrightTag, {icSigTextType,icMaxEnumType}},
+ {icSigCrdInfoTag, {icSigCrdInfoType,icMaxEnumType}},
+ {icSigDeviceMfgDescTag, {icSigTextDescriptionType,icMaxEnumType}},
+ {icSigDeviceModelDescTag, {icSigTextDescriptionType,icMaxEnumType}},
+ {icSigGamutTag, {icSigLut8Type,icSigLut16Type,icMaxEnumType}},
+ {icSigGrayTRCTag, {icSigCurveType,icMaxEnumType}},
+ {icSigGreenColorantTag, {icSigXYZType,icMaxEnumType}},
+ {icSigGreenTRCTag, {icSigCurveType,icMaxEnumType}},
+ {icSigLuminanceTag, {icSigXYZType,icMaxEnumType}},
+ {icSigMeasurementTag, {icSigMeasurementType,icMaxEnumType}},
+ {icSigMediaBlackPointTag, {icSigXYZType,icMaxEnumType}},
+ {icSigMediaWhitePointTag, {icSigXYZType,icMaxEnumType}},
+ {icSigNamedColorTag, {icSigNamedColorType,icMaxEnumType}},
+ {icSigNamedColor2Tag, {icSigNamedColor2Type,icMaxEnumType}},
+ {icSigPreview0Tag, {icSigLut8Type,icSigLut16Type,icMaxEnumType}},
+ {icSigPreview1Tag, {icSigLut8Type,icSigLut16Type,icMaxEnumType}},
+ {icSigPreview2Tag, {icSigLut8Type,icSigLut16Type,icMaxEnumType}},
+ {icSigProfileDescriptionTag, {icSigTextDescriptionType,icMaxEnumType}},
+ {icSigProfileSequenceDescTag, {icSigProfileSequenceDescType,icMaxEnumType}},
+ {icSigPs2CRD0Tag, {icSigDataType,icMaxEnumType}},
+ {icSigPs2CRD1Tag, {icSigDataType,icMaxEnumType}},
+ {icSigPs2CRD2Tag, {icSigDataType,icMaxEnumType}},
+ {icSigPs2CRD3Tag, {icSigDataType,icMaxEnumType}},
+ {icSigPs2CSATag, {icSigDataType,icMaxEnumType}},
+ {icSigPs2RenderingIntentTag, {icSigDataType,icMaxEnumType}},
+ {icSigRedColorantTag, {icSigXYZType,icMaxEnumType}},
+ {icSigRedTRCTag, {icSigCurveType,icMaxEnumType}},
+ {icSigScreeningDescTag, {icSigTextDescriptionType,icMaxEnumType}},
+ {icSigScreeningTag, {icSigScreeningType,icMaxEnumType}},
+ {icSigTechnologyTag, {icSigSignatureType,icMaxEnumType}},
+ {icSigUcrBgTag, {icSigUcrBgType,icMaxEnumType}},
+ {icSigVideoCardGammaTag, {icSigVideoCardGammaType,icMaxEnumType}},
+ {icSigViewingCondDescTag, {icSigTextDescriptionType,icMaxEnumType}},
+ {icSigViewingConditionsTag, {icSigViewingConditionsType,icMaxEnumType}},
+ {icMaxEnumTag, {icMaxEnumType}}
+};
+
+/* Fake color tag for specifying PCS */
+#define icSigPCSData ((icColorSpaceSignature) 0x50435320L)
+
+/* Table that lists the required tags for various profiles */
+static struct {
+ icProfileClassSignature sig; /* Profile signature */
+ int chans; /* Data Color channels, -ve for match but try next, */
+ /* -100 for ignore, -200 for ignore and try next */
+ icColorSpaceSignature colsig; /* Data Color space signature, icMaxEnumData for ignore, */
+ /* icSigPCSData for XYZ of Lab */
+ icColorSpaceSignature pcssig; /* PCS Color space signature, icMaxEnumData for ignore, */
+ /* icSigPCSData for XYZ or Lab */
+ icTagSignature tags[12]; /* Arbitrary max of 12 */
+} tagchecktable[] = {
+ {icSigInputClass, -1, icMaxEnumData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigGrayTRCTag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigInputClass, -3, icMaxEnumData, icSigXYZData,
+ {icSigProfileDescriptionTag,
+ icSigRedColorantTag,
+ icSigGreenColorantTag,
+ icSigBlueColorantTag,
+ icSigRedTRCTag,
+ icSigGreenTRCTag,
+ icSigBlueTRCTag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigInputClass, -100, icMaxEnumData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigAToB0Tag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigDisplayClass, -1, icMaxEnumData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigGrayTRCTag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigDisplayClass, -3, icSigRgbData, icSigXYZData, /* Rgb or any 3 component space ?? */
+ {icSigProfileDescriptionTag,
+ icSigRedColorantTag,
+ icSigGreenColorantTag,
+ icSigBlueColorantTag,
+ icSigRedTRCTag,
+ icSigGreenTRCTag,
+ icSigBlueTRCTag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ /* Non-3 component Display device */
+ {icSigDisplayClass, -100, icMaxEnumData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigAToB0Tag, /* BToA doesn't seem to be required, which is strange... */
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigOutputClass, -1, icMaxEnumData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigGrayTRCTag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigOutputClass, -1, icMaxEnumData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigAToB0Tag,
+ icSigBToA0Tag,
+ icSigGamutTag,
+ icSigAToB1Tag,
+ icSigBToA1Tag,
+ icSigAToB2Tag,
+ icSigBToA2Tag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigOutputClass, -2, icMaxEnumData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigAToB0Tag,
+ icSigBToA0Tag,
+ icSigGamutTag,
+ icSigAToB1Tag,
+ icSigBToA1Tag,
+ icSigAToB2Tag,
+ icSigBToA2Tag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigOutputClass, -3, icMaxEnumData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigAToB0Tag,
+ icSigBToA0Tag,
+ icSigGamutTag,
+ icSigAToB1Tag,
+ icSigBToA1Tag,
+ icSigAToB2Tag,
+ icSigBToA2Tag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigOutputClass, -4, icMaxEnumData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigAToB0Tag,
+ icSigBToA0Tag,
+ icSigGamutTag,
+ icSigAToB1Tag,
+ icSigBToA1Tag,
+ icSigAToB2Tag,
+ icSigBToA2Tag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigOutputClass, -100, icMaxEnumData, icSigPCSData, /* Assumed from Hexachrome examples */
+ {icSigProfileDescriptionTag,
+ icSigBToA0Tag,
+ icSigBToA1Tag,
+ icSigBToA2Tag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigLinkClass, -100, icMaxEnumData, icMaxEnumData,
+ {icSigProfileDescriptionTag,
+ icSigAToB0Tag,
+ icSigProfileSequenceDescTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigColorSpaceClass, -100, icMaxEnumData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigBToA0Tag,
+ icSigAToB0Tag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigAbstractClass, -100, icSigPCSData, icSigPCSData,
+ {icSigProfileDescriptionTag,
+ icSigAToB0Tag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigNamedColorClass, -200, icMaxEnumData, icMaxEnumData,
+ {icSigProfileDescriptionTag,
+ icSigNamedColor2Tag,
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icSigNamedColorClass, -100, icMaxEnumData, icMaxEnumData,
+ {icSigProfileDescriptionTag,
+ icSigNamedColorTag, /* Not strictly V3.4 */
+ icSigMediaWhitePointTag,
+ icSigCopyrightTag, icMaxEnumTag}},
+
+ {icMaxEnumClass,-1,icMaxEnumData, icMaxEnumData, {icMaxEnumTag}}
+};
+
+/* ------------------------------------------------------------- */
+
+/* Return the current read fp (if any) */
+static icmFile *icc_get_rfp(icc *p) {
+ return p->fp;
+}
+
+/* Change the version to be non-default (ie. not 2.2.0), */
+/* e.g. ICC V4 (used for creation) */
+/* Return 0 if OK */
+/* Return 1 on error */
+static int icc_set_version(icc *p, icmICCVersion ver) {
+
+ if (p->header == NULL) {
+ sprintf(p->err,"icc_set_version: Header is missing");
+ return p->errc = 1;
+ }
+
+ switch (ver) {
+ case icmVersionDefault:
+ p->header->majv = 2;
+ p->header->minv = 2;
+ p->header->bfv = 0;
+ break;
+ case icmVersion2_3:
+ p->header->majv = 2;
+ p->header->minv = 3;
+ p->header->bfv = 0;
+ break;
+ case icmVersion2_4:
+ p->header->majv = 2;
+ p->header->minv = 4;
+ p->header->bfv = 0;
+ break;
+#ifdef ENABLE_V4
+ case icmVersion4_1:
+ p->header->majv = 4;
+ p->header->minv = 1;
+ p->header->bfv = 0;
+ break;
+#endif
+ default:
+ sprintf(p->err,"icc_set_version: Unsupported version 0x%x",ver);
+ return p->errc = 1;
+ }
+ return 0;
+}
+
+
+/* Check that the ICC profile looks like it will be legal. */
+/* Return non-zero and set error string if not */
+static int check_icc_legal(
+ icc *p
+) {
+ int i, j;
+ icProfileClassSignature sig;
+ icColorSpaceSignature colsig;
+ icColorSpaceSignature pcssig;
+ int dchans;
+
+ if (p->header == NULL) {
+ sprintf(p->err,"icc_check_legal: Header is missing");
+ return p->errc = 1;
+ }
+
+ sig = p->header->deviceClass;
+ colsig = p->header->colorSpace;
+ dchans = number_ColorSpaceSignature(colsig);
+ pcssig = p->header->pcs;
+
+ /* Find a matching table entry */
+ for (i = 0; tagchecktable[i].sig != icMaxEnumType; i++) {
+ if ( tagchecktable[i].sig == sig
+ && ( tagchecktable[i].chans == dchans /* Exactly matches */
+ || tagchecktable[i].chans == -dchans /* Exactly matches, but can try next table */
+ || tagchecktable[i].chans < -99) /* Doesn't have to match or try next table */
+ && ( tagchecktable[i].colsig == colsig
+ || (tagchecktable[i].colsig == icSigPCSData
+ && (colsig == icSigXYZData || colsig == icSigLabData))
+ || tagchecktable[i].colsig == icMaxEnumData)
+ && ( tagchecktable[i].pcssig == pcssig
+ || (tagchecktable[i].pcssig == icSigPCSData
+ && (pcssig == icSigXYZData || pcssig == icSigLabData))
+ || tagchecktable[i].pcssig == icMaxEnumData)) {
+
+ /* Found entry, so now check that all the required tags are present. */
+ for (j = 0; tagchecktable[i].tags[j] != icMaxEnumType; j++) {
+ if (p->find_tag(p, tagchecktable[i].tags[j]) != 0) { /* Not present! */
+ if (tagchecktable[i].chans == -200
+ || tagchecktable[i].chans == -dchans) { /* But can try next table */
+ break;
+ }
+ sprintf(p->err,"icc_check_legal: deviceClass %s is missing required tag %s",
+ tag2str(sig), tag2str(tagchecktable[i].tags[j]));
+ return p->errc = 1;
+ }
+ }
+ if (tagchecktable[i].tags[j] == icMaxEnumType) {
+ break; /* Fount all required tags */
+ }
+ }
+ }
+
+ /* According to the spec. if the deviceClass is:
+ an Abstract Class: both in and out color spaces should be PCS
+ an Link Class: both in and out color spaces can be any, and should
+ be the input space of the first profile in the link, and the
+ input space of the last profile in the link respectively.
+ a Named Class: in and out color spaces are not defined in the spec.
+ Input, Display, Output and ColorSpace Classes, input color
+ space can be any, and the output space must be PCS.
+ ~~ should check this here ???
+ */
+
+ return 0; /* Assume anything is ok */
+}
+
+
+/* read the object, return 0 on success, error code on fail */
+/* NOTE: this doesn't read the tag types, they should be read on demand. */
+/* NOTE: fp ownership is taken even if the function fails. */
+static int icc_read_x(
+ icc *p,
+ icmFile *fp, /* File to read from */
+ unsigned int of, /* File offset to read from */
+ int take_fp /* NZ if icc is to take ownership of fp */
+) {
+ char tcbuf[4]; /* Tag count read buffer */
+ unsigned int i, len;
+ unsigned int minoff, maxoff; /* Minimum and maximum offsets of tag data */
+ int er = 0; /* Error code */
+
+ p->fp = fp;
+ if (take_fp)
+ p->del_fp = 1;
+ p->of = of;
+ if (p->header == NULL) {
+ sprintf(p->err,"icc_read: No header defined");
+ return p->errc = 1;
+ }
+
+ /* Read the header */
+ if (p->header->read(p->header, 128, of)) {
+ return 1;
+ }
+
+ /* Read the tag count */
+ if ( p->fp->seek(p->fp, of + 128) != 0
+ || p->fp->read(p->fp, tcbuf, 1, 4) != 4) {
+ sprintf(p->err,"icc_read: fseek() or fread() failed on tag count");
+ return p->errc = 1;
+ }
+ p->count = read_UInt32Number(tcbuf);
+
+ /* Sanity check it */
+ if (p->count > 357913940 /* (2^32-5)/12 */
+ || (p->count > ((p->header->size - 128 - 4) / 12))) {
+ sprintf(p->err,"icc_read: tag count %d is too large to be legal",p->count);
+ return p->errc = 1;
+ }
+ minoff = 128 + 4 + p->count * 12;
+ maxoff = p->header->size;
+
+ if (p->count > 0) {
+ char *bp, *buf;
+
+ if (ovr_mul(p->count, sizeof(icmTag))) {
+ sprintf(p->err,"icc_read: size overflow");
+ return p->errc = 1;
+ }
+
+ /* Read the table into memory */
+ if ((p->data = (icmTag *) p->al->calloc(p->al, p->count, sizeof(icmTag))) == NULL) {
+ sprintf(p->err,"icc_read: Tag table malloc() failed");
+ return p->errc = 2;
+ }
+
+ len = sat_mul(p->count, 12);
+ if ((buf = (char *) p->al->malloc(p->al, len)) == NULL) {
+ sprintf(p->err,"icc_read: Tag table read buffer malloc() failed");
+ p->al->free(p->al, p->data);
+ p->data = NULL;
+ return p->errc = 2;
+ }
+ if ( p->fp->seek(p->fp, of + 128 + 4) != 0
+ || p->fp->read(p->fp, buf, 1, len) != len) {
+ sprintf(p->err,"icc_read: fseek() or fread() failed on tag table");
+ p->al->free(p->al, p->data);
+ p->data = NULL;
+ p->al->free(p->al, buf);
+ return p->errc = 1;
+ }
+
+ /* Fill in the tag table structure for each tag */
+ for (bp = buf, i = 0; i < p->count; i++, bp += 12) {
+ p->data[i].sig = (icTagSignature)read_SInt32Number(bp + 0);
+ p->data[i].offset = read_UInt32Number(bp + 4);
+ p->data[i].size = read_UInt32Number(bp + 8);
+ }
+ p->al->free(p->al, buf);
+
+ /* Check that each tag lies within the nominated space available, */
+ /* and has a reasonable size. */
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].offset < minoff
+ || p->data[i].offset > maxoff
+ || p->data[i].size < 4
+ || p->data[i].size > (maxoff - minoff)
+ || (p->data[i].offset + p->data[i].size) < p->data[i].offset /* Overflow */
+ || (p->data[i].offset + p->data[i].size) > p->header->size) {
+ sprintf(p->err,"icc_read: tag %d is out of range of the nominated file size",i);
+ p->al->free(p->al, p->data);
+ p->data = NULL;
+ return p->errc = 1;
+ }
+ }
+
+ /* Read each tag type */
+ for (i = 0; i < p->count; i++) {
+ if ( p->fp->seek(p->fp, of + p->data[i].offset) != 0
+ || p->fp->read(p->fp, tcbuf, 1, 4) != 4) {
+ sprintf(p->err,"icc_read: fseek() or fread() failed on tag headers");
+ p->al->free(p->al, p->data);
+ p->data = NULL;
+ return p->errc = 1;
+ }
+ p->data[i].ttype = (icTagTypeSignature) read_SInt32Number(tcbuf); /* Tag type */
+ p->data[i].objp = NULL; /* Read on demand */
+ }
+ } /* p->count > 0 */
+
+ return er;
+}
+
+/* read the object, return 0 on success, error code on fail */
+/* NOTE: this doesn't read the tag types, they should be read on demand. */
+/* (backward compatible version) */
+static int icc_read(
+ icc *p,
+ icmFile *fp, /* File to read from */
+ unsigned int of /* File offset to read from */
+) {
+ return icc_read_x(p, fp, of, 0);
+}
+
+/* Check the profiles ID. We assume the file has already been read. */
+/* Return 0 if OK, 1 if no ID to check, 2 if doesn't match, 3 if some other error. */
+/* NOTE: this reads the whole file again, to compute the checksum. */
+static int icc_check_id(
+ icc *p,
+ ORD8 *rid /* Optionaly return computed ID */
+) {
+ unsigned char buf[128];
+ ORD8 id[16];
+ icmMD5 *md5 = NULL;
+ unsigned int len;
+
+ if (p->header == NULL) {
+ sprintf(p->err,"icc_check_id: No header defined");
+ return p->errc = 3;
+ }
+ len = p->header->size; /* Claimed size of profile */
+
+ /* See if there is an ID to compare against */
+ for (len = 0; len < 16; len++) {
+ if (p->header->id[len] != 0)
+ break;
+ }
+ if (len >= 16) {
+ return 1;
+ }
+
+ if ((md5 = new_icmMD5(p->al)) == NULL) {
+ sprintf(p->err,"icc_check_id: new_icmMD5 failed");
+ return p->errc = 3;
+ }
+
+ /* Check the header */
+ if ( p->fp->seek(p->fp, p->of) != 0
+ || p->fp->read(p->fp, buf, 1, 128) != 128) {
+ sprintf(p->err,"icc_check_id: fseek() or fread() failed");
+ return p->errc = 3;
+ }
+
+ /* Zero the appropriate bytes in the header */
+ buf[44] = buf[45] = buf[46] = buf[47] = 0;
+ buf[64] = buf[65] = buf[66] = buf[67] = 0;
+ buf[84] = buf[85] = buf[86] = buf[87] =
+ buf[88] = buf[89] = buf[90] = buf[91] =
+ buf[92] = buf[93] = buf[94] = buf[95] =
+ buf[96] = buf[97] = buf[98] = buf[99] = 0;
+
+ md5->add(md5, buf, 128);
+
+ /* Suck in the rest of the profile */
+ for (;len > 0;) {
+ unsigned int rsize = 128;
+ if (rsize > len)
+ rsize = len;
+ if (p->fp->read(p->fp, buf, 1, rsize) != rsize) {
+ sprintf(p->err,"icc_check_id: fread() failed");
+ return p->errc = 3;
+ }
+ md5->add(md5, buf, rsize);
+ len -= rsize;
+ }
+
+ md5->get(md5, id);
+ md5->del(md5);
+
+ if (rid != NULL) {
+ for (len = 0; len < 16; len++)
+ rid[len] = id[len];
+ }
+
+ /* Check the ID */
+ for (len = 0; len < 16; len++) {
+ if (p->header->id[len] != id[len])
+ break;
+ }
+ if (len >= 16) {
+ return 0; /* Matched */
+ }
+ return 2; /* Didn't match */
+}
+
+/* Return the total size needed for the profile */
+/* Return 0 on error. */
+static unsigned int icc_get_size(
+ icc *p
+) {
+ unsigned int i, size = 0;
+
+#ifdef ICM_STRICT
+ /* Check that the right tags etc. are present for a legal ICC profile */
+ if (check_icc_legal(p) != 0) {
+ return 0;
+ }
+#endif /* ICM_STRICT */
+
+ /* Compute the total size and tag element data offsets */
+ if (p->header == NULL) {
+ sprintf(p->err,"icc_get_size: No header defined");
+ p->errc = 1;
+ return 0;
+ }
+
+ size = sat_add(size, p->header->get_size(p->header));
+ /* Assume header is aligned */
+ size = sat_addaddmul(size, 4, p->count, 12); /* Tag table length */
+ size = sat_align(ALIGN_SIZE, size);
+
+ if (size == UINT_MAX) {
+ sprintf(p->err,"icc_get_size: size overflow");
+ return p->errc = 1;
+ }
+
+ /* Reset touched flag for each tag type */
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].objp == NULL) {
+ sprintf(p->err,"icc_get_size: Internal error - NULL tag element");
+ p->errc = 1;
+ return 0;
+ }
+ p->data[i].objp->touched = 0;
+ }
+ /* Get size for each tag type, skipping links */
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].objp->touched == 0) { /* Not alllowed for previously */
+ size = sat_add(size, p->data[i].objp->get_size(p->data[i].objp));
+ size = sat_align(ALIGN_SIZE, size);
+ p->data[i].objp->touched = 1; /* Don't account for this again */
+ }
+ }
+
+ return size; /* Total size needed, or UINT_MAX if overflow */
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+/* NOTE: fp ownership is taken even if the function fails. */
+static int icc_write_x(
+ icc *p,
+ icmFile *fp, /* File to write to */
+ unsigned int of, /* File offset to write to */
+ int take_fp /* NZ if icc is to take ownership of fp */
+) {
+ char *bp, *buf; /* tag table buffer */
+ unsigned int len;
+ int rv = 0;
+ unsigned int i, size = 0;
+ unsigned char pbuf[ALIGN_SIZE];
+
+ p->fp = fp; /* Open file pointer */
+ if (take_fp)
+ p->del_fp = 1;
+ p->of = of; /* Offset of ICC profile */
+
+ for (i = 0; i < ALIGN_SIZE; i++)
+ pbuf[i] = 0;
+
+ /* Check that the right tags etc. are present for a legal ICC profile */
+ if ((rv = check_icc_legal(p)) != 0) {
+ return rv;
+ }
+
+ /* Compute the total size and tag element data offsets */
+ if (p->header == NULL) {
+ sprintf(p->err,"icc_write: No header defined");
+ return p->errc = 1;
+ }
+
+ size = sat_add(size, p->header->get_size(p->header));
+ /* Assume header is aligned */
+ len = sat_addmul(4, p->count, 12); /* Tag table length */
+ len = sat_sub(sat_align(ALIGN_SIZE, sat_add(size, len)), size); /* Aligned size */
+ size = sat_align(ALIGN_SIZE, sat_add(size, len));
+
+ if (len == UINT_MAX) {
+ sprintf(p->err,"icc_write get_size overflow");
+ return p->errc = 1;
+ }
+
+ /* Allocate memory buffer for tag table */
+ if ((buf = (char *) p->al->calloc(p->al, 1, len)) == NULL) {
+ sprintf(p->err,"icc_write calloc() failed");
+ return p->errc = 2;
+ }
+ bp = buf;
+
+ if ((rv = write_UInt32Number(p->count, bp)) != 0) { /* Tag count */
+ sprintf(p->err,"icc_write: write_UInt32Number() failed on tag count");
+ p->al->free(p->al, buf);
+ return p->errc = rv;
+ }
+ bp += 4;
+ /* Reset touched flag for each tag type */
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].objp == NULL) {
+ sprintf(p->err,"icc_write: Internal error - NULL tag element");
+ p->al->free(p->al, buf);
+ return p->errc = 1;
+ }
+ p->data[i].objp->touched = 0;
+ }
+ /* Set the offset and size for each tag type, create the tag table write data */
+ /* and compute the total profile size. */
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].objp->touched == 0) { /* Allocate space for tag type */
+ p->data[i].offset = size; /* Profile relative target */
+ p->data[i].size = p->data[i].objp->get_size(p->data[i].objp);
+ size = sat_add(size, p->data[i].size);
+ p->data[i].pad = sat_sub(sat_align(ALIGN_SIZE, size), size);
+ size = sat_align(ALIGN_SIZE, size);
+ p->data[i].objp->touched = 1; /* Allocated space for it */
+ if (size == UINT_MAX) {
+ sprintf(p->err,"icc_write: size overflow");
+ return p->errc = 1;
+ }
+ } else { /* must be linked - copy allocation */
+ unsigned int k;
+ for (k = 0; k < p->count; k++) { /* Find linked tag */
+ if (p->data[k].objp == p->data[i].objp)
+ break;
+ }
+ if (k == p->count) {
+ sprintf(p->err,"icc_write: corrupted link");
+ return p->errc = 2;
+ }
+ p->data[i].offset = p->data[k].offset;
+ p->data[i].size = p->data[k].size;
+ p->data[i].pad = p->data[k].pad;
+ }
+ /* Write tag table entry for this tag */
+ if ((rv = write_SInt32Number((int)p->data[i].sig,bp + 0)) != 0) {
+ sprintf(p->err,"icc_write: write_SInt32Number() failed on tag signature");
+ p->al->free(p->al, buf);
+ return p->errc = rv;
+ }
+ if ((rv = write_UInt32Number(p->data[i].offset, bp + 4)) != 0) {
+ sprintf(p->err,"icc_write: write_UInt32Number() failed on tag offset");
+ p->al->free(p->al, buf);
+ return p->errc = rv;
+ }
+ if ((rv = write_UInt32Number(p->data[i].size, bp + 8)) != 0) {
+ sprintf(p->err,"icc_write: write_UInt32Number() failed on tag size");
+ p->al->free(p->al, buf);
+ return p->errc = rv;
+ }
+ bp += 12;
+ }
+ p->header->size = size; /* Record total icc padded size */
+
+
+ /* If V4.0+, Compute the MD5 id for the profile. */
+ /* We do this by writing to a fake icmFile */
+ if (p->ver) {
+ icmMD5 *md5 = NULL;
+ icmFile *ofp, *dfp = NULL;
+
+ if ((md5 = new_icmMD5(p->al)) == NULL) {
+ sprintf(p->err,"icc_write: new_icmMD5 failed");
+ p->al->free(p->al, buf);
+ return p->errc = 2;
+ }
+
+ if ((dfp = new_icmFileMD5_a(md5, p->al)) == NULL) {
+ sprintf(p->err,"icc_write: new_icmFileMD5 failed");
+ md5->del(md5);
+ p->al->free(p->al, buf);
+ return p->errc = 2;
+ }
+
+ ofp = p->fp;
+ p->fp = dfp;
+
+ /* Dumy write the header */
+ if ((rv = p->header->write(p->header, 0, 1)) != 0) {
+ p->al->free(p->al, buf);
+ return rv;
+ }
+
+ /* Dumy write the tag table */
+ if ( p->fp->seek(p->fp, 128) != 0
+ || p->fp->write(p->fp, buf, 1, len) != len) {
+ sprintf(p->err,"icc_write: seek() or write() failed");
+ p->al->free(p->al, buf);
+ return p->errc = 1;
+ }
+
+ /* Dumy write all the tag element data */
+ /* (We invert meaning of touched here) */
+ for (i = 0; i < p->count; i++) { /* For all the tag element data */
+ if (p->data[i].objp->touched == 0)
+ continue; /* Must be linked, and we've already written it */
+ if ((rv = p->data[i].objp->write(p->data[i].objp, p->data[i].offset)) != 0) {
+ p->al->free(p->al, buf);
+ return rv;
+ }
+ /* Pad with 0 to next boundary */
+ if (p->data[i].pad > 0) {
+ if (p->fp->write(p->fp, pbuf, 1, p->data[i].pad) != p->data[i].pad) {
+ sprintf(p->err,"icc_write: write() failed");
+ p->al->free(p->al, buf);
+ return p->errc = 1;
+ }
+ }
+ p->data[i].objp->touched = 0; /* Written it, so don't write it again. */
+ }
+
+ if (p->fp->flush(p->fp) != 0) {
+ sprintf(p->err,"icc_write flush() failed");
+ p->al->free(p->al, buf);
+ return p->errc = 1;
+ }
+
+ if ((p->errc = ((icmFileMD5 *)dfp)->get_errc(dfp)) != 0) {
+ sprintf(p->err,"icc_write compute ID failed with code %d", p->errc);
+ p->al->free(p->al, buf);
+ return p->errc;
+ }
+
+ /* Get the MD5 checksum ID */
+ md5->get(md5, p->header->id);
+
+ dfp->del(dfp);
+ md5->del(md5);
+ p->fp = ofp;
+
+ /* Reset the touched flags */
+ for (i = 0; i < p->count; i++)
+ p->data[i].objp->touched = 1;
+ }
+
+ /* Now write out the profile for real. */
+ /* Although it may appear like we're seeking for each element, */
+ /* in fact elements will be written in file order. */
+
+ /* Write the header */
+ if ((rv = p->header->write(p->header, of, 0)) != 0) {
+ p->al->free(p->al, buf);
+ return rv;
+ }
+
+ /* Write the tag table */
+ if ( p->fp->seek(p->fp, of + 128) != 0
+ || p->fp->write(p->fp, buf, 1, len) != len) {
+ sprintf(p->err,"icc_write: seek() or write() failed");
+ p->al->free(p->al, buf);
+ return p->errc = 1;
+ }
+ p->al->free(p->al, buf);
+
+ /* Write all the tag element data */
+ /* (We invert the meaning of touched here) */
+ for (i = 0; i < p->count; i++) { /* For all the tag element data */
+ if (p->data[i].objp->touched == 0)
+ continue; /* Must be linked, and we've already written it */
+ if ((rv = p->data[i].objp->write(p->data[i].objp, of + p->data[i].offset)) != 0) {
+ return rv;
+ }
+ /* Pad with 0 to next boundary */
+ if (p->data[i].pad > 0) {
+ if (p->fp->write(p->fp, pbuf, 1, p->data[i].pad) != p->data[i].pad) {
+ sprintf(p->err,"icc_write: write() failed");
+ return p->errc = 1;
+ }
+ }
+ p->data[i].objp->touched = 0; /* Written it, so don't write it again. */
+ }
+
+ if (p->fp->flush(p->fp) != 0) {
+ sprintf(p->err,"icc_write flush() failed");
+ return p->errc = 1;
+ }
+
+ return rv;
+}
+
+/* Write the contents of the object. Return 0 on sucess, error code on failure */
+/* (backwards compatible version) */
+static int icc_write(
+ icc *p,
+ icmFile *fp, /* File to write to */
+ unsigned int of /* File offset to write to */
+) {
+ return icc_write_x(p, fp, of, 0);
+}
+
+/* Create and add a tag with the given signature. */
+/* Returns a pointer to the element object */
+/* Returns NULL if error - icc->errc will contain */
+/* 2 on system error, */
+/* 3 if unknown tag */
+/* NOTE: that we prevent tag duplication */
+/* NOTE: to create a tag type icmSigUnknownType, set ttype to icmSigUnknownType, */
+/* and set the actual tag type in icmSigUnknownType->uttype */
+static icmBase *icc_add_tag(
+ icc *p,
+ icTagSignature sig, /* Tag signature - may be unknown */
+ icTagTypeSignature ttype /* Tag type */
+) {
+ icmBase *tp;
+ icmBase *nob;
+ int i = 0, ok = 1;
+ unsigned int j;
+
+ if (ttype != icmSigUnknownType) { /* Check only for possibly known types */
+
+ /* Check that a known signature has an acceptable type */
+ for (i = 0; sigtypetable[i].sig != icMaxEnumType; i++) {
+ if (sigtypetable[i].sig == sig) { /* recognized signature */
+ ok = 0;
+ for (j = 0; sigtypetable[i].ttypes[j] != icMaxEnumType; j++) {
+ if (sigtypetable[i].ttypes[j] == ttype) /* recognized type */
+ ok = 1;
+ }
+ break;
+ }
+ }
+ if (!ok) {
+ sprintf(p->err,"icc_add_tag: wrong tag type for signature");
+ p->errc = 1;
+ return NULL;
+ }
+
+ /* Check that we know how to handle this type */
+ for (i = 0; typetable[i].ttype != icMaxEnumType; i++) {
+ if (typetable[i].ttype == ttype)
+ break;
+ }
+ if (typetable[i].ttype == icMaxEnumType) {
+ sprintf(p->err,"icc_add_tag: unsupported tag type");
+ p->errc = 1;
+ return NULL;
+ }
+ }
+
+ /* Check that this tag doesn't already exist */
+ /* (Perhaps we should simply replace it, rather than erroring ?) */
+ for (j = 0; j < p->count; j++) {
+ if (p->data[j].sig == sig) {
+ sprintf(p->err,"icc_add_tag: Already have tag '%s' in profile",tag2str(p->data[j].sig));
+ p->errc = 1;
+ return NULL;
+ }
+ }
+
+ /* Make space in tag table for new tag item */
+ if (ovr_mul(sat_add(p->count,1), sizeof(icmTag))) {
+ sprintf(p->err,"icc_add_tag: size overflow");
+ p->errc = 1;
+ return NULL;
+ }
+ if (p->data == NULL)
+ tp = (icmBase *)p->al->malloc(p->al, (p->count+1) * sizeof(icmTag));
+ else
+ tp = (icmBase *)p->al->realloc(p->al, (void *)p->data, (p->count+1) * sizeof(icmTag));
+ if (tp == NULL) {
+ sprintf(p->err,"icc_add_tag: Tag table realloc() failed");
+ p->errc = 2;
+ return NULL;
+ }
+ p->data = (icmTag *)tp;
+
+ if (ttype == icmSigUnknownType) {
+ if ((nob = new_icmUnknown(p)) == NULL)
+ return NULL;
+ } else {
+ /* Allocate the empty object */
+ if ((nob = typetable[i].new_obj(p)) == NULL)
+ return NULL;
+ }
+
+ /* Fill out our tag table entry */
+ p->data[p->count].sig = sig; /* The tag signature */
+ p->data[p->count].ttype = nob->ttype = ttype; /* The tag type signature */
+ p->data[p->count].offset = 0; /* Unknown offset yet */
+ p->data[p->count].size = 0; /* Unknown size yet */
+ p->data[p->count].objp = nob; /* Empty object */
+ p->count++;
+
+ return nob;
+}
+
+/* Create and add a tag which is a link to an existing tag. */
+/* Returns a pointer to the element object */
+/* Returns NULL if error - icc->errc will contain */
+/* 3 if incompatible tag */
+/* NOTE: that we prevent tag duplication */
+static icmBase *icc_link_tag(
+ icc *p,
+ icTagSignature sig, /* Tag signature - may be unknown */
+ icTagSignature ex_sig /* Tag signature of tag to link to */
+) {
+ icmBase *tp;
+ unsigned int j, exi;
+ int i, ok = 1;
+
+ /* Search for existing signature */
+ for (exi = 0; exi < p->count; exi++) {
+ if (p->data[exi].sig == ex_sig) /* Found it */
+ break;
+ }
+ if (exi == p->count) {
+ sprintf(p->err,"icc_link_tag: Can't find existing tag '%s'",tag2str(ex_sig));
+ p->errc = 1;
+ return NULL;
+ }
+
+ if (p->data[exi].objp == NULL) {
+ sprintf(p->err,"icc_link_tag: Existing tag '%s' isn't loaded",tag2str(ex_sig));
+ p->errc = 1;
+ return NULL;
+ }
+
+ /* Check that a known signature has an acceptable type */
+ for (i = 0; sigtypetable[i].sig != icMaxEnumType; i++) {
+ if (sigtypetable[i].sig == sig) { /* recognized signature */
+ ok = 0;
+ for (j = 0; sigtypetable[i].ttypes[j] != icMaxEnumType; j++) {
+ if (sigtypetable[i].ttypes[j] == p->data[exi].ttype) /* recognized type */
+ ok = 1;
+ }
+ break;
+ }
+ }
+ if (!ok) {
+ sprintf(p->err,"icc_link_tag: wrong tag type for signature");
+ p->errc = 1;
+ return NULL;
+ }
+
+ /* Check that this tag doesn't already exits */
+ for (j = 0; j < p->count; j++) {
+ if (p->data[j].sig == sig) {
+ sprintf(p->err,"icc_link_tag: Already have tag '%s' in profile",tag2str(p->data[j].sig));
+ p->errc = 1;
+ return NULL;
+ }
+ }
+
+ /* Make space in tag table for new tag item */
+ if (p->data == NULL)
+ tp = (icmBase *)p->al->malloc(p->al, (p->count+1) * sizeof(icmTag));
+ else
+ tp = (icmBase *)p->al->realloc(p->al, (void *)p->data, (p->count+1) * sizeof(icmTag));
+ if (tp == NULL) {
+ sprintf(p->err,"icc_link_tag: Tag table realloc() failed");
+ p->errc = 2;
+ return NULL;
+ }
+ p->data = (icmTag *)tp;
+
+ /* Fill out our tag table entry */
+ p->data[p->count].sig = sig; /* The tag signature */
+ p->data[p->count].ttype = p->data[exi].ttype; /* The tag type signature */
+ p->data[p->count].offset = p->data[exi].offset; /* Same offset (may not be allocated yet) */
+ p->data[p->count].size = p->data[exi].size; /* Same size (may not be allocated yet) */
+ p->data[p->count].objp = p->data[exi].objp; /* Shared object */
+ p->data[exi].objp->refcount++; /* Bump reference count on tag type */
+ p->count++;
+
+ return p->data[exi].objp;
+}
+
+/* Search for tag signature */
+/* return: */
+/* 0 if found */
+/* 1 if found but not handled type */
+/* 2 if not found */
+/* NOTE: doesn't set icc->errc or icc->err[] */
+/* NOTE: we don't handle tag duplication - you'll always get the first in the file. */
+static int icc_find_tag(
+ icc *p,
+ icTagSignature sig /* Tag signature - may be unknown */
+) {
+ unsigned int i;
+ int j;
+
+ /* Search for signature */
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].sig == sig) /* Found it */
+ break;
+ }
+ if (i == p->count)
+ return 2;
+
+ /* See if we can handle this type */
+ for (j = 0; typetable[j].ttype != icMaxEnumType; j++) {
+ if (typetable[j].ttype == p->data[i].ttype)
+ break;
+ }
+ if (typetable[j].ttype == icMaxEnumType)
+ return 1;
+
+ return 0;
+}
+
+/* Read the specific tag element data, and return a pointer to the object */
+/* (This is an internal function) */
+/* Returns NULL if error - icc->errc will contain: */
+/* 2 if not found */
+/* Returns an icmSigUnknownType object if the tag type isn't handled by a */
+/* specific object and alow_unk is NZ */
+/* NOTE: we don't handle tag duplication - you'll always get the first in the file */
+static icmBase *icc_read_tag_ix(
+ icc *p,
+ unsigned int i, /* Index from 0.. p->count-1 */
+ int alow_unk /* NZ to allow unknown tag to load */
+) {
+ icTagTypeSignature ttype; /* Tag type we will create */
+ icmBase *nob;
+ unsigned int k;
+ int j;
+
+ if (i >= p->count) {
+ sprintf(p->err,"icc_read_tag_ix: index %d is out of range",i);
+ p->errc = 2;
+ return NULL;
+ }
+
+ /* See if it's already been read */
+ if (p->data[i].objp != NULL) {
+ return p->data[i].objp; /* Just return it */
+ }
+
+ /* See if this should be a link */
+ for (k = 0; k < p->count; k++) {
+ if (i == k)
+ continue;
+ if (p->data[i].ttype == p->data[k].ttype /* Exact match and already read */
+ && p->data[i].offset == p->data[k].offset
+ && p->data[i].size == p->data[k].size
+ && p->data[k].objp != NULL)
+ break;
+ }
+ if (k < p->count) { /* Make this a link */
+ p->data[i].objp = p->data[k].objp;
+ p->data[k].objp->refcount++; /* Bump reference count */
+ return p->data[k].objp; /* Done */
+ }
+
+ /* See if we can handle this type */
+ for (j = 0; typetable[j].ttype != icMaxEnumType; j++) {
+ if (typetable[j].ttype == p->data[i].ttype)
+ break;
+ }
+
+ if (typetable[j].ttype == icMaxEnumType) {
+ if (!alow_unk) {
+ p->errc = 2;
+ return NULL;
+ }
+ ttype = icmSigUnknownType; /* Use the Unknown type to handle an unknown tag type */
+ } else {
+ ttype = p->data[i].ttype; /* We known this type */
+ }
+
+ /* Create and read in the object */
+ if (ttype == icmSigUnknownType)
+ nob = new_icmUnknown(p);
+ else
+ nob = typetable[j].new_obj(p);
+
+ if (nob == NULL)
+ return NULL;
+
+ if ((nob->read(nob, p->data[i].size, p->of + p->data[i].offset)) != 0) {
+ nob->del(nob); /* Failed, so destroy it */
+ return NULL;
+ }
+ p->data[i].objp = nob;
+ return nob;
+}
+
+/* Read the tag element data of the first matching, and return a pointer to the object */
+/* Returns NULL if error - icc->errc will contain: */
+/* 2 if not found */
+/* Doesn't read uknown type tags */
+static icmBase *icc_read_tag(
+ icc *p,
+ icTagSignature sig /* Tag signature - may be unknown */
+) {
+ unsigned int i;
+
+ /* Search for signature */
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].sig == sig) /* Found it */
+ break;
+ }
+ if (i >= p->count) {
+ sprintf(p->err,"icc_read_tag: Tag '%s' not found",string_TagSignature(sig));
+ p->errc = 2;
+ return NULL;
+ }
+
+ /* Let read_tag_ix do all the work */
+ return icc_read_tag_ix(p, i, 0);
+}
+
+/* Read the tag element data of the first matching, and return a pointer to the object */
+/* Returns NULL if error.
+/* Returns an icmSigUnknownType object if the tag type isn't handled by a specific object. */
+/* NOTE: we don't handle tag duplication - you'll always get the first in the file. */
+static icmBase *icc_read_tag_any(
+ icc *p,
+ icTagSignature sig /* Tag signature - may be unknown */
+) {
+ unsigned int i;
+
+ /* Search for signature */
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].sig == sig) /* Found it */
+ break;
+ }
+ if (i >= p->count) {
+ sprintf(p->err,"icc_read_tag: Tag '%s' not found",string_TagSignature(sig));
+ p->errc = 2;
+ return NULL;
+ }
+
+ /* Let read_tag_ix do all the work */
+ return icc_read_tag_ix(p, i, 1);
+}
+
+/* Rename a tag signature */
+static int icc_rename_tag(
+ icc *p,
+ icTagSignature sig, /* Existing Tag signature - may be unknown */
+ icTagSignature sigNew /* New Tag signature - may be unknown */
+) {
+ unsigned int k;
+ int i, j, ok = 1;
+
+ /* Search for signature */
+ for (k = 0; k < p->count; k++) {
+ if (p->data[k].sig == sig) /* Found it */
+ break;
+ }
+ if (k >= p->count) {
+ sprintf(p->err,"icc_rename_tag: Tag '%s' not found",string_TagSignature(sig));
+ return p->errc = 2;
+ }
+
+ /* Check that a known new signature has an acceptable type */
+ for (i = 0; sigtypetable[i].sig != icMaxEnumType; i++) {
+ if (sigtypetable[i].sig == sigNew) { /* recognized signature */
+ ok = 0;
+ for (j = 0; sigtypetable[i].ttypes[j] != icMaxEnumType; j++) {
+ if (sigtypetable[i].ttypes[j] == p->data[k].ttype) /* recognized type */
+ ok = 1;
+ }
+ break;
+ }
+ }
+
+ if (!ok) {
+ sprintf(p->err,"icc_rename_tag: wrong signature for tag type");
+ p->errc = 1;
+ return p->errc;
+ }
+
+ /* change its signature */
+ p->data[k].sig = sigNew;
+
+ return 0;
+}
+
+/* Unread a specific tag, and free the underlying tag type data */
+/* if this was the last reference to it. */
+/* (This is an internal function) */
+/* Returns non-zero on error: */
+/* tag not found - icc->errc will contain 2 */
+/* tag not read - icc->errc will contain 2 */
+static int icc_unread_tag_ix(
+ icc *p,
+ unsigned int i /* Index from 0.. p->count-1 */
+) {
+ if (i >= p->count) {
+ sprintf(p->err,"icc_unread_tag_ix: index %d is out of range",i);
+ return p->errc = 2;
+ }
+
+ /* See if it's been read */
+ if (p->data[i].objp == NULL) {
+ sprintf(p->err,"icc_unread_tag: Tag '%s' not currently loaded",string_TagSignature(p->data[i].sig));
+ return p->errc = 2;
+ }
+
+ if (--(p->data[i].objp->refcount) == 0) /* decrement reference count */
+ (p->data[i].objp->del)(p->data[i].objp); /* Last reference */
+ p->data[i].objp = NULL;
+
+ return 0;
+}
+
+/* Unread the tag, and free the underlying tag type */
+/* if this was the last reference to it. */
+/* Returns non-zero on error: */
+/* tag not found - icc->errc will contain 2 */
+/* tag not read - icc->errc will contain 2 */
+/* NOTE: we don't handle tag duplication - you'll always get the first in the file */
+static int icc_unread_tag(
+ icc *p,
+ icTagSignature sig /* Tag signature - may be unknown */
+) {
+ unsigned int i;
+
+ /* Search for signature */
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].sig == sig) /* Found it */
+ break;
+ }
+ if (i >= p->count) {
+ sprintf(p->err,"icc_unread_tag: Tag '%s' not found",string_TagSignature(sig));
+ return p->errc = 2;
+ }
+
+ return icc_unread_tag(p, i);
+}
+
+/* Delete the tag, and free the underlying tag type, */
+/* if this was the last reference to it. */
+/* Note this finds the first tag with a matching signature */
+/* Returns non-zero on error: */
+/* tag not found - icc->errc will contain 2 */
+static int icc_delete_tag_ix(
+ icc *p,
+ unsigned int i /* Index from 0.. p->count-1 */
+) {
+ if (i >= p->count) {
+ sprintf(p->err,"icc_delete_tag_ix: index %d of range",i);
+ return p->errc = 2;
+ }
+
+ /* If it's been read into memory, decrement the reference count */
+ if (p->data[i].objp != NULL) {
+ if (--(p->data[i].objp->refcount) == 0) /* decrement reference count */
+ (p->data[i].objp->del)(p->data[i].objp); /* Last reference */
+ p->data[i].objp = NULL;
+ }
+
+ /* Now remove it from the tag list */
+ for (; i < (p->count-1); i++)
+ p->data[i] = p->data[i+1]; /* Copy the structure down */
+
+ p->count--; /* One less tag in list */
+
+ return 0;
+}
+
+/* Delete the tag, and free the underlying tag type, */
+/* if this was the last reference to it. */
+/* Note this finds the first tag with a matching signature. */
+/* Returns non-zero on error: */
+/* tag not found - icc->errc will contain 2 */
+static int icc_delete_tag(
+ icc *p,
+ icTagSignature sig /* Tag signature - may be unknown */
+) {
+ unsigned int i;
+
+ /* Search for signature */
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].sig == sig) /* Found it */
+ break;
+ }
+ if (i >= p->count) {
+ sprintf(p->err,"icc_delete_tag: Tag '%s' not found",string_TagSignature(sig));
+ return p->errc = 2;
+ }
+
+ return icc_delete_tag_ix(p, i);
+}
+
+/* Read all the tags into memory, including unknown types. */
+/* Returns non-zero on error. */
+static int icc_read_all_tags(
+ icc *p
+) {
+ unsigned int i;
+
+ for (i = 0; i < p->count; i++) { /* For all the tag element data */
+ if (icc_read_tag_ix(p, i, 1) == NULL)
+ return p->errc;
+ }
+ return 0;
+}
+
+
+static void icc_dump(
+ icc *p,
+ icmFile *op, /* Output to dump to */
+ int verb /* Verbosity level */
+) {
+ unsigned int i;
+ if (verb <= 0)
+ return;
+
+ op->gprintf(op,"icc:\n");
+
+ /* Dump the header */
+ if (p->header != NULL)
+ p->header->dump(p->header,op,verb);
+
+ /* Dump all the tag elements */
+ for (i = 0; i < p->count; i++) { /* For all the tag element data */
+ icmBase *ob;
+ int tr;
+ op->gprintf(op,"tag %d:\n",i);
+ op->gprintf(op," sig %s\n",tag2str(p->data[i].sig));
+ op->gprintf(op," type %s\n",tag2str(p->data[i].ttype));
+ op->gprintf(op," offset %d\n", p->data[i].offset);
+ op->gprintf(op," size %d\n", p->data[i].size);
+ tr = 0;
+ if (p->data[i].objp == NULL) {
+ /* The object is not loaded, so load it then free it */
+ if (icc_read_tag_ix(p, i, 1) == NULL)
+ op->gprintf(op,"Unable to read: %d, %s\n",p->errc,p->err);
+ tr = 1;
+ }
+ if ((ob = p->data[i].objp) != NULL) {
+ /* op->gprintf(op," refcount %d\n", ob->refcount); */
+ ob->dump(ob,op,verb-1);
+
+ if (tr != 0) { /* Cleanup if temporary */
+ icc_unread_tag_ix(p, i);
+ }
+ }
+ op->gprintf(op,"\n");
+ }
+}
+
+static void icc_delete(
+ icc *p
+) {
+ unsigned int i;
+ icmAlloc *al = p->al;
+ int del_al = p->del_al;
+
+ /* Free up the header */
+ if (p->header != NULL)
+ (p->header->del)(p->header);
+
+ /* Free up the tag data objects */
+ if (p->data != NULL) {
+ for (i = 0; i < p->count; i++) {
+ if (p->data[i].objp != NULL) {
+ if (--(p->data[i].objp->refcount) == 0) /* decrement reference count */
+ (p->data[i].objp->del)(p->data[i].objp); /* Last reference */
+ p->data[i].objp = NULL;
+ }
+ }
+ /* Free tag table */
+ al->free(al, p->data);
+ }
+
+ /* We are responsible for deleting the file object */
+ if (p->del_fp && p->fp != NULL)
+ p->fp->del(p->fp);
+
+ /* This object */
+ al->free(al, p);
+
+ if (del_al) /* We are responsible for deleting allocator */
+ al->del(al);
+}
+
+/* ================================================== */
+/* Lut Color normalizing and de-normalizing functions */
+
+/* As a rule, I am representing Lut in memory as values in machine form as real */
+/* numbers in the range 0.0 - 1.0. For many color spaces (ie. RGB, Gray, */
+/* hsv, hls, cmyk and other device coords), this is entirely appropriate. */
+/* For CIE based spaces though, this is not correct, since (I assume!) the binary */
+/* representation will be consistent with the encoding in Annex A, page 74 */
+/* of the standard. Note that the standard doesn't specify the encoding of */
+/* many color spaces (ie. Yuv, Yxy etc.), and is unclear about PCS. */
+
+/* The following functions convert to and from the CIE base spaces */
+/* and the real Lut input/output values. These are used to convert real color */
+/* space values into/out of the raw lut 0.0-1.0 representation (which subsequently */
+/* get converted to ICC integer values in the obvious way as a mapping to 0 .. 2^n-1). */
+
+/* This is used internally to support the Lut->lookup() function, */
+/* and can also be used by someone writing a Lut based profile to determine */
+/* the colorspace range that the input lut indexes cover, as well */
+/* as processing the output luts values into normalized form ready */
+/* for writing. */
+
+/* These functions should be accessed by calling icc.getNormFuncs() */
+
+/* - - - - - - - - - - - - - - - - */
+/* According to 6.5.5 and 6.5.6 of the spec., */
+/* XYZ index values are represented the same as their table */
+/* values, ie. as a u1.15 representation, with a value */
+/* range from 0.0 -> 1.999969482422 */
+
+/* Convert Lut index/value to XYZ coord. */
+static void Lut_Lut2XYZ(double *out, double *in) {
+ out[0] = in[0] * (1.0 + 32767.0/32768); /* X */
+ out[1] = in[1] * (1.0 + 32767.0/32768); /* Y */
+ out[2] = in[2] * (1.0 + 32767.0/32768); /* Z */
+}
+
+/* Convert XYZ coord to Lut index/value. */
+static void Lut_XYZ2Lut(double *out, double *in) {
+ out[0] = in[0] * (1.0/(1.0 + 32767.0/32768));
+ out[1] = in[1] * (1.0/(1.0 + 32767.0/32768));
+ out[2] = in[2] * (1.0/(1.0 + 32767.0/32768));
+}
+
+/* Convert Lut index/value to Y coord. */
+static void Lut_Lut2Y(double *out, double *in) {
+ out[0] = in[0] * (1.0 + 32767.0/32768); /* Y */
+}
+
+/* Convert Y coord to Lut index/value. */
+static void Lut_Y2Lut(double *out, double *in) {
+ out[0] = in[0] * (1.0/(1.0 + 32767.0/32768));
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Convert 8 bit Lab to Lut numbers */
+/* Annex A specifies 8 and 16 bit encoding, but is */
+/* silent on the Lut index normalization. */
+/* Following Michael Bourgoin's 1998 SIGGRAPH course comment on this, */
+/* we assume here that the index encoding is the same as the */
+/* value encoding. */
+
+/* Convert Lut8 table index/value to Lab */
+static void Lut_Lut2Lab_8(double *out, double *in) {
+ out[0] = in[0] * 100.0; /* L */
+ out[1] = (in[1] * 255.0) - 128.0; /* a */
+ out[2] = (in[2] * 255.0) - 128.0; /* b */
+}
+
+/* Convert Lab to Lut8 table index/value */
+static void Lut_Lab2Lut_8(double *out, double *in) {
+ out[0] = in[0] * 1.0/100.0; /* L */
+ out[1] = (in[1] + 128.0) * 1.0/255.0; /* a */
+ out[2] = (in[2] + 128.0) * 1.0/255.0; /* b */
+}
+
+/* Convert Lut8 table index/value to L */
+static void Lut_Lut2L_8(double *out, double *in) {
+ out[0] = in[0] * 100.0; /* L */
+}
+
+/* Convert L to Lut8 table index/value */
+static void Lut_L2Lut_8(double *out, double *in) {
+ out[0] = in[0] * 1.0/100.0; /* L */
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Convert 16 bit Lab to Lut numbers, V2 */
+
+/* Convert Lut16 table index/value to Lab */
+static void Lut_Lut2LabV2_16(double *out, double *in) {
+ out[0] = in[0] * (100.0 * 65535.0)/65280.0; /* L */
+ out[1] = (in[1] * (255.0 * 65535.0)/65280) - 128.0; /* a */
+ out[2] = (in[2] * (255.0 * 65535.0)/65280) - 128.0; /* b */
+}
+
+/* Convert Lab to Lut16 table index/value */
+static void Lut_Lab2LutV2_16(double *out, double *in) {
+ out[0] = in[0] * 65280.0/(100.0 * 65535.0); /* L */
+ out[1] = (in[1] + 128.0) * 65280.0/(255.0 * 65535.0); /* a */
+ out[2] = (in[2] + 128.0) * 65280.0/(255.0 * 65535.0); /* b */
+}
+
+/* Convert Lut16 table index/value to L */
+static void Lut_Lut2LV2_16(double *out, double *in) {
+ out[0] = in[0] * (100.0 * 65535.0)/65280.0; /* L */
+}
+
+/* Convert Lab to Lut16 table index/value */
+static void Lut_L2LutV2_16(double *out, double *in) {
+ out[0] = in[0] * 65280.0/(100.0 * 65535.0); /* L */
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Convert 16 bit Lab to Lut numbers, V4 */
+
+/* Convert Lut16 table index/value to Lab */
+static void Lut_Lut2LabV4_16(double *out, double *in) {
+ out[0] = in[0] * 100.0; /* L */
+ out[1] = (in[1] * 255.0) - 128.0; /* a */
+ out[2] = (in[2] * 255.0) - 128.0; /* b */
+}
+
+/* Convert Lab to Lut16 table index/value */
+static void Lut_Lab2LutV4_16(double *out, double *in) {
+ out[0] = in[0] * 1.0/100.0; /* L */
+ out[1] = (in[1] + 128.0) * 1.0/255.0; /* a */
+ out[2] = (in[2] + 128.0) * 1.0/255.0; /* b */
+}
+
+/* Convert Lut16 table index/value to L */
+static void Lut_Lut2LV4_16(double *out, double *in) {
+ out[0] = in[0] * 100.0; /* L */
+}
+
+/* Convert L to Lut16 table index/value */
+static void Lut_L2LutV4_16(double *out, double *in) {
+ out[0] = in[0] * 1.0/100.0; /* L */
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Convert Luv to Lut number */
+/* This data normalization is taken from Apples */
+/* Colorsync specification. */
+/* As per other color spaces, we assume that the index */
+/* normalization is the same as the data normalization. */
+
+/* Convert Lut table index/value to Luv */
+static void Lut_Lut2Luv(double *out, double *in) {
+ out[0] = in[0] * 100.0; /* L */
+ out[1] = (in[1] * 65535.0/256.0) - 128.0; /* u */
+ out[2] = (in[2] * 65535.0/256.0) - 128.0; /* v */
+}
+
+/* Convert Luv to Lut table index/value */
+static void Lut_Luv2Lut(double *out, double *in) {
+ out[0] = in[0] * 1.0/100.0; /* L */
+ out[1] = (in[1] + 128.0) * 256.0/65535.0; /* u */
+ out[2] = (in[2] + 128.0) * 256.0/65535.0; /* v */
+}
+
+/* - - - - - - - - - - - - - - - - */
+/* Default N component conversions */
+static void Lut_N(double *out, double *in, int nc) {
+ for (--nc; nc >= 0; nc--)
+ out[nc] = in[nc];
+}
+
+/* 1 */
+static void Lut_1(double *out, double *in) {
+ out[0] = in[0];
+}
+
+/* 2 */
+static void Lut_2(double *out, double *in) {
+ out[0] = in[0];
+ out[1] = in[1];
+}
+
+/* 3 */
+static void Lut_3(double *out, double *in) {
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+}
+
+/* 4 */
+static void Lut_4(double *out, double *in) {
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ out[3] = in[3];
+}
+
+/* 5 */
+static void Lut_5(double *out, double *in) {
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ out[3] = in[3];
+ out[4] = in[4];
+}
+
+/* 6 */
+static void Lut_6(double *out, double *in) {
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ out[3] = in[3];
+ out[4] = in[4];
+ out[5] = in[5];
+}
+
+/* 7 */
+static void Lut_7(double *out, double *in) {
+ Lut_N(out, in, 7);
+}
+
+/* 8 */
+static void Lut_8(double *out, double *in) {
+ Lut_N(out, in, 8);
+}
+
+/* 9 */
+static void Lut_9(double *out, double *in) {
+ Lut_N(out, in, 9);
+}
+
+/* 10 */
+static void Lut_10(double *out, double *in) {
+ Lut_N(out, in, 10);
+}
+
+/* 11 */
+static void Lut_11(double *out, double *in) {
+ Lut_N(out, in, 11);
+}
+
+/* 12 */
+static void Lut_12(double *out, double *in) {
+ Lut_N(out, in, 12);
+}
+
+/* 13 */
+static void Lut_13(double *out, double *in) {
+ Lut_N(out, in, 13);
+}
+
+/* 14 */
+static void Lut_14(double *out, double *in) {
+ Lut_N(out, in, 14);
+}
+
+/* 15 */
+static void Lut_15(double *out, double *in) {
+ Lut_N(out, in, 15);
+}
+
+/* Function table - match conversions to color spaces. */
+/* Anything not here, we don't know how to convert. */
+/* (ie. YCbCr) */
+static struct {
+ icColorSpaceSignature csig;
+ void (*fromLut)(double *out, double *in); /* from Lut index/entry */
+ void (*toLut)(double *out, double *in); /* to Lut index/entry */
+} colnormtable[] = {
+ {icSigXYZData, Lut_Lut2XYZ, Lut_XYZ2Lut },
+ {icmSigYData, Lut_Lut2Y, Lut_Y2Lut },
+ {icmSigLab8Data, Lut_Lut2Lab_8, Lut_Lab2Lut_8 },
+ {icmSigLabV2Data, Lut_Lut2LabV2_16, Lut_Lab2LutV2_16 },
+ {icmSigLabV4Data, Lut_Lut2LabV4_16, Lut_Lab2LutV4_16 },
+ {icmSigL8Data, Lut_Lut2L_8, Lut_L2Lut_8 },
+ {icmSigLV2Data, Lut_Lut2LV2_16, Lut_L2LutV2_16 },
+ {icmSigLV4Data, Lut_Lut2LV4_16, Lut_L2LutV4_16 },
+ {icSigLuvData, Lut_Lut2Luv, Lut_Luv2Lut },
+ {icSigYxyData, Lut_3, Lut_3 },
+ {icSigRgbData, Lut_3, Lut_3 },
+ {icSigGrayData, Lut_1, Lut_1 },
+ {icSigHsvData, Lut_3, Lut_3 },
+ {icSigHlsData, Lut_3, Lut_3 },
+ {icSigCmykData, Lut_4, Lut_4 },
+ {icSigCmyData, Lut_3, Lut_3 },
+ {icSigMch6Data, Lut_6, Lut_6 },
+ {icSig2colorData, Lut_2, Lut_2 },
+ {icSig3colorData, Lut_3, Lut_3 },
+ {icSig4colorData, Lut_4, Lut_4 },
+ {icSig5colorData, Lut_5, Lut_5 },
+ {icSig6colorData, Lut_6, Lut_6 },
+ {icSig7colorData, Lut_7, Lut_7 },
+ {icSigMch5Data, Lut_5, Lut_5 },
+ {icSigMch6Data, Lut_6, Lut_6 },
+ {icSigMch7Data, Lut_7, Lut_7 },
+ {icSigMch8Data, Lut_8, Lut_8 },
+ {icSig8colorData, Lut_8, Lut_8 },
+ {icSig9colorData, Lut_9, Lut_9 },
+ {icSig10colorData, Lut_10, Lut_10 },
+ {icSig11colorData, Lut_11, Lut_11 },
+ {icSig12colorData, Lut_12, Lut_12 },
+ {icSig13colorData, Lut_13, Lut_13 },
+ {icSig14colorData, Lut_14, Lut_14 },
+ {icSig15colorData, Lut_15, Lut_15 },
+ {icMaxEnumData, NULL, NULL }
+};
+
+/*
+ Legacy Lab encoding:
+
+ The V4 specificatins are misleading on this, since they assume in this
+ instance that all devices spaces, however labeled, have no defined
+ ICC encoding. The end result is simple enough though:
+
+ ICC V2 Lab encoding should be used in all PCS encodings in
+ a icSigLut16Type or icSigNamedColor2Type tag, and can be used
+ for Lab encoding in device spaces for these tags.
+
+ ICC V4 Lab encoding should be used in all PCS encodings in
+ all other situations, and can be used for Lab encoding in
+ device spaces for all other situtaions.
+
+ [ Since the ICC spec. doesn't cover device spaces labeled as Lab,
+ these are ripe for mis-matches between different implementations.]
+
+ This logic has yet to be fully implemented here.
+*/
+
+/* Find appropriate conversion functions from the normalised */
+/* Lut data range 0.0 - 1.0 to/from a given colorspace value, */
+/* given the color space and Lut type. */
+/* Return 0 on success, 1 on match failure. */
+/* NOTE: doesn't set error value, message etc.! */
+static int getNormFunc(
+ icc *icp,
+// icProfileClassSignature psig, /* Profile signature to use */
+ icColorSpaceSignature csig, /* Colorspace to use. */
+// int lutin, /* 0 if this is for a icSigLut16Type input, nz for output */
+// icTagSignature tagSig, /* Tag signature involved (AtoB or B2A etc.) */
+ icTagTypeSignature tagType, /* icSigLut8Type or icSigLut16Type or V4 lut */
+ icmNormFlag flag, /* icmFromLuti, icmFromLutv or icmToLuti, icmToLutv */
+ void (**nfunc)(double *out, double *in)
+) {
+ int i;
+ if (tagType == icSigLut8Type && csig == icSigLabData) {
+ csig = icmSigLab8Data;
+ }
+ if (csig == icSigLabData) {
+ if (tagType == icSigLut16Type) /* Lut16 retains legacy encoding */
+ csig = icmSigLabV2Data;
+ else { /* Other tag types use version specific encoding */
+ if (icp->ver)
+ csig = icmSigLabV4Data;
+ else
+ csig = icmSigLabV2Data;
+ }
+ }
+
+ for (i = 0; colnormtable[i].csig != icMaxEnumData; i++) {
+ if (colnormtable[i].csig == csig)
+ break; /* Found it */
+ }
+ if (colnormtable[i].csig == icMaxEnumData) { /* Oops */
+ *nfunc = NULL;
+ return 1;
+ }
+
+ if (flag == icmFromLuti || flag == icmFromLutv) { /* Table index/value decoding functions */
+ *nfunc = colnormtable[i].fromLut;
+ return 0;
+ } else if (flag == icmToLuti || flag == icmToLutv) { /* Table index/value encoding functions */
+ *nfunc = colnormtable[i].toLut;
+ return 0;
+ }
+ *nfunc = NULL;
+ return 1;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Colorspace ranges - used instead of norm/denorm by Mono, Matrix and */
+/* override PCS */
+
+/* Function table - match ranges to color spaces. */
+/* Anything not here, we don't know how to convert. */
+/* (ie. YCbCr) */
+/* Hmm. we're not handling Lab8 properly ?? ~~~8888 */
+static struct {
+ icColorSpaceSignature csig;
+ int same; /* Non zero if first entry applies to all channels */
+ double min[3]; /* Minimum value for this colorspace */
+ double max[3]; /* Maximum value for this colorspace */
+} colorrangetable[] = {
+ {icSigXYZData, 1, { 0.0 } , { 1.0 + 32767.0/32768.0 } },
+ {icmSigLab8Data, 0, { 0.0, -128.0, -128.0 }, { 100.0, 127.0, 127.0 } },
+ {icmSigLabV2Data, 0, { 0.0, -128.0, -128.0 },
+ { 100.0 + 25500.0/65280.0, 127.0 + 255.0/256.0, 127.0 + 255.0/256.0 } },
+ {icmSigLabV4Data, 0, { 0.0, -128.0, -128.0 }, { 100.0, 127.0, 127.0 } },
+ {icmSigYData, 1, { 0.0 }, { 1.0 + 32767.0/32768.0 } },
+ {icmSigL8Data, 1, { 0.0 }, { 100.0 } },
+ {icmSigLV2Data, 1, { 0.0 }, { 100.0 + 25500.0/65280.0 } },
+ {icmSigLV4Data, 1, { 0.0 }, { 100.0 } },
+ {icSigLuvData, 0, { 0.0, -128.0, -128.0 },
+ { 100.0, 127.0 + 255.0/256.0, 127.0 + 255.0/256.0 } },
+ {icSigYCbCrData, 1, { 0.0 }, { 1.0 } }, /* ??? */
+ {icSigYxyData, 1, { 0.0 }, { 1.0 } }, /* ??? */
+ {icSigRgbData, 1, { 0.0 }, { 1.0 } },
+ {icSigGrayData, 1, { 0.0 }, { 1.0 } },
+ {icSigHsvData, 1, { 0.0 }, { 1.0 } },
+ {icSigHlsData, 1, { 0.0 }, { 1.0 } },
+ {icSigCmykData, 1, { 0.0 }, { 1.0 } },
+ {icSigCmyData, 1, { 0.0 }, { 1.0 } },
+ {icSigMch6Data, 1, { 0.0 }, { 1.0 } },
+ {icSig2colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig3colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig4colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig5colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig6colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig7colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig8colorData, 1, { 0.0 }, { 1.0 } },
+ {icSigMch5Data, 1, { 0.0 }, { 1.0 } },
+ {icSigMch6Data, 1, { 0.0 }, { 1.0 } },
+ {icSigMch7Data, 1, { 0.0 }, { 1.0 } },
+ {icSigMch8Data, 1, { 0.0 }, { 1.0 } },
+ {icSig9colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig10colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig11colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig12colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig13colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig14colorData, 1, { 0.0 }, { 1.0 } },
+ {icSig15colorData, 1, { 0.0 }, { 1.0 } },
+ {icMaxEnumData, 1, { 0.0 }, { 1.0 } }
+};
+
+/* Find appropriate typical encoding ranges for a */
+/* colorspace given the color space. */
+/* Return 0 on success, 1 on match failure */
+static int getRange(
+ icc *icp,
+// icProfileClassSignature psig, /* Profile signature to use */
+ icColorSpaceSignature csig, /* Colorspace to use. */
+// int lutin, /* 0 if this is for a icSigLut16Type input, nz for output */
+// icTagSignature tagSig, /* Tag signature involved (AtoB or B2A etc.) */
+ icTagTypeSignature tagType, /* icSigLut8Type or icSigLut16Type or V4 lut */
+ double *min, double *max /* Return range values */
+) {
+ int i, e, ee;
+
+ if (tagType == icSigLut8Type && csig == icSigLabData) {
+ csig = icmSigLab8Data;
+ }
+ if (csig == icSigLabData) {
+ if (tagType == icSigLut16Type) /* Lut16 retains legacy encoding */
+ csig = icmSigLabV2Data;
+ else { /* Other tag types use version specific encoding */
+ if (icp->ver)
+ csig = icmSigLabV4Data;
+ else
+ csig = icmSigLabV2Data;
+ }
+ }
+
+ for (i = 0; colorrangetable[i].csig != icMaxEnumData; i++) {
+ if (colorrangetable[i].csig == csig)
+ break; /* Found it */
+ }
+ if (colorrangetable[i].csig == icMaxEnumData) { /* Oops */
+ return 1;
+ }
+ ee = number_ColorSpaceSignature(csig); /* Get number of components */
+
+ if (colorrangetable[i].same) { /* All channels are the same */
+ for (e = 0; e < ee; e++) {
+ if (min != NULL)
+ min[e] = colorrangetable[i].min[0];
+ if (max != NULL)
+ max[e] = colorrangetable[i].max[0];
+ }
+ } else {
+ for (e = 0; e < ee; e++) {
+ if (min != NULL)
+ min[e] = colorrangetable[i].min[e];
+ if (max != NULL)
+ max[e] = colorrangetable[i].max[e];
+ }
+ }
+ return 0;
+}
+
+/* ============================================= */
+/* Misc. support functions. */
+
+/* Clamp a 3 vector to be +ve */
+void icmClamp3(double out[3], double in[3]) {
+ int i;
+ for (i = 0; i < 3; i++)
+ out[i] = in[i] < 0.0 ? 0.0 : in[i];
+}
+
+/* Add two 3 vectors */
+void icmAdd3(double out[3], double in1[3], double in2[3]) {
+ out[0] = in1[0] + in2[0];
+ out[1] = in1[1] + in2[1];
+ out[2] = in1[2] + in2[2];
+}
+
+/* Subtract two 3 vectors, out = in1 - in2 */
+void icmSub3(double out[3], double in1[3], double in2[3]) {
+ out[0] = in1[0] - in2[0];
+ out[1] = in1[1] - in2[1];
+ out[2] = in1[2] - in2[2];
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Set a 3x3 matrix to unity */
+void icmSetUnity3x3(double mat[3][3]) {
+ int i, j;
+ for (j = 0; j < 3; j++) {
+ for (i = 0; i < 3; i++) {
+ if (i == j)
+ mat[j][i] = 1.0;
+ else
+ mat[j][i] = 0.0;
+ }
+ }
+
+}
+
+/* Copy a 3x3 transform matrix */
+void icmCpy3x3(double dst[3][3], double src[3][3]) {
+ int i, j;
+
+ for (j = 0; j < 3; j++) {
+ for (i = 0; i < 3; i++)
+ dst[j][i] = src[j][i];
+ }
+}
+
+/* Scale each element of a 3x3 transform matrix */
+void icmScale3x3(double dst[3][3], double src[3][3], double scale) {
+ int i, j;
+
+ for (j = 0; j < 3; j++) {
+ for (i = 0; i < 3; i++)
+ dst[j][i] = src[j][i] * scale;
+ }
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/*
+
+ mat in out
+
+[ ] [] []
+[ ] * [] => []
+[ ] [] []
+
+ */
+
+/* Multiply 3 array by 3x3 transform matrix */
+void icmMulBy3x3(double out[3], double mat[3][3], double in[3]) {
+ double tt[3];
+
+ tt[0] = mat[0][0] * in[0] + mat[0][1] * in[1] + mat[0][2] * in[2];
+ tt[1] = mat[1][0] * in[0] + mat[1][1] * in[1] + mat[1][2] * in[2];
+ tt[2] = mat[2][0] * in[0] + mat[2][1] * in[1] + mat[2][2] * in[2];
+
+ out[0] = tt[0];
+ out[1] = tt[1];
+ out[2] = tt[2];
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Add one 3x3 to another */
+/* dst = src1 + src2 */
+void icmAdd3x3(double dst[3][3], double src1[3][3], double src2[3][3]) {
+ int i, j;
+
+ for (j = 0; j < 3; j++) {
+ for (i = 0; i < 3; i++)
+ dst[j][i] = src1[j][i] + src2[j][i];
+ }
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Tensor product. Multiply two 3 vectors to form a 3x3 matrix */
+/* src1[] forms the colums, and src2[] forms the rows in the result */
+void icmTensMul3(double dst[3][3], double src1[3], double src2[3]) {
+ int i, j;
+
+ for (j = 0; j < 3; j++) {
+ for (i = 0; i < 3; i++)
+ dst[j][i] = src1[j] * src2[i];
+ }
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Multiply one 3x3 with another */
+/* dst = src * dst */
+void icmMul3x3(double dst[3][3], double src[3][3]) {
+ int i, j, k;
+ double td[3][3]; /* Temporary dest */
+
+ for (j = 0; j < 3; j++) {
+ for (i = 0; i < 3; i++) {
+ double tt = 0.0;
+ for (k = 0; k < 3; k++)
+ tt += src[j][k] * dst[k][i];
+ td[j][i] = tt;
+ }
+ }
+
+ /* Copy result out */
+ for (j = 0; j < 3; j++)
+ for (i = 0; i < 3; i++)
+ dst[j][i] = td[j][i];
+}
+
+/* Multiply one 3x3 with another #2 */
+/* dst = src1 * src2 */
+void icmMul3x3_2(double dst[3][3], double src1[3][3], double src2[3][3]) {
+ int i, j, k;
+ double td[3][3]; /* Temporary dest */
+
+ for (j = 0; j < 3; j++) {
+ for (i = 0; i < 3; i++) {
+ double tt = 0.0;
+ for (k = 0; k < 3; k++)
+ tt += src1[j][k] * src2[k][i];
+ td[j][i] = tt;
+ }
+ }
+
+ /* Copy result out */
+ for (j = 0; j < 3; j++)
+ for (i = 0; i < 3; i++)
+ dst[j][i] = td[j][i];
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/*
+ Matrix Inversion
+ by Richard Carling
+ from "Graphics Gems", Academic Press, 1990
+*/
+
+/*
+ * adjoint( original_matrix, inverse_matrix )
+ *
+ * calculate the adjoint of a 3x3 matrix
+ *
+ * Let a denote the minor determinant of matrix A obtained by
+ * ij
+ *
+ * deleting the ith row and jth column from A.
+ *
+ * i+j
+ * Let b = (-1) a
+ * ij ji
+ *
+ * The matrix B = (b ) is the adjoint of A
+ * ij
+ */
+
+#define det2x2(a, b, c, d) (a * d - b * c)
+
+static void adjoint(
+double out[3][3],
+double in[3][3]
+) {
+ double a1, a2, a3, b1, b2, b3, c1, c2, c3;
+
+ /* assign to individual variable names to aid */
+ /* selecting correct values */
+
+ a1 = in[0][0]; b1 = in[0][1]; c1 = in[0][2];
+ a2 = in[1][0]; b2 = in[1][1]; c2 = in[1][2];
+ a3 = in[2][0]; b3 = in[2][1]; c3 = in[2][2];
+
+ /* row column labeling reversed since we transpose rows & columns */
+
+ out[0][0] = det2x2(b2, b3, c2, c3);
+ out[1][0] = - det2x2(a2, a3, c2, c3);
+ out[2][0] = det2x2(a2, a3, b2, b3);
+
+ out[0][1] = - det2x2(b1, b3, c1, c3);
+ out[1][1] = det2x2(a1, a3, c1, c3);
+ out[2][1] = - det2x2(a1, a3, b1, b3);
+
+ out[0][2] = det2x2(b1, b2, c1, c2);
+ out[1][2] = - det2x2(a1, a2, c1, c2);
+ out[2][2] = det2x2(a1, a2, b1, b2);
+}
+
+/*
+ * double = icmDet3x3( a1, a2, a3, b1, b2, b3, c1, c2, c3 )
+ *
+ * calculate the determinant of a 3x3 matrix
+ * in the form
+ *
+ * | a1, b1, c1 |
+ * | a2, b2, c2 |
+ * | a3, b3, c3 |
+ */
+
+double icmDet3x3(double in[3][3]) {
+ double a1, a2, a3, b1, b2, b3, c1, c2, c3;
+ double ans;
+
+ a1 = in[0][0]; b1 = in[0][1]; c1 = in[0][2];
+ a2 = in[1][0]; b2 = in[1][1]; c2 = in[1][2];
+ a3 = in[2][0]; b3 = in[2][1]; c3 = in[2][2];
+
+ ans = a1 * det2x2(b2, b3, c2, c3)
+ - b1 * det2x2(a2, a3, c2, c3)
+ + c1 * det2x2(a2, a3, b2, b3);
+ return ans;
+}
+
+#define ICM_SMALL_NUMBER 1.e-8
+/*
+ * inverse( original_matrix, inverse_matrix )
+ *
+ * calculate the inverse of a 4x4 matrix
+ *
+ * -1
+ * A = ___1__ adjoint A
+ * det A
+ */
+
+/* Return non-zero if not invertable */
+int icmInverse3x3(
+double out[3][3],
+double in[3][3]
+) {
+ int i, j;
+ double det;
+
+ /* calculate the 3x3 determinant
+ * if the determinant is zero,
+ * then the inverse matrix is not unique.
+ */
+ det = icmDet3x3(in);
+
+ if ( fabs(det) < ICM_SMALL_NUMBER)
+ return 1;
+
+ /* calculate the adjoint matrix */
+ adjoint(out, in);
+
+ /* scale the adjoint matrix to get the inverse */
+ for (i = 0; i < 3; i++)
+ for(j = 0; j < 3; j++)
+ out[i][j] /= det;
+ return 0;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Transpose a 3x3 matrix */
+void icmTranspose3x3(double out[3][3], double in[3][3]) {
+ int i, j;
+ if (out != in) {
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 3; j++)
+ out[i][j] = in[j][i];
+ } else {
+ double tt[3][3];
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 3; j++)
+ tt[i][j] = in[j][i];
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 3; j++)
+ out[i][j] = tt[i][j];
+ }
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Compute the dot product of two 3 vectors */
+double icmDot3(double in1[3], double in2[3]) {
+ return in1[0] * in2[0] + in1[1] * in2[1] + in1[2] * in2[2];
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Compute the cross product of two 3D vectors, out = in1 x in2 */
+void icmCross3(double out[3], double in1[3], double in2[3]) {
+ double tt[3];
+ tt[0] = (in1[1] * in2[2]) - (in1[2] * in2[1]);
+ tt[1] = (in1[2] * in2[0]) - (in1[0] * in2[2]);
+ tt[2] = (in1[0] * in2[1]) - (in1[1] * in2[0]);
+ out[0] = tt[0];
+ out[1] = tt[1];
+ out[2] = tt[2];
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Compute the norm (length) squared of a 3 vector */
+double icmNorm3sq(double in[3]) {
+ return in[0] * in[0] + in[1] * in[1] + in[2] * in[2];
+}
+
+/* Compute the norm (length) of a 3 vector */
+double icmNorm3(double in[3]) {
+ return sqrt(in[0] * in[0] + in[1] * in[1] + in[2] * in[2]);
+}
+
+/* Scale a 3 vector by the given ratio */
+void icmScale3(double out[3], double in[3], double rat) {
+ out[0] = in[0] * rat;
+ out[1] = in[1] * rat;
+ out[2] = in[2] * rat;
+}
+
+/* Compute a blend between in0 and in1 */
+void icmBlend3(double out[3], double in0[3], double in1[3], double bf) {
+ out[0] = (1.0 - bf) * in0[0] + bf * in1[0];
+ out[1] = (1.0 - bf) * in0[1] + bf * in1[1];
+ out[2] = (1.0 - bf) * in0[2] + bf * in1[2];
+}
+
+/* Normalise a 3 vector to the given length. Return nz if not normalisable */
+int icmNormalize3(double out[3], double in[3], double len) {
+ double tt = sqrt(in[0] * in[0] + in[1] * in[1] + in[2] * in[2]);
+
+ if (tt < ICM_SMALL_NUMBER)
+ return 1;
+ tt = len/tt;
+ out[0] = in[0] * tt;
+ out[1] = in[1] * tt;
+ out[2] = in[2] * tt;
+ return 0;
+}
+
+/* Compute the norm (length) squared of a vector define by two points */
+double icmNorm33sq(double in1[3], double in0[3]) {
+ int j;
+ double rv;
+ for (rv = 0.0, j = 0; j < 3; j++) {
+ double tt = in1[j] - in0[j];
+ rv += tt * tt;
+ }
+ return rv;
+}
+
+/* Compute the norm (length) of a vector define by two points */
+double icmNorm33(double in1[3], double in0[3]) {
+ int j;
+ double rv;
+ for (rv = 0.0, j = 0; j < 3; j++) {
+ double tt = in1[j] - in0[j];
+ rv += tt * tt;
+ }
+ return sqrt(rv);
+}
+
+/* Scale a two point vector by the given ratio. in0[] is the origin */
+void icmScale33(double out[3], double in1[3], double in0[3], double rat) {
+ out[0] = in0[0] + (in1[0] - in0[0]) * rat;
+ out[1] = in0[1] + (in1[1] - in0[1]) * rat;
+ out[2] = in0[2] + (in1[2] - in0[2]) * rat;
+}
+
+/* Normalise a two point vector to the given length. */
+/* The new location of in1[] is returned in out[]. */
+/* Return nz if not normalisable */
+int icmNormalize33(double out[3], double in1[3], double in0[3], double len) {
+ int j;
+ double vl;
+
+ for (vl = 0.0, j = 0; j < 3; j++) {
+ double tt = in1[j] - in0[j];
+ vl += tt * tt;
+ }
+ vl = sqrt(vl);
+ if (vl < ICM_SMALL_NUMBER)
+ return 1;
+
+ vl = len/vl;
+ for (j = 0; j < 3; j++) {
+ out[j] = in0[j] + (in1[j] - in0[j]) * vl;
+ }
+ return 0;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Given two 3D points, create a matrix that rotates */
+/* and scales one onto the other about the origin 0,0,0. */
+/* The maths is from page 52 of Tomas Moller and Eric Haines "Real-Time Rendering". */
+/* s is source vector, t is target vector. */
+/* Usage of icmRotMat: */
+/* t[0] == mat[0][0] * s[0] + mat[0][1] * s[1] + mat[0][2] * s[2]; */
+/* t[1] == mat[1][0] * s[0] + mat[1][1] * s[1] + mat[1][2] * s[2]; */
+/* t[2] == mat[2][0] * s[0] + mat[2][1] * s[1] + mat[2][2] * s[2]; */
+/* i.e. use icmMulBy3x3 */
+void icmRotMat(double m[3][3], double s[3], double t[3]) {
+ double sl, tl, sn[3], tn[3];
+ double v[3]; /* Cross product */
+ double e; /* Dot product */
+ double h; /* 1-e/Cross product dot squared */
+
+ /* Normalise input vectors */
+ /* The rotation will be about 0,0,0 */
+ sl = sqrt(s[0] * s[0] + s[1] * s[1] + s[2] * s[2]);
+ tl = sqrt(t[0] * t[0] + t[1] * t[1] + t[2] * t[2]);
+
+ if (sl < 1e-12 || tl < 1e-12) { /* Hmm. Do nothing */
+ m[0][0] = 1.0;
+ m[0][1] = 0.0;
+ m[0][2] = 0.0;
+ m[1][0] = 0.0;
+ m[1][1] = 1.0;
+ m[1][2] = 0.0;
+ m[2][0] = 0.0;
+ m[2][1] = 0.0;
+ m[2][2] = 1.0;
+ return;
+ }
+
+ sn[0] = s[0]/sl; sn[1] = s[1]/sl; sn[2] = s[2]/sl;
+ tn[0] = t[0]/tl; tn[1] = t[1]/tl; tn[2] = t[2]/tl;
+
+ /* Compute the cross product */
+ v[0] = (sn[1] * tn[2]) - (sn[2] * tn[1]);
+ v[1] = (sn[2] * tn[0]) - (sn[0] * tn[2]);
+ v[2] = (sn[0] * tn[1]) - (sn[1] * tn[0]);
+
+ /* Compute the dot product */
+ e = sn[0] * tn[0] + sn[1] * tn[1] + sn[2] * tn[2];
+
+ /* Cross product dot squared */
+ h = v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+
+ /* If the two input vectors are close to being parallel, */
+ /* then h will be close to zero. */
+ if (fabs(h) < 1e-12) {
+ m[0][0] = tl/sl;
+ m[0][1] = 0.0;
+ m[0][2] = 0.0;
+ m[1][0] = 0.0;
+ m[1][1] = tl/sl;
+ m[1][2] = 0.0;
+ m[2][0] = 0.0;
+ m[2][1] = 0.0;
+ m[2][2] = tl/sl;
+ } else {
+ /* 1-e/Cross product dot squared */
+ h = (1.0 - e) / h;
+
+ m[0][0] = tl/sl * (e + h * v[0] * v[0]);
+ m[0][1] = tl/sl * (h * v[0] * v[1] - v[2]);
+ m[0][2] = tl/sl * (h * v[0] * v[2] + v[1]);
+ m[1][0] = tl/sl * (h * v[0] * v[1] + v[2]);
+ m[1][1] = tl/sl * (e + h * v[1] * v[1]);
+ m[1][2] = tl/sl * (h * v[1] * v[2] - v[0]);
+ m[2][0] = tl/sl * (h * v[0] * v[2] - v[1]);
+ m[2][1] = tl/sl * (h * v[1] * v[2] + v[0]);
+ m[2][2] = tl/sl * (e + h * v[2] * v[2]);
+ }
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Multiply 2 array by 2x2 transform matrix */
+void icmMulBy2x2(double out[2], double mat[2][2], double in[2]) {
+ double tt[2];
+
+ tt[0] = mat[0][0] * in[0] + mat[0][1] * in[1];
+ tt[1] = mat[1][0] * in[0] + mat[1][1] * in[1];
+
+ out[0] = tt[0];
+ out[1] = tt[1];
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Copy a 3x4 transform matrix */
+void icmCpy3x4(double dst[3][4], double src[3][4]) {
+ int i, j;
+
+ for (j = 0; j < 3; j++) {
+ for (i = 0; i < 4; i++)
+ dst[j][i] = src[j][i];
+ }
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Multiply 3 array by 3x4 transform matrix */
+void icmMul3By3x4(double out[3], double mat[3][4], double in[3]) {
+ double tt[3];
+
+ tt[0] = mat[0][0] * in[0] + mat[0][1] * in[1] + mat[0][2] * in[2] + mat[0][3];
+ tt[1] = mat[1][0] * in[0] + mat[1][1] * in[1] + mat[1][2] * in[2] + mat[1][3];
+ tt[2] = mat[2][0] * in[0] + mat[2][1] * in[1] + mat[2][2] * in[2] + mat[2][3];
+
+ out[0] = tt[0];
+ out[1] = tt[1];
+ out[2] = tt[2];
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Given two 3D vectors, create a matrix that translates, */
+/* rotates and scales one onto the other. */
+/* The maths is from page 52 of Tomas Moller and Eric Haines */
+/* "Real-Time Rendering". */
+/* s0 -> s1 is source vector, t0 -> t1 is target vector. */
+/* Usage of icmRotMat: */
+/* t[0] == mat[0][0] * s[0] + mat[0][1] * s[1] + mat[0][2] * s[2] + mat[0][3]; */
+/* t[1] == mat[1][0] * s[0] + mat[1][1] * s[1] + mat[1][2] * s[2] + mat[1][3]; */
+/* t[2] == mat[2][0] * s[0] + mat[2][1] * s[1] + mat[2][2] * s[2] + mat[2][3]; */
+/* i.e. use icmMul3By3x4 */
+void icmVecRotMat(double m[3][4], double s1[3], double s0[3], double t1[3], double t0[3]) {
+ int i, j;
+ double ss[3], tt[3], rr[3][3];
+
+ /* Create the rotation matrix: */
+ for (i = 0; i < 3; i++) {
+ ss[i] = s1[i] - s0[i];
+ tt[i] = t1[i] - t0[i];
+ }
+ icmRotMat(rr, ss, tt);
+
+ /* Create rotated version of s0: */
+ icmMulBy3x3(ss, rr, s0);
+
+ /* Create 4x4 matrix */
+ for (j = 0; j < 3; j++) {
+ for (i = 0; i < 4; i++) {
+ if (i < 3 && j < 3)
+ m[j][i] = rr[j][i];
+ else if (i == 3 && j < 3)
+ m[j][i] = t0[j] - ss[j];
+ else if (i == j)
+ m[j][i] = 1.0;
+ else
+ m[j][i] = 0.0;
+ }
+ }
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Compute the 3D intersection of a vector and a plane */
+/* return nz if there is no intersection */
+int icmVecPlaneIsect(
+double isect[3], /* return intersection point */
+double pl_const, /* Plane equation constant */
+double pl_norm[3], /* Plane normal vector */
+double ve_1[3], /* Point on line */
+double ve_0[3] /* Second point on line */
+) {
+ double den; /* denominator */
+ double rv; /* Vector parameter value */
+ double vvec[3]; /* Vector vector */
+ double ival[3]; /* Intersection value */
+
+ /* Compute vector between the two points */
+ vvec[0] = ve_1[0] - ve_0[0];
+ vvec[1] = ve_1[1] - ve_0[1];
+ vvec[2] = ve_1[2] - ve_0[2];
+
+ /* Compute the denominator */
+ den = pl_norm[0] * vvec[0] + pl_norm[1] * vvec[1] + pl_norm[2] * vvec[2];
+
+ /* Too small to intersect ? */
+ if (fabs(den) < 1e-12) {
+ return 1;
+ }
+
+ /* Compute the parameterized intersction point */
+ rv = -(pl_norm[0] * ve_0[0] + pl_norm[1] * ve_0[1] + pl_norm[2] * ve_0[2] + pl_const)/den;
+
+ /* Compute the actual intersection point */
+ isect[0] = ve_0[0] + rv * vvec[0];
+ isect[1] = ve_0[1] + rv * vvec[1];
+ isect[2] = ve_0[2] + rv * vvec[2];
+
+ return 0;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Compute the closest points between two lines a and b. */
+/* Return closest points and parameter values if not NULL. */
+/* Return nz if they are paralel. */
+/* The maths is from page 338 of Tomas Moller and Eric Haines "Real-Time Rendering". */
+int icmLineLineClosest(double ca[3], double cb[3], double *pa, double * pb,
+ double la0[3], double la1[3], double lb0[3], double lb1[3]) {
+ double va[3], vb[3];
+ double vvab[3], vvabns; /* Cross product of va and vb and its norm squared */
+ double vba0[3]; /* lb0 - la0 */
+ double tt[3];
+ double a, b; /* Parameter values */
+
+ icmSub3(va, la1, la0);
+ icmSub3(vb, lb1, lb0);
+ icmCross3(vvab, va, vb);
+ vvabns = icmNorm3sq(vvab);
+
+ if (vvabns < 1e-12)
+ return 1;
+
+ icmSub3(vba0, lb0, la0);
+ icmCross3(tt, vba0, vb);
+ a = icmDot3(tt, vvab) / vvabns;
+
+ icmCross3(tt, vba0, va);
+ b = icmDot3(tt, vvab) / vvabns;
+
+ if (pa != NULL)
+ *pa = a;
+
+ if (pb != NULL)
+ *pb = b;
+
+ if (ca != NULL) {
+ ca[0] = la0[0] + a * va[0];
+ ca[1] = la0[1] + a * va[1];
+ ca[2] = la0[2] + a * va[2];
+ }
+
+ if (cb != NULL) {
+ cb[0] = lb0[0] + b * vb[0];
+ cb[1] = lb0[1] + b * vb[1];
+ cb[2] = lb0[2] + b * vb[2];
+ }
+
+#ifdef NEVER /* Verify */
+ {
+ double vab[3]; /* Vector from ca to cb */
+
+ vab[0] = lb0[0] + b * vb[0] - la0[0] - a * va[0];
+ vab[1] = lb0[1] + b * vb[1] - la0[1] - a * va[1];
+ vab[2] = lb0[2] + b * vb[2] - la0[2] - a * va[2];
+
+ if (icmDot3(va, vab) > 1e-6
+ || icmDot3(vb, vab) > 1e-6)
+ warning("icmLineLineClosest verify failed\n");
+ }
+#endif
+
+ return 0;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Given 3 3D points, compute a plane equation. */
+/* The normal will be right handed given the order of the points */
+/* The plane equation will be the 3 normal components and the constant. */
+/* Return nz if any points are cooincident or co-linear */
+int icmPlaneEqn3(double eq[4], double p0[3], double p1[3], double p2[3]) {
+ double ll, v1[3], v2[3];
+
+ /* Compute vectors along edges */
+ v2[0] = p1[0] - p0[0];
+ v2[1] = p1[1] - p0[1];
+ v2[2] = p1[2] - p0[2];
+
+ v1[0] = p2[0] - p0[0];
+ v1[1] = p2[1] - p0[1];
+ v1[2] = p2[2] - p0[2];
+
+ /* Compute cross products v1 x v2, which will be the normal */
+ eq[0] = v1[1] * v2[2] - v1[2] * v2[1];
+ eq[1] = v1[2] * v2[0] - v1[0] * v2[2];
+ eq[2] = v1[0] * v2[1] - v1[1] * v2[0];
+
+ /* Normalise the equation */
+ ll = sqrt(eq[0] * eq[0] + eq[1] * eq[1] + eq[2] * eq[2]);
+ if (ll < 1e-10) {
+ return 1;
+ }
+ eq[0] /= ll;
+ eq[1] /= ll;
+ eq[2] /= ll;
+
+ /* Compute the plane equation constant */
+ eq[3] = - (eq[0] * p0[0])
+ - (eq[1] * p0[1])
+ - (eq[2] * p0[2]);
+
+ return 0;
+}
+
+/* Given a 3D point and a plane equation, return the signed */
+/* distance from the plane */
+double icmPlaneDist3(double eq[4], double p[3]) {
+ double rv;
+
+ rv = eq[0] * p[0]
+ + eq[1] * p[1]
+ + eq[2] * p[2]
+ + eq[3];
+
+ return rv;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* CIE Y (range 0 .. 1) to perceptual CIE 1976 L* (range 0 .. 100) */
+double
+icmY2L(double val) {
+ if (val > 0.008856451586)
+ val = pow(val,1.0/3.0);
+ else
+ val = 7.787036979 * val + 16.0/116.0;
+
+ val = (116.0 * val - 16.0);
+ return val;
+}
+
+/* Perceptual CIE 1976 L* (range 0 .. 100) to CIE Y (range 0 .. 1) */
+double
+icmL2Y(double val) {
+ val = (val + 16.0)/116.0;
+
+ if (val > 24.0/116.0)
+ val = pow(val,3.0);
+ else
+ val = (val - 16.0/116.0)/7.787036979;
+ return val;
+}
+
+/* CIE XYZ to perceptual CIE 1976 L*a*b* */
+void
+icmXYZ2Lab(icmXYZNumber *w, double *out, double *in) {
+ double X = in[0], Y = in[1], Z = in[2];
+ double x,y,z,fx,fy,fz;
+
+ x = X/w->X;
+ y = Y/w->Y;
+ z = Z/w->Z;
+
+ if (x > 0.008856451586)
+ fx = pow(x,1.0/3.0);
+ else
+ fx = 7.787036979 * x + 16.0/116.0;
+
+ if (y > 0.008856451586)
+ fy = pow(y,1.0/3.0);
+ else
+ fy = 7.787036979 * y + 16.0/116.0;
+
+ if (z > 0.008856451586)
+ fz = pow(z,1.0/3.0);
+ else
+ fz = 7.787036979 * z + 16.0/116.0;
+
+ out[0] = 116.0 * fy - 16.0;
+ out[1] = 500.0 * (fx - fy);
+ out[2] = 200.0 * (fy - fz);
+}
+
+/* Perceptual CIE 1976 L*a*b* to CIE XYZ */
+void
+icmLab2XYZ(icmXYZNumber *w, double *out, double *in) {
+ double L = in[0], a = in[1], b = in[2];
+ double x,y,z,fx,fy,fz;
+
+ fy = (L + 16.0)/116.0;
+ fx = a/500.0 + fy;
+ fz = fy - b/200.0;
+
+ if (fy > 24.0/116.0)
+ y = pow(fy,3.0);
+ else
+ y = (fy - 16.0/116.0)/7.787036979;
+
+ if (fx > 24.0/116.0)
+ x = pow(fx,3.0);
+ else
+ x = (fx - 16.0/116.0)/7.787036979;
+
+ if (fz > 24.0/116.0)
+ z = pow(fz,3.0);
+ else
+ z = (fz - 16.0/116.0)/7.787036979;
+
+ out[0] = x * w->X;
+ out[1] = y * w->Y;
+ out[2] = z * w->Z;
+}
+
+
+/* LCh to Lab */
+void icmLCh2Lab(double *out, double *in) {
+ double C, h;
+
+ C = in[1];
+ h = 3.14159265359/180.0 * in[2];
+
+ out[0] = in[0];
+ out[1] = C * cos(h);
+ out[2] = C * sin(h);
+}
+
+/* Lab to LCh */
+void icmLab2LCh(double *out, double *in) {
+ double C, h;
+
+ C = sqrt(in[1] * in[1] + in[2] * in[2]);
+
+ h = (180.0/3.14159265359) * atan2(in[2], in[1]);
+ h = (h < 0.0) ? h + 360.0 : h;
+
+ out[0] = in[0];
+ out[1] = C;
+ out[2] = h;
+}
+
+/* XYZ to Yxy */
+extern ICCLIB_API void icmXYZ2Yxy(double *out, double *in) {
+ double sum = in[0] + in[1] + in[2];
+ double Y, x, y;
+
+ if (sum < 1e-9) {
+ Y = 0.0;
+ y = 0.333333333;
+ x = 0.333333333;
+ } else {
+ Y = in[1];
+ x = in[0]/sum;
+ y = in[1]/sum;
+ }
+ out[0] = Y;
+ out[1] = x;
+ out[2] = y;
+}
+
+/* Yxy to XYZ */
+extern ICCLIB_API void icmYxy2XYZ(double *out, double *in) {
+ double Y = in[0];
+ double x = in[1];
+ double y = in[2];
+ double z = 1.0 - x - y;
+ double sum;
+ if (y < 1e-9) {
+ out[0] = out[1] = out[2] = 0.0;
+ } else {
+ sum = Y/y;
+ out[0] = x * sum;
+ out[1] = Y;
+ out[2] = z * sum;
+ }
+}
+
+
+/* CIE XYZ to perceptual CIE 1976 L*u*v* */
+extern ICCLIB_API void icmXYZ2Luv(icmXYZNumber *w, double *out, double *in) {
+ double X = in[0], Y = in[1], Z = in[2];
+ double un, vn, u, v, fl, fu, fv;
+
+ un = (4.0 * w->X) / (w->X + 15.0 * w->Y + 3.0 * w->Z);
+ vn = (9.0 * w->Y) / (w->X + 15.0 * w->Y + 3.0 * w->Z);
+ u = (4.0 * X) / (X + 15.0 * Y + 3.0 * Z);
+ v = (9.0 * Y) / (X + 15.0 * Y + 3.0 * Z);
+
+ Y /= w->Y;
+
+ if (Y > 0.008856451586)
+ fl = pow(Y,1.0/3.0);
+ else
+ fl = 7.787036979 * Y + 16.0/116.0;
+
+ fu = u - un;
+ fv = v - vn;
+
+ out[0] = 116.0 * fl - 16.0;
+ out[1] = 13.0 * out[0] * fu;
+ out[2] = 13.0 * out[0] * fv;
+}
+
+/* Perceptual CIE 1976 L*u*v* to CIE XYZ */
+extern ICCLIB_API void icmLuv2XYZ(icmXYZNumber *w, double *out, double *in) {
+ double un, vn, u, v, fl, fu, fv, sum, X, Y, Z;
+
+ fl = (in[0] + 16.0)/116.0;
+ fu = in[1] / (13.0 * in[0]);
+ fv = in[2] / (13.0 * in[0]);
+
+ un = (4.0 * w->X) / (w->X + 15.0 * w->Y + 3.0 * w->Z);
+ vn = (9.0 * w->Y) / (w->X + 15.0 * w->Y + 3.0 * w->Z);
+
+ u = fu + un;
+ v = fv + vn;
+
+ if (fl > 24.0/116.0)
+ Y = pow(fl,3.0);
+ else
+ Y = (fl - 16.0/116.0)/7.787036979;
+ Y *= w->Y;
+
+ sum = (9.0 * Y)/v;
+ X = (u * sum)/4.0;
+ Z = (sum - X - 15.0 * Y)/3.0;
+
+ out[0] = X;
+ out[1] = Y;
+ out[2] = Z;
+}
+
+/* NOTE :- none of the following seven have been protected */
+/* against arithmmetic issues (ie. for black) */
+
+/* CIE XYZ to perceptual CIE 1976 UCS diagram Yu'v'*/
+/* (Yu'v' is a better chromaticity space than Yxy) */
+extern ICCLIB_API void icmXYZ21976UCS(double *out, double *in) {
+ double X = in[0], Y = in[1], Z = in[2];
+ double den, u, v;
+
+ den = (X + 15.0 * Y + 3.0 * Z);
+ u = (4.0 * X) / den;
+ v = (9.0 * Y) / den;
+
+ out[0] = Y;
+ out[1] = u;
+ out[2] = v;
+}
+
+/* Perceptual CIE 1976 UCS diagram Yu'v' to CIE XYZ */
+extern ICCLIB_API void icm1976UCS2XYZ(double *out, double *in) {
+ double u, v, fl, fu, fv, sum, X, Y, Z;
+
+ Y = in[0];
+ u = in[1];
+ v = in[2];
+
+ X = ((9.0 * u * Y)/(4.0 * v));
+ Z = -(((20.0 * v + 3.0 * u - 12.0) * Y)/(4.0 * v));
+
+ out[0] = X;
+ out[1] = Y;
+ out[2] = Z;
+}
+
+/* CIE XYZ to perceptual CIE 1960 UCS */
+/* (This was obsoleted by the 1976UCS, but is still used */
+/* in computing color temperatures.) */
+extern ICCLIB_API void icmXYZ21960UCS(double *out, double *in) {
+ double X = in[0], Y = in[1], Z = in[2];
+ double u, v;
+
+ u = (4.0 * X) / (X + 15.0 * Y + 3.0 * Z);
+ v = (6.0 * Y) / (X + 15.0 * Y + 3.0 * Z);
+
+ out[0] = Y;
+ out[1] = u;
+ out[2] = v;
+}
+
+/* Perceptual CIE 1960 UCS to CIE XYZ */
+extern ICCLIB_API void icm1960UCS2XYZ(double *out, double *in) {
+ double u, v, fl, fu, fv, sum, X, Y, Z;
+
+ Y = in[0];
+ u = in[1];
+ v = in[2];
+
+ X = ((3.0 * u * Y)/(2.0 * v));
+ Z = -(((10.0 * v + u - 4.0) * Y)/(2.0 * v));
+
+ out[0] = X;
+ out[1] = Y;
+ out[2] = Z;
+}
+
+/* CIE XYZ to perceptual CIE 1964 WUV (U*V*W*) */
+/* (This is obsolete but still used in computing CRI) */
+extern ICCLIB_API void icmXYZ21964WUV(icmXYZNumber *w, double *out, double *in) {
+ double W, U, V;
+ double wucs[3];
+ double iucs[3];
+
+ icmXYZ2Ary(wucs, *w);
+ icmXYZ21960UCS(wucs, wucs);
+ icmXYZ21960UCS(iucs, in);
+
+ W = 25.0 * pow(iucs[0] * 100.0/wucs[0], 1.0/3.0) - 17.0;
+ U = 13.0 * W * (iucs[1] - wucs[1]);
+ V = 13.0 * W * (iucs[2] - wucs[2]);
+
+ out[0] = W;
+ out[1] = U;
+ out[2] = V;
+}
+
+/* Perceptual CIE 1964 WUV (U*V*W*) to CIE XYZ */
+extern ICCLIB_API void icm1964WUV2XYZ(icmXYZNumber *w, double *out, double *in) {
+ double W, U, V;
+ double wucs[3];
+ double iucs[3];
+
+ icmXYZ2Ary(wucs, *w);
+ icmXYZ21960UCS(wucs, wucs);
+
+ W = in[0];
+ U = in[1];
+ V = in[2];
+
+ iucs[0] = pow((W + 17.0)/25.0, 3.0) * wucs[0]/100.0;
+ iucs[1] = U / (13.0 * W) + wucs[1];
+ iucs[2] = V / (13.0 * W) + wucs[2];
+
+ icm1960UCS2XYZ(out, iucs);
+}
+
+/* CIE CIE1960 UCS to perceptual CIE 1964 WUV (U*V*W*) */
+extern ICCLIB_API void icm1960UCS21964WUV(icmXYZNumber *w, double *out, double *in) {
+ double W, U, V;
+ double wucs[3];
+
+ icmXYZ2Ary(wucs, *w);
+ icmXYZ21960UCS(wucs, wucs);
+
+ W = 25.0 * pow(in[0] * 100.0/wucs[0], 1.0/3.0) - 17.0;
+ U = 13.0 * W * (in[1] - wucs[1]);
+ V = 13.0 * W * (in[2] - wucs[2]);
+
+ out[0] = W;
+ out[1] = U;
+ out[2] = V;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* available D50 Illuminant */
+icmXYZNumber icmD50 = { /* Profile illuminant - D50 */
+ 0.9642, 1.0000, 0.8249
+};
+
+icmXYZNumber icmD50_100 = { /* Profile illuminant - D50, scaled to 100 */
+ 96.42, 100.00, 82.49
+};
+
+double icmD50_ary3[3] = { /* Profile illuminant - D50 */
+ 0.9642, 1.0000, 0.8249
+};
+
+double icmD50_100_ary3[3] = { /* Profile illuminant - D50, scaled to 100 */
+ 96.42, 100.00, 82.49
+};
+
+/* available D65 Illuminant */
+icmXYZNumber icmD65 = { /* Profile illuminant - D65 */
+ 0.9505, 1.0000, 1.0890
+};
+
+icmXYZNumber icmD65_100 = { /* Profile illuminant - D65, scaled to 100 */
+ 95.05, 100.00, 108.90
+};
+
+double icmD65_ary3[3] = { /* Profile illuminant - D65 */
+ 0.9505, 1.0000, 1.0890
+};
+
+double icmD65_100_ary3[3] = { /* Profile illuminant - D65, scaled to 100 */
+ 95.05, 100.00, 108.90
+};
+
+/* Default black point */
+icmXYZNumber icmBlack = {
+ 0.0000, 0.0000, 0.0000
+};
+
+/* Return the normal Delta E given two Lab values */
+double icmLabDE(double *Lab0, double *Lab1) {
+ double rv = 0.0, tt;
+
+ tt = Lab0[0] - Lab1[0];
+ rv += tt * tt;
+ tt = Lab0[1] - Lab1[1];
+ rv += tt * tt;
+ tt = Lab0[2] - Lab1[2];
+ rv += tt * tt;
+
+ return sqrt(rv);
+}
+
+/* Return the normal Delta E squared, given two Lab values */
+double icmLabDEsq(double *Lab0, double *Lab1) {
+ double rv = 0.0, tt;
+
+ tt = Lab0[0] - Lab1[0];
+ rv += tt * tt;
+ tt = Lab0[1] - Lab1[1];
+ rv += tt * tt;
+ tt = Lab0[2] - Lab1[2];
+ rv += tt * tt;
+
+ return rv;
+}
+
+/* Return the normal Delta E given two XYZ values */
+extern ICCLIB_API double icmXYZLabDE(icmXYZNumber *w, double *in0, double *in1) {
+ double lab0[3], lab1[3], rv;
+
+ icmXYZ2Lab(w, lab0, in0);
+ icmXYZ2Lab(w, lab1, in1);
+ rv = icmLabDE(lab0, lab1);
+ return rv;
+}
+
+/* (Note that CIE94 can give odd results for very large delta E's, */
+/* when one of the two points is near the neutral axis: */
+/* ie DE(A,B + del) != DE(A,B) + DE(del) */
+#ifdef NEVER
+{
+ double w1[3] = { 99.996101, -0.058417, -0.010557 };
+ double c1[3] = { 60.267956, 98.845863, -61.163277 };
+ double w2[3] = { 100.014977, -0.138339, 0.089744 };
+ double c2[3] = { 60.294464, 98.117104, -60.843159 };
+
+ printf("DE 1 = %f, 2 = %f\n", icmLabDE(c1, w1), icmLabDE(c2, w2));
+ printf("DE94 1 = %f, 2 = %f\n", icmCIE94(c1, w1), icmCIE94(c2, w2));
+}
+#endif
+
+
+/* Return the CIE94 Delta E color difference measure, squared */
+double icmCIE94sq(double Lab0[3], double Lab1[3]) {
+ double desq, dhsq;
+ double dlsq, dcsq;
+ double c12;
+
+ {
+ double dl, da, db;
+ dl = Lab0[0] - Lab1[0];
+ dlsq = dl * dl; /* dl squared */
+ da = Lab0[1] - Lab1[1];
+ db = Lab0[2] - Lab1[2];
+
+ /* Compute normal Lab delta E squared */
+ desq = dlsq + da * da + db * db;
+ }
+
+ {
+ double c1, c2, dc;
+
+ /* Compute chromanance for the two colors */
+ c1 = sqrt(Lab0[1] * Lab0[1] + Lab0[2] * Lab0[2]);
+ c2 = sqrt(Lab1[1] * Lab1[1] + Lab1[2] * Lab1[2]);
+ c12 = sqrt(c1 * c2); /* Symetric chromanance */
+
+ /* delta chromanance squared */
+ dc = c2 - c1;
+ dcsq = dc * dc;
+ }
+
+ /* Compute delta hue squared */
+ if ((dhsq = desq - dlsq - dcsq) < 0.0)
+ dhsq = 0.0;
+ {
+ double sc, sh;
+
+ /* Weighting factors for delta chromanance & delta hue */
+ sc = 1.0 + 0.048 * c12;
+ sh = 1.0 + 0.014 * c12;
+ return dlsq + dcsq/(sc * sc) + dhsq/(sh * sh);
+ }
+}
+
+/* Return the CIE94 Delta E color difference measure */
+double icmCIE94(double Lab0[3], double Lab1[3]) {
+ return sqrt(icmCIE94sq(Lab0, Lab1));
+}
+
+/* Return the CIE94 Delta E color difference measure for two XYZ values */
+extern ICCLIB_API double icmXYZCIE94(icmXYZNumber *w, double *in0, double *in1) {
+ double lab0[3], lab1[3];
+
+ icmXYZ2Lab(w, lab0, in0);
+ icmXYZ2Lab(w, lab1, in1);
+ return sqrt(icmCIE94sq(lab0, lab1));
+}
+
+
+/* From the paper "The CIEDE2000 Color-Difference Formula: Implementation Notes, */
+/* Supplementary Test Data, and Mathematical Observations", by */
+/* Gaurav Sharma, Wencheng Wu and Edul N. Dalal, */
+/* Color Res. Appl., vol. 30, no. 1, pp. 21-30, Feb. 2005. */
+
+/* Return the CIEDE2000 Delta E color difference measure squared, for two Lab values */
+double icmCIE2Ksq(double *Lab0, double *Lab1) {
+ double C1, C2;
+ double h1, h2;
+ double dL, dC, dH;
+ double dsq;
+
+ /* The trucated value of PI is needed to ensure that the */
+ /* test cases pass, as one of them lies on the edge of */
+ /* a mathematical discontinuity. The precision is still */
+ /* enough for any practical use. */
+#define RAD2DEG(xx) (180.0/3.14159265358979 * (xx))
+#define DEG2RAD(xx) (3.14159265358979/180.0 * (xx))
+
+ /* Compute Cromanance and Hue angles */
+ {
+ double C1ab, C2ab;
+ double Cab, Cab7, G;
+ double a1, a2;
+
+ C1ab = sqrt(Lab0[1] * Lab0[1] + Lab0[2] * Lab0[2]);
+ C2ab = sqrt(Lab1[1] * Lab1[1] + Lab1[2] * Lab1[2]);
+ Cab = 0.5 * (C1ab + C2ab);
+ Cab7 = pow(Cab,7.0);
+ G = 0.5 * (1.0 - sqrt(Cab7/(Cab7 + 6103515625.0)));
+ a1 = (1.0 + G) * Lab0[1];
+ a2 = (1.0 + G) * Lab1[1];
+ C1 = sqrt(a1 * a1 + Lab0[2] * Lab0[2]);
+ C2 = sqrt(a2 * a2 + Lab1[2] * Lab1[2]);
+
+ if (C1 < 1e-9)
+ h1 = 0.0;
+ else {
+ h1 = RAD2DEG(atan2(Lab0[2], a1));
+ if (h1 < 0.0)
+ h1 += 360.0;
+ }
+
+ if (C2 < 1e-9)
+ h2 = 0.0;
+ else {
+ h2 = RAD2DEG(atan2(Lab1[2], a2));
+ if (h2 < 0.0)
+ h2 += 360.0;
+ }
+ }
+
+ /* Compute delta L, C and H */
+ {
+ double dh;
+
+ dL = Lab1[0] - Lab0[0];
+ dC = C2 - C1;
+ if (C1 < 1e-9 || C2 < 1e-9) {
+ dh = 0.0;
+ } else {
+ dh = h2 - h1;
+ if (dh > 180.0)
+ dh -= 360.0;
+ else if (dh < -180.0)
+ dh += 360.0;
+ }
+
+ dH = 2.0 * sqrt(C1 * C2) * sin(DEG2RAD(0.5 * dh));
+ }
+
+ {
+ double L, C, h, T;
+ double hh, ddeg;
+ double C7, RC, L50sq, SL, SC, SH, RT;
+ double dLsq, dCsq, dHsq, RCH;
+
+ L = 0.5 * (Lab0[0] + Lab1[0]);
+ C = 0.5 * (C1 + C2);
+ if (C1 < 1e-9 || C2 < 1e-9) {
+ h = h1 + h2;
+ } else {
+ h = h1 + h2;
+ if (fabs(h1 - h2) > 180.0) {
+ if (h < 360.0)
+ h += 360.0;
+ else if (h >= 360.0)
+ h -= 360.0;
+ }
+ h *= 0.5;
+ }
+ T = 1.0 - 0.17 * cos(DEG2RAD(h-30.0)) + 0.24 * cos(DEG2RAD(2.0 * h))
+ + 0.32 * cos(DEG2RAD(3.0 * h + 6.0)) - 0.2 * cos(DEG2RAD(4.0 * h - 63.0));
+ hh = (h - 275.0)/25.0;
+ ddeg = 30.0 * exp(-hh * hh);
+ C7 = pow(C,7.0);
+ RC = 2.0 * sqrt(C7/(C7 + 6103515625.0));
+ L50sq = (L - 50.0) * (L - 50.0);
+ SL = 1.0 + (0.015 * L50sq)/sqrt(20.0 + L50sq);
+ SC = 1.0 + 0.045 * C;
+ SH = 1.0 + 0.015 * C * T;
+ RT = -sin(DEG2RAD(2 * ddeg)) * RC;
+
+ dLsq = dL/SL;
+ dCsq = dC/SC;
+ dHsq = dH/SH;
+
+ RCH = RT * dCsq * dHsq;
+
+ dLsq *= dLsq;
+ dCsq *= dCsq;
+ dHsq *= dHsq;
+
+ dsq = dLsq + dCsq + dHsq + RCH;
+ }
+
+ return dsq;
+
+#undef RAD2DEG
+#undef DEG2RAD
+}
+
+/* Return the CIE2DE000 Delta E color difference measure for two Lab values */
+double icmCIE2K(double *Lab0, double *Lab1) {
+ return sqrt(icmCIE2Ksq(Lab0, Lab1));
+}
+
+/* Return the CIEDE2000 Delta E color difference measure for two XYZ values */
+extern ICCLIB_API double icmXYZCIE2K(icmXYZNumber *w, double *in0, double *in1) {
+ double lab0[3], lab1[3];
+
+ icmXYZ2Lab(w, lab0, in0);
+ icmXYZ2Lab(w, lab1, in1);
+ return sqrt(icmCIE2Ksq(lab0, lab1));
+}
+
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Chromatic adaptation transform utility */
+/* Return a 3x3 chromatic adaptation matrix */
+/* Use icmMulBy3x3(dst, mat, src) */
+void icmChromAdaptMatrix(
+ int flags, /* Use bradford, Transform given matrix flags */
+ icmXYZNumber d_wp, /* Destination white point */
+ icmXYZNumber s_wp, /* Source white point */
+ double mat[3][3] /* Destination matrix */
+) {
+ double dst[3], src[3]; /* Source & destination white points */
+ double vkmat[3][3]; /* Von Kries matrix */
+#ifdef NEVER
+ static double bradford[3][3] = { /* Linear cone space matrix */
+ { 1.0, 0.0, 0.0 },
+ { 0.0, 1.0, 0.0 },
+ { 0.0, 0.0, 1.0 }
+ };
+#endif /* NEVER */
+ static double bradford[3][3] = { /* Bradford cone space matrix */
+ { 0.8951, 0.2664, -0.1614 },
+ { -0.7502, 1.7135, 0.0367 },
+ { 0.0389, -0.0685, 1.0296 }
+ };
+ static int inited = 0; /* Compute inverse bradford once */
+ static double ibradford[3][3]; /* Inverse Bradford */
+
+ /* Set initial matrix to unity */
+ if (!(flags & ICM_CAM_MULMATRIX)) {
+ icmSetUnity3x3(mat);
+ }
+
+ icmXYZ2Ary(src, s_wp);
+ icmXYZ2Ary(dst, d_wp);
+
+ if (flags & ICM_CAM_BRADFORD) {
+ icmMulBy3x3(src, bradford, src);
+ icmMulBy3x3(dst, bradford, dst);
+ }
+
+ /* Setup the Von Kries white point adaptation matrix */
+ vkmat[0][0] = dst[0]/src[0];
+ vkmat[1][1] = dst[1]/src[1];
+ vkmat[2][2] = dst[2]/src[2];
+ vkmat[0][1] = vkmat[0][2] = 0.0;
+ vkmat[1][0] = vkmat[1][2] = 0.0;
+ vkmat[2][0] = vkmat[2][1] = 0.0;
+
+ /* Transform to Bradford space if requested */
+ if (flags & ICM_CAM_BRADFORD) {
+ icmMul3x3(mat, bradford);
+ }
+
+ /* Apply chromatic adaptation */
+ icmMul3x3(mat, vkmat);
+
+ /* Transform from Bradford space */
+ if (flags & ICM_CAM_BRADFORD) {
+ if (inited == 0) {
+ icmInverse3x3(ibradford, bradford);
+ inited = 1;
+ }
+ icmMul3x3(mat, ibradford);
+ }
+
+ /* We're done */
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* RGB primaries device to RGB->XYZ transform matrix. */
+/* We assume that the device is perfectly additive, but that */
+/* there may be a scale factor applied to the channels to */
+/* match the white point at RGB = 1. */
+
+/* Return non-zero if matrix would be singular */
+int icmRGBprim2matrix(
+ icmXYZNumber white, /* White point */
+ icmXYZNumber red, /* Red colorant */
+ icmXYZNumber green, /* Green colorant */
+ icmXYZNumber blue, /* Blue colorant */
+ double mat[3][3] /* Destination matrix */
+) {
+ double tmat[3][3];
+ double t[3];
+
+ /* Assemble the colorants into a matrix */
+ tmat[0][0] = red.X;
+ tmat[0][1] = green.X;
+ tmat[0][2] = blue.X;
+ tmat[1][0] = red.Y;
+ tmat[1][1] = green.Y;
+ tmat[1][2] = blue.Y;
+ tmat[2][0] = red.Z;
+ tmat[2][1] = green.Z;
+ tmat[2][2] = blue.Z;
+
+ /* Compute the inverse */
+ if (icmInverse3x3(mat, tmat))
+ return 1;
+
+ /* Compute scale vector that maps colorants to white point */
+ t[0] = mat[0][0] * white.X
+ + mat[0][1] * white.Y
+ + mat[0][2] * white.Z;
+ t[1] = mat[1][0] * white.X
+ + mat[1][1] * white.Y
+ + mat[1][2] * white.Z;
+ t[2] = mat[2][0] * white.X
+ + mat[2][1] * white.Y
+ + mat[2][2] * white.Z;
+
+ /* Now formulate the transform matrix */
+ mat[0][0] = red.X * t[0];
+ mat[0][1] = green.X * t[1];
+ mat[0][2] = blue.X * t[2];
+ mat[1][0] = red.Y * t[0];
+ mat[1][1] = green.Y * t[1];
+ mat[1][2] = blue.Y * t[2];
+ mat[2][0] = red.Z * t[0];
+ mat[2][1] = green.Z * t[1];
+ mat[2][2] = blue.Z * t[2];
+
+ return 0;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Some PCS utility functions */
+
+/* Clip Lab, while maintaining hue angle. */
+/* Return nz if clipping occured */
+int icmClipLab(double out[3], double in[3]) {
+ double C;
+
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+
+ if (out[0] >= 0.0 && out[0] <= 100.0
+ && out[1] >= -128.0 && out[1] <= 127.0
+ && out[2] >= -128.0 && out[2] <= 127.0)
+ return 0;
+
+ /* Clip L */
+ if (out[0] < 0.0)
+ out[0] = 0.0;
+ else if (out[0] > 100.0)
+ out[0] = 100.0;
+
+ C = out[1];
+ if (fabs(out[2]) > fabs(C))
+ C = out[2];
+ if (C < -128.0 || C > 127.0) {
+ if (C < 0.0)
+ C = -128.0/C;
+ else
+ C = 127.0/C;
+ out[1] *= C;
+ out[2] *= C;
+ }
+
+ return 1;
+}
+
+/* Clip XYZ, while maintaining hue angle */
+/* Return nz if clipping occured */
+int icmClipXYZ(double out[3], double in[3]) {
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+
+ if (out[0] >= 0.0 && out[0] <= 1.9999
+ && out[1] >= 0.0 && out[1] <= 1.9999
+ && out[2] >= 0.0 && out[2] <= 1.9999)
+ return 0;
+
+ /* Clip Y and scale X and Z similarly */
+
+ if (out[1] > 1.9999) {
+ out[0] *= 1.9999/out[1];
+ out[2] *= 1.9999/out[1];
+ out[1] = 1.9999;
+ } else if (out[1] < 0.0) {
+ out[0] = 0.0;
+ out[1] = 0.0;
+ out[2] = 0.0;
+ }
+
+ if (out[0] < 0.0 || out[0] > 1.9999
+ || out[2] < 0.0 || out[2] > 1.9999) {
+ double D50[3] = { 0.9642, 1.0000, 0.8249 };
+ double bb = 0.0;
+
+ /* Scale the D50 so that it has the same Y value as our color */
+ D50[0] *= out[1];
+ D50[1] *= out[1];
+ D50[2] *= out[1];
+
+ /* Figure out what blend factor with Y scaled D50, brings our */
+ /* color X and Z values into range */
+
+ if (out[0] < 0.0) {
+ double b;
+ b = (0.0 - out[0])/(D50[0] - out[0]);
+ if (b > bb)
+ bb = b;
+ } else if (out[0] > 1.9999) {
+ double b;
+ b = (1.9999 - out[0])/(D50[0] - out[0]);
+ if (b > bb)
+ bb = b;
+ }
+ if (out[2] < 0.0) {
+ double b;
+ b = (0.0 - out[2])/(D50[2] - out[2]);
+ if (b > bb)
+ bb = b;
+ } else if (out[2] > 1.9999) {
+ double b;
+ b = (1.9999 - out[2])/(D50[2] - out[2]);
+ if (b > bb)
+ bb = b;
+ }
+ /* Do the desaturation */
+ out[0] = D50[0] * bb + (1.0 - bb) * out[0];
+ out[2] = D50[2] * bb + (1.0 - bb) * out[2];
+ }
+ return 1;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Object for computing RFC 1321 MD5 checksums. */
+/* Derived from Colin Plumb's 1993 public domain code. */
+
+/* Reset the checksum */
+static void icmMD5_reset(icmMD5 *p) {
+ p->tlen = 0;
+
+ p->sum[0] = 0x67452301;
+ p->sum[1] = 0xefcdab89;
+ p->sum[2] = 0x98badcfe;
+ p->sum[3] = 0x10325476;
+
+ p->fin = 0;
+}
+
+#define F1(x, y, z) (z ^ (x & (y ^ z)))
+#define F2(x, y, z) F1(z, x, y)
+#define F3(x, y, z) (x ^ y ^ z)
+#define F4(x, y, z) (y ^ (x | ~z))
+
+#define MD5STEP(f, w, x, y, z, pp, xtra, s) \
+ data = (pp)[0] + ((pp)[3] << 24) + ((pp)[2] << 16) + ((pp)[1] << 8); \
+ w += f(x, y, z) + data + xtra; \
+ w = (w << s) | (w >> (32-s)); \
+ w += x;
+
+/* Add another 64 bytes to the checksum */
+static void icmMD5_accume(icmMD5 *p, ORD8 *in) {
+ ORD32 data, a, b, c, d;
+
+ a = p->sum[0];
+ b = p->sum[1];
+ c = p->sum[2];
+ d = p->sum[3];
+
+ MD5STEP(F1, a, b, c, d, in + (4 * 0), 0xd76aa478, 7);
+ MD5STEP(F1, d, a, b, c, in + (4 * 1), 0xe8c7b756, 12);
+ MD5STEP(F1, c, d, a, b, in + (4 * 2), 0x242070db, 17);
+ MD5STEP(F1, b, c, d, a, in + (4 * 3), 0xc1bdceee, 22);
+ MD5STEP(F1, a, b, c, d, in + (4 * 4), 0xf57c0faf, 7);
+ MD5STEP(F1, d, a, b, c, in + (4 * 5), 0x4787c62a, 12);
+ MD5STEP(F1, c, d, a, b, in + (4 * 6), 0xa8304613, 17);
+ MD5STEP(F1, b, c, d, a, in + (4 * 7), 0xfd469501, 22);
+ MD5STEP(F1, a, b, c, d, in + (4 * 8), 0x698098d8, 7);
+ MD5STEP(F1, d, a, b, c, in + (4 * 9), 0x8b44f7af, 12);
+ MD5STEP(F1, c, d, a, b, in + (4 * 10), 0xffff5bb1, 17);
+ MD5STEP(F1, b, c, d, a, in + (4 * 11), 0x895cd7be, 22);
+ MD5STEP(F1, a, b, c, d, in + (4 * 12), 0x6b901122, 7);
+ MD5STEP(F1, d, a, b, c, in + (4 * 13), 0xfd987193, 12);
+ MD5STEP(F1, c, d, a, b, in + (4 * 14), 0xa679438e, 17);
+ MD5STEP(F1, b, c, d, a, in + (4 * 15), 0x49b40821, 22);
+
+ MD5STEP(F2, a, b, c, d, in + (4 * 1), 0xf61e2562, 5);
+ MD5STEP(F2, d, a, b, c, in + (4 * 6), 0xc040b340, 9);
+ MD5STEP(F2, c, d, a, b, in + (4 * 11), 0x265e5a51, 14);
+ MD5STEP(F2, b, c, d, a, in + (4 * 0), 0xe9b6c7aa, 20);
+ MD5STEP(F2, a, b, c, d, in + (4 * 5), 0xd62f105d, 5);
+ MD5STEP(F2, d, a, b, c, in + (4 * 10), 0x02441453, 9);
+ MD5STEP(F2, c, d, a, b, in + (4 * 15), 0xd8a1e681, 14);
+ MD5STEP(F2, b, c, d, a, in + (4 * 4), 0xe7d3fbc8, 20);
+ MD5STEP(F2, a, b, c, d, in + (4 * 9), 0x21e1cde6, 5);
+ MD5STEP(F2, d, a, b, c, in + (4 * 14), 0xc33707d6, 9);
+ MD5STEP(F2, c, d, a, b, in + (4 * 3), 0xf4d50d87, 14);
+ MD5STEP(F2, b, c, d, a, in + (4 * 8), 0x455a14ed, 20);
+ MD5STEP(F2, a, b, c, d, in + (4 * 13), 0xa9e3e905, 5);
+ MD5STEP(F2, d, a, b, c, in + (4 * 2), 0xfcefa3f8, 9);
+ MD5STEP(F2, c, d, a, b, in + (4 * 7), 0x676f02d9, 14);
+ MD5STEP(F2, b, c, d, a, in + (4 * 12), 0x8d2a4c8a, 20);
+
+ MD5STEP(F3, a, b, c, d, in + (4 * 5), 0xfffa3942, 4);
+ MD5STEP(F3, d, a, b, c, in + (4 * 8), 0x8771f681, 11);
+ MD5STEP(F3, c, d, a, b, in + (4 * 11), 0x6d9d6122, 16);
+ MD5STEP(F3, b, c, d, a, in + (4 * 14), 0xfde5380c, 23);
+ MD5STEP(F3, a, b, c, d, in + (4 * 1), 0xa4beea44, 4);
+ MD5STEP(F3, d, a, b, c, in + (4 * 4), 0x4bdecfa9, 11);
+ MD5STEP(F3, c, d, a, b, in + (4 * 7), 0xf6bb4b60, 16);
+ MD5STEP(F3, b, c, d, a, in + (4 * 10), 0xbebfbc70, 23);
+ MD5STEP(F3, a, b, c, d, in + (4 * 13), 0x289b7ec6, 4);
+ MD5STEP(F3, d, a, b, c, in + (4 * 0), 0xeaa127fa, 11);
+ MD5STEP(F3, c, d, a, b, in + (4 * 3), 0xd4ef3085, 16);
+ MD5STEP(F3, b, c, d, a, in + (4 * 6), 0x04881d05, 23);
+ MD5STEP(F3, a, b, c, d, in + (4 * 9), 0xd9d4d039, 4);
+ MD5STEP(F3, d, a, b, c, in + (4 * 12), 0xe6db99e5, 11);
+ MD5STEP(F3, c, d, a, b, in + (4 * 15), 0x1fa27cf8, 16);
+ MD5STEP(F3, b, c, d, a, in + (4 * 2), 0xc4ac5665, 23);
+
+ MD5STEP(F4, a, b, c, d, in + (4 * 0), 0xf4292244, 6);
+ MD5STEP(F4, d, a, b, c, in + (4 * 7), 0x432aff97, 10);
+ MD5STEP(F4, c, d, a, b, in + (4 * 14), 0xab9423a7, 15);
+ MD5STEP(F4, b, c, d, a, in + (4 * 5), 0xfc93a039, 21);
+ MD5STEP(F4, a, b, c, d, in + (4 * 12), 0x655b59c3, 6);
+ MD5STEP(F4, d, a, b, c, in + (4 * 3), 0x8f0ccc92, 10);
+ MD5STEP(F4, c, d, a, b, in + (4 * 10), 0xffeff47d, 15);
+ MD5STEP(F4, b, c, d, a, in + (4 * 1), 0x85845dd1, 21);
+ MD5STEP(F4, a, b, c, d, in + (4 * 8), 0x6fa87e4f, 6);
+ MD5STEP(F4, d, a, b, c, in + (4 * 15), 0xfe2ce6e0, 10);
+ MD5STEP(F4, c, d, a, b, in + (4 * 6), 0xa3014314, 15);
+ MD5STEP(F4, b, c, d, a, in + (4 * 13), 0x4e0811a1, 21);
+ MD5STEP(F4, a, b, c, d, in + (4 * 4), 0xf7537e82, 6);
+ MD5STEP(F4, d, a, b, c, in + (4 * 11), 0xbd3af235, 10);
+ MD5STEP(F4, c, d, a, b, in + (4 * 2), 0x2ad7d2bb, 15);
+ MD5STEP(F4, b, c, d, a, in + (4 * 9), 0xeb86d391, 21);
+
+ p->sum[0] += a;
+ p->sum[1] += b;
+ p->sum[2] += c;
+ p->sum[3] += d;
+}
+
+#undef F1
+#undef F2
+#undef F3
+#undef F4
+#undef MD5STEP
+
+/* Add some bytes */
+static void icmMD5_add(icmMD5 *p, ORD8 *ibuf, unsigned int len) {
+ unsigned int bs;
+
+ if (p->fin)
+ return; /* This is actually an error */
+
+ bs = p->tlen; /* Current bytes added */
+ p->tlen = bs + len; /* Update length after adding this buffer */
+ bs &= 0x3f; /* Bytes already in buffer */
+
+ /* Deal with any existing partial bytes in p->buf */
+ if (bs) {
+ ORD8 *np = (ORD8 *)p->buf + bs; /* Next free location in partial buffer */
+
+ bs = 64 - bs; /* Free space in partial buffer */
+
+ if (len < bs) { /* Not enought new to make a full buffer */
+ memmove(np, ibuf, len);
+ return;
+ }
+
+ memmove(np, ibuf, bs); /* Now got one full buffer */
+ icmMD5_accume(p, np);
+ ibuf += bs;
+ len -= bs;
+ }
+
+ /* Deal with input data 64 bytes at a time */
+ while (len >= 64) {
+ icmMD5_accume(p, ibuf);
+ ibuf += 64;
+ len -= 64;
+ }
+
+ /* Deal with any remaining bytes */
+ memmove(p->buf, ibuf, len);
+}
+
+/* Finalise the checksum and return the result. */
+static void icmMD5_get(icmMD5 *p, ORD8 chsum[16]) {
+ int i;
+ unsigned count;
+ ORD32 bits1, bits0;
+ ORD8 *pp;
+
+ if (p->fin == 0) {
+
+ /* Compute number of bytes processed mod 64 */
+ count = p->tlen & 0x3f;
+
+ /* Set the first char of padding to 0x80. This is safe since there is
+ always at least one byte free */
+ pp = p->buf + count;
+ *pp++ = 0x80;
+
+ /* Bytes of padding needed to make 64 bytes */
+ count = 64 - 1 - count;
+
+ /* Pad out to 56 mod 64, allowing 8 bytes for length in bits. */
+ if (count < 8) { /* Not enough space for padding and length */
+
+ memset(pp, 0, count);
+ icmMD5_accume(p, p->buf);
+
+ /* Now fill the next block with 56 bytes */
+ memset(p->buf, 0, 56);
+ } else {
+ /* Pad block to 56 bytes */
+ memset(pp, 0, count - 8);
+ }
+
+ /* Compute number of bits */
+ bits1 = 0x7 & (p->tlen >> (32 - 3));
+ bits0 = p->tlen << 3;
+
+ /* Append number of bits */
+ p->buf[64 - 8] = bits0 & 0xff;
+ p->buf[64 - 7] = (bits0 >> 8) & 0xff;
+ p->buf[64 - 6] = (bits0 >> 16) & 0xff;
+ p->buf[64 - 5] = (bits0 >> 24) & 0xff;
+ p->buf[64 - 4] = bits1 & 0xff;
+ p->buf[64 - 3] = (bits1 >> 8) & 0xff;
+ p->buf[64 - 2] = (bits1 >> 16) & 0xff;
+ p->buf[64 - 1] = (bits1 >> 24) & 0xff;
+
+ icmMD5_accume(p, p->buf);
+
+ p->fin = 1;
+ }
+
+ /* Return the result, lsb to msb */
+ pp = chsum;
+ for (i = 0; i < 4; i++) {
+ *pp++ = p->sum[i] & 0xff;
+ *pp++ = (p->sum[i] >> 8) & 0xff;
+ *pp++ = (p->sum[i] >> 16) & 0xff;
+ *pp++ = (p->sum[i] >> 24) & 0xff;
+ }
+}
+
+
+/* Delete the instance */
+static void icmMD5_del(icmMD5 *p) {
+ p->al->free(p->al, p);
+}
+
+/* Create a new MD5 checksumming object, with a reset checksum value */
+/* Return it or NULL if there is an error */
+icmMD5 *new_icmMD5(icmAlloc *al) {
+ icmMD5 *p;
+
+ if ((p = (icmMD5 *)al->calloc(al,1,sizeof(icmMD5))) == NULL)
+ return NULL;
+
+ p->al = al;
+ p->reset = icmMD5_reset;
+ p->add = icmMD5_add;
+ p->get = icmMD5_get;
+ p->del = icmMD5_del;
+
+ p->reset(p);
+
+ return p;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Dumy icmFile used to compute MD5 checksum on write */
+
+/* Get the size of the file (Only valid for reading file. */
+static size_t icmFileMD5_get_size(icmFile *pp) {
+ icmFileMD5 *p = (icmFileMD5 *)pp;
+
+ return p->size;
+}
+
+/* Set current position to offset. Return 0 on success, nz on failure. */
+/* Seek can't be supported for MD5, so and seek must be to current location. */
+static int icmFileMD5_seek(
+icmFile *pp,
+unsigned int offset
+) {
+ icmFileMD5 *p = (icmFileMD5 *)pp;
+
+ if (p->of != offset) {
+ p->errc = 1;
+ }
+ if (p->of > p->size)
+ p->size = p->of;
+ return 0;
+}
+
+/* Read count items of size length. Return number of items successfully read. */
+/* Read is not implemented */
+static size_t icmFileMD5_read(
+icmFile *pp,
+void *buffer,
+size_t size,
+size_t count
+) {
+ return 0;
+}
+
+/* write count items of size length. Return number of items successfully written. */
+/* Simply pass to MD5 to compute checksum */
+static size_t icmFileMD5_write(
+icmFile *pp,
+void *buffer,
+size_t size,
+size_t count
+) {
+ icmFileMD5 *p = (icmFileMD5 *)pp;
+ size_t len = size * count;
+
+ p->md5->add(p->md5, (ORD8 *)buffer, len);
+ p->of += len;
+ if (p->of > p->size)
+ p->size = p->of;
+ return count;
+}
+
+/* do a printf */
+/* Not implemented */
+static int icmFileMD5_printf(
+icmFile *pp,
+const char *format,
+...
+) {
+ icmFileMD5 *p = (icmFileMD5 *)pp;
+ p->errc = 2;
+ return 0;
+}
+
+/* flush all write data out to secondary storage. Return nz on failure. */
+static int icmFileMD5_flush(
+icmFile *pp
+) {
+ return 0;
+}
+
+/* we're done with the file object, return nz on failure */
+static int icmFileMD5_delete(
+icmFile *pp
+) {
+ icmFileMD5 *p = (icmFileMD5 *)pp;
+
+ p->al->free(p->al, p); /* Free object */
+ return 0;
+}
+
+/* Return the error code. Error code will usually be set */
+/* if we did a seek to other than the current location, */
+/* or did a printf. */
+static int icmFileMD5_geterrc(
+icmFile *pp
+) {
+ icmFileMD5 *p = (icmFileMD5 *)pp;
+
+ return p->errc;
+}
+
+/* Create a checksum dump file access class with allocator */
+icmFile *new_icmFileMD5_a(
+icmMD5 *md5, /* MD5 object to use */
+icmAlloc *al /* heap allocator */
+) {
+ icmFileMD5 *p;
+
+ if ((p = (icmFileMD5 *) al->calloc(al, 1, sizeof(icmFileMD5))) == NULL) {
+ return NULL;
+ }
+ p->md5 = md5; /* MD5 compute object */
+ p->al = al; /* Heap allocator */
+ p->get_size = icmFileMD5_get_size;
+ p->seek = icmFileMD5_seek;
+ p->read = icmFileMD5_read;
+ p->write = icmFileMD5_write;
+ p->gprintf = icmFileMD5_printf;
+ p->flush = icmFileMD5_flush;
+ p->del = icmFileMD5_delete;
+ p->get_errc = icmFileMD5_geterrc;
+
+ p->of = 0;
+ p->errc = 0;
+
+ return (icmFile *)p;
+}
+
+
+/* ============================================= */
+/* Implementation of color transform lookups. */
+
+/* - - - - - - - - - - - - - - - - - - - - - - - */
+/* Methods common to all transforms (icmLuBase) : */
+
+/* Return information about the native lut in/out/pcs colorspaces. */
+/* Any pointer may be NULL if value is not to be returned */
+static void
+icmLutSpaces(
+ struct _icmLuBase *p, /* This */
+ icColorSpaceSignature *ins, /* Return Native input color space */
+ int *inn, /* Return number of input components */
+ icColorSpaceSignature *outs, /* Return Native output color space */
+ int *outn, /* Return number of output components */
+ icColorSpaceSignature *pcs /* Return Native PCS color space */
+ /* (this will be the same as ins or outs */
+ /* depending on the lookup direction) */
+) {
+ if (ins != NULL)
+ *ins = p->inSpace;
+ if (inn != NULL)
+ *inn = (int)number_ColorSpaceSignature(p->inSpace);
+
+ if (outs != NULL)
+ *outs = p->outSpace;
+ if (outn != NULL)
+ *outn = (int)number_ColorSpaceSignature(p->outSpace);
+ if (pcs != NULL)
+ *pcs = p->pcs;
+}
+
+/* Return information about the effective lookup in/out colorspaces, */
+/* including allowance for PCS override. */
+/* Any pointer may be NULL if value is not to be returned */
+static void
+icmLuSpaces(
+ struct _icmLuBase *p, /* This */
+ icColorSpaceSignature *ins, /* Return effective input color space */
+ int *inn, /* Return number of input components */
+ icColorSpaceSignature *outs, /* Return effective output color space */
+ int *outn, /* Return number of output components */
+ icmLuAlgType *alg, /* Return type of lookup algorithm used */
+ icRenderingIntent *intt, /* Return the intent being implented */
+ icmLookupFunc *fnc, /* Return the profile function being implemented */
+ icColorSpaceSignature *pcs, /* Return the profile effective PCS */
+ icmLookupOrder *ord /* return the search Order */
+) {
+ if (ins != NULL)
+ *ins = p->e_inSpace;
+ if (inn != NULL)
+ *inn = (int)number_ColorSpaceSignature(p->e_inSpace);
+
+ if (outs != NULL)
+ *outs = p->e_outSpace;
+ if (outn != NULL)
+ *outn = (int)number_ColorSpaceSignature(p->e_outSpace);
+
+ if (alg != NULL)
+ *alg = p->ttype;
+
+ if (intt != NULL)
+ *intt = p->intent;
+
+ if (fnc != NULL)
+ *fnc = p->function;
+
+ if (pcs != NULL)
+ *pcs = p->e_pcs;
+
+ if (ord != NULL)
+ *ord = p->order;
+}
+
+/* Relative to Absolute for this WP in XYZ */
+static void icmLuXYZ_Rel2Abs(icmLuBase *p, double *out, double *in) {
+ icmMulBy3x3(out, p->toAbs, in);
+}
+
+/* Absolute to Relative for this WP in XYZ */
+static void icmLuXYZ_Abs2Rel(icmLuBase *p, double *out, double *in) {
+ icmMulBy3x3(out, p->fromAbs, in);
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Methods common to all non-named transforms (icmLuBase) : */
+
+/* Initialise the LU white and black points from the ICC tags, */
+/* and the corresponding absolute<->relative conversion matrices */
+/* return nz on error */
+static int icmLuInit_Wh_bk(
+struct _icmLuBase *lup
+) {
+ icmXYZArray *whitePointTag, *blackPointTag;
+ icc *p = lup->icp;
+
+ if ((whitePointTag = (icmXYZArray *)p->read_tag(p, icSigMediaWhitePointTag)) == NULL
+ || whitePointTag->ttype != icSigXYZType || whitePointTag->size < 1) {
+ if (p->header->deviceClass != icSigLinkClass
+ && (lup->intent == icAbsoluteColorimetric
+ || lup->intent == icmAbsolutePerceptual
+ || lup->intent == icmAbsoluteSaturation)) {
+ sprintf(p->err,"icc_lookup: Profile is missing Media White Point Tag");
+ p->errc = 1;
+ return 1;
+ }
+ p->err[0] = '\000';
+ p->errc = 0;
+ lup->whitePoint = icmD50; /* safe value */
+ } else
+ lup->whitePoint = whitePointTag->data[0]; /* Copy structure */
+
+ if ((blackPointTag = (icmXYZArray *)p->read_tag(p, icSigMediaBlackPointTag)) == NULL
+ || blackPointTag->ttype != icSigXYZType || blackPointTag->size < 1) {
+ p->err[0] = '\000';
+ p->errc = 0;
+ lup->blackPoint = icmBlack; /* default */
+ lup->blackisassumed = 1; /* We assumed the default */
+ } else {
+ lup->blackPoint = blackPointTag->data[0]; /* Copy structure */
+ lup->blackisassumed = 0; /* The black is from the tag */
+ }
+
+ /* Create absolute <-> relative conversion matricies */
+ icmChromAdaptMatrix(ICM_CAM_BRADFORD, lup->whitePoint, icmD50, lup->toAbs);
+ icmChromAdaptMatrix(ICM_CAM_BRADFORD, icmD50, lup->whitePoint, lup->fromAbs);
+ DBLLL(("toAbs and fromAbs created from wp %f %f %f and D50 %f %f %f\n", lup->whitePoint.X, lup->whitePoint.Y, lup->whitePoint.Z, icmD50.X, icmD50.Y, icmD50.Z));
+ DBLLL(("toAbs = %f %f %f\n %f %f %f\n %f %f %f\n", lup->toAbs[0][0], lup->toAbs[0][1], lup->toAbs[0][2], lup->toAbs[1][0], lup->toAbs[1][1], lup->toAbs[1][2], lup->toAbs[2][0], lup->toAbs[2][1], lup->toAbs[2][2]));
+ DBLLL(("fromAbs = %f %f %f\n %f %f %f\n %f %f %f\n", lup->fromAbs[0][0], lup->fromAbs[0][1], lup->fromAbs[0][2], lup->fromAbs[1][0], lup->fromAbs[1][1], lup->fromAbs[1][2], lup->fromAbs[2][0], lup->fromAbs[2][1], lup->fromAbs[2][2]));
+
+ return 0;
+}
+
+/* Return the media white and black points in absolute XYZ space. */
+/* Note that if not in the icc, the black point will be returned as 0, 0, 0, */
+/* and the function will return nz. */
+/* Any pointer may be NULL if value is not to be returned */
+static int icmLuWh_bk_points(
+struct _icmLuBase *p,
+double *wht,
+double *blk
+) {
+ if (wht != NULL) {
+ icmXYZ2Ary(wht,p->whitePoint);
+ }
+
+ if (blk != NULL) {
+ icmXYZ2Ary(blk,p->blackPoint);
+ }
+ if (p->blackisassumed)
+ return 1;
+ return 0;
+}
+
+/* Get the LU white and black points in LU PCS space, converted to XYZ. */
+/* (ie. white and black will be relative if LU is relative intent etc.) */
+/* Return nz if the black point is being assumed to be 0,0,0 rather */
+/* than being from the tag. */ \
+static int icmLuLu_wh_bk_points(
+struct _icmLuBase *p,
+double *wht,
+double *blk
+) {
+ if (wht != NULL) {
+ icmXYZ2Ary(wht,p->whitePoint);
+ }
+
+ if (blk != NULL) {
+ icmXYZ2Ary(blk,p->blackPoint);
+ }
+ if (p->intent != icAbsoluteColorimetric
+ && p->intent != icmAbsolutePerceptual
+ && p->intent != icmAbsoluteSaturation) {
+ if (wht != NULL)
+ icmMulBy3x3(wht, p->fromAbs, wht);
+ if (blk != NULL)
+ icmMulBy3x3(blk, p->fromAbs, blk);
+ }
+ if (p->blackisassumed)
+ return 1;
+ return 0;
+}
+
+/* Get the native (internal) ranges for the Monochrome or Matrix profile */
+/* Arguments may be NULL */
+static void
+icmLu_get_lutranges (
+ struct _icmLuBase *p,
+ double *inmin, double *inmax, /* Return maximum range of inspace values */
+ double *outmin, double *outmax /* Return maximum range of outspace values */
+) {
+ icTagTypeSignature tagType;
+
+ if (p->ttype == icmLutType) {
+ icmLuLut *pp = (icmLuLut *)p;
+ tagType = pp->lut->ttype;
+ } else {
+ tagType = icMaxEnumType;
+ }
+
+ /* Hmm. we have no way of handling an error from getRange. */
+ /* It shouldn't ever return one unless there is a mismatch between */
+ /* getRange and Lu creation... */
+ getRange(p->icp, p->inSpace, tagType, inmin, inmax);
+ getRange(p->icp, p->outSpace, tagType, outmin, outmax);
+}
+
+/* Get the effective (externally visible) ranges for the all profile types */
+/* Arguments may be NULL */
+static void
+icmLu_get_ranges (
+ struct _icmLuBase *p,
+ double *inmin, double *inmax, /* Return maximum range of inspace values */
+ double *outmin, double *outmax /* Return maximum range of outspace values */
+) {
+ icTagTypeSignature tagType;
+
+ if (p->ttype == icmLutType) {
+ icmLuLut *pp = (icmLuLut *)p;
+ tagType = pp->lut->ttype;
+ } else {
+ tagType = icMaxEnumType;
+ }
+ /* Hmm. we have no way of handling an error from getRange. */
+ /* It shouldn't ever return one unless there is a mismatch between */
+ /* getRange and Lu creation... */
+ getRange(p->icp, p->e_inSpace, tagType, inmin, inmax);
+ getRange(p->icp, p->e_outSpace, tagType, outmin, outmax);
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Forward and Backward Monochrome type methods: */
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+
+/* Individual components of Fwd conversion: */
+
+/* Actual device to linearised device */
+static int
+icmLuMonoFwd_curve (
+icmLuMono *p, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ icc *icp = p->icp;
+ int rv = 0;
+
+ /* Translate from device to PCS scale */
+ if ((rv |= p->grayCurve->lookup_fwd(p->grayCurve,&out[0],&in[0])) > 1) {
+ sprintf(icp->err,"icc_lookup: Curve->lookup_fwd() failed");
+ icp->errc = rv;
+ return 2;
+ }
+
+ return rv;
+}
+
+/* Linearised device to relative PCS */
+static int
+icmLuMonoFwd_map (
+icmLuMono *p, /* This */
+double *out, /* Vector of output values (native space) */
+double *in /* Vector of input values (native space) */
+) {
+ int rv = 0;
+ double Y = in[0]; /* In case out == in */
+
+ out[0] = p->pcswht.X;
+ out[1] = p->pcswht.Y;
+ out[2] = p->pcswht.Z;
+ if (p->pcs == icSigLabData)
+ icmXYZ2Lab(&p->pcswht, out, out); /* in Lab */
+
+ /* Scale linearized device level to PCS white */
+ out[0] *= Y;
+ out[1] *= Y;
+ out[2] *= Y;
+
+ return rv;
+}
+
+/* relative PCS to absolute PCS (if required) */
+static int
+icmLuMonoFwd_abs ( /* Abs comes last in Fwd conversion */
+icmLuMono *p, /* This */
+double *out, /* Vector of output values in Effective PCS */
+double *in /* Vector of input values in Native PCS */
+) {
+ int rv = 0;
+
+ if (out != in) { /* Don't alter input values */
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ }
+
+ /* Do absolute conversion */
+ if (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation) {
+
+ if (p->pcs == icSigLabData) /* Convert L to Y */
+ icmLab2XYZ(&p->pcswht, out, out);
+
+ /* Convert from Relative to Absolute colorimetric */
+ icmMulBy3x3(out, p->toAbs, out);
+
+ if (p->e_pcs == icSigLabData)
+ icmXYZ2Lab(&p->pcswht, out, out);
+
+ } else {
+
+ /* Convert from Native to Effective output space */
+ if (p->pcs == icSigLabData && p->e_pcs == icSigXYZData)
+ icmLab2XYZ(&p->pcswht, out, out);
+ else if (p->pcs == icSigXYZData && p->e_pcs == icSigLabData)
+ icmXYZ2Lab(&p->pcswht, out, out);
+ }
+
+ return rv;
+}
+
+
+/* Overall Fwd conversion routine (Dev->PCS) */
+static int
+icmLuMonoFwd_lookup (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Input value */
+) {
+ int rv = 0;
+ icmLuMono *p = (icmLuMono *)pp;
+ rv |= icmLuMonoFwd_curve(p, out, in);
+ rv |= icmLuMonoFwd_map(p, out, out);
+ rv |= icmLuMonoFwd_abs(p, out, out);
+ return rv;
+}
+
+/* Three stage conversion routines */
+static int
+icmLuMonoFwd_lookup_in(
+icmLuBase *pp, /* This */
+double *out, /* Output value */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuMono *p = (icmLuMono *)pp;
+ rv |= icmLuMonoFwd_curve(p, out, in);
+ return rv;
+}
+
+static int
+icmLuMonoFwd_lookup_core(
+icmLuBase *pp, /* This */
+double *out, /* Output value */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuMono *p = (icmLuMono *)pp;
+ rv |= icmLuMonoFwd_map(p, out, in);
+ rv |= icmLuMonoFwd_abs(p, out, out);
+ return rv;
+}
+
+static int
+icmLuMonoFwd_lookup_out(
+icmLuBase *pp, /* This */
+double *out, /* Output value */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ return rv;
+}
+
+
+/* - - - - - - - - - - - - - - */
+/* Individual components of Bwd conversion: */
+
+/* Convert from relative PCS to absolute PCS (if required) */
+static int
+icmLuMonoBwd_abs ( /* Abs comes first in Bwd conversion */
+icmLuMono *p, /* This */
+double *out, /* Vector of output values in Native PCS */
+double *in /* Vector of input values in Effective PCS */
+) {
+ int rv = 0;
+
+ if (out != in) { /* Don't alter input values */
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ }
+
+ /* Force to monochrome locus in correct space */
+ if (p->e_pcs == icSigLabData) {
+ double wp[3];
+
+ if (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation) {
+ wp[0] = p->whitePoint.X;
+ wp[1] = p->whitePoint.Y;
+ wp[2] = p->whitePoint.Z;
+ } else {
+ wp[0] = p->pcswht.X;
+ wp[1] = p->pcswht.Y;
+ wp[2] = p->pcswht.Z;
+ }
+ icmXYZ2Lab(&p->pcswht, wp, wp); /* Convert to Lab white point */
+ out[1] = out[0]/wp[0] * wp[1];
+ out[2] = out[0]/wp[0] * wp[2];
+
+ } else {
+ if (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation) {
+ out[0] = out[1]/p->whitePoint.Y * p->whitePoint.X;
+ out[2] = out[1]/p->whitePoint.Y * p->whitePoint.Z;
+ } else {
+ out[0] = out[1]/p->pcswht.Y * p->pcswht.X;
+ out[2] = out[1]/p->pcswht.Y * p->pcswht.Z;
+ }
+ }
+
+ /* Do absolute conversion, and conversion to effective PCS */
+ if (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation) {
+
+ if (p->e_pcs == icSigLabData)
+ icmLab2XYZ(&p->pcswht, out, out);
+
+ icmMulBy3x3(out, p->fromAbs, out);
+
+ /* Convert from Effective to Native input space */
+ if (p->pcs == icSigLabData)
+ icmXYZ2Lab(&p->pcswht, out, out);
+
+ } else {
+
+ /* Convert from Effective to Native input space */
+ if (p->e_pcs == icSigLabData && p->pcs == icSigXYZData)
+ icmLab2XYZ(&p->pcswht, out, out);
+ else if (p->e_pcs == icSigXYZData && p->pcs == icSigLabData)
+ icmXYZ2Lab(&p->pcswht, out, out);
+ }
+
+ return rv;
+}
+
+/* Map from relative PCS to linearised device */
+static int
+icmLuMonoBwd_map (
+icmLuMono *p, /* This */
+double *out, /* Output value */
+double *in /* Vector of input values (native space) */
+) {
+ int rv = 0;
+ double pcsw[3];
+
+ pcsw[0] = p->pcswht.X;
+ pcsw[1] = p->pcswht.Y;
+ pcsw[2] = p->pcswht.Z;
+ if (p->pcs == icSigLabData)
+ icmXYZ2Lab(&p->pcswht, pcsw, pcsw); /* in Lab (should be 100.0!) */
+
+ /* Divide linearized device level into PCS white luminence */
+ if (p->pcs == icSigLabData)
+ out[0] = in[0]/pcsw[0];
+ else
+ out[0] = in[1]/pcsw[1];
+
+ return rv;
+}
+
+/* Map from linearised device to actual device */
+static int
+icmLuMonoBwd_curve (
+icmLuMono *p, /* This */
+double *out, /* Output value */
+double *in /* Input value */
+) {
+ icc *icp = p->icp;
+ int rv = 0;
+
+ /* Convert to device value through curve */
+ if ((rv = p->grayCurve->lookup_bwd(p->grayCurve,&out[0],&in[0])) > 1) {
+ sprintf(icp->err,"icc_lookup: Curve->lookup_bwd() failed");
+ icp->errc = rv;
+ return 2;
+ }
+
+ return rv;
+}
+
+/* Overall Bwd conversion routine (PCS->Dev) */
+static int
+icmLuMonoBwd_lookup (
+icmLuBase *pp, /* This */
+double *out, /* Output value */
+double *in /* Vector of input values */
+) {
+ double temp[3];
+ int rv = 0;
+ icmLuMono *p = (icmLuMono *)pp;
+ rv |= icmLuMonoBwd_abs(p, temp, in);
+ rv |= icmLuMonoBwd_map(p, out, temp);
+ rv |= icmLuMonoBwd_curve(p, out, out);
+ return rv;
+}
+
+/* Three stage conversion routines */
+static int
+icmLuMonoBwd_lookup_in(
+icmLuBase *pp, /* This */
+double *out, /* Output value */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ return rv;
+}
+
+static int
+icmLuMonoBwd_lookup_core(
+icmLuBase *pp, /* This */
+double *out, /* Output value */
+double *in /* Vector of input values */
+) {
+ double temp[3];
+ int rv = 0;
+ icmLuMono *p = (icmLuMono *)pp;
+ rv |= icmLuMonoBwd_abs(p, temp, in);
+ rv |= icmLuMonoBwd_map(p, out, temp);
+ return rv;
+}
+
+static int
+icmLuMonoBwd_lookup_out(
+icmLuBase *pp, /* This */
+double *out, /* Output value */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuMono *p = (icmLuMono *)pp;
+ rv |= icmLuMonoBwd_curve(p, out, in);
+ return rv;
+}
+
+/* - - - - - - - - - - - - - - */
+
+static void
+icmLuMono_delete(
+icmLuBase *p
+) {
+ icc *icp = p->icp;
+
+ icp->al->free(icp->al, p);
+}
+
+static icmLuBase *
+new_icmLuMono(
+ struct _icc *icp,
+ icColorSpaceSignature inSpace, /* Native Input color space */
+ icColorSpaceSignature outSpace, /* Native Output color space */
+ icColorSpaceSignature pcs, /* Native PCS */
+ icColorSpaceSignature e_inSpace, /* Effective Input color space */
+ icColorSpaceSignature e_outSpace, /* Effective Output color space */
+ icColorSpaceSignature e_pcs, /* Effective PCS */
+ icRenderingIntent intent, /* Rendering intent */
+ icmLookupFunc func, /* Functionality requested */
+ int dir /* 0 = fwd, 1 = bwd */
+) {
+ icmLuMono *p;
+
+ if ((p = (icmLuMono *) icp->al->calloc(icp->al,1,sizeof(icmLuMono))) == NULL)
+ return NULL;
+ p->icp = icp;
+ p->del = icmLuMono_delete;
+ p->lutspaces= icmLutSpaces;
+ p->spaces = icmLuSpaces;
+ p->XYZ_Rel2Abs = icmLuXYZ_Rel2Abs;
+ p->XYZ_Abs2Rel = icmLuXYZ_Abs2Rel;
+ p->get_lutranges = icmLu_get_lutranges;
+ p->get_ranges = icmLu_get_ranges;
+ p->init_wh_bk = icmLuInit_Wh_bk;
+ p->wh_bk_points = icmLuWh_bk_points;
+ p->lu_wh_bk_points = icmLuLu_wh_bk_points;
+ p->fwd_lookup = icmLuMonoFwd_lookup;
+ p->fwd_curve = icmLuMonoFwd_curve;
+ p->fwd_map = icmLuMonoFwd_map;
+ p->fwd_abs = icmLuMonoFwd_abs;
+ p->bwd_lookup = icmLuMonoBwd_lookup;
+ p->bwd_abs = icmLuMonoFwd_abs;
+ p->bwd_map = icmLuMonoFwd_map;
+ p->bwd_curve = icmLuMonoFwd_curve;
+ if (dir) {
+ p->ttype = icmMonoBwdType;
+ p->lookup = icmLuMonoBwd_lookup;
+ p->lookup_in = icmLuMonoBwd_lookup_in;
+ p->lookup_core = icmLuMonoBwd_lookup_core;
+ p->lookup_out = icmLuMonoBwd_lookup_out;
+ p->lookup_inv_in = icmLuMonoFwd_lookup_out; /* Opposite of Bwd_lookup_in */
+ } else {
+ p->ttype = icmMonoFwdType;
+ p->lookup = icmLuMonoFwd_lookup;
+ p->lookup_in = icmLuMonoFwd_lookup_in;
+ p->lookup_core = icmLuMonoFwd_lookup_core;
+ p->lookup_out = icmLuMonoFwd_lookup_out;
+ p->lookup_inv_in = icmLuMonoBwd_lookup_out; /* Opposite of Fwd_lookup_in */
+ }
+
+ /* Lookup the white and black points */
+ if (p->init_wh_bk((icmLuBase *)p)) {
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* See if the color spaces are appropriate for the mono type */
+ if (number_ColorSpaceSignature(icp->header->colorSpace) != 1
+ || ( icp->header->pcs != icSigXYZData && icp->header->pcs != icSigLabData)) {
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* Find the appropriate tags */
+ if ((p->grayCurve = (icmCurve *)icp->read_tag(icp, icSigGrayTRCTag)) == NULL
+ || p->grayCurve->ttype != icSigCurveType) {
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ p->pcswht = icp->header->illuminant;
+ p->intent = intent;
+ p->function = func;
+ p->inSpace = inSpace;
+ p->outSpace = outSpace;
+ p->pcs = pcs;
+ p->e_inSpace = e_inSpace;
+ p->e_outSpace = e_outSpace;
+ p->e_pcs = e_pcs;
+
+ return (icmLuBase *)p;
+}
+
+static icmLuBase *
+new_icmLuMonoFwd(
+ struct _icc *icp,
+ icColorSpaceSignature inSpace, /* Native Input color space */
+ icColorSpaceSignature outSpace, /* Native Output color space */
+ icColorSpaceSignature pcs, /* Native PCS */
+ icColorSpaceSignature e_inSpace, /* Effective Input color space */
+ icColorSpaceSignature e_outSpace, /* Effective Output color space */
+ icColorSpaceSignature e_pcs, /* Effective PCS */
+ icRenderingIntent intent, /* Rendering intent */
+ icmLookupFunc func /* Functionality requested */
+) {
+ return new_icmLuMono(icp, inSpace, outSpace, pcs, e_inSpace, e_outSpace, e_pcs,
+ intent, func, 0);
+}
+
+
+static icmLuBase *
+new_icmLuMonoBwd(
+ struct _icc *icp,
+ icColorSpaceSignature inSpace, /* Native Input color space */
+ icColorSpaceSignature outSpace, /* Native Output color space */
+ icColorSpaceSignature pcs, /* Native PCS */
+ icColorSpaceSignature e_inSpace, /* Effective Input color space */
+ icColorSpaceSignature e_outSpace, /* Effective Output color space */
+ icColorSpaceSignature e_pcs, /* Effective PCS */
+ icRenderingIntent intent, /* Rendering intent */
+ icmLookupFunc func /* Functionality requested */
+) {
+ return new_icmLuMono(icp, inSpace, outSpace, pcs, e_inSpace, e_outSpace, e_pcs,
+ intent, func, 1);
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - */
+/* Forward and Backward Matrix type conversion */
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+
+/* Individual components of Fwd conversion: */
+static int
+icmLuMatrixFwd_curve (
+icmLuMatrix *p, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ icc *icp = p->icp;
+ int rv = 0;
+
+ /* Curve lookups */
+ if ((rv |= p->redCurve->lookup_fwd( p->redCurve, &out[0],&in[0])) > 1
+ || (rv |= p->greenCurve->lookup_fwd(p->greenCurve,&out[1],&in[1])) > 1
+ || (rv |= p->blueCurve->lookup_fwd( p->blueCurve, &out[2],&in[2])) > 1) {
+ sprintf(icp->err,"icc_lookup: Curve->lookup_fwd() failed");
+ icp->errc = rv;
+ return 2;
+ }
+
+ return rv;
+}
+
+static int
+icmLuMatrixFwd_matrix (
+icmLuMatrix *p, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ double tt[3];
+
+ /* Matrix */
+ tt[0] = p->mx[0][0] * in[0] + p->mx[0][1] * in[1] + p->mx[0][2] * in[2];
+ tt[1] = p->mx[1][0] * in[0] + p->mx[1][1] * in[1] + p->mx[1][2] * in[2];
+ tt[2] = p->mx[2][0] * in[0] + p->mx[2][1] * in[1] + p->mx[2][2] * in[2];
+
+ out[0] = tt[0];
+ out[1] = tt[1];
+ out[2] = tt[2];
+
+ return rv;
+}
+
+static int
+icmLuMatrixFwd_abs (/* Abs comes last in Fwd conversion */
+icmLuMatrix *p, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+
+ if (out != in) { /* Don't alter input values */
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ }
+
+ /* If required, convert from Relative to Absolute colorimetric */
+ if (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation) {
+ icmMulBy3x3(out, p->toAbs, out);
+ }
+
+ /* If e_pcs is Lab, then convert XYZ to Lab */
+ if (p->e_pcs == icSigLabData)
+ icmXYZ2Lab(&p->pcswht, out, out);
+
+ return rv;
+}
+
+
+/* Overall Fwd conversion (Dev->PCS)*/
+static int
+icmLuMatrixFwd_lookup (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuMatrix *p = (icmLuMatrix *)pp;
+ rv |= icmLuMatrixFwd_curve(p, out, in);
+ rv |= icmLuMatrixFwd_matrix(p, out, out);
+ rv |= icmLuMatrixFwd_abs(p, out, out);
+ return rv;
+}
+
+/* Three stage conversion routines */
+static int
+icmLuMatrixFwd_lookup_in (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuMatrix *p = (icmLuMatrix *)pp;
+ rv |= icmLuMatrixFwd_curve(p, out, in);
+ return rv;
+}
+
+static int
+icmLuMatrixFwd_lookup_core (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuMatrix *p = (icmLuMatrix *)pp;
+ rv |= icmLuMatrixFwd_matrix(p, out, in);
+ rv |= icmLuMatrixFwd_abs(p, out, out);
+ return rv;
+}
+
+static int
+icmLuMatrixFwd_lookup_out (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ return rv;
+}
+
+/* - - - - - - - - - - - - - - */
+/* Individual components of Bwd conversion: */
+
+static int
+icmLuMatrixBwd_abs (/* Abs comes first in Bwd conversion */
+icmLuMatrix *p, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+
+ if (out != in) { /* Don't alter input values */
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ }
+
+ /* If e_pcs is Lab, then convert Lab to XYZ */
+ if (p->e_pcs == icSigLabData)
+ icmLab2XYZ(&p->pcswht, out, out);
+
+ /* If required, convert from Absolute to Relative colorimetric */
+ if (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation) {
+ icmMulBy3x3(out, p->fromAbs, out);
+ }
+
+ return rv;
+}
+
+static int
+icmLuMatrixBwd_matrix (
+icmLuMatrix *p, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ double tt[3];
+
+ tt[0] = in[0];
+ tt[1] = in[1];
+ tt[2] = in[2];
+
+ /* Matrix */
+ out[0] = p->bmx[0][0] * tt[0] + p->bmx[0][1] * tt[1] + p->bmx[0][2] * tt[2];
+ out[1] = p->bmx[1][0] * tt[0] + p->bmx[1][1] * tt[1] + p->bmx[1][2] * tt[2];
+ out[2] = p->bmx[2][0] * tt[0] + p->bmx[2][1] * tt[1] + p->bmx[2][2] * tt[2];
+
+ return rv;
+}
+
+static int
+icmLuMatrixBwd_curve (
+icmLuMatrix *p, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ icc *icp = p->icp;
+ int rv = 0;
+
+ /* Curves */
+ if ((rv |= p->redCurve->lookup_bwd(p->redCurve,&out[0],&in[0])) > 1
+ || (rv |= p->greenCurve->lookup_bwd(p->greenCurve,&out[1],&in[1])) > 1
+ || (rv |= p->blueCurve->lookup_bwd(p->blueCurve,&out[2],&in[2])) > 1) {
+ sprintf(icp->err,"icc_lookup: Curve->lookup_bwd() failed");
+ icp->errc = rv;
+ return 2;
+ }
+ return rv;
+}
+
+/* Overall Bwd conversion (PCS->Dev) */
+static int
+icmLuMatrixBwd_lookup (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuMatrix *p = (icmLuMatrix *)pp;
+ rv |= icmLuMatrixBwd_abs(p, out, in);
+ rv |= icmLuMatrixBwd_matrix(p, out, out);
+ rv |= icmLuMatrixBwd_curve(p, out, out);
+ return rv;
+}
+
+/* Three stage conversion routines */
+static int
+icmLuMatrixBwd_lookup_in (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ out[0] = in[0];
+ out[1] = in[1];
+ out[2] = in[2];
+ return rv;
+}
+
+static int
+icmLuMatrixBwd_lookup_core (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuMatrix *p = (icmLuMatrix *)pp;
+ rv |= icmLuMatrixBwd_abs(p, out, in);
+ rv |= icmLuMatrixBwd_matrix(p, out, out);
+ return rv;
+}
+
+static int
+icmLuMatrixBwd_lookup_out (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuMatrix *p = (icmLuMatrix *)pp;
+ rv |= icmLuMatrixBwd_curve(p, out, in);
+ return rv;
+}
+
+/* - - - - - - - - - - - - - - */
+
+static void
+icmLuMatrix_delete(
+icmLuBase *p
+) {
+ icc *icp = p->icp;
+
+ icp->al->free(icp->al, p);
+}
+
+/* We setup valid fwd and bwd component conversions, */
+/* but setup only the asked for overal conversion. */
+static icmLuBase *
+new_icmLuMatrix(
+ struct _icc *icp,
+ icColorSpaceSignature inSpace, /* Native Input color space */
+ icColorSpaceSignature outSpace, /* Native Output color space */
+ icColorSpaceSignature pcs, /* Native PCS */
+ icColorSpaceSignature e_inSpace, /* Effective Input color space */
+ icColorSpaceSignature e_outSpace, /* Effective Output color space */
+ icColorSpaceSignature e_pcs, /* Effective PCS */
+ icRenderingIntent intent, /* Rendering intent */
+ icmLookupFunc func, /* Functionality requested */
+ int dir /* 0 = fwd, 1 = bwd */
+) {
+ icmLuMatrix *p;
+
+ if ((p = (icmLuMatrix *) icp->al->calloc(icp->al,1,sizeof(icmLuMatrix))) == NULL)
+ return NULL;
+ p->icp = icp;
+ p->del = icmLuMatrix_delete;
+ p->lutspaces= icmLutSpaces;
+ p->spaces = icmLuSpaces;
+ p->XYZ_Rel2Abs = icmLuXYZ_Rel2Abs;
+ p->XYZ_Abs2Rel = icmLuXYZ_Abs2Rel;
+ p->get_lutranges = icmLu_get_lutranges;
+ p->get_ranges = icmLu_get_ranges;
+ p->init_wh_bk = icmLuInit_Wh_bk;
+ p->wh_bk_points = icmLuWh_bk_points;
+ p->lu_wh_bk_points = icmLuLu_wh_bk_points;
+ p->fwd_lookup = icmLuMatrixFwd_lookup;
+ p->fwd_curve = icmLuMatrixFwd_curve;
+ p->fwd_matrix = icmLuMatrixFwd_matrix;
+ p->fwd_abs = icmLuMatrixFwd_abs;
+ p->bwd_lookup = icmLuMatrixBwd_lookup;
+ p->bwd_abs = icmLuMatrixBwd_abs;
+ p->bwd_matrix = icmLuMatrixBwd_matrix;
+ p->bwd_curve = icmLuMatrixBwd_curve;
+ if (dir) {
+ p->ttype = icmMatrixBwdType;
+ p->lookup = icmLuMatrixBwd_lookup;
+ p->lookup_in = icmLuMatrixBwd_lookup_in;
+ p->lookup_core = icmLuMatrixBwd_lookup_core;
+ p->lookup_out = icmLuMatrixBwd_lookup_out;
+ p->lookup_inv_in = icmLuMatrixFwd_lookup_out; /* Opposite of Bwd_lookup_in */
+ } else {
+ p->ttype = icmMatrixFwdType;
+ p->lookup = icmLuMatrixFwd_lookup;
+ p->lookup_in = icmLuMatrixFwd_lookup_in;
+ p->lookup_core = icmLuMatrixFwd_lookup_core;
+ p->lookup_out = icmLuMatrixFwd_lookup_out;
+ p->lookup_inv_in = icmLuMatrixBwd_lookup_out; /* Opposite of Fwd_lookup_in */
+ }
+
+ /* Lookup the white and black points */
+ if (p->init_wh_bk((icmLuBase *)p)) {
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* Note that we can use matrix type even if PCS is Lab, */
+ /* by simply converting it. */
+
+ /* Find the appropriate tags */
+ if ((p->redCurve = (icmCurve *)icp->read_tag(icp, icSigRedTRCTag)) == NULL
+ || p->redCurve->ttype != icSigCurveType
+ || (p->greenCurve = (icmCurve *)icp->read_tag(icp, icSigGreenTRCTag)) == NULL
+ || p->greenCurve->ttype != icSigCurveType
+ || (p->blueCurve = (icmCurve *)icp->read_tag(icp, icSigBlueTRCTag)) == NULL
+ || p->blueCurve->ttype != icSigCurveType
+ || (p->redColrnt = (icmXYZArray *)icp->read_tag(icp, icSigRedColorantTag)) == NULL
+ || p->redColrnt->ttype != icSigXYZType || p->redColrnt->size < 1
+ || (p->greenColrnt = (icmXYZArray *)icp->read_tag(icp, icSigGreenColorantTag)) == NULL
+ || p->greenColrnt->ttype != icSigXYZType || p->greenColrnt->size < 1
+ || (p->blueColrnt = (icmXYZArray *)icp->read_tag(icp, icSigBlueColorantTag)) == NULL
+ || p->blueColrnt->ttype != icSigXYZType || p->blueColrnt->size < 1) {
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* Setup the matrix */
+ p->mx[0][0] = p->redColrnt->data[0].X;
+ p->mx[0][1] = p->greenColrnt->data[0].X;
+ p->mx[0][2] = p->blueColrnt->data[0].X;
+ p->mx[1][1] = p->greenColrnt->data[0].Y;
+ p->mx[1][0] = p->redColrnt->data[0].Y;
+ p->mx[1][2] = p->blueColrnt->data[0].Y;
+ p->mx[2][1] = p->greenColrnt->data[0].Z;
+ p->mx[2][0] = p->redColrnt->data[0].Z;
+ p->mx[2][2] = p->blueColrnt->data[0].Z;
+
+#ifndef ICM_STRICT
+ /* Workaround for buggy Kodak RGB profiles. Their matrix values */
+ /* may be scaled to 100 rather than 1.0, and the colorant curves */
+ /* may be scaled by 0.5 */
+ if (icp->header->cmmId == str2tag("KCMS")) {
+ int i, j, oc = 0;
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 3; j++)
+ if (p->mx[i][j] > 5.0)
+ oc++;
+ if (oc > 4) { /* Looks like it */
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 3; j++)
+ p->mx[i][j] /= 100.0;
+ }
+ }
+#endif /* ICM_STRICT */
+
+ if (icmInverse3x3(p->bmx, p->mx) != 0) { /* Compute inverse */
+ sprintf(icp->err,"icc_new_iccLuMatrix: Matrix wasn't invertable");
+ icp->errc = 2;
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ p->pcswht = icp->header->illuminant;
+ p->intent = intent;
+ p->function = func;
+ p->inSpace = inSpace;
+ p->outSpace = outSpace;
+ p->pcs = pcs;
+ p->e_inSpace = e_inSpace;
+ p->e_outSpace = e_outSpace;
+ p->e_pcs = e_pcs;
+
+ /* Lookup the white and black points */
+ if (p->init_wh_bk((icmLuBase *)p)) {
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ return (icmLuBase *)p;
+}
+
+static icmLuBase *
+new_icmLuMatrixFwd(
+ struct _icc *icp,
+ icColorSpaceSignature inSpace, /* Native Input color space */
+ icColorSpaceSignature outSpace, /* Native Output color space */
+ icColorSpaceSignature pcs, /* Native PCS */
+ icColorSpaceSignature e_inSpace, /* Effective Input color space */
+ icColorSpaceSignature e_outSpace, /* Effective Output color space */
+ icColorSpaceSignature e_pcs, /* Effective PCS */
+ icRenderingIntent intent, /* Rendering intent */
+ icmLookupFunc func /* Functionality requested */
+) {
+ return new_icmLuMatrix(icp, inSpace, outSpace, pcs, e_inSpace, e_outSpace, e_pcs,
+ intent, func, 0);
+}
+
+
+static icmLuBase *
+new_icmLuMatrixBwd(
+ struct _icc *icp,
+ icColorSpaceSignature inSpace, /* Native Input color space */
+ icColorSpaceSignature outSpace, /* Native Output color space */
+ icColorSpaceSignature pcs, /* Native PCS */
+ icColorSpaceSignature e_inSpace, /* Effective Input color space */
+ icColorSpaceSignature e_outSpace, /* Effective Output color space */
+ icColorSpaceSignature e_pcs, /* Effective PCS */
+ icRenderingIntent intent, /* Rendering intent */
+ icmLookupFunc func /* Functionality requested */
+) {
+ return new_icmLuMatrix(icp, inSpace, outSpace, pcs, e_inSpace, e_outSpace, e_pcs,
+ intent, func, 1);
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - */
+/* Forward and Backward Multi-Dimensional Interpolation type conversion */
+/* Return 0 on success, 1 if clipping occured, 2 on other error */
+
+/* Components of overall lookup, in order */
+static int icmLuLut_in_abs(icmLuLut *p, double *out, double *in) {
+ icmLut *lut = p->lut;
+ int rv = 0;
+
+ DBLLL(("icm in_abs: input %s\n",icmPdv(lut->inputChan, in)));
+ if (out != in) {
+ unsigned int i;
+ for (i = 0; i < lut->inputChan; i++) /* Don't alter input values */
+ out[i] = in[i];
+ }
+
+ /* If Bwd Lut, take care of Absolute color space and effective input space */
+ if ((p->function == icmBwd || p->function == icmGamut || p->function == icmPreview)
+ && (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation)) {
+
+ if (p->e_inSpace == icSigLabData) {
+ icmLab2XYZ(&p->pcswht, out, out);
+ DBLLL(("icm in_abs: after Lab2XYZ %s\n",icmPdv(lut->inputChan, out)));
+ }
+
+ /* Convert from Absolute to Relative colorimetric */
+ icmMulBy3x3(out, p->fromAbs, out);
+ DBLLL(("icm in_abs: after fromAbs %s\n",icmPdv(lut->inputChan, out)));
+
+ if (p->inSpace == icSigLabData) {
+ icmXYZ2Lab(&p->pcswht, out, out);
+ DBLLL(("icm in_abs: after XYZ2Lab %s\n",icmPdv(lut->inputChan, out)));
+ }
+
+ } else {
+
+ /* Convert from Effective to Native input space */
+ if (p->e_inSpace == icSigLabData && p->inSpace == icSigXYZData) {
+ icmLab2XYZ(&p->pcswht, out, out);
+ DBLLL(("icm in_abs: after Lab2XYZ %s\n",icmPdv(lut->inputChan, out)));
+ } else if (p->e_inSpace == icSigXYZData && p->inSpace == icSigLabData) {
+ icmXYZ2Lab(&p->pcswht, out, out);
+ DBLLL(("icm in_abs: after XYZ2Lab %s\n",icmPdv(lut->inputChan, out)));
+ }
+ }
+ DBLLL(("icm in_abs: returning %s\n",icmPdv(lut->inputChan, out)));
+
+ return rv;
+}
+
+/* Possible matrix lookup */
+static int icmLuLut_matrix(icmLuLut *p, double *out, double *in) {
+ icmLut *lut = p->lut;
+ int rv = 0;
+
+ if (p->usematrix)
+ rv |= lut->lookup_matrix(lut,out,in);
+ else if (out != in) {
+ unsigned int i;
+ for (i = 0; i < lut->inputChan; i++)
+ out[i] = in[i];
+ }
+ return rv;
+}
+
+/* Do input -> input' lookup */
+static int icmLuLut_input(icmLuLut *p, double *out, double *in) {
+ icmLut *lut = p->lut;
+ int rv = 0;
+
+ p->in_normf(out, in); /* Normalize from input color space */
+ rv |= lut->lookup_input(lut,out,out); /* Lookup though input tables */
+ p->in_denormf(out,out); /* De-normalize to input color space */
+ return rv;
+}
+
+/* Do input'->output' lookup */
+static int icmLuLut_clut(icmLuLut *p, double *out, double *in) {
+ icmLut *lut = p->lut;
+ double temp[MAX_CHAN];
+ int rv = 0;
+
+ p->in_normf(temp, in); /* Normalize from input color space */
+ rv |= p->lookup_clut(lut,out,temp); /* Lookup though clut tables */
+ p->out_denormf(out,out); /* De-normalize to output color space */
+ return rv;
+}
+
+/* Do output'->output lookup */
+static int icmLuLut_output(icmLuLut *p, double *out, double *in) {
+ icmLut *lut = p->lut;
+ int rv = 0;
+
+ p->out_normf(out,in); /* Normalize from output color space */
+ rv |= lut->lookup_output(lut,out,out); /* Lookup though output tables */
+ p->out_denormf(out, out); /* De-normalize to output color space */
+ return rv;
+}
+
+static int icmLuLut_out_abs(icmLuLut *p, double *out, double *in) {
+ icmLut *lut = p->lut;
+ int rv = 0;
+
+ DBLLL(("icm out_abs: input %s\n",icmPdv(lut->outputChan, in)));
+ if (out != in) {
+ unsigned int i;
+ for (i = 0; i < lut->outputChan; i++) /* Don't alter input values */
+ out[i] = in[i];
+ }
+
+ /* If Fwd Lut, take care of Absolute color space */
+ /* and convert from native to effective out PCS */
+ if ((p->function == icmFwd || p->function == icmPreview)
+ && (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation)) {
+
+ if (p->outSpace == icSigLabData) {
+ icmLab2XYZ(&p->pcswht, out, out);
+ DBLLL(("icm out_abs: after Lab2XYZ %s\n",icmPdv(lut->outputChan, out)));
+ }
+
+ /* Convert from Relative to Absolute colorimetric XYZ */
+ icmMulBy3x3(out, p->toAbs, out);
+ DBLLL(("icm out_abs: after toAbs %s\n",icmPdv(lut->outputChan, out)));
+
+ if (p->e_outSpace == icSigLabData) {
+ icmXYZ2Lab(&p->pcswht, out, out);
+ DBLLL(("icm out_abs: after XYZ2Lab %s\n",icmPdv(lut->outputChan, out)));
+ }
+ } else {
+
+ /* Convert from Native to Effective output space */
+ if (p->outSpace == icSigLabData && p->e_outSpace == icSigXYZData) {
+ icmLab2XYZ(&p->pcswht, out, out);
+ DBLLL(("icm out_abs: after Lab2 %s\n",icmPdv(lut->outputChan, out)));
+ } else if (p->outSpace == icSigXYZData && p->e_outSpace == icSigLabData) {
+ icmXYZ2Lab(&p->pcswht, out, out);
+ DBLLL(("icm out_abs: after XYZ2Lab %s\n",icmPdv(lut->outputChan, out)));
+ }
+ }
+ DBLLL(("icm out_abs: returning %s\n",icmPdv(lut->outputChan, out)));
+ return rv;
+}
+
+
+/* Overall lookup */
+static int
+icmLuLut_lookup (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuLut *p = (icmLuLut *)pp;
+ icmLut *lut = p->lut;
+ double temp[MAX_CHAN];
+
+ DBGLL(("icmLuLut_lookup: in = %s\n", icmPdv(p->inputChan, in)));
+ rv |= p->in_abs(p,temp,in); /* Possible absolute conversion */
+ DBGLL(("icmLuLut_lookup: in_abs = %s\n", icmPdv(p->inputChan, temp)));
+ if (p->usematrix) {
+ rv |= lut->lookup_matrix(lut,temp,temp);/* If XYZ, multiply by non-unity matrix */
+ DBGLL(("icmLuLut_lookup: matrix = %s\n", icmPdv(p->inputChan, temp)));
+ }
+ p->in_normf(temp, temp); /* Normalize for input color space */
+ DBGLL(("icmLuLut_lookup: norm = %s\n", icmPdv(p->inputChan, temp)));
+ rv |= lut->lookup_input(lut,temp,temp); /* Lookup though input tables */
+ DBGLL(("icmLuLut_lookup: input = %s\n", icmPdv(p->inputChan, temp)));
+ rv |= p->lookup_clut(lut,out,temp); /* Lookup though clut tables */
+ DBGLL(("icmLuLut_lookup: clut = %s\n", icmPdv(p->outputChan, out)));
+ rv |= lut->lookup_output(lut,out,out); /* Lookup though output tables */
+ DBGLL(("icmLuLut_lookup: output = %s\n", icmPdv(p->outputChan, out)));
+ p->out_denormf(out,out); /* Normalize for output color space */
+ DBGLL(("icmLuLut_lookup: denorm = %s\n", icmPdv(p->outputChan, out)));
+ rv |= p->out_abs(p,out,out); /* Possible absolute conversion */
+ DBGLL(("icmLuLut_lookup: out_abse = %s\n", icmPdv(p->outputChan, out)));
+
+ return rv;
+}
+
+#ifdef NEVER /* The following should be identical in effect to the above. */
+
+/* Overall lookup */
+static int
+icmLuLut_lookup (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int i, rv = 0;
+ icmLuLut *p = (icmLuLut *)pp;
+ icmLut *lut = p->lut;
+ double temp[MAX_CHAN];
+
+ rv |= p->in_abs(p,temp,in);
+ rv |= p->matrix(p,temp,temp);
+ rv |= p->input(p,temp,temp);
+ rv |= p->clut(p,out,temp);
+ rv |= p->output(p,out,out);
+ rv |= p->out_abs(p,out,out);
+
+ return rv;
+}
+
+#endif /* NEVER */
+
+/* Three stage conversion */
+static int
+icmLuLut_lookup_in (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuLut *p = (icmLuLut *)pp;
+ icmLut *lut = p->lut;
+
+ /* If in_abs() or matrix() are active, then we can't have a per component input curve */
+ if (((p->function == icmBwd || p->function == icmGamut || p->function == icmPreview)
+ && (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation))
+ || (p->e_inSpace != p->inSpace)
+ || (p->usematrix)) {
+ unsigned int i;
+ for (i = 0; i < lut->inputChan; i++)
+ out[i] = in[i];
+ } else {
+ rv |= p->input(p,out,in);
+ }
+ return rv;
+}
+
+static int
+icmLuLut_lookup_core (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuLut *p = (icmLuLut *)pp;
+
+ /* If in_abs() or matrix() are active, then we have to do the per component input curve here */
+ if (((p->function == icmBwd || p->function == icmGamut || p->function == icmPreview)
+ && (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation))
+ || (p->e_inSpace != p->inSpace)
+ || (p->usematrix)) {
+ double temp[MAX_CHAN];
+ rv |= p->in_abs(p,temp,in);
+ rv |= p->matrix(p,temp,temp);
+ rv |= p->input(p,temp,temp);
+ rv |= p->clut(p,out,temp);
+ } else {
+ rv |= p->clut(p,out,in);
+ }
+
+ /* If out_abs() is active, then we can't have do per component out curve here */
+ if (((p->function == icmFwd || p->function == icmPreview)
+ && (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation))
+ || (p->outSpace != p->e_outSpace)) {
+ rv |= p->output(p,out,out);
+ rv |= p->out_abs(p,out,out);
+ }
+
+ return rv;
+}
+
+static int
+icmLuLut_lookup_out (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuLut *p = (icmLuLut *)pp;
+ icmLut *lut = p->lut;
+
+ /* If out_abs() is active, then we can't have a per component out curve */
+ if (((p->function == icmFwd || p->function == icmPreview)
+ && (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation))
+ || (p->outSpace != p->e_outSpace)) {
+ unsigned int i;
+ for (i = 0; i < lut->outputChan; i++)
+ out[i] = in[i];
+ } else {
+ rv |= p->output(p,out,in);
+ }
+
+ return rv;
+}
+
+/* Inverse three stage conversion (partly implemented) */
+static int
+icmLuLut_lookup_inv_in (
+icmLuBase *pp, /* This */
+double *out, /* Vector of output values */
+double *in /* Vector of input values */
+) {
+ int rv = 0;
+ icmLuLut *p = (icmLuLut *)pp;
+ icmLut *lut = p->lut;
+
+ /* If in_abs() or matrix() are active, then we can't have a per component input curve */
+ if (((p->function == icmBwd || p->function == icmGamut || p->function == icmPreview)
+ && (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation))
+ || (p->e_inSpace != p->inSpace)
+ || (p->usematrix)) {
+ unsigned int i;
+ for (i = 0; i < lut->inputChan; i++)
+ out[i] = in[i];
+ } else {
+ rv |= p->inv_input(p,out,in);
+ }
+ return rv;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - */
+/* Some components of inverse lookup, in order */
+/* ~~ should these be in icmLut (like all the fwd transforms)? */
+
+static int icmLuLut_inv_out_abs(icmLuLut *p, double *out, double *in) {
+ icmLut *lut = p->lut;
+ int rv = 0;
+
+ DBLLL(("icm inv_out_abs: input %s\n",icmPdv(lut->outputChan, in)));
+ if (out != in) {
+ unsigned int i;
+ for (i = 0; i < lut->outputChan; i++) /* Don't alter input values */
+ out[i] = in[i];
+ }
+
+ /* If Fwd Lut, take care of Absolute color space */
+ /* and convert from effective to native inverse output PCS */
+ /* OutSpace must be PCS: XYZ or Lab */
+ if ((p->function == icmFwd || p->function == icmPreview)
+ && (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation)) {
+
+ if (p->e_outSpace == icSigLabData) {
+ icmLab2XYZ(&p->pcswht, out, out);
+ DBLLL(("icm inv_out_abs: after Lab2XYZ %s\n",icmPdv(lut->outputChan, out)));
+ }
+
+ /* Convert from Absolute to Relative colorimetric */
+ icmMulBy3x3(out, p->fromAbs, out);
+ DBLLL(("icm inv_out_abs: after fromAbs %s\n",icmPdv(lut->outputChan, out)));
+
+ if (p->outSpace == icSigLabData) {
+ icmXYZ2Lab(&p->pcswht, out, out);
+ DBLLL(("icm inv_out_abs: after XYZ2Lab %s\n",icmPdv(lut->outputChan, out)));
+ }
+
+ } else {
+
+ /* Convert from Effective to Native output space */
+ if (p->e_outSpace == icSigLabData && p->outSpace == icSigXYZData) {
+ icmLab2XYZ(&p->pcswht, out, out);
+ DBLLL(("icm inv_out_abs: after Lab2XYZ %s\n",icmPdv(lut->outputChan, out)));
+ } else if (p->e_outSpace == icSigXYZData && p->outSpace == icSigLabData) {
+ icmXYZ2Lab(&p->pcswht, out, out);
+ DBLLL(("icm inv_out_abs: after XYZ2Lab %s\n",icmPdv(lut->outputChan, out)));
+ }
+ }
+ return rv;
+}
+
+/* Do output->output' inverse lookup */
+static int icmLuLut_inv_output(icmLuLut *p, double *out, double *in) {
+ icc *icp = p->icp;
+ icmLut *lut = p->lut;
+ int i;
+ int rv = 0;
+
+ if (lut->rot[0].inited == 0) {
+ for (i = 0; i < lut->outputChan; i++) {
+ rv = icmTable_setup_bwd(icp, &lut->rot[i], lut->outputEnt,
+ lut->outputTable + i * lut->outputEnt);
+ if (rv != 0) {
+ sprintf(icp->err,"icc_Lut_inv_input: Malloc failure in inverse lookup init.");
+ return icp->errc = rv;
+ }
+ }
+ }
+
+ p->out_normf(out,in); /* Normalize from output color space */
+ for (i = 0; i < lut->outputChan; i++) {
+ /* Reverse lookup though output tables */
+ rv |= icmTable_lookup_bwd(&lut->rot[i], &out[i], &out[i]);
+ }
+ p->out_denormf(out, out); /* De-normalize to output color space */
+ return rv;
+}
+
+/* No output' -> input inverse lookup. */
+/* This is non-trivial ! */
+
+/* Do input' -> input inverse lookup */
+static int icmLuLut_inv_input(icmLuLut *p, double *out, double *in) {
+ icc *icp = p->icp;
+ icmLut *lut = p->lut;
+ int i;
+ int rv = 0;
+
+ if (lut->rit[0].inited == 0) {
+ for (i = 0; i < lut->inputChan; i++) {
+ rv = icmTable_setup_bwd(icp, &lut->rit[i], lut->inputEnt,
+ lut->inputTable + i * lut->inputEnt);
+ if (rv != 0) {
+ sprintf(icp->err,"icc_Lut_inv_input: Malloc failure in inverse lookup init.");
+ return icp->errc = rv;
+ }
+ }
+ }
+
+ p->in_normf(out, in); /* Normalize from input color space */
+ for (i = 0; i < lut->inputChan; i++) {
+ /* Reverse lookup though input tables */
+ rv |= icmTable_lookup_bwd(&lut->rit[i], &out[i], &out[i]);
+ }
+ p->in_denormf(out,out); /* De-normalize to input color space */
+ return rv;
+}
+
+/* Possible inverse matrix lookup */
+static int icmLuLut_inv_matrix(icmLuLut *p, double *out, double *in) {
+ icc *icp = p->icp;
+ icmLut *lut = p->lut;
+ int rv = 0;
+
+ if (p->usematrix) {
+ double tt[3];
+ if (p->imx_valid == 0) {
+ if (icmInverse3x3(p->imx, lut->e) != 0) { /* Compute inverse */
+ sprintf(icp->err,"icc_new_iccLuMatrix: Matrix wasn't invertable");
+ icp->errc = 2;
+ return 2;
+ }
+ p->imx_valid = 1;
+ }
+ /* Matrix multiply */
+ tt[0] = p->imx[0][0] * in[0] + p->imx[0][1] * in[1] + p->imx[0][2] * in[2];
+ tt[1] = p->imx[1][0] * in[0] + p->imx[1][1] * in[1] + p->imx[1][2] * in[2];
+ tt[2] = p->imx[2][0] * in[0] + p->imx[2][1] * in[1] + p->imx[2][2] * in[2];
+ out[0] = tt[0], out[1] = tt[1], out[2] = tt[2];
+ } else if (out != in) {
+ unsigned int i;
+ for (i = 0; i < lut->inputChan; i++)
+ out[i] = in[i];
+ }
+ return rv;
+}
+
+static int icmLuLut_inv_in_abs(icmLuLut *p, double *out, double *in) {
+ icmLut *lut = p->lut;
+ int rv = 0;
+
+ DBLLL(("icm inv_in_abs: input %s\n",icmPdv(lut->inputChan, in)));
+ if (out != in) {
+ unsigned int i;
+ for (i = 0; i < lut->inputChan; i++) /* Don't alter input values */
+ out[i] = in[i];
+ }
+
+ /* If Bwd Lut, take care of Absolute color space, and */
+ /* convert from native to effective input space */
+ if ((p->function == icmBwd || p->function == icmGamut || p->function == icmPreview)
+ && (p->intent == icAbsoluteColorimetric
+ || p->intent == icmAbsolutePerceptual
+ || p->intent == icmAbsoluteSaturation)) {
+
+ if (p->inSpace == icSigLabData) {
+ icmLab2XYZ(&p->pcswht, out, out);
+ DBLLL(("icm inv_in_abs: after Lab2XYZ %s\n",icmPdv(lut->inputChan, out)));
+ }
+
+ /* Convert from Relative to Absolute colorimetric XYZ */
+ icmMulBy3x3(out, p->toAbs, out);
+ DBLLL(("icm inv_in_abs: after toAbs %s\n",icmPdv(lut->inputChan, out)));
+
+ if (p->e_inSpace == icSigLabData) {
+ icmXYZ2Lab(&p->pcswht, out, out);
+ DBLLL(("icm inv_in_abs: after XYZ2Lab %s\n",icmPdv(lut->inputChan, out)));
+ }
+ } else {
+
+ /* Convert from Native to Effective input space */
+ if (p->inSpace == icSigLabData && p->e_inSpace == icSigXYZData) {
+ icmLab2XYZ(&p->pcswht, out, out);
+ DBLLL(("icm inv_in_abs: after Lab2XYZ %s\n",icmPdv(lut->inputChan, out)));
+ } else if (p->inSpace == icSigXYZData && p->e_inSpace == icSigLabData) {
+ icmXYZ2Lab(&p->pcswht, out, out);
+ DBLLL(("icm inv_in_abs: after XYZ2Lab %s\n",icmPdv(lut->inputChan, out)));
+ }
+ }
+ DBLLL(("icm inv_in_abs: returning %s\n",icmPdv(lut->inputChan, out)));
+ return rv;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Return LuLut information */
+static void icmLuLut_get_info(
+ icmLuLut *p, /* this */
+ icmLut **lutp, /* Pointer to icc lut type */
+ icmXYZNumber *pcswhtp, /* Pointer to profile PCS white point */
+ icmXYZNumber *whitep, /* Pointer to profile absolute white point */
+ icmXYZNumber *blackp /* Pointer to profile absolute black point */
+) {
+ if (lutp != NULL)
+ *lutp = p->lut;
+ if (pcswhtp != NULL)
+ *pcswhtp = p->pcswht;
+ if (whitep != NULL)
+ *whitep = p->whitePoint;
+ if (blackp != NULL)
+ *blackp = p->blackPoint;
+}
+
+/* Get the native ranges for the LuLut */
+/* This is computed differently to the mono & matrix types, to */
+/* accurately take into account the different range for 8 bit Lab */
+/* lut type. The range returned for the effective PCS is not so accurate. */
+static void
+icmLuLut_get_lutranges (
+ struct _icmLuBase *pp,
+ double *inmin, double *inmax, /* Return maximum range of inspace values */
+ double *outmin, double *outmax /* Return maximum range of outspace values */
+) {
+ icmLuLut *p = (icmLuLut *)pp;
+ unsigned int i;
+
+ for (i = 0; i < p->lut->inputChan; i++) {
+ inmin[i] = 0.0; /* Normalized range of input space values */
+ inmax[i] = 1.0;
+ }
+ p->in_denormf(inmin,inmin); /* Convert to real colorspace range */
+ p->in_denormf(inmax,inmax);
+
+ /* Make sure min and max are so. */
+ for (i = 0; i < p->lut->inputChan; i++) {
+ if (inmin[i] > inmax[i]) {
+ double tt;
+ tt = inmin[i];
+ inmin[i] = inmax[i];
+ inmax[i] = tt;
+ }
+ }
+
+ for (i = 0; i < p->lut->outputChan; i++) {
+ outmin[i] = 0.0; /* Normalized range of output space values */
+ outmax[i] = 1.0;
+ }
+ p->out_denormf(outmin,outmin); /* Convert to real colorspace range */
+ p->out_denormf(outmax,outmax);
+
+ /* Make sure min and max are so. */
+ for (i = 0; i < p->lut->outputChan; i++) {
+ if (outmin[i] > outmax[i]) {
+ double tt;
+ tt = outmin[i];
+ outmin[i] = outmax[i];
+ outmax[i] = tt;
+ }
+ }
+}
+
+/* Get the effective (externaly visible) ranges for the LuLut */
+/* This will be accurate if there is no override, but only */
+/* aproximate if a PCS override is in place. */
+static void
+icmLuLut_get_ranges (
+ struct _icmLuBase *pp,
+ double *inmin, double *inmax, /* Return maximum range of inspace values */
+ double *outmin, double *outmax /* Return maximum range of outspace values */
+) {
+ icmLuLut *p = (icmLuLut *)pp;
+
+ /* Get the native ranges first */
+ icmLuLut_get_lutranges(pp, inmin, inmax, outmin, outmax);
+
+ /* And replace them if the effective space is different */
+ if (p->e_inSpace != p->inSpace)
+ getRange(p->icp, p->e_inSpace, p->lut->ttype, inmin, inmax);
+
+ if (p->e_outSpace != p->outSpace)
+ getRange(p->icp, p->e_outSpace, p->lut->ttype, outmin, outmax);
+}
+
+/* Return the underlying Lut matrix */
+static void
+icmLuLut_get_matrix (
+ struct _icmLuLut *p,
+ double m[3][3]
+) {
+ int i, j;
+ icmLut *lut = p->lut;
+
+ if (p->usematrix) {
+ for (i = 0; i < 3; i++)
+ for (j = 0; j < 3; j++)
+ m[i][j] = lut->e[i][j]; /* Copy from Lut */
+
+ } else { /* return unity matrix */
+ icmSetUnity3x3(m);
+ }
+}
+
+
+static void
+icmLuLut_delete(
+icmLuBase *p
+) {
+ icc *icp = p->icp;
+
+ icp->al->free(icp->al, p);
+}
+
+icmLuBase *
+icc_new_icmLuLut(
+ icc *icp,
+ icTagSignature ttag, /* Target Lut tag */
+ icColorSpaceSignature inSpace, /* Native Input color space */
+ icColorSpaceSignature outSpace, /* Native Output color space */
+ icColorSpaceSignature pcs, /* Native PCS (from header) */
+ icColorSpaceSignature e_inSpace, /* Effective Input color space */
+ icColorSpaceSignature e_outSpace, /* Effective Output color space */
+ icColorSpaceSignature e_pcs, /* Effective PCS */
+ icRenderingIntent intent, /* Rendering intent (For absolute) */
+ icmLookupFunc func /* Functionality requested (for icmLuSpaces()) */
+) {
+ icmLuLut *p;
+
+ if ((p = (icmLuLut *) icp->al->calloc(icp->al,1,sizeof(icmLuLut))) == NULL)
+ return NULL;
+ p->ttype = icmLutType;
+ p->icp = icp;
+ p->del = icmLuLut_delete;
+ p->lutspaces= icmLutSpaces;
+ p->spaces = icmLuSpaces;
+ p->XYZ_Rel2Abs = icmLuXYZ_Rel2Abs;
+ p->XYZ_Abs2Rel = icmLuXYZ_Abs2Rel;
+ p->init_wh_bk = icmLuInit_Wh_bk;
+ p->wh_bk_points = icmLuWh_bk_points;
+ p->lu_wh_bk_points = icmLuLu_wh_bk_points;
+
+ p->lookup = icmLuLut_lookup;
+ p->lookup_in = icmLuLut_lookup_in;
+ p->lookup_core = icmLuLut_lookup_core;
+ p->lookup_out = icmLuLut_lookup_out;
+ p->lookup_inv_in = icmLuLut_lookup_inv_in;
+
+ p->in_abs = icmLuLut_in_abs;
+ p->matrix = icmLuLut_matrix;
+ p->input = icmLuLut_input;
+ p->clut = icmLuLut_clut;
+ p->output = icmLuLut_output;
+ p->out_abs = icmLuLut_out_abs;
+
+ p->inv_in_abs = icmLuLut_inv_in_abs;
+ p->inv_matrix = icmLuLut_inv_matrix;
+ p->inv_input = icmLuLut_inv_input;
+ p->inv_output = icmLuLut_inv_output;
+ p->inv_out_abs = icmLuLut_inv_out_abs;
+
+ p->pcswht = icp->header->illuminant;
+ p->intent = intent; /* used to trigger absolute processing */
+ p->function = func;
+ p->inSpace = inSpace;
+ p->outSpace = outSpace;
+ p->pcs = pcs;
+ p->e_inSpace = e_inSpace;
+ p->e_outSpace = e_outSpace;
+ p->e_pcs = e_pcs;
+ p->get_info = icmLuLut_get_info;
+ p->get_lutranges = icmLuLut_get_lutranges;
+ p->get_ranges = icmLuLut_get_ranges;
+ p->get_matrix = icmLuLut_get_matrix;
+
+ /* Lookup the white and black points */
+ if (p->init_wh_bk((icmLuBase *)p)) {
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* Get the Lut tag, & check that it is expected type */
+ if ((p->lut = (icmLut *)icp->read_tag(icp, ttag)) == NULL
+ || (p->lut->ttype != icSigLut8Type && p->lut->ttype != icSigLut16Type)) {
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* Check if matrix should be used */
+ if (inSpace == icSigXYZData && p->lut->nu_matrix(p->lut))
+ p->usematrix = 1;
+ else
+ p->usematrix = 0;
+
+ /* Lookup input color space to normalized index function */
+ if (getNormFunc(icp, inSpace, p->lut->ttype, icmToLuti, &p->in_normf)) {
+ sprintf(icp->err,"icc_get_luobj: Unknown colorspace");
+ icp->errc = 1;
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* Lookup normalized index to input color space function */
+ if (getNormFunc(icp, inSpace, p->lut->ttype, icmFromLuti, &p->in_denormf)) {
+ sprintf(icp->err,"icc_get_luobj: Unknown colorspace");
+ icp->errc = 1;
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* Lookup output color space to normalized Lut entry value function */
+ if (getNormFunc(icp, outSpace, p->lut->ttype, icmToLutv, &p->out_normf)) {
+ sprintf(icp->err,"icc_get_luobj: Unknown colorspace");
+ icp->errc = 1;
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* Lookup normalized Lut entry value to output color space function */
+ if (getNormFunc(icp, outSpace, p->lut->ttype, icmFromLutv, &p->out_denormf)) {
+ sprintf(icp->err,"icc_get_luobj: Unknown colorspace");
+ icp->errc = 1;
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* Note that the following two are only used in computing the expected */
+ /* value ranges of the effective PCS. This might not be the best way of */
+ /* doing this. */
+ /* Lookup normalized index to effective input color space function */
+ if (getNormFunc(icp, e_inSpace, p->lut->ttype, icmFromLuti, &p->e_in_denormf)) {
+ sprintf(icp->err,"icc_get_luobj: Unknown effective colorspace");
+ icp->errc = 1;
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+ /* Lookup normalized Lut entry value to effective output color space function */
+ if (getNormFunc(icp, e_outSpace, p->lut->ttype, icmFromLutv, &p->e_out_denormf)) {
+ sprintf(icp->err,"icc_get_luobj: Unknown effective colorspace");
+ icp->errc = 1;
+ p->del((icmLuBase *)p);
+ return NULL;
+ }
+
+// ~~~999
+#ifndef NEVER
+ /* Standard code */
+ /* Determine appropriate clut lookup algorithm */
+ {
+ int use_sx; /* -1 = undecided, 0 = N-linear, 1 = Simplex lookup */
+ icColorSpaceSignature ins, outs; /* In and out Lut color spaces */
+ int inn, outn; /* in and out number of Lut components */
+
+ p->lutspaces((icmLuBase *)p, &ins, &inn, &outs, &outn, NULL);
+
+ /* Determine if the input space is "Device" like, */
+ /* ie. luminance will be expected to vary most strongly */
+ /* with the diagonal change in input coordinates. */
+ switch(ins) {
+
+ /* Luminence is carried by the sum of all the output channels, */
+ /* so output luminence will dominantly be in diagonal direction. */
+ case icSigXYZData: /* This seems to be appropriate ? */
+ case icSigRgbData:
+ case icSigGrayData:
+ case icSigCmykData:
+ case icSigCmyData:
+ case icSigMch6Data:
+ use_sx = 1; /* Simplex interpolation is appropriate */
+ break;
+
+ /* A single channel carries the luminence information */
+ case icSigLabData:
+ case icSigLuvData:
+ case icSigYCbCrData:
+ case icSigYxyData:
+ case icSigHlsData:
+ case icSigHsvData:
+ use_sx = 0; /* N-linear interpolation is appropriate */
+ break;
+ default:
+ use_sx = -1; /* undecided */
+ break;
+ }
+
+ /* If we couldn't figure it out from the input space, */
+ /* check output luminance variation with a diagonal input */
+ /* change. */
+ if (use_sx == -1) {
+ int lc; /* Luminance channel */
+
+ /* Determine where the luminence is carried in the output */
+ switch(outs) {
+
+ /* Luminence is carried by the sum of all the output channels */
+ case icSigRgbData:
+ case icSigGrayData:
+ case icSigCmykData:
+ case icSigCmyData:
+ case icSigMch6Data:
+ lc = -1; /* Average all channels */
+ break;
+
+ /* A single channel carries the luminence information */
+ case icSigLabData:
+ case icSigLuvData:
+ case icSigYCbCrData:
+ case icSigYxyData:
+ lc = 0;
+ break;
+
+ case icSigXYZData:
+ case icSigHlsData:
+ lc = 1;
+ break;
+
+ case icSigHsvData:
+ lc = 2;
+ break;
+
+ /* default means give up and use N-linear type lookup */
+ default:
+ lc = -2;
+ break;
+ }
+
+ /* If we know how luminance is represented in output space */
+ if (lc != -2) {
+ double tout1[MAX_CHAN]; /* Test output values */
+ double tout2[MAX_CHAN];
+ double tt, diag;
+ int n;
+
+ /* Determine input space location of min and max of */
+ /* given output channel (chan = -1 means average of all) */
+ p->lut->min_max(p->lut, tout1, tout2, lc);
+
+ /* Convert to vector and then calculate normalized */
+ /* dot product with diagonal vector (1,1,1...) */
+ for (tt = 0.0, n = 0; n < inn; n++) {
+ tout1[n] = tout2[n] - tout1[n];
+ tt += tout1[n] * tout1[n];
+ }
+ if (tt > 0.0)
+ tt = sqrt(tt); /* normalizing factor for maximum delta */
+ else
+ tt = 1.0; /* Hmm. */
+ tt *= sqrt((double)inn); /* Normalizing factor for diagonal vector */
+ for (diag = 0.0, n = 0; n < outn; n++)
+ diag += tout1[n] / tt;
+ diag = fabs(diag);
+
+ /* I'm not really convinced that this is a reliable */
+ /* indicator of whether simplex interpolation should be used ... */
+ /* It does seem to do the right thing with YCC space though. */
+ if (diag > 0.8) /* Diagonal is dominant ? */
+ use_sx = 1;
+
+ /* If we couldn't figure it out, use N-linear interpolation */
+ if (use_sx == -1)
+ use_sx = 0;
+ }
+ }
+
+ if (use_sx) {
+ p->lookup_clut = p->lut->lookup_clut_sx;
+ } else {
+ p->lookup_clut = p->lut->lookup_clut_nl;
+ }
+ }
+#else /* Development code */
+ /* Determine appropriate clut lookup algorithm, */
+ /* and set optimised simplex tables */
+ {
+ int lualg = 0; /* 0 = simplex, 1 = multi-linear, 2 = optimised simlpex */
+ icColorSpaceSignature ins, outs; /* In and out Lut color spaces */
+ int inn, outn; /* in and out number of Lut components */
+
+ p->lutspaces((icmLuBase *)p, &ins, &inn, &outs, &outn, NULL);
+
+ /* Determine which type of Lut lookup algorithm is likely to give */
+ /* minimal interpolation errors. */
+ /* To use the optimised simplex, we should ideally determine */
+ /* the simplex cell orientation that makes the simplex split diagonal */
+ /* always point towards the white or black points. */
+ switch(ins) {
+
+ case icSigXYZData: /* This seems to be appropriate ? */
+ case icSigRgbData:
+ case icSigGrayData:
+ case icSigCmykData:
+ case icSigCmyData:
+ case icSigMch6Data:
+ lualg = 0; /* Simplex interpolation is appropriate */
+ break;
+
+ case icSigLabData:
+// ~~~~9999 this isn't right! need to lookup Lab 50,0,0 through input curves then */
+/* quantize to clut nodes to figure threshold for axis flips */
+ p->lut->finfo[0].fth = 0.5; p->lut->finfo[0].bthff = 0; p->lut->finfo[0].athff = 1;
+ p->lut->finfo[1].fth = 0.5; p->lut->finfo[1].bthff = 1; p->lut->finfo[1].athff = 0;
+ p->lut->finfo[2].fth = 0.5; p->lut->finfo[2].bthff = 1; p->lut->finfo[2].athff = 0;
+ lualg = 2;
+ break;
+
+ /* !!! Should switch to optimised simplex for these too !!! */
+ case icSigLuvData:
+ case icSigYCbCrData:
+ case icSigYxyData:
+ case icSigHlsData:
+ case icSigHsvData:
+ lualg = 1; /* Multi-linear is best as a default for these ? */
+ break;
+
+ default:
+ lualg = 0; /* Simplex is best if we known nothing. */
+ break;
+ }
+
+ if (lualg == 2) {
+ p->lookup_clut = icmLut_lookup_clut_osx;
+ } else if (lualg == 1) {
+ p->lookup_clut = p->lut->lookup_clut_nl;
+ } else {
+ p->lookup_clut = p->lut->lookup_clut_sx;
+ }
+ }
+#endif
+ return (icmLuBase *)p;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Return an appropriate lookup object */
+/* Return NULL on error, and detailed error in icc */
+static icmLuBase* icc_get_luobj (
+ icc *p, /* ICC */
+ icmLookupFunc func, /* Conversion functionality */
+ icRenderingIntent intent, /* Rendering intent, including icmAbsoluteColorimetricXYZ */
+ icColorSpaceSignature pcsor,/* PCS override (0 = def) */
+ icmLookupOrder order /* Conversion representation search Order */
+) {
+ icmLuBase *luobj = NULL; /* Lookup object to return */
+ icColorSpaceSignature pcs, e_pcs; /* PCS and effective PCS */
+
+#ifdef ICM_STRICT
+ int rv;
+ /* Check that the profile is legal, since we depend on it ? */
+ if ((rv = check_icc_legal(p)) != 0)
+ return NULL;
+#endif /* ICM_STRICT */
+
+ /* Figure out the native and effective PCS */
+ e_pcs = pcs = p->header->pcs;
+ if (pcsor != icmSigDefaultData)
+ e_pcs = pcsor; /* Override */
+
+ /* How we expect to execute the request depends firstly on the type of profile */
+ switch (p->header->deviceClass) {
+ case icSigInputClass:
+ case icSigDisplayClass:
+ case icSigColorSpaceClass:
+
+ /* Look for Intent based AToBX profile + optional BToAX reverse */
+ /* or for AToB0 based profile + optional BToA0 reverse */
+ /* or three component matrix profile (reversable) */
+ /* or momochrome table profile (reversable) */
+ /* No Lut intent for ICC < V2.4, but possible for >= V2.4, */
+ /* so fall back if we can't find the chosen Lut intent.. */
+ /* Device <-> PCS */
+ /* Determine the algorithm and set its parameters */
+
+ switch (func) {
+ icRenderingIntent fbintent; /* Fallback intent */
+ icTagSignature ttag, fbtag;
+
+ case icmFwd: /* Device to PCS */
+ if (intent == icmDefaultIntent)
+ intent = icPerceptual; /* Make this the default */
+
+ switch (intent) {
+ case icAbsoluteColorimetric:
+ ttag = icSigAToB1Tag;
+ fbtag = icSigAToB0Tag;
+ fbintent = intent;
+ break;
+ case icRelativeColorimetric:
+ ttag = icSigAToB1Tag;
+ fbtag = icSigAToB0Tag;
+ fbintent = icmDefaultIntent;
+ break;
+ case icPerceptual:
+ ttag = icSigAToB0Tag;
+ fbtag = icSigAToB0Tag;
+ fbintent = icmDefaultIntent;
+ break;
+ case icSaturation:
+ ttag = icSigAToB2Tag;
+ fbtag = icSigAToB0Tag;
+ fbintent = icmDefaultIntent;
+ break;
+ case icmAbsolutePerceptual: /* Special icclib intent */
+ ttag = icSigAToB0Tag;
+ fbtag = icSigAToB0Tag;
+ fbintent = intent;
+ break;
+ case icmAbsoluteSaturation: /* Special icclib intent */
+ ttag = icSigAToB2Tag;
+ fbtag = icSigAToB0Tag;
+ fbintent = intent;
+ break;
+ default:
+ sprintf(p->err,"icc_get_luobj: Unknown intent");
+ p->errc = 1;
+ return NULL;
+ }
+
+ if (order != icmLuOrdRev) {
+ /* Try Lut type lookup with the chosen intent first */
+ if ((luobj = icc_new_icmLuLut(p, ttag,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* Try the fallback tag */
+ if ((luobj = icc_new_icmLuLut(p, fbtag,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ fbintent, func)) != NULL)
+ break;
+
+ /* See if it could be a matrix lookup */
+ if ((luobj = new_icmLuMatrixFwd(p,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* See if it could be a monochrome lookup */
+ if ((luobj = new_icmLuMonoFwd(p,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ } else {
+ /* See if it could be a monochrome lookup */
+ if ((luobj = new_icmLuMonoFwd(p,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* See if it could be a matrix lookup */
+ if ((luobj = new_icmLuMatrixFwd(p,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* Try Lut type lookup last */
+ if ((luobj = icc_new_icmLuLut(p, ttag,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* Try the fallback tag */
+ if ((luobj = icc_new_icmLuLut(p, fbtag,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ fbintent, func)) != NULL)
+ break;
+ }
+ break;
+
+ case icmBwd: /* PCS to Device */
+ if (intent == icmDefaultIntent)
+ intent = icPerceptual; /* Make this the default */
+
+ switch (intent) {
+ case icAbsoluteColorimetric:
+ ttag = icSigBToA1Tag;
+ fbtag = icSigBToA0Tag;
+ fbintent = intent;
+ break;
+ case icRelativeColorimetric:
+ ttag = icSigBToA1Tag;
+ fbtag = icSigBToA0Tag;
+ fbintent = icmDefaultIntent;
+ break;
+ case icPerceptual:
+ ttag = icSigBToA0Tag;
+ fbtag = icSigBToA0Tag;
+ fbintent = icmDefaultIntent;
+ break;
+ case icSaturation:
+ ttag = icSigBToA2Tag;
+ fbtag = icSigBToA0Tag;
+ fbintent = icmDefaultIntent;
+ break;
+ case icmAbsolutePerceptual: /* Special icclib intent */
+ ttag = icSigBToA0Tag;
+ fbtag = icSigBToA0Tag;
+ fbintent = intent;
+ break;
+ case icmAbsoluteSaturation: /* Special icclib intent */
+ ttag = icSigBToA2Tag;
+ fbtag = icSigBToA0Tag;
+ fbintent = intent;
+ break;
+ default:
+ sprintf(p->err,"icc_get_luobj: Unknown intent");
+ p->errc = 1;
+ return NULL;
+ }
+
+
+ if (order != icmLuOrdRev) {
+ /* Try Lut type lookup first */
+ if ((luobj = icc_new_icmLuLut(p, ttag,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* Try the fallback Lut */
+ if ((luobj = icc_new_icmLuLut(p, fbtag,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ fbintent, func)) != NULL)
+ break;
+
+ /* See if it could be a matrix lookup */
+ if ((luobj = new_icmLuMatrixBwd(p,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* See if it could be a monochrome lookup */
+ if ((luobj = new_icmLuMonoBwd(p,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+ } else {
+ /* See if it could be a monochrome lookup */
+ if ((luobj = new_icmLuMonoBwd(p,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* See if it could be a matrix lookup */
+ if ((luobj = new_icmLuMatrixBwd(p,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* Try Lut type lookup last */
+ if ((luobj = icc_new_icmLuLut(p, ttag,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* Try the fallback Lut */
+ if ((luobj = icc_new_icmLuLut(p, fbtag,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ fbintent, func)) != NULL)
+ break;
+ }
+ break;
+
+ default:
+ sprintf(p->err,"icc_get_luobj: Inaproptiate function requested");
+ p->errc = 1;
+ return NULL;
+ }
+ break;
+
+ case icSigOutputClass:
+ /* Expect BToA Lut and optional AToB Lut, All intents, expect gamut */
+ /* or momochrome table profile (reversable) */
+ /* Device <-> PCS */
+ /* Gamut Lut - no intent */
+ /* Optional preview links PCS <-> PCS */
+
+ /* Determine the algorithm and set its parameters */
+ switch (func) {
+ icTagSignature ttag;
+
+ case icmFwd: /* Device to PCS */
+
+ if (intent == icmDefaultIntent)
+ intent = icPerceptual; /* Make this the default */
+
+ switch (intent) {
+ case icRelativeColorimetric:
+ case icAbsoluteColorimetric:
+ ttag = icSigAToB1Tag;
+ break;
+ case icPerceptual:
+ case icmAbsolutePerceptual: /* Special icclib intent */
+ ttag = icSigAToB0Tag;
+ break;
+ case icSaturation:
+ case icmAbsoluteSaturation: /* Special icclib intent */
+ ttag = icSigAToB2Tag;
+ break;
+ default:
+ sprintf(p->err,"icc_get_luobj: Unknown intent");
+ p->errc = 1;
+ return NULL;
+ }
+
+ if (order != icmLuOrdRev) {
+ /* Try Lut type lookup first */
+ if ((luobj = icc_new_icmLuLut(p, ttag,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL) {
+ break;
+ }
+
+ /* See if it could be a matrix lookup */
+ if ((luobj = new_icmLuMatrixFwd(p,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* See if it could be a monochrome lookup */
+ if ((luobj = new_icmLuMonoFwd(p,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+ } else {
+ /* See if it could be a monochrome lookup */
+ if ((luobj = new_icmLuMonoFwd(p,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* See if it could be a matrix lookup */
+ if ((luobj = new_icmLuMatrixFwd(p,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* Try Lut type lookup last */
+ if ((luobj = icc_new_icmLuLut(p, ttag,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, e_pcs, e_pcs,
+ intent, func)) != NULL)
+ break;
+ }
+ break;
+
+ case icmBwd: /* PCS to Device */
+
+ if (intent == icmDefaultIntent)
+ intent = icPerceptual; /* Make this the default */
+
+ switch (intent) {
+ case icRelativeColorimetric:
+ case icAbsoluteColorimetric:
+ ttag = icSigBToA1Tag;
+ break;
+ case icPerceptual:
+ case icmAbsolutePerceptual: /* Special icclib intent */
+ ttag = icSigBToA0Tag;
+ break;
+ case icSaturation:
+ case icmAbsoluteSaturation: /* Special icclib intent */
+ ttag = icSigBToA2Tag;
+ break;
+ default:
+ sprintf(p->err,"icc_get_luobj: Unknown intent");
+ p->errc = 1;
+ return NULL;
+ }
+
+ if (order != icmLuOrdRev) {
+ /* Try Lut type lookup first */
+ if ((luobj = icc_new_icmLuLut(p, ttag,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* See if it could be a matrix lookup */
+ if ((luobj = new_icmLuMatrixBwd(p,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* See if it could be a monochrome lookup */
+ if ((luobj = new_icmLuMonoBwd(p,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+ } else {
+ /* See if it could be a monochrome lookup */
+ if ((luobj = new_icmLuMonoBwd(p,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* See if it could be a matrix lookup */
+ if ((luobj = new_icmLuMatrixBwd(p,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+
+ /* Try Lut type lookup last */
+ if ((luobj = icc_new_icmLuLut(p, ttag,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, p->header->colorSpace, e_pcs,
+ intent, func)) != NULL)
+ break;
+ }
+ break;
+
+ case icmGamut: /* PCS to 1D */
+
+#ifdef ICM_STRICT /* Allow only default and absolute */
+ if (intent != icmDefaultIntent
+ && intent != icAbsoluteColorimetric) {
+ sprintf(p->err,"icc_get_luobj: Intent is inappropriate for Gamut table");
+ p->errc = 1;
+ return NULL;
+ }
+#else /* Be more forgiving */
+ switch (intent) {
+ case icAbsoluteColorimetric:
+ case icmAbsolutePerceptual: /* Special icclib intent */
+ case icmAbsoluteSaturation: /* Special icclib intent */
+ break;
+ case icmDefaultIntent:
+ case icRelativeColorimetric:
+ case icPerceptual:
+ case icSaturation:
+ intent = icmDefaultIntent; /* Make all other look like default */
+ break;
+ default:
+ sprintf(p->err,"icc_get_luobj: Unknown intent (0x%x)",intent);
+ p->errc = 1;
+ return NULL;
+ }
+
+#endif
+ /* If the target tag exists, and it is a Lut */
+ luobj = icc_new_icmLuLut(p, icSigGamutTag,
+ pcs, icSigGrayData, pcs,
+ e_pcs, icSigGrayData, e_pcs,
+ intent, func);
+ break;
+
+ case icmPreview: /* PCS to PCS */
+
+ switch (intent) {
+ case icRelativeColorimetric:
+ ttag = icSigPreview1Tag;
+ break;
+ case icPerceptual:
+ ttag = icSigPreview0Tag;
+ break;
+ case icSaturation:
+ ttag = icSigPreview2Tag;
+ break;
+ case icAbsoluteColorimetric:
+ case icmAbsolutePerceptual: /* Special icclib intent */
+ case icmAbsoluteSaturation: /* Special icclib intent */
+ sprintf(p->err,"icc_get_luobj: Intent is inappropriate for preview table");
+ p->errc = 1;
+ return NULL;
+ default:
+ sprintf(p->err,"icc_get_luobj: Unknown intent");
+ p->errc = 1;
+ return NULL;
+ }
+
+ /* If the target tag exists, and it is a Lut */
+ luobj = icc_new_icmLuLut(p, ttag,
+ pcs, pcs, pcs,
+ e_pcs, e_pcs, e_pcs,
+ intent, func);
+ break;
+
+ default:
+ sprintf(p->err,"icc_get_luobj: Inaproptiate function requested");
+ p->errc = 1;
+ return NULL;
+ }
+ break;
+
+ case icSigLinkClass:
+ /* Expect AToB0 Lut and optional BToA0 Lut, One intent in header */
+ /* Device <-> Device */
+
+ if (intent != p->header->renderingIntent
+ && intent != icmDefaultIntent) {
+ sprintf(p->err,"icc_get_luobj: Intent is inappropriate for Link profile");
+ p->errc = 1;
+ return NULL;
+ }
+ intent = p->header->renderingIntent;
+
+ /* Determine the algorithm and set its parameters */
+ switch (func) {
+ case icmFwd: /* Device to PCS (== Device) */
+
+ luobj = icc_new_icmLuLut(p, icSigAToB0Tag,
+ p->header->colorSpace, pcs, pcs,
+ p->header->colorSpace, pcs, pcs,
+ intent, func);
+ break;
+
+ case icmBwd: /* PCS (== Device) to Device */
+
+ luobj = icc_new_icmLuLut(p, icSigBToA0Tag,
+ pcs, p->header->colorSpace, pcs,
+ pcs, p->header->colorSpace, pcs,
+ intent, func);
+ break;
+
+ default:
+ sprintf(p->err,"icc_get_luobj: Inaproptiate function requested");
+ p->errc = 1;
+ return NULL;
+ }
+ break;
+
+ case icSigAbstractClass:
+ /* Expect AToB0 Lut and option BToA0 Lut, with either relative or absolute intent. */
+ /* PCS <-> PCS */
+ /* Determine the algorithm and set its parameters */
+
+ if (intent != icmDefaultIntent
+ && intent != icRelativeColorimetric
+ && intent != icAbsoluteColorimetric) {
+ sprintf(p->err,"icc_get_luobj: Intent is inappropriate for Abstract profile");
+ p->errc = 1;
+ return NULL;
+ }
+
+ switch (func) {
+ case icmFwd: /* PCS (== Device) to PCS */
+
+ luobj = icc_new_icmLuLut(p, icSigAToB0Tag,
+ p->header->colorSpace, pcs, pcs,
+ e_pcs, e_pcs, e_pcs,
+ intent, func);
+ break;
+
+ case icmBwd: /* PCS to PCS (== Device) */
+
+ luobj = icc_new_icmLuLut(p, icSigBToA0Tag,
+ pcs, p->header->colorSpace, pcs,
+ e_pcs, e_pcs, e_pcs,
+ intent, func);
+ break;
+
+ default:
+ sprintf(p->err,"icc_get_luobj: Inaproptiate function requested");
+ p->errc = 1;
+ return NULL;
+ }
+ break;
+
+ case icSigNamedColorClass:
+ /* Expect Name -> Device, Optional PCS */
+ /* and a reverse lookup would be useful */
+ /* (ie. PCS or Device coords to closest named color) */
+ /* ~~ to be implemented ~~ */
+
+ /* ~~ Absolute intent is valid for processing of */
+ /* PCS from named Colors. Also allow for e_pcs */
+ if (intent != icmDefaultIntent
+ && intent != icRelativeColorimetric
+ && intent != icAbsoluteColorimetric) {
+ sprintf(p->err,"icc_get_luobj: Intent is inappropriate for Named Color profile");
+ p->errc = 1;
+ return NULL;
+ }
+
+ sprintf(p->err,"icc_get_luobj: Named Colors not handled yet");
+ p->errc = 1;
+ return NULL;
+
+ default:
+ sprintf(p->err,"icc_get_luobj: Unknown profile class");
+ p->errc = 1;
+ return NULL;
+ }
+
+ if (luobj == NULL) {
+ sprintf(p->err,"icc_get_luobj: Unable to locate usable conversion");
+ p->errc = 1;
+ } else {
+ luobj->order = order;
+ }
+
+ return luobj;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Returns total ink limit and channel maximums. */
+/* Returns -1.0 if not applicable for this type of profile. */
+/* Returns -1.0 for grey, additive, or any profiles < 4 channels. */
+/* This is a place holder that uses a heuristic, */
+/* until there is a private or standard tag for this information */
+static double icm_get_tac( /* return TAC */
+icc *p,
+double *chmax, /* device return channel sums. May be NULL */
+void (*calfunc)(void *cntx, double *out, double *in), /* Optional calibration func. */
+void *cntx
+) {
+ icmHeader *rh = p->header;
+ icmLuBase *luo;
+ icmLuLut *ll;
+ icmLut *lut;
+ icColorSpaceSignature outs; /* Type of output space */
+ int inn, outn; /* Number of components */
+ icmLuAlgType alg; /* Type of lookup algorithm */
+ double tac = 0.0;
+ double max[MAX_CHAN]; /* Channel maximums */
+ int i, f;
+ unsigned int uf;
+ int size; /* Lut table size */
+ double *gp; /* Pointer to grid cube base */
+
+ /* If not something that can really have a TAC */
+ if (rh->deviceClass != icSigDisplayClass
+ && rh->deviceClass != icSigOutputClass
+ && rh->deviceClass != icSigLinkClass) {
+ return -1.0;
+ }
+
+ /* If not a suitable color space */
+ switch (rh->colorSpace) {
+ /* Not applicable */
+ case icSigXYZData:
+ case icSigLabData:
+ case icSigLuvData:
+ case icSigYCbCrData:
+ case icSigYxyData:
+ case icSigHsvData:
+ case icSigHlsData:
+ return -1.0;
+
+ /* Assume no limit */
+ case icSigGrayData:
+ case icSig2colorData:
+ case icSig3colorData:
+ case icSigRgbData:
+ return -1.0;
+
+ default:
+ break;
+ }
+
+ /* Get a PCS->device colorimetric lookup */
+ if ((luo = p->get_luobj(p, icmBwd, icRelativeColorimetric, icmSigDefaultData, icmLuOrdNorm)) == NULL) {
+ if ((luo = p->get_luobj(p, icmBwd, icmDefaultIntent, icmSigDefaultData, icmLuOrdNorm)) == NULL) {
+ return -1.0;
+ }
+ }
+
+ /* Get details of conversion (Arguments may be NULL if info not needed) */
+ luo->spaces(luo, NULL, &inn, &outs, &outn, &alg, NULL, NULL, NULL, NULL);
+
+ /* Assume any non-Lut type doesn't have a TAC */
+ if (alg != icmLutType) {
+ return -1.0;
+ }
+
+ ll = (icmLuLut *)luo;
+
+ /* We have a Lut type. Search the lut for the largest values */
+ for (f = 0; f < outn; f++)
+ max[f] = 0.0;
+
+ lut = ll->lut;
+ gp = lut->clutTable; /* Base of grid array */
+ size = sat_pow(lut->clutPoints,lut->inputChan);
+ for (i = 0; i < size; i++) {
+ double tot, vv[MAX_CHAN];
+
+ lut->lookup_output(lut,vv,gp); /* Lookup though output tables */
+ ll->out_denormf(vv,vv); /* Normalize for output color space */
+
+ if (calfunc != NULL)
+ calfunc(cntx, vv, vv); /* Apply device calibration */
+
+ for (tot = 0.0, uf = 0; uf < lut->outputChan; uf++) {
+ tot += vv[uf];
+ if (vv[uf] > max[uf])
+ max[uf] = vv[uf];
+ }
+ if (tot > tac)
+ tac = tot;
+ gp += lut->outputChan;
+ }
+
+ if (chmax != NULL) {
+ for (f = 0; f < outn; f++)
+ chmax[f] = max[f];
+ }
+
+ luo->del(luo);
+
+ return tac;
+}
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - */
+
+/* Create an empty object. Return NULL on error */
+icc *new_icc_a(
+icmAlloc *al /* Memory allocator */
+) {
+ unsigned int i;
+ icc *p;
+
+ if ((p = (icc *) al->calloc(al, 1,sizeof(icc))) == NULL) {
+ return NULL;
+ }
+ p->ver = 0; /* default is V2 profile */
+
+ p->al = al; /* Heap allocator */
+
+ p->get_rfp = icc_get_rfp;
+ p->set_version = icc_set_version;
+ p->get_size = icc_get_size;
+ p->read = icc_read;
+ p->read_x = icc_read_x;
+ p->write = icc_write;
+ p->write_x = icc_write_x;
+ p->dump = icc_dump;
+ p->del = icc_delete;
+ p->add_tag = icc_add_tag;
+ p->link_tag = icc_link_tag;
+ p->find_tag = icc_find_tag;
+ p->read_tag = icc_read_tag;
+ p->read_tag_any = icc_read_tag_any;
+ p->rename_tag = icc_rename_tag;
+ p->unread_tag = icc_unread_tag;
+ p->read_all_tags = icc_read_all_tags;
+ p->delete_tag = icc_delete_tag;
+ p->check_id = icc_check_id;
+ p->get_tac = icm_get_tac;
+ p->get_luobj = icc_get_luobj;
+ p->new_clutluobj = icc_new_icmLuLut;
+
+#if defined(__IBMC__) && defined(_M_IX86)
+ _control87(EM_UNDERFLOW, EM_UNDERFLOW);
+#endif
+
+ /* Allocate a header object */
+ if ((p->header = new_icmHeader(p)) == NULL) {
+ al->free(al, p);
+ return NULL;
+ }
+
+ /* Values that must be set before writing */
+ p->header->deviceClass = icMaxEnumClass;/* Type of profile - must be set! */
+ p->header->colorSpace = icMaxEnumData; /* Clr space of data - must be set! */
+ p->header->pcs = icMaxEnumData; /* PCS: XYZ or Lab - must be set! */
+ p->header->renderingIntent = icMaxEnumIntent; /* Rendering intent - must be set ! */
+
+ /* Values that should be set before writing */
+ p->header->manufacturer = -1; /* Dev manufacturer - should be set ! */
+ p->header->model = -1; /* Dev model number - should be set ! */
+ p->header->attributes.l = 0; /* ICC Device attributes - should set ! */
+ p->header->flags = 0; /* Embedding flags - should be set ! */
+
+ /* Values that may be set before writing */
+ p->header->attributes.h = 0; /* Dev Device attributes - may be set ! */
+ p->header->creator = str2tag("argl"); /* Profile creator - Argyll - may be set ! */
+
+ /* Init default values in header */
+ p->header->cmmId = str2tag("argl"); /* CMM for profile - Argyll CMM */
+ p->header->majv = 2; /* Current version 2.2.0 */
+ p->header->minv = 2;
+ p->header->bfv = 0;
+ setcur_DateTimeNumber(&p->header->date);/* Creation Date */
+ p->header->platform = icSigMicrosoft; /* Primary Platform */
+ p->header->illuminant = icmD50; /* Profile illuminant - D50 */
+
+ /* Values that will be created automatically */
+ for (i = 0; i < 16; i++)
+ p->header->id[i] = 0;
+
+ return p;
+}
+
+
+/* ---------------------------------------------------------- */
+/* Print an int vector to a string. */
+/* Returned static buffer is re-used every 5 calls. */
+char *icmPiv(int di, int *p) {
+ static char buf[5][MAX_CHAN * 16];
+ static int ix = 0;
+ int e;
+ char *bp;
+
+ if (++ix >= 5)
+ ix = 0;
+ bp = buf[ix];
+
+ if (di > MAX_CHAN)
+ di = MAX_CHAN; /* Make sure that buf isn't overrun */
+
+ for (e = 0; e < di; e++) {
+ if (e > 0)
+ *bp++ = ' ';
+ sprintf(bp, "%d", p[e]); bp += strlen(bp);
+ }
+ return buf[ix];
+}
+
+/* Print a double color vector to a string. */
+/* Returned static buffer is re-used every 5 calls. */
+char *icmPdv(int di, double *p) {
+ static char buf[5][MAX_CHAN * 16];
+ static int ix = 0;
+ int e;
+ char *bp;
+
+ if (++ix >= 5)
+ ix = 0;
+ bp = buf[ix];
+
+ if (di > MAX_CHAN)
+ di = MAX_CHAN; /* Make sure that buf isn't overrun */
+
+ for (e = 0; e < di; e++) {
+ if (e > 0)
+ *bp++ = ' ';
+ sprintf(bp, "%f", p[e]); bp += strlen(bp);
+ }
+ return buf[ix];
+}
+
+/* Print a float color vector to a string. */
+/* Returned static buffer is re-used every 5 calls. */
+char *icmPfv(int di, float *p) {
+ static char buf[5][MAX_CHAN * 16];
+ static int ix = 0;
+ int e;
+ char *bp;
+
+ if (++ix >= 5)
+ ix = 0;
+ bp = buf[ix];
+
+ if (di > MAX_CHAN)
+ di = MAX_CHAN; /* Make sure that buf isn't overrun */
+
+ for (e = 0; e < di; e++) {
+ if (e > 0)
+ *bp++ = ' ';
+ sprintf(bp, "%f", p[e]); bp += strlen(bp);
+ }
+ return buf[ix];
+}
+
+/* Print an 0..1 range XYZ as a D50 Lab string */
+/* Returned static buffer is re-used every 5 calls. */
+char *icmPLab(double *p) {
+ static char buf[5][MAX_CHAN * 16];
+ static int ix = 0;
+ int e;
+ char *bp;
+ double lab[3];
+
+ if (++ix >= 5)
+ ix = 0;
+ bp = buf[ix];
+
+ icmXYZ2Lab(&icmD50, lab, p);
+
+ for (e = 0; e < 3; e++) {
+ if (e > 0)
+ *bp++ = ' ';
+ sprintf(bp, "%f", lab[e]); bp += strlen(bp);
+ }
+ return buf[ix];
+}
+
+
+/* ---------------------------------------------------------- */
+