The Tor Browser / file revision

 /* vim: set ts=8 sw=8 noexpandtab: */

 //  qcms

 //  Copyright (C) 2009 Mozilla Foundation

 //  Copyright (C) 1998-2007 Marti Maria

 //

 // Permission is hereby granted, free of charge, to any person obtaining 

 // a copy of this software and associated documentation files (the "Software"), 

 // to deal in the Software without restriction, including without limitation 

 // the rights to use, copy, modify, merge, publish, distribute, sublicense, 

 // and/or sell copies of the Software, and to permit persons to whom the Software 

 // is furnished to do so, subject to the following conditions:

 //

 // The above copyright notice and this permission notice shall be included in 

 // all copies or substantial portions of the Software.

 //

 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 

 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO 

 // THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 

 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE 

 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 

 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION 

 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 #include <math.h>

 #include <assert.h>

 #include <stdlib.h>

 #include <string.h> //memset

 #include "qcmsint.h"

 /* It might be worth having a unified limit on content controlled

  * allocation per profile. This would remove the need for many

  * of the arbitrary limits that we used */

 typedef uint32_t be32;

 typedef uint16_t be16;

 static be32 cpu_to_be32(uint32_t v)

 {

 #ifdef IS_LITTLE_ENDIAN

 	return ((v & 0xff) << 24) | ((v & 0xff00) << 8) | ((v & 0xff0000) >> 8) | ((v & 0xff000000) >> 24);

 #else

 	return v;

 #endif

 }

 static be16 cpu_to_be16(uint16_t v)

 {

 #ifdef IS_LITTLE_ENDIAN

 	return ((v & 0xff) << 8) | ((v & 0xff00) >> 8);

 #else

 	return v;

 #endif

 }

 static uint32_t be32_to_cpu(be32 v)

 {

 #ifdef IS_LITTLE_ENDIAN

 	return ((v & 0xff) << 24) | ((v & 0xff00) << 8) | ((v & 0xff0000) >> 8) | ((v & 0xff000000) >> 24);

 	//return __builtin_bswap32(v);

 #else

 	return v;

 #endif

 }

 static uint16_t be16_to_cpu(be16 v)

 {

 #ifdef IS_LITTLE_ENDIAN

 	return ((v & 0xff) << 8) | ((v & 0xff00) >> 8);

 #else

 	return v;

 #endif

 }

 /* a wrapper around the memory that we are going to parse

  * into a qcms_profile */

 struct mem_source

 {

 	const unsigned char *buf;

 	size_t size;

 	qcms_bool valid;

 	const char *invalid_reason;

 };

 static void invalid_source(struct mem_source *mem, const char *reason)

 {

 	mem->valid = false;

 	mem->invalid_reason = reason;

 }

 static uint32_t read_u32(struct mem_source *mem, size_t offset)

 {

 	/* Subtract from mem->size instead of the more intuitive adding to offset.

 	 * This avoids overflowing offset. The subtraction is safe because

 	 * mem->size is guaranteed to be > 4 */

 	if (offset > mem->size - 4) {

 		invalid_source(mem, "Invalid offset");

 		return 0;

 	} else {

 		be32 k;

 		memcpy(&k, mem->buf + offset, sizeof(k));

 		return be32_to_cpu(k);

 	}

 }

 static uint16_t read_u16(struct mem_source *mem, size_t offset)

 {

 	if (offset > mem->size - 2) {

 		invalid_source(mem, "Invalid offset");

 		return 0;

 	} else {

 		be16 k;

 		memcpy(&k, mem->buf + offset, sizeof(k));

 		return be16_to_cpu(k);

 	}

 }

 static uint8_t read_u8(struct mem_source *mem, size_t offset)

 {

 	if (offset > mem->size - 1) {

 		invalid_source(mem, "Invalid offset");

 		return 0;

 	} else {

 		return *(uint8_t*)(mem->buf + offset);

 	}

 }

 static s15Fixed16Number read_s15Fixed16Number(struct mem_source *mem, size_t offset)

 {

 	return read_u32(mem, offset);

 }

 static uInt8Number read_uInt8Number(struct mem_source *mem, size_t offset)

 {

 	return read_u8(mem, offset);

 }

 static uInt16Number read_uInt16Number(struct mem_source *mem, size_t offset)

 {

 	return read_u16(mem, offset);

 }

 static void write_u32(void *mem, size_t offset, uint32_t value)

 {

     *((uint32_t *)((unsigned char*)mem + offset)) = cpu_to_be32(value);

 }

 static void write_u16(void *mem, size_t offset, uint16_t value)

 {

     *((uint16_t *)((unsigned char*)mem + offset)) = cpu_to_be16(value);

 }

 #define BAD_VALUE_PROFILE NULL

 #define INVALID_PROFILE NULL

 #define NO_MEM_PROFILE NULL

 /* An arbitrary 4MB limit on profile size */

 #define MAX_PROFILE_SIZE 1024*1024*4

 #define MAX_TAG_COUNT 1024

 static void check_CMM_type_signature(struct mem_source *src)

 {

 	//uint32_t CMM_type_signature = read_u32(src, 4);

 	//TODO: do the check?

 }

 static void check_profile_version(struct mem_source *src)

 {

 	/*

 	uint8_t major_revision = read_u8(src, 8 + 0);

 	uint8_t minor_revision = read_u8(src, 8 + 1);

 	*/

 	uint8_t reserved1      = read_u8(src, 8 + 2);

 	uint8_t reserved2      = read_u8(src, 8 + 3);

 	/* Checking the version doesn't buy us anything

 	if (major_revision != 0x4) {

 		if (major_revision > 0x2)

 			invalid_source(src, "Unsupported major revision");

 		if (minor_revision > 0x40)

 			invalid_source(src, "Unsupported minor revision");

 	}

 	*/

 	if (reserved1 != 0 || reserved2 != 0)

 		invalid_source(src, "Invalid reserved bytes");

 }

 #define INPUT_DEVICE_PROFILE   0x73636e72 // 'scnr'

 #define DISPLAY_DEVICE_PROFILE 0x6d6e7472 // 'mntr'

 #define OUTPUT_DEVICE_PROFILE  0x70727472 // 'prtr'

 #define DEVICE_LINK_PROFILE    0x6c696e6b // 'link'

 #define COLOR_SPACE_PROFILE    0x73706163 // 'spac'

 #define ABSTRACT_PROFILE       0x61627374 // 'abst'

 #define NAMED_COLOR_PROFILE    0x6e6d636c // 'nmcl'

 static void read_class_signature(qcms_profile *profile, struct mem_source *mem)

 {

 	profile->class = read_u32(mem, 12);

 	switch (profile->class) {

 		case DISPLAY_DEVICE_PROFILE:

 		case INPUT_DEVICE_PROFILE:

 		case OUTPUT_DEVICE_PROFILE:

 		case COLOR_SPACE_PROFILE:

 			break;

 		default:

 			invalid_source(mem, "Invalid  Profile/Device Class signature");

 	}

 }

 static void read_color_space(qcms_profile *profile, struct mem_source *mem)

 {

 	profile->color_space = read_u32(mem, 16);

 	switch (profile->color_space) {

 		case RGB_SIGNATURE:

 		case GRAY_SIGNATURE:

 			break;

 		default:

 			invalid_source(mem, "Unsupported colorspace");

 	}

 }

 static void read_pcs(qcms_profile *profile, struct mem_source *mem)

 {

 	profile->pcs = read_u32(mem, 20);

 	switch (profile->pcs) {

 		case XYZ_SIGNATURE:

 		case LAB_SIGNATURE:

 			break;

 		default:

 			invalid_source(mem, "Unsupported pcs");

 	}

 }

 struct tag

 {

 	uint32_t signature;

 	uint32_t offset;

 	uint32_t size;

 };

 struct tag_index {

 	uint32_t count;

 	struct tag *tags;

 };

 static struct tag_index read_tag_table(qcms_profile *profile, struct mem_source *mem)

 {

 	struct tag_index index = {0, NULL};

 	unsigned int i;

 	index.count = read_u32(mem, 128);

 	if (index.count > MAX_TAG_COUNT) {

 		invalid_source(mem, "max number of tags exceeded");

 		return index;

 	}

 	index.tags = malloc(sizeof(struct tag)*index.count);

 	if (index.tags) {

 		for (i = 0; i < index.count; i++) {

 			index.tags[i].signature = read_u32(mem, 128 + 4 + 4*i*3);

 			index.tags[i].offset    = read_u32(mem, 128 + 4 + 4*i*3 + 4);

 			index.tags[i].size      = read_u32(mem, 128 + 4 + 4*i*3 + 8);

 		}

 	}

 	return index;

 }

 // Checks a profile for obvious inconsistencies and returns

 // true if the profile looks bogus and should probably be

 // ignored.

 qcms_bool qcms_profile_is_bogus(qcms_profile *profile)

 {

        float sum[3], target[3], tolerance[3];

        float rX, rY, rZ, gX, gY, gZ, bX, bY, bZ;

        bool negative;

        unsigned i;

        // We currently only check the bogosity of RGB profiles

        if (profile->color_space != RGB_SIGNATURE)

 	       return false;

        if (profile->A2B0 || profile->B2A0)

                return false;

        rX = s15Fixed16Number_to_float(profile->redColorant.X);

        rY = s15Fixed16Number_to_float(profile->redColorant.Y);

        rZ = s15Fixed16Number_to_float(profile->redColorant.Z);

        gX = s15Fixed16Number_to_float(profile->greenColorant.X);

        gY = s15Fixed16Number_to_float(profile->greenColorant.Y);

        gZ = s15Fixed16Number_to_float(profile->greenColorant.Z);

        bX = s15Fixed16Number_to_float(profile->blueColorant.X);

        bY = s15Fixed16Number_to_float(profile->blueColorant.Y);

        bZ = s15Fixed16Number_to_float(profile->blueColorant.Z);

        // Check if any of the XYZ values are negative (see mozilla bug 498245)

        // CIEXYZ tristimulus values cannot be negative according to the spec.

        negative =

 	       (rX < 0) || (rY < 0) || (rZ < 0) ||

 	       (gX < 0) || (gY < 0) || (gZ < 0) ||

 	       (bX < 0) || (bY < 0) || (bZ < 0);

        if (negative)

 	       return true;

        // Sum the values; they should add up to something close to white

        sum[0] = rX + gX + bX;

        sum[1] = rY + gY + bY;

        sum[2] = rZ + gZ + bZ;

        // Build our target vector (see mozilla bug 460629)

        target[0] = 0.96420;

        target[1] = 1.00000;

        target[2] = 0.82491;

        // Our tolerance vector - Recommended by Chris Murphy based on

        // conversion from the LAB space criterion of no more than 3 in any one

        // channel. This is similar to, but slightly more tolerant than Adobe's

        // criterion.

        tolerance[0] = 0.02;

        tolerance[1] = 0.02;

        tolerance[2] = 0.04;

        // Compare with our tolerance

        for (i = 0; i < 3; ++i) {

            if (!(((sum[i] - tolerance[i]) <= target[i]) &&

                  ((sum[i] + tolerance[i]) >= target[i])))

                return true;

        }

        // All Good

        return false;

 }

 #define TAG_bXYZ 0x6258595a

 #define TAG_gXYZ 0x6758595a

 #define TAG_rXYZ 0x7258595a

 #define TAG_rTRC 0x72545243

 #define TAG_bTRC 0x62545243

 #define TAG_gTRC 0x67545243

 #define TAG_kTRC 0x6b545243

 #define TAG_A2B0 0x41324230

 #define TAG_B2A0 0x42324130

 #define TAG_CHAD 0x63686164

 static struct tag *find_tag(struct tag_index index, uint32_t tag_id)

 {

 	unsigned int i;

 	struct tag *tag = NULL;

 	for (i = 0; i < index.count; i++) {

 		if (index.tags[i].signature == tag_id) {

 			return &index.tags[i];

 		}

 	}

 	return tag;

 }

 #define XYZ_TYPE		0x58595a20 // 'XYZ '

 #define CURVE_TYPE		0x63757276 // 'curv'

 #define PARAMETRIC_CURVE_TYPE	0x70617261 // 'para'

 #define LUT16_TYPE		0x6d667432 // 'mft2'

 #define LUT8_TYPE		0x6d667431 // 'mft1'

 #define LUT_MAB_TYPE		0x6d414220 // 'mAB '

 #define LUT_MBA_TYPE		0x6d424120 // 'mBA '

 #define CHROMATIC_TYPE		0x73663332 // 'sf32'

 static struct matrix read_tag_s15Fixed16ArrayType(struct mem_source *src, struct tag_index index, uint32_t tag_id)

 {

 	struct tag *tag = find_tag(index, tag_id);

 	struct matrix matrix;

 	if (tag) {

 		uint8_t i;

 		uint32_t offset = tag->offset;

 		uint32_t type = read_u32(src, offset);

 		// Check mandatory type signature for s16Fixed16ArrayType

 		if (type != CHROMATIC_TYPE) {

 			invalid_source(src, "unexpected type, expected 'sf32'");

 		}

 		for (i = 0; i < 9; i++) {

 			matrix.m[i/3][i%3] = s15Fixed16Number_to_float(read_s15Fixed16Number(src, offset+8+i*4));

 		}

 		matrix.invalid = false;

 	} else {

 		matrix.invalid = true;

 		invalid_source(src, "missing sf32tag");

 	}

 	return matrix;

 }

 static struct XYZNumber read_tag_XYZType(struct mem_source *src, struct tag_index index, uint32_t tag_id)

 {

 	struct XYZNumber num = {0, 0, 0};

 	struct tag *tag = find_tag(index, tag_id);

 	if (tag) {

 		uint32_t offset = tag->offset;

 		uint32_t type = read_u32(src, offset);

 		if (type != XYZ_TYPE)

 			invalid_source(src, "unexpected type, expected XYZ");

 		num.X = read_s15Fixed16Number(src, offset+8);

 		num.Y = read_s15Fixed16Number(src, offset+12);

 		num.Z = read_s15Fixed16Number(src, offset+16);

 	} else {

 		invalid_source(src, "missing xyztag");

 	}

 	return num;

 }

 // Read the tag at a given offset rather then the tag_index. 

 // This method is used when reading mAB tags where nested curveType are

 // present that are not part of the tag_index.

 static struct curveType *read_curveType(struct mem_source *src, uint32_t offset, uint32_t *len)

 {

 	static const uint32_t COUNT_TO_LENGTH[5] = {1, 3, 4, 5, 7};

 	struct curveType *curve = NULL;

 	uint32_t type = read_u32(src, offset);

 	uint32_t count;

 	uint32_t i;

 	if (type != CURVE_TYPE && type != PARAMETRIC_CURVE_TYPE) {

 		invalid_source(src, "unexpected type, expected CURV or PARA");

 		return NULL;

 	}

 	if (type == CURVE_TYPE) {

 		count = read_u32(src, offset+8);

 #define MAX_CURVE_ENTRIES 40000 //arbitrary

 		if (count > MAX_CURVE_ENTRIES) {

 			invalid_source(src, "curve size too large");

 			return NULL;

 		}

 		curve = malloc(sizeof(struct curveType) + sizeof(uInt16Number)*count);

 		if (!curve)

 			return NULL;

 		curve->count = count;

 		curve->type = CURVE_TYPE;

 		for (i=0; i<count; i++) {

 			curve->data[i] = read_u16(src, offset + 12 + i*2);

 		}

 		*len = 12 + count * 2;

 	} else { //PARAMETRIC_CURVE_TYPE

 		count = read_u16(src, offset+8);

 		if (count > 4) {

 			invalid_source(src, "parametric function type not supported.");

 			return NULL;

 		}

 		curve = malloc(sizeof(struct curveType));

 		if (!curve)

 			return NULL;

 		curve->count = count;

 		curve->type = PARAMETRIC_CURVE_TYPE;

 		for (i=0; i < COUNT_TO_LENGTH[count]; i++) {

 			curve->parameter[i] = s15Fixed16Number_to_float(read_s15Fixed16Number(src, offset + 12 + i*4));	

 		}

 		*len = 12 + COUNT_TO_LENGTH[count] * 4;

 		if ((count == 1 || count == 2)) {

 			/* we have a type 1 or type 2 function that has a division by 'a' */

 			float a = curve->parameter[1];

 			if (a == 0.f)

 				invalid_source(src, "parametricCurve definition causes division by zero.");

 		}

 	}

 	return curve;

 }

 static struct curveType *read_tag_curveType(struct mem_source *src, struct tag_index index, uint32_t tag_id)

 {

 	struct tag *tag = find_tag(index, tag_id);

 	struct curveType *curve = NULL;

 	if (tag) {

 		uint32_t len;

 		return read_curveType(src, tag->offset, &len);

 	} else {

 		invalid_source(src, "missing curvetag");

 	}

 	return curve;

 }

 #define MAX_CLUT_SIZE 500000 // arbitrary

 #define MAX_CHANNELS 10 // arbitrary

 static void read_nested_curveType(struct mem_source *src, struct curveType *(*curveArray)[MAX_CHANNELS], uint8_t num_channels, uint32_t curve_offset)

 {

 	uint32_t channel_offset = 0;

 	int i;

 	for (i = 0; i < num_channels; i++) {

 		uint32_t tag_len;

 		(*curveArray)[i] = read_curveType(src, curve_offset + channel_offset, &tag_len);

 		if (!(*curveArray)[i]) {

 			invalid_source(src, "invalid nested curveType curve");

 		}

 		channel_offset += tag_len;

 		// 4 byte aligned

 		if ((tag_len % 4) != 0)

 			channel_offset += 4 - (tag_len % 4);

 	}

 }

 static void mAB_release(struct lutmABType *lut)

 {

 	uint8_t i;

 	for (i = 0; i < lut->num_in_channels; i++){

 		free(lut->a_curves[i]);

 	}

 	for (i = 0; i < lut->num_out_channels; i++){

 		free(lut->b_curves[i]);

 		free(lut->m_curves[i]);

 	}

 	free(lut);

 }

 /* See section 10.10 for specs */

 static struct lutmABType *read_tag_lutmABType(struct mem_source *src, struct tag_index index, uint32_t tag_id)

 {

 	struct tag *tag = find_tag(index, tag_id);

 	uint32_t offset = tag->offset;

 	uint32_t a_curve_offset, b_curve_offset, m_curve_offset;

 	uint32_t matrix_offset;

 	uint32_t clut_offset;

 	uint32_t clut_size = 1;

 	uint8_t clut_precision;

 	uint32_t type = read_u32(src, offset);

 	uint8_t num_in_channels, num_out_channels;

 	struct lutmABType *lut;

 	uint32_t i;

 	if (type != LUT_MAB_TYPE && type != LUT_MBA_TYPE) {

 		return NULL;

 	}

 	num_in_channels = read_u8(src, offset + 8);

 	num_out_channels = read_u8(src, offset + 8);

 	if (num_in_channels > MAX_CHANNELS || num_out_channels > MAX_CHANNELS)

 		return NULL;

 	// We require 3in/out channels since we only support RGB->XYZ (or RGB->LAB)

 	// XXX: If we remove this restriction make sure that the number of channels

 	//      is less or equal to the maximum number of mAB curves in qcmsint.h

 	//      also check for clut_size overflow.

 	if (num_in_channels != 3 || num_out_channels != 3)

 		return NULL;

 	// some of this data is optional and is denoted by a zero offset

 	// we also use this to track their existance

 	a_curve_offset = read_u32(src, offset + 28);

 	clut_offset = read_u32(src, offset + 24);

 	m_curve_offset = read_u32(src, offset + 20);

 	matrix_offset = read_u32(src, offset + 16);

 	b_curve_offset = read_u32(src, offset + 12);

 	// Convert offsets relative to the tag to relative to the profile

 	// preserve zero for optional fields

 	if (a_curve_offset)

 		a_curve_offset += offset;

 	if (clut_offset)

 		clut_offset += offset;

 	if (m_curve_offset)

 		m_curve_offset += offset;

 	if (matrix_offset)

 		matrix_offset += offset;

 	if (b_curve_offset)

 		b_curve_offset += offset;

 	if (clut_offset) {

 		assert (num_in_channels == 3);

 		// clut_size can not overflow since lg(256^num_in_channels) = 24 bits.

 		for (i = 0; i < num_in_channels; i++) {

 			clut_size *= read_u8(src, clut_offset + i);

 		}

 	} else {

 		clut_size = 0;

 	}

 	// 24bits * 3 won't overflow either

 	clut_size = clut_size * num_out_channels;

 	if (clut_size > MAX_CLUT_SIZE)

 		return NULL;

 	lut = malloc(sizeof(struct lutmABType) + (clut_size) * sizeof(float));

 	if (!lut)

 		return NULL;

 	// we'll fill in the rest below

 	memset(lut, 0, sizeof(struct lutmABType));

 	lut->clut_table   = &lut->clut_table_data[0];

 	for (i = 0; i < num_in_channels; i++) {

 		lut->num_grid_points[i] = read_u8(src, clut_offset + i);

 	}

 	// Reverse the processing of transformation elements for mBA type.

 	lut->reversed = (type == LUT_MBA_TYPE);

 	lut->num_in_channels = num_in_channels;

 	lut->num_out_channels = num_out_channels;

 	if (matrix_offset) {

 		// read the matrix if we have it

 		lut->e00 = read_s15Fixed16Number(src, matrix_offset+4*0);

 		lut->e01 = read_s15Fixed16Number(src, matrix_offset+4*1);

 		lut->e02 = read_s15Fixed16Number(src, matrix_offset+4*2);

 		lut->e10 = read_s15Fixed16Number(src, matrix_offset+4*3);

 		lut->e11 = read_s15Fixed16Number(src, matrix_offset+4*4);

 		lut->e12 = read_s15Fixed16Number(src, matrix_offset+4*5);

 		lut->e20 = read_s15Fixed16Number(src, matrix_offset+4*6);

 		lut->e21 = read_s15Fixed16Number(src, matrix_offset+4*7);

 		lut->e22 = read_s15Fixed16Number(src, matrix_offset+4*8);

 		lut->e03 = read_s15Fixed16Number(src, matrix_offset+4*9);

 		lut->e13 = read_s15Fixed16Number(src, matrix_offset+4*10);

 		lut->e23 = read_s15Fixed16Number(src, matrix_offset+4*11);

 	}

 	if (a_curve_offset) {

 		read_nested_curveType(src, &lut->a_curves, num_in_channels, a_curve_offset);

 	}

 	if (m_curve_offset) {

 		read_nested_curveType(src, &lut->m_curves, num_out_channels, m_curve_offset);

 	}

 	if (b_curve_offset) {

 		read_nested_curveType(src, &lut->b_curves, num_out_channels, b_curve_offset);

 	} else {

 		invalid_source(src, "B curves required");

 	}

 	if (clut_offset) {

 		clut_precision = read_u8(src, clut_offset + 16);

 		if (clut_precision == 1) {

 			for (i = 0; i < clut_size; i++) {

 				lut->clut_table[i] = uInt8Number_to_float(read_uInt8Number(src, clut_offset + 20 + i*1));

 			}

 		} else if (clut_precision == 2) {

 			for (i = 0; i < clut_size; i++) {

 				lut->clut_table[i] = uInt16Number_to_float(read_uInt16Number(src, clut_offset + 20 + i*2));

 			}

 		} else {

 			invalid_source(src, "Invalid clut precision");

 		}

 	}

 	if (!src->valid) {

 		mAB_release(lut);

 		return NULL;

 	}

 	return lut;

 }

 static struct lutType *read_tag_lutType(struct mem_source *src, struct tag_index index, uint32_t tag_id)

 {

 	struct tag *tag = find_tag(index, tag_id);

 	uint32_t offset = tag->offset;

 	uint32_t type = read_u32(src, offset);

 	uint16_t num_input_table_entries;

 	uint16_t num_output_table_entries;

 	uint8_t in_chan, grid_points, out_chan;

 	uint32_t clut_offset, output_offset;

 	uint32_t clut_size;

 	size_t entry_size;

 	struct lutType *lut;

 	uint32_t i;

 	/* I'm not sure why the spec specifies a fixed number of entries for LUT8 tables even though

 	 * they have room for the num_entries fields */

 	if (type == LUT8_TYPE) {

 		num_input_table_entries = 256;

 		num_output_table_entries = 256;

 		entry_size = 1;

 	} else if (type == LUT16_TYPE) {

 		num_input_table_entries  = read_u16(src, offset + 48);

 		num_output_table_entries = read_u16(src, offset + 50);

 		entry_size = 2;

 	} else {

 		assert(0); // the caller checks that this doesn't happen

 		invalid_source(src, "Unexpected lut type");

 		return NULL;

 	}

 	in_chan     = read_u8(src, offset + 8);

 	out_chan    = read_u8(src, offset + 9);

 	grid_points = read_u8(src, offset + 10);

 	clut_size = pow(grid_points, in_chan);

 	if (clut_size > MAX_CLUT_SIZE) {

 		return NULL;

 	}

 	if (in_chan != 3 || out_chan != 3) {

 		return NULL;

 	}

 	lut = malloc(sizeof(struct lutType) + (num_input_table_entries * in_chan + clut_size*out_chan + num_output_table_entries * out_chan)*sizeof(float));

 	if (!lut) {

 		return NULL;

 	}

 	/* compute the offsets of tables */

 	lut->input_table  = &lut->table_data[0];

 	lut->clut_table   = &lut->table_data[in_chan*num_input_table_entries];

 	lut->output_table = &lut->table_data[in_chan*num_input_table_entries + clut_size*out_chan];

 	lut->num_input_table_entries  = num_input_table_entries;

 	lut->num_output_table_entries = num_output_table_entries;

 	lut->num_input_channels   = read_u8(src, offset + 8);

 	lut->num_output_channels  = read_u8(src, offset + 9);

 	lut->num_clut_grid_points = read_u8(src, offset + 10);

 	lut->e00 = read_s15Fixed16Number(src, offset+12);

 	lut->e01 = read_s15Fixed16Number(src, offset+16);

 	lut->e02 = read_s15Fixed16Number(src, offset+20);

 	lut->e10 = read_s15Fixed16Number(src, offset+24);

 	lut->e11 = read_s15Fixed16Number(src, offset+28);

 	lut->e12 = read_s15Fixed16Number(src, offset+32);

 	lut->e20 = read_s15Fixed16Number(src, offset+36);

 	lut->e21 = read_s15Fixed16Number(src, offset+40);

 	lut->e22 = read_s15Fixed16Number(src, offset+44);

 	for (i = 0; i < lut->num_input_table_entries * in_chan; i++) {

 		if (type == LUT8_TYPE) {

 			lut->input_table[i] = uInt8Number_to_float(read_uInt8Number(src, offset + 52 + i * entry_size));

 		} else {

 			lut->input_table[i] = uInt16Number_to_float(read_uInt16Number(src, offset + 52 + i * entry_size));

 		}

 	}

 	clut_offset = offset + 52 + lut->num_input_table_entries * in_chan * entry_size;

 	for (i = 0; i < clut_size * out_chan; i+=3) {

 		if (type == LUT8_TYPE) {

 			lut->clut_table[i+0] = uInt8Number_to_float(read_uInt8Number(src, clut_offset + i*entry_size + 0));

 			lut->clut_table[i+1] = uInt8Number_to_float(read_uInt8Number(src, clut_offset + i*entry_size + 1));

 			lut->clut_table[i+2] = uInt8Number_to_float(read_uInt8Number(src, clut_offset + i*entry_size + 2));

 		} else {

 			lut->clut_table[i+0] = uInt16Number_to_float(read_uInt16Number(src, clut_offset + i*entry_size + 0));

 			lut->clut_table[i+1] = uInt16Number_to_float(read_uInt16Number(src, clut_offset + i*entry_size + 2));

 			lut->clut_table[i+2] = uInt16Number_to_float(read_uInt16Number(src, clut_offset + i*entry_size + 4));

 		}

 	}

 	output_offset = clut_offset + clut_size * out_chan * entry_size;

 	for (i = 0; i < lut->num_output_table_entries * out_chan; i++) {

 		if (type == LUT8_TYPE) {

 			lut->output_table[i] = uInt8Number_to_float(read_uInt8Number(src, output_offset + i*entry_size));

 		} else {

 			lut->output_table[i] = uInt16Number_to_float(read_uInt16Number(src, output_offset + i*entry_size));

 		}

 	}

 	return lut;

 }

 static void read_rendering_intent(qcms_profile *profile, struct mem_source *src)

 {

 	profile->rendering_intent = read_u32(src, 64);

 	switch (profile->rendering_intent) {

 		case QCMS_INTENT_PERCEPTUAL:

 		case QCMS_INTENT_SATURATION:

 		case QCMS_INTENT_RELATIVE_COLORIMETRIC:

 		case QCMS_INTENT_ABSOLUTE_COLORIMETRIC:

 			break;

 		default:

 			invalid_source(src, "unknown rendering intent");

 	}

 }

 qcms_profile *qcms_profile_create(void)

 {

 	return calloc(sizeof(qcms_profile), 1);

 }

 /* build sRGB gamma table */

 /* based on cmsBuildParametricGamma() */

 static uint16_t *build_sRGB_gamma_table(int num_entries)

 {

 	int i;

 	/* taken from lcms: Build_sRGBGamma() */

 	double gamma = 2.4;

 	double a = 1./1.055;

 	double b = 0.055/1.055;

 	double c = 1./12.92;

 	double d = 0.04045;

 	uint16_t *table = malloc(sizeof(uint16_t) * num_entries);

 	if (!table)

 		return NULL;

 	for (i=0; i<num_entries; i++) {

 		double x = (double)i / (num_entries-1);

 		double y, output;

 		// IEC 61966-2.1 (sRGB)

 		// Y = (aX + b)^Gamma | X >= d

 		// Y = cX             | X < d

 		if (x >= d) {

 			double e = (a*x + b);

 			if (e > 0)

 				y = pow(e, gamma);

 			else

 				y = 0;

 		} else {

 			y = c*x;

 		}

 		// Saturate -- this could likely move to a separate function

 		output = y * 65535. + .5;

 		if (output > 65535.)

 			output = 65535;

 		if (output < 0)

 			output = 0;

 		table[i] = (uint16_t)floor(output);

 	}

 	return table;

 }

 static struct curveType *curve_from_table(uint16_t *table, int num_entries)

 {

 	struct curveType *curve;

 	int i;

 	curve = malloc(sizeof(struct curveType) + sizeof(uInt16Number)*num_entries);

 	if (!curve)

 		return NULL;

 	curve->type = CURVE_TYPE;

 	curve->count = num_entries;

 	for (i = 0; i < num_entries; i++) {

 		curve->data[i] = table[i];

 	}

 	return curve;

 }

 static uint16_t float_to_u8Fixed8Number(float a)

 {

 	if (a > (255.f + 255.f/256))

 		return 0xffff;

 	else if (a < 0.f)

 		return 0;

 	else

 		return floorf(a*256.f + .5f);

 }

 static struct curveType *curve_from_gamma(float gamma)

 {

 	struct curveType *curve;

 	int num_entries = 1;

 	curve = malloc(sizeof(struct curveType) + sizeof(uInt16Number)*num_entries);

 	if (!curve)

 		return NULL;

 	curve->count = num_entries;

 	curve->data[0] = float_to_u8Fixed8Number(gamma);

   	curve->type = CURVE_TYPE;

 	return curve;

 }

 //XXX: it would be nice if we had a way of ensuring

 // everything in a profile was initialized regardless of how it was created

 //XXX: should this also be taking a black_point?

 /* similar to CGColorSpaceCreateCalibratedRGB */

 qcms_profile* qcms_profile_create_rgb_with_gamma(

 		qcms_CIE_xyY white_point,

 		qcms_CIE_xyYTRIPLE primaries,

 		float gamma)

 {

 	qcms_profile* profile = qcms_profile_create();

 	if (!profile)

 		return NO_MEM_PROFILE;

 	//XXX: should store the whitepoint

 	if (!set_rgb_colorants(profile, white_point, primaries)) {

 		qcms_profile_release(profile);

 		return INVALID_PROFILE;

 	}

 	profile->redTRC = curve_from_gamma(gamma);

 	profile->blueTRC = curve_from_gamma(gamma);

 	profile->greenTRC = curve_from_gamma(gamma);

 	if (!profile->redTRC || !profile->blueTRC || !profile->greenTRC) {

 		qcms_profile_release(profile);

 		return NO_MEM_PROFILE;

 	}

 	profile->class = DISPLAY_DEVICE_PROFILE;

 	profile->rendering_intent = QCMS_INTENT_PERCEPTUAL;

 	profile->color_space = RGB_SIGNATURE;

 	return profile;

 }

 qcms_profile* qcms_profile_create_rgb_with_table(

 		qcms_CIE_xyY white_point,

 		qcms_CIE_xyYTRIPLE primaries,

 		uint16_t *table, int num_entries)

 {

 	qcms_profile* profile = qcms_profile_create();

 	if (!profile)

 		return NO_MEM_PROFILE;

 	//XXX: should store the whitepoint

 	if (!set_rgb_colorants(profile, white_point, primaries)) {

 		qcms_profile_release(profile);

 		return INVALID_PROFILE;

 	}

 	profile->redTRC = curve_from_table(table, num_entries);

 	profile->blueTRC = curve_from_table(table, num_entries);

 	profile->greenTRC = curve_from_table(table, num_entries);

 	if (!profile->redTRC || !profile->blueTRC || !profile->greenTRC) {

 		qcms_profile_release(profile);

 		return NO_MEM_PROFILE;

 	}

 	profile->class = DISPLAY_DEVICE_PROFILE;

 	profile->rendering_intent = QCMS_INTENT_PERCEPTUAL;

 	profile->color_space = RGB_SIGNATURE;

 	return profile;

 }

 /* from lcms: cmsWhitePointFromTemp */

 /* tempK must be >= 4000. and <= 25000.

  * Invalid values of tempK will return

  * (x,y,Y) = (-1.0, -1.0, -1.0)

  * similar to argyll: icx_DTEMP2XYZ() */

 static qcms_CIE_xyY white_point_from_temp(int temp_K)

 {

 	qcms_CIE_xyY white_point;

 	double x, y;

 	double T, T2, T3;

 	// double M1, M2;

 	// No optimization provided.

 	T = temp_K;

 	T2 = T*T;            // Square

 	T3 = T2*T;           // Cube

 	// For correlated color temperature (T) between 4000K and 7000K:

 	if (T >= 4000. && T <= 7000.) {

 		x = -4.6070*(1E9/T3) + 2.9678*(1E6/T2) + 0.09911*(1E3/T) + 0.244063;

 	} else {

 		// or for correlated color temperature (T) between 7000K and 25000K:

 		if (T > 7000.0 && T <= 25000.0) {

 			x = -2.0064*(1E9/T3) + 1.9018*(1E6/T2) + 0.24748*(1E3/T) + 0.237040;

 		} else {

 			// Invalid tempK

 			white_point.x = -1.0;

 			white_point.y = -1.0;

 			white_point.Y = -1.0;

 			assert(0 && "invalid temp");

 			return white_point;

 		}

 	}

 	// Obtain y(x)

 	y = -3.000*(x*x) + 2.870*x - 0.275;

 	// wave factors (not used, but here for futures extensions)

 	// M1 = (-1.3515 - 1.7703*x + 5.9114 *y)/(0.0241 + 0.2562*x - 0.7341*y);

 	// M2 = (0.0300 - 31.4424*x + 30.0717*y)/(0.0241 + 0.2562*x - 0.7341*y);

 	// Fill white_point struct

 	white_point.x = x;

 	white_point.y = y;

 	white_point.Y = 1.0;

 	return white_point;

 }

 qcms_profile* qcms_profile_sRGB(void)

 {

 	qcms_profile *profile;

 	uint16_t *table;

 	qcms_CIE_xyYTRIPLE Rec709Primaries = {

 		{0.6400, 0.3300, 1.0},

 		{0.3000, 0.6000, 1.0},

 		{0.1500, 0.0600, 1.0}

 	};

 	qcms_CIE_xyY D65;

 	D65 = white_point_from_temp(6504);

 	table = build_sRGB_gamma_table(1024);

 	if (!table)

 		return NO_MEM_PROFILE;

 	profile = qcms_profile_create_rgb_with_table(D65, Rec709Primaries, table, 1024);

 	free(table);

 	return profile;

 }

 /* qcms_profile_from_memory does not hold a reference to the memory passed in */

 qcms_profile* qcms_profile_from_memory(const void *mem, size_t size)

 {

 	uint32_t length;

 	struct mem_source source;

 	struct mem_source *src = &source;

 	struct tag_index index;

 	qcms_profile *profile;

 	source.buf = mem;

 	source.size = size;

 	source.valid = true;

 	if (size < 4)

 		return INVALID_PROFILE;

 	length = read_u32(src, 0);

 	if (length <= size) {

 		// shrink the area that we can read if appropriate

 		source.size = length;

 	} else {

 		return INVALID_PROFILE;

 	}

 	/* ensure that the profile size is sane so it's easier to reason about */

 	if (source.size <= 64 || source.size >= MAX_PROFILE_SIZE)

 		return INVALID_PROFILE;

 	profile = qcms_profile_create();

 	if (!profile)

 		return NO_MEM_PROFILE;

 	check_CMM_type_signature(src);

 	check_profile_version(src);

 	read_class_signature(profile, src);

 	read_rendering_intent(profile, src);

 	read_color_space(profile, src);

 	read_pcs(profile, src);

 	//TODO read rest of profile stuff

 	if (!src->valid)

 		goto invalid_profile;

 	index = read_tag_table(profile, src);

 	if (!src->valid || !index.tags)

 		goto invalid_tag_table;

 	if (find_tag(index, TAG_CHAD)) {

 		profile->chromaticAdaption = read_tag_s15Fixed16ArrayType(src, index, TAG_CHAD);

 	} else {

 		profile->chromaticAdaption.invalid = true; //Signal the data is not present

 	}

 	if (profile->class == DISPLAY_DEVICE_PROFILE || profile->class == INPUT_DEVICE_PROFILE ||

             profile->class == OUTPUT_DEVICE_PROFILE  || profile->class == COLOR_SPACE_PROFILE) {

 		if (profile->color_space == RGB_SIGNATURE) {

 			if (find_tag(index, TAG_A2B0)) {

 				if (read_u32(src, find_tag(index, TAG_A2B0)->offset) == LUT8_TYPE ||

 				    read_u32(src, find_tag(index, TAG_A2B0)->offset) == LUT16_TYPE) {

 					profile->A2B0 = read_tag_lutType(src, index, TAG_A2B0);

 				} else if (read_u32(src, find_tag(index, TAG_A2B0)->offset) == LUT_MAB_TYPE) {

 					profile->mAB = read_tag_lutmABType(src, index, TAG_A2B0);

 				}

 			}

 			if (find_tag(index, TAG_B2A0)) {

 				if (read_u32(src, find_tag(index, TAG_B2A0)->offset) == LUT8_TYPE ||

 				    read_u32(src, find_tag(index, TAG_B2A0)->offset) == LUT16_TYPE) {

 					profile->B2A0 = read_tag_lutType(src, index, TAG_B2A0);

 				} else if (read_u32(src, find_tag(index, TAG_B2A0)->offset) == LUT_MBA_TYPE) {

 					profile->mBA = read_tag_lutmABType(src, index, TAG_B2A0);

 				}

 			}

 			if (find_tag(index, TAG_rXYZ) || !qcms_supports_iccv4) {

 				profile->redColorant = read_tag_XYZType(src, index, TAG_rXYZ);

 				profile->greenColorant = read_tag_XYZType(src, index, TAG_gXYZ);

 				profile->blueColorant = read_tag_XYZType(src, index, TAG_bXYZ);

 			}

 			if (!src->valid)

 				goto invalid_tag_table;

 			if (find_tag(index, TAG_rTRC) || !qcms_supports_iccv4) {

 				profile->redTRC = read_tag_curveType(src, index, TAG_rTRC);

 				profile->greenTRC = read_tag_curveType(src, index, TAG_gTRC);

 				profile->blueTRC = read_tag_curveType(src, index, TAG_bTRC);

 				if (!profile->redTRC || !profile->blueTRC || !profile->greenTRC)

 					goto invalid_tag_table;

 			}

 		} else if (profile->color_space == GRAY_SIGNATURE) {

 			profile->grayTRC = read_tag_curveType(src, index, TAG_kTRC);

 			if (!profile->grayTRC)

 				goto invalid_tag_table;

 		} else {

 			assert(0 && "read_color_space protects against entering here");

 			goto invalid_tag_table;

 		}

 	} else {

 		goto invalid_tag_table;

 	}

 	if (!src->valid)

 		goto invalid_tag_table;

 	free(index.tags);

 	return profile;

 invalid_tag_table:

 	free(index.tags);

 invalid_profile:

 	qcms_profile_release(profile);

 	return INVALID_PROFILE;

 }

 qcms_intent qcms_profile_get_rendering_intent(qcms_profile *profile)

 {

 	return profile->rendering_intent;

 }

 icColorSpaceSignature

 qcms_profile_get_color_space(qcms_profile *profile)

 {

 	return profile->color_space;

 }

 static void lut_release(struct lutType *lut)

 {

 	free(lut);

 }

 void qcms_profile_release(qcms_profile *profile)

 {

 	if (profile->output_table_r)

 		precache_release(profile->output_table_r);

 	if (profile->output_table_g)

 		precache_release(profile->output_table_g);

 	if (profile->output_table_b)

 		precache_release(profile->output_table_b);

 	if (profile->A2B0)

 		lut_release(profile->A2B0);

 	if (profile->B2A0)

 		lut_release(profile->B2A0);

 	if (profile->mAB)

 		mAB_release(profile->mAB);

 	if (profile->mBA)

 		mAB_release(profile->mBA);

 	free(profile->redTRC);

 	free(profile->blueTRC);

 	free(profile->greenTRC);

 	free(profile->grayTRC);

 	free(profile);

 }

 #include <stdio.h>

 static void qcms_data_from_file(FILE *file, void **mem, size_t *size)

 {

 	uint32_t length, remaining_length;

 	size_t read_length;

 	be32 length_be;

 	void *data;

 	*mem = NULL;

 	*size = 0;

 	if (fread(&length_be, 1, sizeof(length_be), file) != sizeof(length_be))

 		return;

 	length = be32_to_cpu(length_be);

 	if (length > MAX_PROFILE_SIZE || length < sizeof(length_be))

 		return;

 	/* allocate room for the entire profile */

 	data = malloc(length);

 	if (!data)

 		return;

 	/* copy in length to the front so that the buffer will contain the entire profile */

 	*((be32*)data) = length_be;

 	remaining_length = length - sizeof(length_be);

 	/* read the rest profile */

 	read_length = fread((unsigned char*)data + sizeof(length_be), 1, remaining_length, file);

 	if (read_length != remaining_length) {

 		free(data);

 		return;

 	}

 	/* successfully get the profile.*/

 	*mem = data;

 	*size = length;

 }

 qcms_profile* qcms_profile_from_file(FILE *file)

 {

 	size_t length;

 	qcms_profile *profile;

 	void *data;

 	qcms_data_from_file(file, &data, &length);

 	if ((data == NULL) || (length == 0))

 		return INVALID_PROFILE;

 	profile = qcms_profile_from_memory(data, length);

 	free(data);

 	return profile;

 }

 qcms_profile* qcms_profile_from_path(const char *path)

 {

 	qcms_profile *profile = NULL;

 	FILE *file = fopen(path, "rb");

 	if (file) {

 		profile = qcms_profile_from_file(file);

 		fclose(file);

 	}

 	return profile;

 }

 void qcms_data_from_path(const char *path, void **mem, size_t *size)

 {

 	FILE *file = NULL;

 	*mem = NULL;

 	*size  = 0;

 	file = fopen(path, "rb");

 	if (file) {

 		qcms_data_from_file(file, mem, size);

 		fclose(file);

 	}

 }

 #ifdef _WIN32

 /* Unicode path version */

 qcms_profile* qcms_profile_from_unicode_path(const wchar_t *path)

 {

 	qcms_profile *profile = NULL;

 	FILE *file = _wfopen(path, L"rb");

 	if (file) {

 		profile = qcms_profile_from_file(file);

 		fclose(file);

 	}

 	return profile;

 }

 void qcms_data_from_unicode_path(const wchar_t *path, void **mem, size_t *size)

 {

 	FILE *file = NULL;

 	*mem = NULL;

 	*size  = 0;

 	file = _wfopen(path, L"rb");

 	if (file) {

 		qcms_data_from_file(file, mem, size);

 		fclose(file);

 	}

 }

 #endif

 /*

 * This function constructs an ICC profile memory with given header and tag data,

 * which can be read via qcms_profile_from_memory(). that means, we must satisfy

 * the profiler header type check (which seems not complete till now) and proper

 * information to read data from the tag table and tag data elements memory.

 * 

 * To construct a valid ICC profile, its divided into three steps :

 *	(1) construct the r/g/bXYZ part

 *	(2) construct the r/g/bTRC part

 *	(3) construct the profile header

 * this is a hardcode step just for "create_rgb_with_gamma", it is the only

 * requirement till now, maybe we can make this method more general in future,

 *

 * NOTE : some of the parameters below are hardcode, please refer to the ICC documentation.

 */

 #define ICC_PROFILE_HEADER_LENGTH 128

 void qcms_data_create_rgb_with_gamma(qcms_CIE_xyY white_point, qcms_CIE_xyYTRIPLE primaries, float gamma, void **mem, size_t *size)

 {

 	uint32_t length, offset, index, xyz_count, trc_count;

 	size_t tag_table_offset, tag_data_offset;

 	void *data;

 	struct matrix colorants;

 	uint32_t TAG_XYZ[3] = {TAG_rXYZ, TAG_gXYZ, TAG_bXYZ};

 	uint32_t TAG_TRC[3] = {TAG_rTRC, TAG_gTRC, TAG_bTRC};

 	if ((mem == NULL) || (size == NULL))

 		return;

 	*mem = NULL;

 	*size = 0;

 	/* 

 	* total length = icc profile header(128) + tag count(4) + 

 	* (tag table item (12) * total tag (6 = 3 rTRC + 3 rXYZ)) + rTRC elements data (3 * 20)

 	* + rXYZ elements data (3*16), and all tag data elements must start at the 4-byte boundary.

 	*/

 	xyz_count = 3; // rXYZ, gXYZ, bXYZ

 	trc_count = 3; // rTRC, gTRC, bTRC

 	length =  ICC_PROFILE_HEADER_LENGTH + 4 + (12 * (xyz_count + trc_count)) + (xyz_count * 20) + (trc_count * 16);

 	// reserve the total memory.

 	data = malloc(length);

 	if (!data)

 		return;

 	memset(data, 0, length);

 	// Part1 : write rXYZ, gXYZ and bXYZ

 	if (!get_rgb_colorants(&colorants, white_point, primaries)) {

 		free(data);

 		return;

 	}

 	 // the position of first tag's signature in tag table

 	tag_table_offset = ICC_PROFILE_HEADER_LENGTH + 4;

 	tag_data_offset = ICC_PROFILE_HEADER_LENGTH + 4 +

 	   (12 * (xyz_count + trc_count)); // the start of tag data elements.

 	for (index = 0; index < xyz_count; ++index) {

 		// tag table

 		write_u32(data, tag_table_offset, TAG_XYZ[index]);

 		write_u32(data, tag_table_offset+4, tag_data_offset);

 		write_u32(data, tag_table_offset+8, 20); // 20 bytes per TAG_(r/g/b)XYZ tag element

 		// tag data element

 		write_u32(data, tag_data_offset, XYZ_TYPE);

 		// reserved 4 bytes.

 		write_u32(data, tag_data_offset+8, double_to_s15Fixed16Number(colorants.m[0][index]));

 		write_u32(data, tag_data_offset+12, double_to_s15Fixed16Number(colorants.m[1][index]));

 		write_u32(data, tag_data_offset+16, double_to_s15Fixed16Number(colorants.m[2][index]));

 		tag_table_offset += 12;

 		tag_data_offset += 20;

 	}

 	// Part2 : write rTRC, gTRC and bTRC

 	for (index = 0; index < trc_count; ++index) {

 		// tag table

 		write_u32(data, tag_table_offset, TAG_TRC[index]);

 		write_u32(data, tag_table_offset+4, tag_data_offset);

 		write_u32(data, tag_table_offset+8, 14); // 14 bytes per TAG_(r/g/b)TRC element

 		// tag data element

 		write_u32(data, tag_data_offset, CURVE_TYPE);

 		// reserved 4 bytes.

 		write_u32(data, tag_data_offset+8, 1); // count

 		write_u16(data, tag_data_offset+12, float_to_u8Fixed8Number(gamma));

 		tag_table_offset += 12;

 		tag_data_offset += 16;

 	}

 	/* Part3 : write profile header

 	 *

 	 * Important header fields are left empty. This generates a profile for internal use only.

 	 * We should be generating: Profile version (04300000h), Profile signature (acsp), 

 	 * PCS illumiant field. Likewise mandatory profile tags are omitted.

 	 */

 	write_u32(data, 0, length); // the total length of this memory

 	write_u32(data, 12, DISPLAY_DEVICE_PROFILE); // profile->class

 	write_u32(data, 16, RGB_SIGNATURE); // profile->color_space

 	write_u32(data, 20, XYZ_SIGNATURE); // profile->pcs

 	write_u32(data, 64, QCMS_INTENT_PERCEPTUAL); // profile->rendering_intent

 	write_u32(data, ICC_PROFILE_HEADER_LENGTH, 6); // total tag count

 	// prepare the result

 	*mem = data;

 	*size = length;

 }