state from 2014-09-07 13:30 MESZ

1 files changed, 0 insertions, 17833 deletions

diff --git a/.pc/04_CVE-2012-4405.diff/icc/icc.c b/.pc/04_CVE-2012-4405.diff/icc/icc.c
deleted file mode 100644
index 68668d0..0000000
--- a/.pc/04_CVE-2012-4405.diff/icc/icc.c
+++ /dev/null
@@ -1,17833 +0,0 @@
-
-/* 
- * 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];
-}
-
-
-/* ---------------------------------------------------------- */
-