diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 0000000..2fd0a12
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1,8 @@
+# This is the list of Fuchsia Authors.
+# Names should be added to this file as one of
+#     Organization's name
+#     Individual's name <submission email address>
+#     Individual's name <submission email address> <email2> <emailN>
+
+Google Inc.
+The Chromium Authors
diff --git a/BUILD.gn b/BUILD.gn
new file mode 100644
index 0000000..fdcad17
--- /dev/null
+++ b/BUILD.gn
@@ -0,0 +1,31 @@
+# Copyright 2016 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+config("qcms_config") {
+  include_dirs = [ "." ]
+}
+
+source_set("qcms") {
+  public_configs = [ ":qcms_config" ]
+
+  sources = [
+    "chain.c",
+    "chain.h",
+    "iccread.c",
+    "matrix.c",
+    "matrix.h",
+    "qcms.h",
+    "qcms_util.c",
+    "qcmsint.h",
+    "qcmstypes.h",
+    "transform.c",
+    "transform_util.c",
+    "transform_util.h",
+  ]
+
+  if (current_cpu == "x86" || current_cpu == "x64") {
+    defines = [ "SSE2_ENABLE" ]
+    sources += [ "transform-sse2.c" ]
+  }
+}
diff --git a/Makefile b/Makefile
deleted file mode 100644
index 32e6991..0000000
--- a/Makefile
+++ /dev/null
@@ -1,32 +0,0 @@
-
-COVERAGE_FLAGS=-fprofile-arcs -ftest-coverage
-#COVERAGE_FLAGS=
-OPT_FLAGS=-O0
-OPT_FLAGS=
-CFLAGS=`pkg-config --cflags lcms` -Wall $(OPT_FLAGS) $(COVERAGE_FLAGS) -Wdeclaration-after-statement -ggdb
-LDFLAGS=-ldl
-
-QCMS_SRC=iccread.c transform.c matrix.c chain.c transform_util.c transform-sse2.c transform-sse1.c
-QCMS_OBJS=iccread.o transform.o matrix.o chain.o transform_util.o transform-sse2.o transform-sse1.o
-
-PROGRAMS=profile-gen test test-invalid test-transform dump-profile div-test coverage malloc-fail invalid-coverage
-
-# I don't know a good way to get the exit code of pkg-config into a make variable
-HAS_LCMS:=$(shell pkg-config --exists lcms; echo $$?)
-ifeq ($(HAS_LCMS),0)
-PROGRAMS+=lcms-compare
-CFLAGS+=`pkg-config --cflags lcms`
-LDFLAGS+=`pkg-config --libs lcms`
-endif
-
-all: $(PROGRAMS)
-
-$(PROGRAMS): $(QCMS_OBJS)
-
-gen-coverage:
-	mkdir -p lcov
-	lcov -d . -c --output-file lcov/lcov.info
-	genhtml -o lcov/ lcov/lcov.info
-
-clean:
-	rm -f $(PROGRAMS) $(QCMS_OBJS)
diff --git a/README.fuchsia b/README.fuchsia
new file mode 100644
index 0000000..bf93f45
--- /dev/null
+++ b/README.fuchsia
@@ -0,0 +1,106 @@
+Name: Quick Color Management System
+Short Name: qcms
+URL: https://github.com/jrmuizel/qcms/tree/v4
+Version: v4
+Date: 2012-03-13
+License: MIT
+License File: COPYING
+Security Critical: yes
+
+Description:
+Contains support for applying an ICC color profile to an image.  The code is
+originally based on tinycms, re-written by Mozilla for better security and
+performance.  This copy is a source-drop from Mozilla on March 13, 2012.
+
+Local Modifications:
+Some files only have license headers in the master branch.
+ - Added the same license headers to the versions brought down from the 'v4'
+   branch src URL qcms/tree/v4
+The following changes have been made since qcms was imported:
+ - Add bgra output support.
+ - Use HAVE_POSIX_MEMALIGN instead of HAS_POSIX_MEMALIG
+   (https://bugzilla.mozilla.org/show_bug.cgi?id=692922)
+ - Applied upstream patch:
+   - https://bug752254.bugzilla.mozilla.org/attachment.cgi?id=626102
+ - Applied upstream patch for sanitizing gamma table:
+   - Expanded gamma clamp range to allow 1.0.
+ - Do not short-circuit bogus profile check for A2B0 or B2A0 unless v4 enabled.
+ - Only reference code from transform-sse1.c and transform-sse2.c when SSE is
+   enabled.
+ - Limit the use an x86-only attribute to 32-bit x86 builds.
+ - Fix integer truncation warning/errors on Win64 build.
+ - Apply upstream thread safety (fix) patch from
+   - https://bugzilla.mozilla.org/show_bug.cgi?id=853169
+ - Apply upstream fix for qcms_profile_from_memory from
+   - https://bugzilla.mozilla.org/show_bug.cgi?id=969226
+ - Apply upstream simplification of qcmstypes.h
+   - https://hg.mozilla.org/mozilla-central/rev/b5be94737a83
+ - Check for unused tag_len in read_nested_curveType()
+ - Apply qcms_transform_precacheLUT_float does not properly free dest buffer
+   - https://bugzilla.mozilla.org/show_bug.cgi?id=701348
+ - Add qcms_profile_match api
+ - Add qcms_profile_get_description api71
+ - Convert MLUC profile description embedded nulls to '.'
+ - [APPLE port] Use en-localized profile description names
+ - [APPLE port] Use mmod data for profile descriptions
+ - Minor variable name change: description -> description_offset
+ - Avoid divisions creating sample points in the float cube LUT builder
+ - Add bgra (z,y,x) sampled transform lookup table api
+ - Apply upstream fix reject invalid sizes from
+ - lut_inverse_interp16: remove odd whitespace formatting
+ - lut_inverse_interp16: better handle degenerate TRC curves
+ - Add vcgt tag reader and API to read its RGB gamma data
+ - Consolidate loop over channels and elements in VCGT parser
+ - Limit vcgt table to a maximum of 1024 entries
+ - Add float to half float conversion routine
+ - Use half float conversion tables (not functions)
+ - Add matrix transform flag and matrix extraction api
+ - Add tone reproduction curve (TRC) extraction api
+ - lut_inverse_interp16: interpolate degenerate zeros in TRC curves
+ - Make half float code self-contained: add halffloat.h
+ - lut_inverse_interp16: fix black level inversion error
+ - Apply upstream fix of uninitialized value
+   - https://github.com/jrmuizel/qcms/commit/0edb697
+ - Apply Keep the output of the TRC between 0 and 1
+   - https://bugzilla.mozilla.org/show_bug.cgi?id=764181
+ - Drop SSE1 code as Chromium mandates SSE2 as a minimum requirement
+ - Apply Fix potential leaks in qcms_transform_create
+   - https://bugzilla.mozilla.org/show_bug.cgi?id=1168480
+ - Apply fix for crash in qcms_transform_data_rgb_out_lut_sse1
+   - https://bugzilla.mozilla.org/show_bug.cgi?id=1163740
+ - Add SSE2 code for qcms_transform_data_rgba_out_lut_sse2
+ - Turbo charge SSE2 qcms_transform_data_rgba_out_lut_sse2
+ - Check matrix transforms have the same PCS
+ - Apply Don't reject valid profiles with no CLUT offset
+   - https://bugzilla.mozilla.org/show_bug.cgi?id=1176551
+ - Runtime detect qcms_transform_data_tetra_clut_rgba_sse2 use
+ - LUT8/16 profiles with an empty CLUT are invalid
+ - Caching transform prelude to save computation in V4 profiles
+ - Use the caching transform prelude for non-SSE code in transform.c
+ - Expand QCMS tests. Add Munsell test for transform accuracy
+ - Compute RMS error from color error dE in the Munsell test
+ - Store color profile version and add a version read API
+ - Add support for VCGT tag formula gamma
+ - Minimize transform RMS in qcms_transform_data_rgb(a)_out_lut
+ - Allow negative XYZ for display profiles on the APPLE port
+ - Add a color profile white point transform api
+ - Compute the pole and zero values needed by lut_inverse_interp16 once
+ - Store the profile media white point during iccread.c
+ - Add an API to check for profile media white point
+ - Add a qcms_profile_get_white_point() api
+ - Set the media white point of the sRGB profile
+ - Don't build QCMS on Android and iOS
+ - Fix para curve tag interval paramater use
+ - Verify internal sRGB profile tristimulus match the standard sRGB profile
+ - Expose unsigned short version of TRC curve
+ - Add qcms_profile_ntsc_relative_gamut_size api
+ - Fix build issue of qcms_tests for MIPS Linux
+ - Update primaries used to build internal sRGB profile
+ - Update internal sRGB profile test report output
+ - Add more internal sRGB profile tests
+ - Fix build_output_lut to return correct data for parametric curves
+ - Make build_output_lut output 4096 points for parametric curves
+ - Use a static table in build_output_lut to invert para curves
+ - Make qcms_test_output_trc handle normal gamma curves
+ - Add API to output parametric gamma curve data
+ - Fix an unitialized read in gamma curve data.
diff --git a/chain.c b/chain.c
index a259499..5255070 100644
--- a/chain.c
+++ b/chain.c
@@ -133,6 +133,8 @@
 	float* g_table = transform->g_clut;
 	float* b_table = transform->b_clut;
 
+	assert(transform->grid_size >= 1);
+
 	for (i = 0; i < length; i++) {
 		float linear_r = *src++;
 		float linear_g = *src++;
@@ -187,6 +189,9 @@
 	float* r_table = transform->r_clut;
 	float* g_table = transform->g_clut;
 	float* b_table = transform->b_clut;
+
+	assert(transform->grid_size >= 1);
+
 	for (i = 0; i < length; i++) {
 		float device_r = *src++;
 		float device_g = *src++;
@@ -892,6 +897,7 @@
 {
 	struct qcms_modular_transform *first_transform = NULL;
 	struct qcms_modular_transform **next_transform = &first_transform;
+	qcms_bool transform_to_pcs_xyz_only = (out == NULL);
 
 	if (in->color_space == RGB_SIGNATURE) {
 		struct qcms_modular_transform* rgb_to_pcs;
@@ -904,7 +910,7 @@
 		goto fail;
 	}
 
-	if (in->pcs == LAB_SIGNATURE && out->pcs == XYZ_SIGNATURE) {
+	if (in->pcs == LAB_SIGNATURE && (transform_to_pcs_xyz_only || out->pcs == XYZ_SIGNATURE)) {
 		struct qcms_modular_transform* lab_to_pcs;
 		lab_to_pcs = qcms_modular_transform_alloc();
 		if (!lab_to_pcs) 
@@ -913,6 +919,9 @@
 		lab_to_pcs->transform_module_fn = qcms_transform_module_LAB_to_XYZ;
 	}
 
+	if (transform_to_pcs_xyz_only)
+		return first_transform;
+
 	// This does not improve accuracy in practice, something is wrong here.
 	//if (in->chromaticAdaption.invalid == false) {
 	//	struct qcms_modular_transform* chromaticAdaption;
@@ -987,3 +996,31 @@
 	}
 	return NULL;
 }
+
+qcms_bool qcms_profile_white_transform(qcms_profile *profile, float XYZ[3])
+{
+	const float inverse_internal_scale = 1.999969482421875f;
+
+	// Set the output profile to NULL to request a color transform to PCS XYZ only.
+	struct qcms_modular_transform *transform_list = qcms_modular_transform_create(profile, NULL);
+
+	// Now calculate how the profile transforms white input color to PCS XYZ space.
+	if (transform_list != NULL) {
+		XYZ[0] = XYZ[1] = XYZ[2] = 1.0f; // white input
+		qcms_modular_transform_data(transform_list, XYZ, XYZ, 1);
+		// qcms_modular_transform_create internally scales input by 1/1.999969482421875f
+		// but no qcms changelog describes why / how that number was choosen. junov@ "it
+		// might be related to the epsilon of the fixed-point type 2*(1-1/(2^16)), but
+		// there is no explanation, which is disconcerting." Meanwhile, undo the internal
+		// scaling so we return a normalized CIEXYZ value viz., where Y is scaled to 1.0.
+		// A properly created color profile should produce Y=~1.0 in PCS XYZ with white
+		// input (the D50 test). If it does not, then the profile is likely bogus.
+		XYZ[0] *= inverse_internal_scale;
+		XYZ[1] *= inverse_internal_scale;
+		XYZ[2] *= inverse_internal_scale;
+		qcms_modular_transform_release(transform_list);
+		return true;
+	}
+
+	return false;
+}
diff --git a/coverage.c b/coverage.c
deleted file mode 100644
index 09e0f7f..0000000
--- a/coverage.c
+++ /dev/null
@@ -1,122 +0,0 @@
-#include <stdlib.h>
-#include <assert.h>
-#include "qcms.h"
-const unsigned char gray_icc[] =
-{0x00, 0x00, 0x01, 0x70, 0x4E, 0x4B, 0x4F, 0x4E, 0x02, 0x20, 0x00, 0x00,
-0x6D, 0x6E, 0x74, 0x72, 0x47, 0x52, 0x41, 0x59, 0x58, 0x59, 0x5A, 0x20,
-0x07, 0xCE, 0x00, 0x0B, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4C, 0x00, 0x00, 0x00, 0x00,
-0x6E, 0x6F, 0x6E, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0xD6,
-0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x2D, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
-0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x4B,
-0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0x0C, 0x00, 0x00, 0x00, 0x14,
-0x6B, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x20, 0x00, 0x00, 0x00, 0x0E,
-0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x2C,
-0x62, 0x6B, 0x70, 0x74, 0x00, 0x00, 0x01, 0x5C, 0x00, 0x00, 0x00, 0x14,
-0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1A,
-0x4E, 0x69, 0x6B, 0x6F, 0x6E, 0x47, 0x72, 0x61, 0x79, 0x47, 0x31, 0x2E,
-0x38, 0x20, 0x76, 0x34, 0x2E, 0x30, 0x2E, 0x30, 0x2E, 0x33, 0x30, 0x30,
-0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x1A, 0x4E, 0x69, 0x6B, 0x6F, 0x6E, 0x47, 0x72, 0x61, 0x79, 0x47, 0x31,
-0x2E, 0x38, 0x20, 0x76, 0x34, 0x2E, 0x30, 0x2E, 0x30, 0x2E, 0x33, 0x30,
-0x30, 0x30, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0xF3, 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xCC,
-0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-0x01, 0xCD, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00,
-0x4E, 0x69, 0x6B, 0x6F, 0x6E, 0x20, 0x49, 0x6E, 0x63, 0x2E, 0x20, 0x26,
-0x20, 0x4E, 0x69, 0x6B, 0x6F, 0x6E, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F,
-0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x32, 0x30, 0x30, 0x31, 0x00,
-0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-void test_gray(qcms_profile *output_profile)
-{
-	unsigned char srct[3] = { 221, 79, 129};
-	unsigned char outt[3];
-	qcms_transform *transform;
-	qcms_profile *gray_profile = qcms_profile_from_memory(gray_icc, sizeof(gray_icc));
-	assert(gray_profile);
-	transform = qcms_transform_create(gray_profile, QCMS_DATA_GRAY_8, output_profile, QCMS_DATA_RGB_8, QCMS_INTENT_PERCEPTUAL);
-	qcms_transform_data(transform, srct, outt, 1);
-	assert(
-			outt[0] == 0xe4 &&
-			outt[1] == 0xe4 &&
-			outt[2] == 0xe4);
-	qcms_transform_release(transform);
-
-	transform = qcms_transform_create(gray_profile, QCMS_DATA_GRAYA_8, output_profile, QCMS_DATA_RGBA_8, QCMS_INTENT_PERCEPTUAL);
-	qcms_transform_data(transform, srct, outt, 1);
-	assert(
-			outt[0] == 0xe4 &&
-			outt[1] == 0xe4 &&
-			outt[2] == 0xe4 &&
-			outt[3] == 79);
-	qcms_transform_release(transform);
-	qcms_profile_release(gray_profile);
-}
-
-const extern unsigned char gray_icc[];
-int main()
-{
-	unsigned char srct[4] = { 221, 79, 129, 92};
-	unsigned char outt[4];
-	qcms_transform *transform;
-	qcms_profile *input_profile, *output_profile, *rgb;
-	qcms_CIE_xyY white_point = { 0, 0.1, 1.};
-	qcms_CIE_xyYTRIPLE primaries = { {1, 0.01, 0}, {0, 0, 0.01}, {20, .4, 1.}};
-
-	input_profile = qcms_profile_sRGB();
-	output_profile = qcms_profile_sRGB();
-
-	test_gray(output_profile);
-
-	rgb = qcms_profile_create_rgb_with_gamma(white_point, primaries, 1.8);
-	// it is not clear how to create a bogus profile with the above interface
-	//assert(qcms_profile_is_bogus(rgb));
-
-	assert(!qcms_profile_is_bogus(input_profile));
-	assert(!qcms_profile_is_bogus(output_profile));
-
-	transform = qcms_transform_create(input_profile, QCMS_DATA_RGBA_8, output_profile, QCMS_DATA_RGBA_8, QCMS_INTENT_PERCEPTUAL);
-
-	qcms_transform_data(transform, srct, outt, 1);
-	assert(outt[0] == 0xdd && outt[1] == 0x4f && outt[2] == 0x81 && outt[3] == 92);
-
-	qcms_transform_release(transform);
-
-	transform = qcms_transform_create(input_profile, QCMS_DATA_RGB_8, output_profile, QCMS_DATA_RGB_8, QCMS_INTENT_PERCEPTUAL);
-
-	qcms_transform_data(transform, srct, outt, 1);
-	assert(outt[0] == 0xdd && outt[1] == 0x4f && outt[2] == 0x81);
-
-	qcms_transform_release(transform);
-
-	qcms_profile_precache_output_transform(output_profile);
-
-	transform = qcms_transform_create(input_profile, QCMS_DATA_RGBA_8, output_profile, QCMS_DATA_RGBA_8, QCMS_INTENT_PERCEPTUAL);
-
-	qcms_transform_data(transform, srct, outt, 1);
-	assert(outt[0] == 0xdd && outt[1] == 0x4f && outt[2] == 0x81 && outt[3] == 92);
-
-	qcms_transform_release(transform);
-
-	transform = qcms_transform_create(input_profile, QCMS_DATA_RGB_8, output_profile, QCMS_DATA_RGB_8, QCMS_INTENT_PERCEPTUAL);
-
-	qcms_transform_data(transform, srct, outt, 1);
-	assert(outt[0] == 0xdd && outt[1] == 0x4f && outt[2] == 0x81);
-
-	qcms_transform_release(transform);
-
-	test_gray(output_profile);
-
-	qcms_profile_release(input_profile);
-	qcms_profile_release(output_profile);
-
-	return 0;
-}
-
diff --git a/div-test.c b/div-test.c
deleted file mode 100644
index 4e4a009..0000000
--- a/div-test.c
+++ /dev/null
@@ -1,33 +0,0 @@
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-uint32_t ref(uint32_t a)
-{
-	return (a + 128)/ 255;
-	return (a + (65535/2))/ 65535;
-}
-
-uint32_t try1(a)
-{
-	return (((uint64_t)a + 128)*257) / 65535LL;
-	return (((uint64_t)a + 32767)*65538) / 4294967296LL;
-}
-
-
-
-int main()
-{
-	uint32_t x = 0;
-	do {
-		uint32_t r1 = ref(x);
-		uint32_t r2 = try1(x);
-		if (r1 != r2) {
-			printf("FAIL: %x -> %x %x\n", x, r1, r2);
-			exit(1);
-		}
-		if (x == 0xffffffff)
-			break;
-		x++;
-	} while (1);
-	return 0;
-}
diff --git a/dump-profile.c b/dump-profile.c
deleted file mode 100644
index 4427f0c..0000000
--- a/dump-profile.c
+++ /dev/null
@@ -1,32 +0,0 @@
-#include <stdlib.h>
-#include "qcms.h"
-
-void dump_profile(qcms_profile *profile)
-{
-	if (profile) {
-		printf(" rendering intent: %d\n", qcms_profile_get_rendering_intent(profile));
-		if (qcms_profile_is_bogus(profile)) {
-			printf(" bogus\n");
-		}
-		qcms_profile_release(profile);
-	} else {
-		printf("bad profile\n");
-	}
-}
-
-int main(int argc, char **argv)
-{
-	if (argc > 1) {
-		int i;
-		for (i=1; i<argc; i++) {
-			char *input_path = argv[i];
-			printf("%s\n", input_path);
-			dump_profile(qcms_profile_from_path(input_path));
-		}
-	} else {
-		dump_profile(qcms_profile_sRGB());
-	}
-
-
-	return 0;
-}
diff --git a/halffloat.h b/halffloat.h
new file mode 100644
index 0000000..35c7250
--- /dev/null
+++ b/halffloat.h
@@ -0,0 +1,106 @@
+/* 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.
+
+#ifndef _QCMS_HALFFLOAT_H
+#define _QCMS_HALFFLOAT_H
+
+const unsigned short qcms_half_float_base_table[512] = {
+        0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,
+        0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,
+        0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,
+        0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,
+        0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,
+        0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,      0,
+        0,      0,      0,      0,      0,      0,      0,      1,      2,      4,      8,      16,     32,     64,     128,    256,
+        512,    1024,   2048,   3072,   4096,   5120,   6144,   7168,   8192,   9216,   10240,  11264,  12288,  13312,  14336,  15360,
+        16384,  17408,  18432,  19456,  20480,  21504,  22528,  23552,  24576,  25600,  26624,  27648,  28672,  29696,  30720,  31744,
+        31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,
+        31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,
+        31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,
+        31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,
+        31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,
+        31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,
+        31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,  31744,
+        32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,
+        32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,
+        32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,
+        32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,
+        32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,
+        32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,  32768,
+        32768,  32768,  32768,  32768,  32768,  32768,  32768,  32769,  32770,  32772,  32776,  32784,  32800,  32832,  32896,  33024,
+        33280,  33792,  34816,  35840,  36864,  37888,  38912,  39936,  40960,  41984,  43008,  44032,  45056,  46080,  47104,  48128,
+        49152,  50176,  51200,  52224,  53248,  54272,  55296,  56320,  57344,  58368,  59392,  60416,  61440,  62464,  63488,  64512,
+        64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,
+        64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,
+        64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,
+        64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,
+        64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,
+        64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,
+        64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512,  64512
+};
+
+const unsigned char qcms_half_float_shift_table[512] = {
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     23,     22,     21,     20,     19,     18,     17,     16,     15,
+        14,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,
+        13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     13,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     23,     22,     21,     20,     19,     18,     17,     16,     15,
+        14,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,
+        13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     13,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,
+        24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     24,     13
+};
+
+static inline unsigned short float_to_half_float(float f)
+{
+	// See Blink::Source/platform/graphics/gpu/WebGLImageConversion.cpp::convertFloatToHalfFloat() and http://crbug.com/491784
+
+	unsigned temp = *((unsigned *)(&f));
+	unsigned signexp = (temp >> 23) & 0x1ff;
+	return qcms_half_float_base_table[signexp] + ((temp & 0x007fffff) >> qcms_half_float_shift_table[signexp]);
+}
+
+#endif
diff --git a/iccread.c b/iccread.c
index 5bd12a2..0bdba02 100644
--- a/iccread.c
+++ b/iccread.c
@@ -3,22 +3,22 @@
 //  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 
+// 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 
+// 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 
+// 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>
@@ -146,29 +146,31 @@
 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)
+static void read_profile_version(qcms_profile *profile, 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)
+	uint8_t reserved_byte1 = read_u8(src, 8 + 2);
+	uint8_t reserved_byte2 = read_u8(src, 8 + 3);
+
+	profile->icc_version = major_revision << 8 | minor_revision;
+
+	if (reserved_byte1 || reserved_byte2) {
 		invalid_source(src, "Invalid reserved bytes");
+		return;
+	}
+
+	if (major_revision == 2)
+		return; // ICC V2.X color profile
+	if (major_revision == 4 && qcms_supports_iccv4)
+		return; // ICC V4.X color profile
+
+	/* Checking the version doesn't buy us anything: permit any
+	   version without failure for now */
+	// invalid_source(src, "Unsupported ICC revision");
+	return;
 }
 
 #define INPUT_DEVICE_PROFILE   0x73636e72 // 'scnr'
@@ -217,8 +219,7 @@
 	}
 }
 
-struct tag
-{
+struct tag {
 	uint32_t signature;
 	uint32_t offset;
 	uint32_t size;
@@ -252,73 +253,112 @@
 	return index;
 }
 
-// Checks a profile for obvious inconsistencies and returns
-// true if the profile looks bogus and should probably be
-// ignored.
+/* Checks a profile for obvious inconsistencies and return 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;
+    float rX, rY, rZ, gX, gY, gZ, bX, bY, bZ;
+    float target[3], tolerance[3], sum[3];
+    unsigned i;
 
-       // We currently only check the bogosity of RGB profiles
-       if (profile->color_space != RGB_SIGNATURE)
-	       return false;
+    // We currently only check the bogosity of RGB profiles.
+    if (profile->color_space != RGB_SIGNATURE)
+        return false;
 
-       if (profile->A2B0 || profile->B2A0)
-               return false;
+    if (qcms_supports_iccv4 && (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);
+    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);
+    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);
+    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);
+    // Build our target vector: CIE D50 white. See also mozilla bug 460629,
+    // and http://www.color.org/whyd50.xalter "Why is the media white point
+    // of a display profile always D50?"
 
-       if (negative)
-	       return true;
+    target[0] = (float) 0.96420;
+    target[1] = (float) 1.00000;
+    target[2] = (float) 0.82491;
 
+    // Our tolerance vector - Recommended by Chris Murphy [1] based on
+    // conversion from the L*a*b space criterion of no more than 3 in any
+    // one channel. This is similar to, but slightly more tolerant than
+    // Adobe's criterion. [1] https://bugzil.la/460629#c10
 
-       // 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;
+    tolerance[0] = (float) 0.02;
+    tolerance[1] = (float) 0.02;
+    tolerance[2] = (float) 0.04;
 
-       // Build our target vector (see mozilla bug 460629)
-       target[0] = 0.96420;
-       target[1] = 1.00000;
-       target[2] = 0.82491;
+    // Sum the XYZ values: they should add to D50 white, within tolerance.
 
-       // 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;
+    // FIXME: this test assumes the TRC RGB curves equal 1.0 for the white
+    // input (255,255,255) RGB test color. For user display profiles, that
+    // is the normal case. Profiles with abnormal TRC exist. A better test
+    // would transform 255,255,255 white through the profile to either XYZ
+    // or L*a*b color and compare the result to D50 in XYZ or L*a*b color.
 
-       // 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;
-       }
+    sum[0] = rX + gX + bX;
+    sum[1] = rY + gY + bY;
+    sum[2] = rZ + gZ + bZ;
 
-       // All Good
-       return false;
+    for (i = 0; i < 3; ++i) {
+        if (!(((sum[i] - tolerance[i]) <= target[i]) &&
+              ((sum[i] + tolerance[i]) >= target[i]))) {
+            return true; // out of tolerance: bogus
+        }
+    }
+
+#ifndef __APPLE__
+    // Check if any of the XYZ values are negative (see mozilla bug 498245)
+    // CIEXYZ tristimulus values cannot be negative according to the spec.
+
+    bool negative =
+        (rX < 0) || (rY < 0) || (rZ < 0) ||
+        (gX < 0) || (gY < 0) || (gZ < 0) ||
+        (bX < 0) || (bY < 0) || (bZ < 0);
+
+    if (negative)
+        return true; // bogus
+#else
+    // Chromatic adaption to D50 can result in negative XYZ, but the white
+    // point D50 tolerance test has passed. Accept negative values herein.
+    // See https://bugzilla.mozilla.org/show_bug.cgi?id=498245#c18 onwards
+    // for discussion about whether profile XYZ can or cannot be negative,
+    // per the spec. Also the https://bugzil.la/450923 user report.
+
+    // FIXME: allow this relaxation on all ports?
+#endif
+    // All good.
+    return false;
+}
+
+qcms_bool qcms_profile_has_white_point(qcms_profile *profile)
+{
+    struct XYZNumber wp = profile->mediaWhitePoint;
+
+    return (wp.X != 0) && (wp.Y != 0) && (wp.Z != 0);
+}
+
+qcms_xyz_float qcms_profile_get_white_point(qcms_profile *profile)
+{
+    qcms_xyz_float wp = { 0.0f, 0.0f, 0.0f };
+
+    if (qcms_profile_has_white_point(profile)) {
+        wp.X = s15Fixed16Number_to_float(profile->mediaWhitePoint.X);
+        wp.Y = s15Fixed16Number_to_float(profile->mediaWhitePoint.Y);
+        wp.Z = s15Fixed16Number_to_float(profile->mediaWhitePoint.Z);
+    }
+
+    return wp;
 }
 
 #define TAG_bXYZ 0x6258595a
@@ -331,19 +371,272 @@
 #define TAG_A2B0 0x41324230
 #define TAG_B2A0 0x42324130
 #define TAG_CHAD 0x63686164
+#define TAG_desc 0x64657363
+#define TAG_vcgt 0x76636774
+#define TAG_wtpt 0x77747074
 
 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) {
+		if (index.tags[i].signature == tag_id)
 			return &index.tags[i];
+	}
+
+	return NULL;
+}
+
+#define DESC_TYPE 0x64657363 // 'desc'
+#define MLUC_TYPE 0x6d6c7563 // 'mluc'
+#define MMOD_TYPE 0x6D6D6F64 // 'mmod'
+#define VCGT_TYPE 0x76636774 // 'vcgt'
+
+enum {
+	VCGT_TYPE_TABLE,
+	VCGT_TYPE_FORMULA,
+	VCGT_TYPE_LAST = VCGT_TYPE_FORMULA
+};
+
+static qcms_bool read_tag_vcgtType(qcms_profile *profile, struct mem_source *src, struct tag_index index)
+{
+	size_t tag_offset = find_tag(index, TAG_vcgt)->offset;
+	uint32_t tag_type = read_u32(src, tag_offset);
+	uint32_t vcgt_type = read_u32(src, tag_offset + 8);
+
+	if (!src->valid || tag_type != VCGT_TYPE)
+		goto invalid_vcgt_tag;
+
+	// Only support table and equation types.
+	if (vcgt_type > VCGT_TYPE_LAST)
+		return true;
+
+	if (vcgt_type == VCGT_TYPE_TABLE) {
+		uint16_t channels = read_u16(src, tag_offset + 12);
+		uint16_t elements = read_u16(src, tag_offset + 14);
+		uint16_t byte_depth = read_u16(src, tag_offset + 16);
+		size_t table_offset = tag_offset + 18;
+		uint32_t i;
+		uint16_t *dest;
+
+		if (!src->valid)
+			goto invalid_vcgt_tag;
+
+		// Only support 3 channels.
+		if (channels != 3)
+			return true;
+		// Only support single or double byte values.
+		if (byte_depth != 1 && byte_depth != 2)
+			return true;
+		// Limit the table to a sensible size; 10-bit gamma is a reasonable
+		// maximum for hardware correction.
+		if (elements > 1024)
+			return true;
+
+		// Empty table is invalid.
+		if (!elements)
+			goto invalid_vcgt_tag;
+
+		profile->vcgt.length = elements;
+		profile->vcgt.data = malloc(3 * elements * sizeof(uint16_t));
+		if (!profile->vcgt.data)
+			return false;
+
+		dest = profile->vcgt.data;
+
+		for (i = 0; i < 3 * elements; ++i) {
+			if (byte_depth == 1) {
+				*dest++ = read_u8(src, table_offset) * 256;
+			} else {
+				*dest++ = read_u16(src, table_offset);
+			}
+
+			table_offset += byte_depth;
+
+			if (!src->valid)
+				goto invalid_vcgt_tag;
+		}
+	} else {
+		size_t formula_offset = tag_offset + 12;
+		int i;
+		size_t j;
+		uint16_t *dest;
+
+		// For formula always provide an 8-bit lut.
+		profile->vcgt.length = 256;
+		profile->vcgt.data = malloc(3 * profile->vcgt.length * sizeof(uint16_t));
+		if (!profile->vcgt.data)
+			return false;
+
+		dest = profile->vcgt.data;
+		for (i = 0; i < 3; ++i) {
+			float gamma = s15Fixed16Number_to_float(
+					read_s15Fixed16Number(src, formula_offset + 12 * i));
+			float min = s15Fixed16Number_to_float(
+					read_s15Fixed16Number(src, formula_offset + 4 + 12 * i));
+			float max = s15Fixed16Number_to_float(
+					read_s15Fixed16Number(src, formula_offset + 8 + 12 * i));
+			float range = max - min;
+
+			if (!src->valid)
+				goto invalid_vcgt_tag;
+
+			for (j = 0; j < profile->vcgt.length; ++j) {
+				*dest++ = 65535.f *
+					(min + range * pow((float)j / (profile->vcgt.length - 1), gamma));
+			}
 		}
 	}
-	return tag;
+
+	return true;
+
+invalid_vcgt_tag:
+	invalid_source(src, "invalid vcgt tag");
+	return false;
 }
 
+static bool read_tag_descType(qcms_profile *profile, struct mem_source *src, struct tag_index index, uint32_t tag_id)
+{
+	struct tag *tag = find_tag(index, tag_id);
+	if (tag) {
+		const uint32_t limit = sizeof profile->description;
+		uint32_t offset = tag->offset;
+		uint32_t type = read_u32(src, offset);
+		uint32_t length = read_u32(src, offset+8);
+		uint32_t i, description_offset;
+		bool mluc = false;
+		if (length && type == MLUC_TYPE) {
+			length = read_u32(src, offset+20);
+			if (!length || (length & 1) || (read_u32(src, offset+12) != 12))
+				goto invalid_desc_tag;
+			description_offset = offset + read_u32(src, offset+24);
+			if (!src->valid)
+				goto invalid_desc_tag;
+			mluc = true;
+		} else if (length && type == DESC_TYPE) {
+			description_offset = offset + 12;
+		} else {
+			goto invalid_desc_tag;
+		}
+		if (length >= limit)
+			length = limit - 1;
+		for (i = 0; i < length; ++i) {
+			uint8_t value = read_u8(src, description_offset + i);
+			if (!src->valid)
+				goto invalid_desc_tag;
+			if (mluc && !value)
+				value = '.';
+			profile->description[i] = value;
+		}
+		profile->description[length] = 0;
+	} else {
+		goto invalid_desc_tag;
+	}
+
+	if (src->valid)
+		return true;
+
+invalid_desc_tag:
+	invalid_source(src, "invalid description");
+	return false;
+}
+
+#if defined(__APPLE__)
+
+// Use the dscm tag to change profile description "Display" to its more specific en-localized monitor name, if any.
+
+#define TAG_dscm  0x6473636D // 'dscm'
+
+static bool read_tag_dscmType(qcms_profile *profile, struct mem_source *src, struct tag_index index, uint32_t tag_id)
+{
+	if (strcmp(profile->description, "Display") != 0)
+		return true;
+
+	struct tag *tag = find_tag(index, tag_id);
+	if (tag) {
+		uint32_t offset = tag->offset;
+		uint32_t type = read_u32(src, offset);
+		uint32_t records = read_u32(src, offset+8);
+
+		if (!src->valid || !records || type != MLUC_TYPE)
+			goto invalid_dscm_tag;
+		if (read_u32(src, offset+12) != 12) // MLUC record size: bytes
+			goto invalid_dscm_tag;
+
+		for (uint32_t i = 0; i < records; ++i) {
+			const uint32_t limit = sizeof profile->description;
+			const uint16_t isoen = 0x656E; // ISO-3166-1 language 'en'
+
+			uint16_t language = read_u16(src, offset + 16 + (i * 12) + 0);
+			uint32_t length = read_u32(src, offset + 16 + (i * 12) + 4);
+			uint32_t description_offset = read_u32(src, offset + 16 + (i * 12) + 8);
+
+			if (!src->valid || !length || (length & 1))
+				goto invalid_dscm_tag;
+			if (language != isoen)
+				continue;
+
+			// Use a prefix to identify the display description source
+			strcpy(profile->description, "dscm:");
+			length += 5;
+
+			if (length >= limit)
+				length = limit - 1;
+			for (uint32_t j = 5; j < length; ++j) {
+				uint8_t value = read_u8(src, offset + description_offset + j - 5);
+				if (!src->valid)
+					goto invalid_dscm_tag;
+				profile->description[j] = value ? value : '.';
+			}
+			profile->description[length] = 0;
+			break;
+		}
+	}
+
+	if (src->valid)
+		return true;
+
+invalid_dscm_tag:
+	invalid_source(src, "invalid dscm tag");
+	return false;
+}
+
+// Use the mmod tag to change profile description "Display" to its specific mmod maker model data, if any.
+
+#define TAG_mmod  0x6D6D6F64 // 'mmod'
+
+static bool read_tag_mmodType(qcms_profile *profile, struct mem_source *src, struct tag_index index, uint32_t tag_id)
+{
+	if (strcmp(profile->description, "Display") != 0)
+		return true;
+
+	struct tag *tag = find_tag(index, tag_id);
+	if (tag) {
+		const uint8_t length = 4 * 4; // Four 4-byte fields: 'mmod', 0, maker, model.
+
+		uint32_t offset = tag->offset;
+		if (tag->size < 40 || read_u32(src, offset) != MMOD_TYPE)
+			goto invalid_mmod_tag;
+
+		for (uint8_t i = 0; i < length; ++i) {
+			uint8_t value = read_u8(src, offset + i);
+			if (!src->valid)
+				goto invalid_mmod_tag;
+			profile->description[i] = value ? value : '.';
+		}
+		profile->description[length] = 0;
+	}
+
+	if (src->valid)
+		return true;
+
+invalid_mmod_tag:
+	invalid_source(src, "invalid mmod tag");
+	return false;
+}
+
+#endif // __APPLE__
+
 #define XYZ_TYPE		0x58595a20 // 'XYZ '
 #define CURVE_TYPE		0x63757276 // 'curv'
 #define PARAMETRIC_CURVE_TYPE	0x70617261 // 'para'
@@ -397,7 +690,7 @@
 	return num;
 }
 
-// Read the tag at a given offset rather then the tag_index. 
+// 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)
@@ -448,7 +741,7 @@
 		curve->type = type;
 
 		for (i=0; i < COUNT_TO_LENGTH[count]; i++) {
-			curve->parameter[i] = s15Fixed16Number_to_float(read_s15Fixed16Number(src, offset + 12 + i*4));	
+			curve->parameter[i] = s15Fixed16Number_to_float(read_s15Fixed16Number(src, offset + 12 + i*4));
 		}
 		*len = 12 + COUNT_TO_LENGTH[count] * 4;
 
@@ -484,19 +777,23 @@
 	uint32_t channel_offset = 0;
 	int i;
 	for (i = 0; i < num_channels; i++) {
-		uint32_t tag_len;
+		uint32_t tag_len = ~0;
 
 		(*curveArray)[i] = read_curveType(src, curve_offset + channel_offset, &tag_len);
 		if (!(*curveArray)[i]) {
 			invalid_source(src, "invalid nested curveType curve");
 		}
 
+		if (tag_len == (uint32_t)~0) {
+			invalid_source(src, "invalid nested curveType tag length");
+			return;
+		}
+
 		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)
@@ -526,7 +823,7 @@
 	uint32_t type = read_u32(src, offset);
 	uint8_t num_in_channels, num_out_channels;
 	struct lutmABType *lut;
-	int i;
+	uint32_t i;
 
 	if (type != LUT_MAB_TYPE && type != LUT_MBA_TYPE) {
 		return NULL;
@@ -540,7 +837,7 @@
 	// 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.
+	//      also check for clut_size overflow. Also make sure it's != 0
 	if (num_in_channels != 3 || num_out_channels != 3)
 		return NULL;
 
@@ -570,6 +867,9 @@
 		// 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);
+			if (clut_size == 0) {
+				invalid_source(src, "bad clut_size");
+			}
 		}
 	} else {
 		clut_size = 0;
@@ -588,8 +888,13 @@
 	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);
+	if (clut_offset) {
+		for (i = 0; i < num_in_channels; i++) {
+			lut->num_grid_points[i] = read_u8(src, clut_offset + i);
+			if (lut->num_grid_points[i] == 0) {
+				invalid_source(src, "bad grid_points");
+			}
+		}
 	}
 
 	// Reverse the processing of transformation elements for mBA type.
@@ -657,11 +962,11 @@
 	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;
+	size_t clut_offset, output_offset;
 	uint32_t clut_size;
 	size_t entry_size;
 	struct lutType *lut;
-	int i;
+	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 */
@@ -672,6 +977,10 @@
 	} else if (type == LUT16_TYPE) {
 		num_input_table_entries  = read_u16(src, offset + 48);
 		num_output_table_entries = read_u16(src, offset + 50);
+		if (num_input_table_entries == 0 || num_output_table_entries == 0) {
+			invalid_source(src, "Bad channel count");
+			return NULL;
+		}
 		entry_size = 2;
 	} else {
 		assert(0); // the caller checks that this doesn't happen
@@ -685,15 +994,23 @@
 
 	clut_size = pow(grid_points, in_chan);
 	if (clut_size > MAX_CLUT_SIZE) {
+		invalid_source(src, "CLUT too large");
+		return NULL;
+	}
+
+	if (clut_size <= 0) {
+		invalid_source(src, "CLUT must not be empty.");
 		return NULL;
 	}
 
 	if (in_chan != 3 || out_chan != 3) {
+		invalid_source(src, "CLUT only supports RGB");
 		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) {
+		invalid_source(src, "CLUT too large");
 		return NULL;
 	}
 
@@ -704,9 +1021,9 @@
 
 	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->num_input_channels   = in_chan;
+	lut->num_output_channels  = out_chan;
+	lut->num_clut_grid_points = grid_points;
 	lut->e00 = read_s15Fixed16Number(src, offset+12);
 	lut->e01 = read_s15Fixed16Number(src, offset+16);
 	lut->e02 = read_s15Fixed16Number(src, offset+20);
@@ -846,6 +1163,7 @@
 	curve = malloc(sizeof(struct curveType) + sizeof(uInt16Number)*num_entries);
 	if (!curve)
 		return NULL;
+	curve->type = CURVE_TYPE;
 	curve->count = num_entries;
 	curve->data[0] = float_to_u8Fixed8Number(gamma);
 	return curve;
@@ -866,7 +1184,6 @@
 	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;
@@ -880,9 +1197,11 @@
 		qcms_profile_release(profile);
 		return NO_MEM_PROFILE;
 	}
+
 	profile->class = DISPLAY_DEVICE_PROFILE;
 	profile->rendering_intent = QCMS_INTENT_PERCEPTUAL;
 	profile->color_space = RGB_SIGNATURE;
+	profile->pcs = XYZ_SIGNATURE;
 	return profile;
 }
 
@@ -895,7 +1214,6 @@
 	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;
@@ -909,9 +1227,11 @@
 		qcms_profile_release(profile);
 		return NO_MEM_PROFILE;
 	}
+
 	profile->class = DISPLAY_DEVICE_PROFILE;
 	profile->rendering_intent = QCMS_INTENT_PERCEPTUAL;
 	profile->color_space = RGB_SIGNATURE;
+	profile->pcs = XYZ_SIGNATURE;
 	return profile;
 }
 
@@ -920,7 +1240,7 @@
  * 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_from_temp(int temp_K)
 {
 	qcms_CIE_xyY white_point;
 	double x, y;
@@ -973,26 +1293,81 @@
 	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}
+	// Standard Illuminant D65 in XYZ coordinates, which is the standard
+	// sRGB IEC61966-2.1 / Rec.709 profile reference media white point.
+	struct XYZNumber D65 = {
+		0xf351, 0x10000, 0x116cc // ( 0.950455, 1.000000, 1.089050 )
 	};
-	qcms_CIE_xyY D65;
 
-	D65 = white_point_from_temp(6504);
+	// sRGB IEC61966-2.1 / Rec.709 color profile primaries, chromatically
+	// adapted (via Bradford procedures) to D50 white point.
+	// For details, refer to crbug/580917
+#if 0
+	// lindbloom: ASTM E308-01 D50 White point.
+	s15Fixed16Number primaries[3][3] = {
+		{ 0x06fa3, 0x06294, 0x024a1 }, // ( 0.436081, 0.385071, 0.143082 )
+		{ 0x038f6, 0x0b785, 0x00f85 }, // ( 0.222504, 0.716873, 0.060623 )
+		{ 0x00391, 0x018dc, 0x0b6d4 }, // ( 0.013931, 0.097107, 0.714172 )
+	};
+#else
+	// ninedegreesbelow: ICC D50 White point.
+	s15Fixed16Number primaries[3][3] = {
+		{ 0x06fa0, 0x06296, 0x024a0 }, // ( 0.436035, 0.385101, 0.143066 )
+		{ 0x038f2, 0x0b789, 0x00f85 }, // ( 0.222443, 0.716934, 0.060623 )
+		{ 0x0038f, 0x018da, 0x0b6c4 }, // ( 0.013901, 0.097076, 0.713928 )
+	};
+#endif
 
 	table = build_sRGB_gamma_table(1024);
 
 	if (!table)
 		return NO_MEM_PROFILE;
 
-	profile = qcms_profile_create_rgb_with_table(D65, Rec709Primaries, table, 1024);
+	profile = qcms_profile_create();
+
+	if (!profile) {
+		free(table);
+		return NO_MEM_PROFILE;
+	}
+
+	profile->redTRC = curve_from_table(table, 1024);
+	profile->blueTRC = curve_from_table(table, 1024);
+	profile->greenTRC = curve_from_table(table, 1024);
+
+	if (!profile->redTRC || !profile->blueTRC || !profile->greenTRC) {
+		qcms_profile_release(profile);
+		free(table);
+		return NO_MEM_PROFILE;
+	}
+
+	profile->redColorant.X = primaries[0][0];
+	profile->redColorant.Y = primaries[1][0];
+	profile->redColorant.Z = primaries[2][0];
+
+	profile->greenColorant.X = primaries[0][1];
+	profile->greenColorant.Y = primaries[1][1];
+	profile->greenColorant.Z = primaries[2][1];
+
+	profile->blueColorant.X = primaries[0][2];
+	profile->blueColorant.Y = primaries[1][2];
+	profile->blueColorant.Z = primaries[2][2];
+
+	profile->mediaWhitePoint.X = D65.X;
+	profile->mediaWhitePoint.Y = D65.Y;
+	profile->mediaWhitePoint.Z = D65.Z;
+
+	profile->class = DISPLAY_DEVICE_PROFILE;
+	profile->rendering_intent = QCMS_INTENT_PERCEPTUAL;
+	profile->color_space = RGB_SIGNATURE;
+	profile->pcs = XYZ_SIGNATURE;
+
+	strcpy(profile->description, "sRGB IEC61966-2.1");
+
 	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)
 {
@@ -1006,6 +1381,9 @@
 	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
@@ -1023,7 +1401,7 @@
 		return NO_MEM_PROFILE;
 
 	check_CMM_type_signature(src);
-	check_profile_version(src);
+	read_profile_version(profile, src);
 	read_class_signature(profile, src);
 	read_rendering_intent(profile, src);
 	read_color_space(profile, src);
@@ -1037,12 +1415,26 @@
 	if (!src->valid || !index.tags)
 		goto invalid_tag_table;
 
+	if (!read_tag_descType(profile, src, index, TAG_desc))
+		goto invalid_tag_table;
+#if defined(__APPLE__)
+	if (!read_tag_dscmType(profile, src, index, TAG_dscm))
+		goto invalid_tag_table;
+	if (!read_tag_mmodType(profile, src, index, TAG_mmod))
+		goto invalid_tag_table;
+#endif // __APPLE__
+
 	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 (find_tag(index, TAG_vcgt)) {
+		if (!read_tag_vcgtType(profile, src, index))
+			goto invalid_tag_table;
+	}
+
 	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) {
@@ -1093,31 +1485,70 @@
 		goto invalid_tag_table;
 	}
 
+	// Profiles other than DeviceLink should have a media white point.
+	// Here we read it if present.
+	if (find_tag(index, TAG_wtpt)) {
+		profile->mediaWhitePoint = read_tag_XYZType(src, index, TAG_wtpt);
+	}
+
 	if (!src->valid)
 		goto invalid_tag_table;
 
 	free(index.tags);
-
 	return profile;
 
 invalid_tag_table:
-	free(index.tags);
+	if (index.tags)
+		free(index.tags);
 invalid_profile:
 	qcms_profile_release(profile);
 	return INVALID_PROFILE;
 }
 
+qcms_bool qcms_profile_match(qcms_profile *p1, qcms_profile *p2)
+{
+	return memcmp(p1->description, p2->description, sizeof p1->description) == 0;
+}
+
+const char* qcms_profile_get_description(qcms_profile *profile)
+{
+	return profile->description;
+}
+
 qcms_intent qcms_profile_get_rendering_intent(qcms_profile *profile)
 {
 	return profile->rendering_intent;
 }
 
-icColorSpaceSignature
-qcms_profile_get_color_space(qcms_profile *profile)
+qcms_color_space qcms_profile_get_color_space(qcms_profile *profile)
 {
 	return profile->color_space;
 }
 
+unsigned qcms_profile_get_version(qcms_profile *profile)
+{
+	return profile->icc_version & 0xffff;
+}
+
+size_t qcms_profile_get_vcgt_channel_length(qcms_profile *profile)
+{
+	return profile->vcgt.length;
+}
+
+// Check unsigned short is uint16_t.
+typedef char assert_short_not_16b[(sizeof(unsigned short) == sizeof(uint16_t)) ? 1 : -1];
+
+qcms_bool qcms_profile_get_vcgt_rgb_channels(qcms_profile *profile, unsigned short *data)
+{
+	size_t vcgt_channel_bytes = qcms_profile_get_vcgt_channel_length(profile) * sizeof(uint16_t);
+
+	if (!vcgt_channel_bytes || !data)
+		return false;
+
+	memcpy(data, profile->vcgt.data, 3 * vcgt_channel_bytes);
+	return true;
+}
+
 static void lut_release(struct lutType *lut)
 {
 	free(lut);
@@ -1142,6 +1573,9 @@
 	if (profile->mBA)
 		mAB_release(profile->mBA);
 
+	if (profile->vcgt.data)
+		free(profile->vcgt.data);
+
 	free(profile->redTRC);
 	free(profile->blueTRC);
 	free(profile->greenTRC);
@@ -1149,8 +1583,8 @@
 	free(profile);
 }
 
-
 #include <stdio.h>
+
 qcms_profile* qcms_profile_from_file(FILE *file)
 {
 	uint32_t length, remaining_length;
@@ -1197,17 +1631,3 @@
 	}
 	return profile;
 }
-
-#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;
-}
-#endif
diff --git a/invalid-coverage.c b/invalid-coverage.c
deleted file mode 100644
index b96df73..0000000
--- a/invalid-coverage.c
+++ /dev/null
@@ -1,308 +0,0 @@
-#include <stdlib.h>
-#include <assert.h>
-#include <stdint.h>
-#include "qcms.h"
-
-typedef uint32_t __be32;
-
-/* __builtin_bswap isn't available in older gccs
- * so open code it for now */
-static __be32 cpu_to_be32(int32_t v)
-{
-#ifdef LITTLE_ENDIAN
-	return ((v & 0xff) << 24) | ((v & 0xff00) << 8) | ((v & 0xff0000) >> 8) | ((v & 0xff000000) >> 24);
-	//return __builtin_bswap32(v);
-#else
-	return v;
-#endif
-}
-
-char *buf;
-
-static void write_u32(size_t offset, uint32_t value)
-{
-	*(__be32*)(buf + offset) = cpu_to_be32(value);
-}
-#if 0
-static uint16_t read_u16(struct mem_source *mem, size_t offset)
-{
-	if (offset + 2 > mem->size) {
-		invalid_source(mem, "Invalid offset");
-		return 0;
-	} else {
-		return be16_to_cpu(*(__be16*)(mem->buf + offset));
-	}
-}
-#endif
-static void write_u8(size_t offset, uint8_t value)
-{
-	*(uint8_t*)(buf + offset) = value;
-}
-static void write_u16(size_t offset, uint16_t value)
-{
-	*(uint8_t*)(buf + offset + 1) = value & 0xff;
-	*(uint8_t*)(buf + offset) = (value>>8) & 0xff;
-}
-
-
-#define PROFILE_LENGTH 18000
-int main()
-{
-	qcms_profile_release(qcms_profile_sRGB());
-
-	buf = calloc(PROFILE_LENGTH, 1);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	// invalid size
-	write_u32(0, PROFILE_LENGTH + 2500);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	// proper size
-	write_u32(0, PROFILE_LENGTH);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-#define INPUT_DEVICE_PROFILE   0x73636e72 // 'scnr'
-	write_u32(12, INPUT_DEVICE_PROFILE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(8, 0x3); // invalid major revision
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(8, 0x2); // major revision
-	write_u8(9, 0x55); // invalid minor revision
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(8, 0x2); // major revision
-	write_u8(9, 0x40); // minor revision
-	write_u8(10, 1); // reserved 1
-	write_u8(11, 0); // reserved 2
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(10, 0); // reserved 1
-
-	write_u8(64, 0x32); // invalid rendering intent
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(64, 0); // invalid rendering intent
-
-#define RGB_SIGNATURE  0x52474220
-#define GRAY_SIGNATURE 0x47524159
-	write_u32(16, 0xdeadbeef);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(16, RGB_SIGNATURE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-#define XYZ_SIGNATURE  0x58595A20
-	write_u32(20, XYZ_SIGNATURE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128, 15000); // tag count
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128, 15); // tag count
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-     #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
-
-	write_u32(128 + 4, TAG_rXYZ); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u32(128 + 4 + 4, 1000); // offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*1*3, TAG_gXYZ); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u32(128 + 4 + 4*1*3 + 4, 1000); // offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*2*3, TAG_bXYZ); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u32(128 + 4 + 4*2*3 + 4, 1000); // offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-#define XYZ_TYPE   0x58595a20 // 'XYZ '
-#define CURVE_TYPE 0x63757276 // 'curv'
-#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'
-#define PARAMETRIC_CURVE_TYPE   0x70617261 // 'para'
-	write_u32(1000, XYZ_TYPE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*3*3, TAG_rTRC); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u32(128 + 4 + 4*3*3 + 4, 1100); // offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*4*3, TAG_gTRC); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u32(128 + 4 + 4*4*3 + 4, 1100); // offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*5*3, TAG_bTRC); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u32(128 + 4 + 4*5*3 + 4, 1100); // offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*6*3, TAG_A2B0); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*6*3 + 4, 1200); // offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*7*3, TAG_CHAD); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u32(128 + 4 + 4*7*3 + 4, 5000); // offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1200, 5); // invalid lut type
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1200, LUT8_TYPE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(1200 + 8, 9); // max clut size
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(1200 + 10, 9); // max clut size
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(1200 + 8, 3); // in_chan
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(1200 + 9, 3); // proper out_chan
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(1200 + 10, 1); // sane clut size
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1200, LUT16_TYPE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u16(1200 + 48, 3); // input_table_entries
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u16(1200 + 50, 3); // output_table_entries
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*6*3, TAG_A2B0); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*6*3, TAG_B2A0); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1200, LUT_MBA_TYPE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1200, LUT_MAB_TYPE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*6*3, TAG_A2B0); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(1200 + 8, 15); // > max in_chan
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(1200 + 9, 15); // > max out_chan
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(1200 + 9, 4); // long out_chan
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(1200 + 8, 2); // short in_chan
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(1200 + 9, 3); // proper out_chan
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(1200 + 8, 3); // proper out_chan
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-
-	write_u32(1200 + 12, 5); // b curve offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1200 + 12, 2000); // b curve offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1200 + 16, 2000); // matrix offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1200 + 20, 2000); // m curve offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1200 + 24, 3000); // clut offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(4200, 255); // clut channel size
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(4201, 255); // clut channel size
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(4202, 255); // clut channel size
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(4200, 2); // clut channel size
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(4201, 2); // clut channel size
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(4202, 2); // clut channel size
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u8(4216, 1); // clut precision
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u8(4216, 2); // clut precision
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1200 + 28, 2000); // a curve offset
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(3200, PARAMETRIC_CURVE_TYPE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u16(3208, 5);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u16(3208, 4);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u16(3208, 2);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(3200, CURVE_TYPE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	// reset the values
-	write_u16(3208, 0);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-
-	write_u32(3212, CURVE_TYPE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u32(3224, CURVE_TYPE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(5000, CHROMATIC_TYPE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-#if 1
-	write_u32(1100, CURVE_TYPE);
-	qcms_profile_release(qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1108, 100000); // curve count
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(1108, 1); // curve count
-	qcms_profile_release(qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	/* test out gray profiles */
-	write_u32(16, GRAY_SIGNATURE);
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	write_u32(128 + 4 + 4*8*3, TAG_kTRC); // tag
-	assert(!qcms_profile_from_memory(buf, PROFILE_LENGTH));
-	write_u32(128 + 4 + 4*8*3 + 4, 1100); // offset
-	qcms_profile_release(qcms_profile_from_memory(buf, PROFILE_LENGTH));
-
-	/* test out profiles that are the wrong size */
-	qcms_profile_from_path("sample-trunc.icc");
-#endif
-	return 0;
-}
-
diff --git a/lcms-compare.c b/lcms-compare.c
deleted file mode 100644
index 566eb1e..0000000
--- a/lcms-compare.c
+++ /dev/null
@@ -1,96 +0,0 @@
-#include <stdlib.h>
-#include <time.h>
-#include "sum.h"
-#include "lcms.h"
-#include "qcms.h"
-
-int main(int argc, char **argv)
-{
-	char *input_path = argv[1];
-	char *output_path = argv[2];
-	
-	qcms_profile *input_profile, *output_profile;
-	qcms_transform *transform;
-#define ALL
-#ifndef ALL
-#define LENGTH 1
-#else
-#define LENGTH (256*256*256)
-#endif
-	static unsigned char src[LENGTH*3];
-	static unsigned char qoutput[LENGTH*3];
-	static unsigned char loutput[LENGTH*3];
-#ifdef ALL
-	int i,j,k,l=0;
-	for (i=0; i<256; i++) {
-		for (j=0; j<256; j++) {
-			for (k=0; k<256; k++) {
-				src[l++] = i;
-				src[l++] = j;
-				src[l++] = k;
-			}
-		}
-	}
-#else
-	int i;
-	src[0] = 19;
-	src[1] = 28;
-	src[2] = 56;
-#endif
-	clock_t lcms_start = clock();
-	cmsHPROFILE linput_profile, loutput_profile;
-	cmsHTRANSFORM transformFixed;
-	linput_profile = cmsOpenProfileFromFile(input_path, "r");
-	loutput_profile = cmsOpenProfileFromFile(output_path, "r");
-#if 0
-	cmsPrecacheProfile(loutput_profile, CMS_PRECACHE_LI168_REVERSE);
-	cmsPrecacheProfile(linput_profile, CMS_PRECACHE_LI8F_FORWARD);
-	int flags = cmsFLAGS_FLOATSHAPER;
-#else
-	int flags = 0;
-#endif
-	transformFixed = cmsCreateTransform(
-			linput_profile, TYPE_RGB_8, 
-			loutput_profile, TYPE_RGB_8, 
-			INTENT_RELATIVE_COLORIMETRIC, flags);
-#if 0
-        QCMS_INTENT_PERCEPTUAL = 0,
-			               QCMS_INTENT_RELATIVE_COLORIMETRIC = 1,
-				               QCMS_INTENT_SATURATION = 2,
-					               QCMS_INTENT_ABSOLUTE_COLORIMETRIC = 3
-
-#endif
-	cmsDoTransform(transformFixed, src, loutput, LENGTH);
-	clock_t lcms_time = clock() - lcms_start;
-	clock_t qcms_start = clock();
-	input_profile = qcms_profile_from_path(input_path);
-	output_profile = qcms_profile_from_path(output_path);
-	qcms_profile_precache_output_transform(output_profile);
-
-	transform = qcms_transform_create(input_profile, QCMS_DATA_RGB_8, output_profile, QCMS_DATA_RGB_8, QCMS_INTENT_PERCEPTUAL);
-	qcms_transform_data(transform, src, qoutput, LENGTH);
-	clock_t qcms_time = clock() - qcms_start;
-	printf("lcms: %ld\n", lcms_time);
-	printf("qcms: %ld\n", qcms_time);
-	int total_diff = 0;
-	for (i=0; i<LENGTH; i++) {
-		int diff = 0;
-		diff += abs(loutput[i*3]-qoutput[i*3]);
-		diff += abs(loutput[i*3+1]-qoutput[i*3+1]);
-		diff += abs(loutput[i*3+2]-qoutput[i*3+2]);
-		total_diff += diff;
-		if (diff > 3) {
-			printf("differing output(%d): (%d %d %d) -> l(%d %d %d) vs. q(%d %d %d)\n",
-					diff, src[i*3], src[i*3+1], src[i*3+2],
-					loutput[i*3], loutput[i*3+1], loutput[i*3+2],
-					qoutput[i*3],
-					qoutput[i*3+1],
-					qoutput[i*3+2]);
-			//exit(1);
-		}
-	}
-	printf("%d - %f\n", total_diff, (double)total_diff/LENGTH);
-	qcms_profile_release(input_profile);
-	qcms_profile_release(output_profile);
-	return 0;
-}
diff --git a/malloc-fail.c b/malloc-fail.c
deleted file mode 100644
index 9554aa4..0000000
--- a/malloc-fail.c
+++ /dev/null
@@ -1,141 +0,0 @@
-#define _GNU_SOURCE
-
-#include <stdlib.h>
-#include <assert.h>
-#include <dlfcn.h> 
-
-#include "qcms.h"
-
-const unsigned char gray_icc[] =
-{0x00, 0x00, 0x01, 0x70, 0x4E, 0x4B, 0x4F, 0x4E, 0x02, 0x20, 0x00, 0x00,
-0x6D, 0x6E, 0x74, 0x72, 0x47, 0x52, 0x41, 0x59, 0x58, 0x59, 0x5A, 0x20,
-0x07, 0xCE, 0x00, 0x0B, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4C, 0x00, 0x00, 0x00, 0x00,
-0x6E, 0x6F, 0x6E, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF6, 0xD6,
-0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xD3, 0x2D, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
-0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x4B,
-0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0x0C, 0x00, 0x00, 0x00, 0x14,
-0x6B, 0x54, 0x52, 0x43, 0x00, 0x00, 0x01, 0x20, 0x00, 0x00, 0x00, 0x0E,
-0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x30, 0x00, 0x00, 0x00, 0x2C,
-0x62, 0x6B, 0x70, 0x74, 0x00, 0x00, 0x01, 0x5C, 0x00, 0x00, 0x00, 0x14,
-0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1A,
-0x4E, 0x69, 0x6B, 0x6F, 0x6E, 0x47, 0x72, 0x61, 0x79, 0x47, 0x31, 0x2E,
-0x38, 0x20, 0x76, 0x34, 0x2E, 0x30, 0x2E, 0x30, 0x2E, 0x33, 0x30, 0x30,
-0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x1A, 0x4E, 0x69, 0x6B, 0x6F, 0x6E, 0x47, 0x72, 0x61, 0x79, 0x47, 0x31,
-0x2E, 0x38, 0x20, 0x76, 0x34, 0x2E, 0x30, 0x2E, 0x30, 0x2E, 0x33, 0x30,
-0x30, 0x30, 0x00, 0x00, 0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0xF3, 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xCC,
-0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
-0x01, 0xCD, 0x00, 0x00, 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00,
-0x4E, 0x69, 0x6B, 0x6F, 0x6E, 0x20, 0x49, 0x6E, 0x63, 0x2E, 0x20, 0x26,
-0x20, 0x4E, 0x69, 0x6B, 0x6F, 0x6E, 0x20, 0x43, 0x6F, 0x72, 0x70, 0x6F,
-0x72, 0x61, 0x74, 0x69, 0x6F, 0x6E, 0x20, 0x32, 0x30, 0x30, 0x31, 0x00,
-0x58, 0x59, 0x5A, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-
-void test_gray(qcms_profile *output_profile)
-{
-	unsigned char srct[3] = { 221, 79, 129};
-	unsigned char outt[3];
-	qcms_transform *transform;
-	qcms_profile *gray_profile = qcms_profile_from_memory(gray_icc, sizeof(gray_icc));
-	if (gray_profile) {
-		transform = qcms_transform_create(gray_profile, QCMS_DATA_GRAY_8, output_profile, QCMS_DATA_RGB_8, QCMS_INTENT_PERCEPTUAL);
-		if (transform) {
-			qcms_transform_data(transform, srct, outt, 1);
-			qcms_transform_release(transform);
-		}
-		qcms_profile_release(gray_profile);
-	}
-
-}
-
-void test_gray_precache(qcms_profile *output_profile)
-{
-	unsigned char srct[3] = { 221, 79, 129};
-	unsigned char outt[3];
-	qcms_transform *transform;
-	qcms_profile *gray_profile = qcms_profile_from_memory(gray_icc, sizeof(gray_icc));
-	qcms_profile_precache_output_transform(output_profile);
-	if (gray_profile) {
-		transform = qcms_transform_create(gray_profile, QCMS_DATA_GRAY_8, output_profile, QCMS_DATA_RGB_8, QCMS_INTENT_PERCEPTUAL);
-		if (transform) {
-			qcms_transform_data(transform, srct, outt, 1);
-			qcms_transform_release(transform);
-		}
-		qcms_profile_release(gray_profile);
-	}
-
-}
-void do_test(void) {
-	unsigned char srct[4] = { 221, 79, 129, 92};
-	unsigned char outt[4];
-	qcms_transform *transform;
-	qcms_profile *input_profile, *output_profile, *rgb;
-	qcms_CIE_xyY invalid_white_point = { 0., 0., 1.};
-	qcms_CIE_xyY white_point = { 0.9, 1., 1.};
-	qcms_CIE_xyYTRIPLE primaries = { {.9, .3, 1.}, {.2, .4, 1.}, {.7, .4, 1.}};
-
-	rgb = qcms_profile_create_rgb_with_gamma(invalid_white_point, primaries, 1.8);
-	if (rgb)
-		qcms_profile_release(rgb);
-	rgb = qcms_profile_create_rgb_with_gamma(white_point, primaries, 1.8);
-	input_profile = qcms_profile_sRGB();
-	output_profile = qcms_profile_sRGB();
-	if (output_profile) {
-		test_gray(output_profile);
-		test_gray_precache(output_profile);
-		qcms_profile_release(output_profile);
-	}
-	if (input_profile)
-		qcms_profile_release(input_profile);
-	if (rgb)
-		qcms_profile_release(rgb);
-	rgb = qcms_profile_from_path("sample-trunc.icc");
-	if (rgb)
-		qcms_profile_release(rgb);
-}
-
-static int current_counter;
-static int counter;
-
-void* malloc(size_t size)
-{
-	if (counter == current_counter++) {
-		return NULL;
-	}
-	static void* (*real_malloc)(size_t size);
-	if (!real_malloc)
-		real_malloc = (void* (*)(size_t)) dlsym(RTLD_NEXT, "malloc");
-	return real_malloc(size);
-}
-
-void* calloc(size_t count, size_t size)
-{
-	if (counter == current_counter++) {
-		return NULL;
-	}
-	static void* (*real_calloc)(size_t count, size_t size);
-	if (!real_calloc)
-		real_calloc = (void* (*)(size_t, size_t)) dlsym(RTLD_NEXT, "calloc");
-	return real_calloc(count, size);
-}
-
-
-const extern unsigned char gray_icc[];
-int main()
-{
-	while (current_counter >= counter) {
-		current_counter = 0;
-		do_test();
-		counter++;
-	}
-	return 0;
-}
-
diff --git a/qcms.h b/qcms.h
index 7d83623..b91498c 100644
--- a/qcms.h
+++ b/qcms.h
@@ -1,3 +1,25 @@
+/* vim: set ts=8 sw=8 noexpandtab: */
+//  qcms
+//  Copyright (C) 2009 Mozilla Foundation
+//
+// 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.
+
 #ifndef QCMS_H
 #define QCMS_H
 
@@ -5,87 +27,32 @@
 extern "C" {
 #endif
 
-/* if we've already got an ICC_H header we can ignore the following */
-#ifndef ICC_H
-/* icc34 defines */
-
-/***************************************************************** 
- Copyright (c) 1994-1996 SunSoft, Inc.
-
-                    Rights Reserved
-
-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 restrict- 
-ion, 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 NON-
-INFRINGEMENT.  IN NO EVENT SHALL SUNSOFT, INC. OR ITS PARENT 
-COMPANY 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. 
- 
-Except as contained in this notice, the name of SunSoft, Inc. 
-shall not be used in advertising or otherwise to promote the 
-sale, use or other dealings in this Software without written 
-authorization from SunSoft Inc. 
-******************************************************************/
-
-/* 
- * Color Space Signatures
- * Note that only icSigXYZData and icSigLabData are valid
- * Profile Connection Spaces (PCSs)
- */ 
-typedef enum {
-    icSigXYZData                        = 0x58595A20L,  /* 'XYZ ' */
-    icSigLabData                        = 0x4C616220L,  /* 'Lab ' */
-    icSigLuvData                        = 0x4C757620L,  /* 'Luv ' */
-    icSigYCbCrData                      = 0x59436272L,  /* 'YCbr' */
-    icSigYxyData                        = 0x59787920L,  /* 'Yxy ' */
-    icSigRgbData                        = 0x52474220L,  /* 'RGB ' */
-    icSigGrayData                       = 0x47524159L,  /* 'GRAY' */
-    icSigHsvData                        = 0x48535620L,  /* 'HSV ' */
-    icSigHlsData                        = 0x484C5320L,  /* 'HLS ' */
-    icSigCmykData                       = 0x434D594BL,  /* 'CMYK' */
-    icSigCmyData                        = 0x434D5920L,  /* 'CMY ' */
-    icSig2colorData                     = 0x32434C52L,  /* '2CLR' */
-    icSig3colorData                     = 0x33434C52L,  /* '3CLR' */
-    icSig4colorData                     = 0x34434C52L,  /* '4CLR' */
-    icSig5colorData                     = 0x35434C52L,  /* '5CLR' */
-    icSig6colorData                     = 0x36434C52L,  /* '6CLR' */
-    icSig7colorData                     = 0x37434C52L,  /* '7CLR' */
-    icSig8colorData                     = 0x38434C52L,  /* '8CLR' */
-    icSig9colorData                     = 0x39434C52L,  /* '9CLR' */
-    icSig10colorData                    = 0x41434C52L,  /* 'ACLR' */
-    icSig11colorData                    = 0x42434C52L,  /* 'BCLR' */
-    icSig12colorData                    = 0x43434C52L,  /* 'CCLR' */
-    icSig13colorData                    = 0x44434C52L,  /* 'DCLR' */
-    icSig14colorData                    = 0x45434C52L,  /* 'ECLR' */
-    icSig15colorData                    = 0x46434C52L,  /* 'FCLR' */
-    icMaxEnumData                       = 0xFFFFFFFFL   
-} icColorSpaceSignature;
-#endif
-
 #include <stdio.h>
 
-typedef int qcms_bool;
-
-struct _qcms_transform;
-typedef struct _qcms_transform qcms_transform;
-
 struct _qcms_profile;
 typedef struct _qcms_profile qcms_profile;
 
-/* these values match the Rendering Intent values from the ICC spec */
+struct _qcms_transform;
+typedef struct _qcms_transform qcms_transform;
+
+typedef int qcms_bool;
+
+/* ICC Section 6.1.5 Color Space Signatures (abridged) */
+typedef enum {
+	XYZData		/* ‘XYZ ’ */ = 0x58595A20,
+	labData		/* ‘Lab ’ */ = 0x4C616220,
+	luvData		/* ‘Luv ’ */ = 0x4C757620,
+	YCbCrData	/* ‘YCbr' */ = 0x59436272,
+	YxyData		/* ‘Yxy ’ */ = 0x59787920,
+	rgbData		/* ‘RGB ’ */ = 0x52474220,
+	grayData	/* ‘GRAY’ */ = 0x47524159,
+	hsvData		/* ‘HSV ’ */ = 0x48535620,
+	hlsData		/* ‘HLS ’ */ = 0x484C5320,
+	cmykData	/* ‘CMYK’ */ = 0x434D594B,
+	cmyData		/* ‘CMY ’ */ = 0x434D5920,
+} qcms_color_space;
+
+/* ICC Section 6.1.11 Rendering Intents */
 typedef enum {
 	QCMS_INTENT_DEFAULT = 0,
 	QCMS_INTENT_PERCEPTUAL = 0,
@@ -94,7 +61,7 @@
 	QCMS_INTENT_ABSOLUTE_COLORIMETRIC = 3
 } qcms_intent;
 
-//XXX: I don't really like the _DATA_ prefix
+/* Input data formats */
 typedef enum {
 	QCMS_DATA_RGB_8,
 	QCMS_DATA_RGBA_8,
@@ -102,21 +69,45 @@
 	QCMS_DATA_GRAYA_8
 } qcms_data_type;
 
-/* the names for the following two types are sort of ugly */
-typedef struct
-{
+/* Output data format for qcms_transform_data_type() */
+typedef enum {
+	QCMS_OUTPUT_RGBX,
+	QCMS_OUTPUT_BGRX
+} qcms_output_type;
+
+/* Output data format for qcms_transform_get_input|output_trc_rgba() */
+typedef enum {
+	QCMS_TRC_PARAMETRIC, // Not implemented.
+	QCMS_TRC_FLOAT,      // Not implemented.
+	QCMS_TRC_HALF_FLOAT, // IEE754: binary16.
+	QCMS_TRC_USHORT,     // 0.16 fixed point.
+} qcms_trc_type;
+
+/* Output data of specific channel curve for qcms_profile_get_parametric_curve() */
+typedef enum {
+	QCMS_TRC_RED,
+	QCMS_TRC_GREEN,
+	QCMS_TRC_BLUE,
+} qcms_trc_channel;
+
+typedef struct {
 	double x;
 	double y;
 	double Y;
 } qcms_CIE_xyY;
 
-typedef struct
-{
+typedef struct {
 	qcms_CIE_xyY red;
 	qcms_CIE_xyY green;
 	qcms_CIE_xyY blue;
 } qcms_CIE_xyYTRIPLE;
 
+typedef struct {
+	float X;
+	float Y;
+	float Z;
+} qcms_xyz_float;
+
 qcms_profile* qcms_profile_create_rgb_with_gamma(
 		qcms_CIE_xyY white_point,
 		qcms_CIE_xyYTRIPLE primaries,
@@ -126,26 +117,50 @@
 
 qcms_profile* qcms_profile_from_file(FILE *file);
 qcms_profile* qcms_profile_from_path(const char *path);
-#ifdef _WIN32
-qcms_profile* qcms_profile_from_unicode_path(const wchar_t *path);
-#endif
 qcms_profile* qcms_profile_sRGB(void);
 void qcms_profile_release(qcms_profile *profile);
 
 qcms_bool qcms_profile_is_bogus(qcms_profile *profile);
+qcms_bool qcms_profile_has_white_point(qcms_profile *profile);
+qcms_xyz_float qcms_profile_get_white_point(qcms_profile *profile);
 qcms_intent qcms_profile_get_rendering_intent(qcms_profile *profile);
-icColorSpaceSignature qcms_profile_get_color_space(qcms_profile *profile);
+qcms_color_space qcms_profile_get_color_space(qcms_profile *profile);
+unsigned qcms_profile_get_version(qcms_profile *profile);
+qcms_bool qcms_profile_white_transform(qcms_profile *profile, float XYZ[3]);
+
+qcms_bool qcms_profile_match(qcms_profile *p1, qcms_profile *p2);
+const char* qcms_profile_get_description(qcms_profile *profile);
 
 void qcms_profile_precache_output_transform(qcms_profile *profile);
 
+size_t qcms_profile_get_vcgt_channel_length(qcms_profile *profile);
+qcms_bool qcms_profile_get_vcgt_rgb_channels(qcms_profile *profile, unsigned short *data);
+
+float qcms_profile_ntsc_relative_gamut_size(qcms_profile *profile);
+
+size_t qcms_profile_get_parametric_curve(qcms_profile *profile, qcms_trc_channel channel, float data[7]);
+
 qcms_transform* qcms_transform_create(
 		qcms_profile *in, qcms_data_type in_type,
-		qcms_profile* out, qcms_data_type out_type,
+		qcms_profile *out, qcms_data_type out_type,
 		qcms_intent intent);
 
-void qcms_transform_release(qcms_transform *);
+size_t qcms_transform_get_input_trc_rgba(
+		qcms_transform *transform, qcms_profile *in, qcms_trc_type type, unsigned short *data);
+size_t qcms_transform_get_output_trc_rgba(
+		qcms_transform *transform, qcms_profile *out, qcms_trc_type type, unsigned short *data);
+
+qcms_bool qcms_transform_is_matrix(qcms_transform *transform);
+float qcms_transform_get_matrix(qcms_transform *transform, unsigned i, unsigned j);
+
+qcms_bool qcms_transform_create_LUT_zyx_bgra(
+		qcms_profile *in, qcms_profile *out, qcms_intent intent,
+		int samples, unsigned char* lut);
 
 void qcms_transform_data(qcms_transform *transform, void *src, void *dest, size_t length);
+void qcms_transform_data_type(qcms_transform *transform, void *src, void *dest, size_t length, qcms_output_type type);
+
+void qcms_transform_release(qcms_transform *);
 
 void qcms_enable_iccv4();
 
@@ -153,4 +168,10 @@
 }
 #endif
 
+/*
+ * In general, QCMS is not threadsafe. However, it should be safe to create
+ * profile and transformation objects on different threads, so long as you
+ * don't use the same objects on different threads at the same time.
+ */
+
 #endif
diff --git a/qcms_util.c b/qcms_util.c
new file mode 100644
index 0000000..9b2d9fa
--- /dev/null
+++ b/qcms_util.c
@@ -0,0 +1,69 @@
+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the Chromium LICENSE file.
+
+#include "qcmsint.h"
+
+#include <math.h>
+
+typedef struct _qcms_coords {
+    float x;
+    float y;
+} qcms_coords;
+
+typedef struct _qcms_triangle {
+    qcms_coords verticies[3];
+} qcms_triangle;
+
+#define NTSC_1953_GAMUT_SIZE    0.1582
+
+static qcms_triangle get_profile_triangle(qcms_profile *profile)
+{
+    float sumRed = s15Fixed16Number_to_float(profile->redColorant.X) +
+                   s15Fixed16Number_to_float(profile->redColorant.Y) +
+                   s15Fixed16Number_to_float(profile->redColorant.Z);
+    float xRed = s15Fixed16Number_to_float(profile->redColorant.X) / sumRed;
+    float yRed = s15Fixed16Number_to_float(profile->redColorant.Y) / sumRed;
+
+    float sumGreen = s15Fixed16Number_to_float(profile->greenColorant.X) +
+                     s15Fixed16Number_to_float(profile->greenColorant.Y) +
+                     s15Fixed16Number_to_float(profile->greenColorant.Z);
+    float xGreen = s15Fixed16Number_to_float(profile->greenColorant.X) / sumGreen;
+    float yGreen = s15Fixed16Number_to_float(profile->greenColorant.Y) / sumGreen;
+
+    float sumBlue = s15Fixed16Number_to_float(profile->blueColorant.X) +
+                    s15Fixed16Number_to_float(profile->blueColorant.Y) +
+                    s15Fixed16Number_to_float(profile->blueColorant.Z);
+    float xBlue = s15Fixed16Number_to_float(profile->blueColorant.X) / sumBlue;
+    float yBlue = s15Fixed16Number_to_float(profile->blueColorant.Y) / sumBlue;
+
+    qcms_triangle triangle = {{{xRed, yRed}, {xGreen, yGreen}, {xBlue, yBlue}}};
+    return triangle;
+}
+
+static float get_triangle_area(const qcms_triangle candidate)
+{
+    float xRed = candidate.verticies[0].x;
+    float yRed = candidate.verticies[0].y;
+    float xGreen = candidate.verticies[1].x;
+    float yGreen = candidate.verticies[1].y;
+    float xBlue = candidate.verticies[2].x;
+    float yBlue = candidate.verticies[2].y;
+
+    float area = fabs((xRed - xBlue) * (yGreen - yBlue) - (xGreen - xBlue) * (yRed - yBlue)) / 2;
+    return area;
+}
+
+static float get_ntsc_gamut_metric_area(const qcms_triangle candidate)
+{
+    float area = get_triangle_area(candidate);
+    return area * 100 / NTSC_1953_GAMUT_SIZE;
+}
+
+float qcms_profile_ntsc_relative_gamut_size(qcms_profile *profile)
+{
+    qcms_triangle triangle = get_profile_triangle(profile);
+    return get_ntsc_gamut_metric_area(triangle);
+}
+
+
diff --git a/qcmsint.h b/qcmsint.h
index 15c18ff..005b089 100644
--- a/qcmsint.h
+++ b/qcmsint.h
@@ -1,23 +1,23 @@
-// vim: set ts=8 sw=8 noexpandtab:
+/* vim: set ts=8 sw=8 noexpandtab: */
 //  qcms
 //  Copyright (C) 2009 Mozilla Foundation
 //
-// 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 
+// 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 
+// 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 
+// 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 "qcms.h"
@@ -45,6 +45,11 @@
 #define ALIGN __attribute__(( aligned (16) ))
 #endif
 
+typedef struct _qcms_format_type {
+	int r;
+	int b;
+} qcms_format_type;
+
 struct _qcms_transform {
 	float ALIGN matrix[3][4];
 	float *input_gamma_table_r;
@@ -88,7 +93,16 @@
 	struct precache_output *output_table_g;
 	struct precache_output *output_table_b;
 
-	void (*transform_fn)(struct _qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length);
+	void (*transform_fn)(struct _qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, struct _qcms_format_type output_format);
+
+	unsigned char floor_cache[256];
+	unsigned char ceil_cache[256];
+	float r_cache[256];
+
+#define TRANSFORM_FLAG_MATRIX		0x0001
+#define TRANSFORM_FLAG_CLUT_CACHE	0x0002
+
+	uint16_t transform_flags;
 };
 
 struct matrix {
@@ -200,6 +214,14 @@
 
 	float table_data[];
 };
+
+struct vcgtType {
+	/* data contains three gamma channels: R[length], then G[length], then
+	 * B[length]. */
+	uint16_t *data;
+	size_t length;
+};
+
 #if 0
 /* this is from an intial idea of having the struct correspond to the data in
  * the file. I decided that it wasn't a good idea.
@@ -225,10 +247,13 @@
 #define LAB_SIGNATURE  0x4C616220
 
 struct _qcms_profile {
+	uint32_t icc_version;
+	char description[64];
 	uint32_t class;
 	uint32_t color_space;
 	uint32_t pcs;
 	qcms_intent rendering_intent;
+	struct XYZNumber mediaWhitePoint;
 	struct XYZNumber redColorant;
 	struct XYZNumber blueColorant;
 	struct XYZNumber greenColorant;
@@ -241,6 +266,7 @@
 	struct lutmABType *mAB;
 	struct lutmABType *mBA;
 	struct matrix chromaticAdaption;
+	struct vcgtType vcgt;
 
 	struct precache_output *output_table_r;
 	struct precache_output *output_table_g;
@@ -280,41 +306,37 @@
 void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform,
                                           unsigned char *src,
                                           unsigned char *dest,
-                                          size_t length);
+                                          size_t length,
+                                          qcms_format_type output_format);
 void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform,
                                           unsigned char *src,
                                           unsigned char *dest,
-                                          size_t length);
-void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform,
-                                          unsigned char *src,
-                                          unsigned char *dest,
-                                          size_t length);
-void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform,
-                                          unsigned char *src,
-                                          unsigned char *dest,
-                                          size_t length);
+                                          size_t length,
+                                          qcms_format_type output_format);
+void qcms_transform_data_tetra_clut_rgba_sse2(qcms_transform* transform,
+                                              unsigned char* src,
+                                              unsigned char* dest,
+                                              size_t length,
+                                              qcms_format_type output_format);
+
+void qcms_transform_build_clut_cache(qcms_transform* transform);
 
 extern qcms_bool qcms_supports_iccv4;
 
-#ifdef NATIVE_OUTPUT
-# define RGB_OUTPUT_COMPONENTS 4
-# define RGBA_OUTPUT_COMPONENTS 4
-# ifdef IS_LITTLE_ENDIAN
-#  define OUTPUT_INDEX_A 3
-#  define OUTPUT_INDEX_R 2
-#  define OUTPUT_INDEX_G 1
-#  define OUTPUT_INDEX_B 0
-# else
-#  define OUTPUT_INDEX_A 0
-#  define OUTPUT_INDEX_R 1
-#  define OUTPUT_INDEX_G 2
-#  define OUTPUT_INDEX_B 3
-# endif
+
+#ifdef _MSC_VER
+
+long __cdecl _InterlockedIncrement(long volatile *);
+long __cdecl _InterlockedDecrement(long volatile *);
+#pragma intrinsic(_InterlockedIncrement)
+#pragma intrinsic(_InterlockedDecrement)
+
+#define qcms_atomic_increment(x) _InterlockedIncrement((long volatile *)&x)
+#define qcms_atomic_decrement(x) _InterlockedDecrement((long volatile*)&x)
+
 #else
-# define RGB_OUTPUT_COMPONENTS 3
-# define RGBA_OUTPUT_COMPONENTS 4
-# define OUTPUT_R_INDEX 0
-# define OUTPUT_G_INDEX 1
-# define OUTPUT_B_INDEX 2
-# define OUTPUT_A_INDEX 3
+
+#define qcms_atomic_increment(x) __sync_add_and_fetch(&x, 1)
+#define qcms_atomic_decrement(x) __sync_sub_and_fetch(&x, 1)
+
 #endif
diff --git a/qcmstypes.h b/qcmstypes.h
index 584ca94..b97307a 100644
--- a/qcmstypes.h
+++ b/qcmstypes.h
@@ -1,48 +1,27 @@
 //  qcms
 //  Copyright (C) 2009 Mozilla Foundation
 //
-// 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 
+// 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 
+// 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 
+// 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.
 
 #ifndef QCMS_TYPES_H
 #define QCMS_TYPES_H
 
-#ifdef MOZ_QCMS
-
-#include "mozilla/StandardInteger.h"
-
-#include "prtypes.h"
-/* prtypes.h defines IS_LITTLE_ENDIAN and IS_BIG_ENDIAN */
-
-#if defined (__SVR4) && defined (__sun)
-/* int_types.h gets included somehow, so avoid redefining the types differently */
-#include <sys/int_types.h>
-#elif defined (_AIX)
-#include <sys/types.h>
-#elif defined(__OS2__)
-/* OS/2's stdlib typdefs uintptr_t. So we'll just include that so we don't collide */
-#include <stdlib.h>
-#elif !defined(__intptr_t_defined) && !defined(_UINTPTR_T_DEFINED)
-typedef unsigned long uintptr_t;
-#endif
-
-#else // MOZ_QCMS
-
 #if BYTE_ORDER == LITTLE_ENDIAN
 #define IS_LITTLE_ENDIAN
 #elif BYTE_ORDER == BIG_ENDIAN
@@ -65,7 +44,7 @@
 
 #if defined (_SVR4) || defined (SVR4) || defined (__OpenBSD__) || defined (_sgi) || defined (__sun) || defined (sun) || defined (__digital__)
 #  include <inttypes.h>
-#elif defined (_MSC_VER)
+#elif defined (_MSC_VER) && _MSC_VER < 1600
 typedef __int8 int8_t;
 typedef unsigned __int8 uint8_t;
 typedef __int16 int16_t;
@@ -74,11 +53,6 @@
 typedef unsigned __int32 uint32_t;
 typedef __int64 int64_t;
 typedef unsigned __int64 uint64_t;
-#ifdef _WIN64
-typedef unsigned __int64 uintptr_t;
-#else
-typedef unsigned long uintptr_t;
-#endif
 
 #elif defined (_AIX)
 #  include <sys/inttypes.h>
@@ -86,8 +60,6 @@
 #  include <stdint.h>
 #endif
 
-#endif
-
 typedef qcms_bool bool;
 #define true 1
 #define false 0
diff --git a/sample-trunc.icc b/sample-trunc.icc
deleted file mode 100644
index 8a41f39..0000000
--- a/sample-trunc.icc
+++ /dev/null
Binary files differ
diff --git a/sum.h b/sum.h
deleted file mode 100644
index 15c949e..0000000
--- a/sum.h
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
-SHA-1 in C
-By Steve Reid <sreid@sea-to-sky.net>
-100% Public Domain
-
------------------
-Modified 7/98 
-By James H. Brown <jbrown@burgoyne.com>
-Still 100% Public Domain
-
-Corrected a problem which generated improper hash values on 16 bit machines
-Routine SHA1Update changed from
-	void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int
-len)
-to
-	void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned
-long len)
-
-The 'len' parameter was declared an int which works fine on 32 bit machines.
-However, on 16 bit machines an int is too small for the shifts being done
-against
-it.  This caused the hash function to generate incorrect values if len was
-greater than 8191 (8K - 1) due to the 'len << 3' on line 3 of SHA1Update().
-
-Since the file IO in main() reads 16K at a time, any file 8K or larger would
-be guaranteed to generate the wrong hash (e.g. Test Vector #3, a million
-"a"s).
-
-I also changed the declaration of variables i & j in SHA1Update to 
-unsigned long from unsigned int for the same reason.
-
-These changes should make no difference to any 32 bit implementations since
-an
-int and a long are the same size in those environments.
-
---
-I also corrected a few compiler warnings generated by Borland C.
-1. Added #include <process.h> for exit() prototype
-2. Removed unused variable 'j' in SHA1Final
-3. Changed exit(0) to return(0) at end of main.
-
-ALL changes I made can be located by searching for comments containing 'JHB'
------------------
-Modified 8/98
-By Steve Reid <sreid@sea-to-sky.net>
-Still 100% public domain
-
-1- Removed #include <process.h> and used return() instead of exit()
-2- Fixed overwriting of finalcount in SHA1Final() (discovered by Chris Hall)
-3- Changed email address from steve@edmweb.com to sreid@sea-to-sky.net
-
------------------
-Modified 4/01
-By Saul Kravitz <Saul.Kravitz@celera.com>
-Still 100% PD
-Modified to run on Compaq Alpha hardware.  
-
------------------
-Modified 07/2002
-By Ralph Giles <giles@artofcode.com>
-Still 100% public domain
-modified for use with stdint types, autoconf
-code cleanup, removed attribution comments
-switched SHA1Final() argument order for consistency
-use SHA1_ prefix for public api
-move public api to sha1.h
-*/
-
-/*
-Test Vectors (from FIPS PUB 180-1)
-"abc"
-  A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
-"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
-  84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
-A million repetitions of "a"
-  34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
-*/
-
-#include <stddef.h>
-#include <stdint.h>
-/* public api for steve reid's public domain SHA-1 implementation */
-/* this file is in the public domain */
-
-#ifndef __SHA1_H
-#define __SHA1_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct {
-    uint32_t state[5];
-    uint32_t count[2];
-    uint8_t  buffer[64];
-} SHA1_CTX;
-
-#define SHA1_DIGEST_SIZE 20
-
-static void SHA1_Init(SHA1_CTX* context);
-static void SHA1_Update(SHA1_CTX* context, const uint8_t* data, const size_t len);
-static void SHA1_Final(SHA1_CTX* context, uint8_t digest[SHA1_DIGEST_SIZE]);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* __SHA1_H */
-#define SHA1HANDSOFF
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include <stdio.h>
-#include <string.h>
-
-//#include "os_types.h"
-//#include "sha1.h"
-
-static void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64]);
-
-#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
-
-/* blk0() and blk() perform the initial expand. */
-/* I got the idea of expanding during the round function from SSLeay */
-/* FIXME: can we do this in an endian-proof way? */
-#ifdef WORDS_BIGENDIAN
-#define blk0(i) block->l[i]
-#else
-#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \
-    |(rol(block->l[i],8)&0x00FF00FF))
-#endif
-#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \
-    ^block->l[(i+2)&15]^block->l[i&15],1))
-
-/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
-#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
-#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30);
-#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
-#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
-#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
-
-
-#ifdef VERBOSE  /* SAK */
-void SHAPrintContext(SHA1_CTX *context, char *msg){
-  printf("%s (%d,%d) %x %x %x %x %x\n",
-	 msg,
-	 context->count[0], context->count[1], 
-	 context->state[0],
-	 context->state[1],
-	 context->state[2],
-	 context->state[3],
-	 context->state[4]);
-}
-#endif /* VERBOSE */
-
-/* Hash a single 512-bit block. This is the core of the algorithm. */
-static void SHA1_Transform(uint32_t state[5], const uint8_t buffer[64])
-{
-    uint32_t a, b, c, d, e;
-    typedef union {
-        uint8_t c[64];
-        uint32_t l[16];
-    } CHAR64LONG16;
-    CHAR64LONG16* block;
-
-#ifdef SHA1HANDSOFF
-    static uint8_t workspace[64];
-    block = (CHAR64LONG16*)workspace;
-    memcpy(block, buffer, 64);
-#else
-    block = (CHAR64LONG16*)buffer;
-#endif
-
-    /* Copy context->state[] to working vars */
-    a = state[0];
-    b = state[1];
-    c = state[2];
-    d = state[3];
-    e = state[4];
-
-    /* 4 rounds of 20 operations each. Loop unrolled. */
-    R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
-    R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
-    R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
-    R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
-    R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
-    R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
-    R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
-    R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
-    R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
-    R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
-    R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
-    R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
-    R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
-    R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
-    R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
-    R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
-    R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
-    R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
-    R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
-    R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
-
-    /* Add the working vars back into context.state[] */
-    state[0] += a;
-    state[1] += b;
-    state[2] += c;
-    state[3] += d;
-    state[4] += e;
-
-    /* Wipe variables */
-    a = b = c = d = e = 0;
-}
-
-
-/* SHA1Init - Initialize new context */
-static void SHA1_Init(SHA1_CTX* context)
-{
-    /* SHA1 initialization constants */
-    context->state[0] = 0x67452301;
-    context->state[1] = 0xEFCDAB89;
-    context->state[2] = 0x98BADCFE;
-    context->state[3] = 0x10325476;
-    context->state[4] = 0xC3D2E1F0;
-    context->count[0] = context->count[1] = 0;
-}
-
-
-/* Run your data through this. */
-static void SHA1_Update(SHA1_CTX* context, const uint8_t* data, const size_t len)
-{
-    size_t i, j;
-
-#ifdef VERBOSE
-    SHAPrintContext(context, "before");
-#endif
-
-    j = (context->count[0] >> 3) & 63;
-    if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;
-    context->count[1] += (len >> 29);
-    if ((j + len) > 63) {
-        memcpy(&context->buffer[j], data, (i = 64-j));
-        SHA1_Transform(context->state, context->buffer);
-        for ( ; i + 63 < len; i += 64) {
-            SHA1_Transform(context->state, data + i);
-        }
-        j = 0;
-    }
-    else i = 0;
-    memcpy(&context->buffer[j], &data[i], len - i);
-
-#ifdef VERBOSE
-    SHAPrintContext(context, "after ");
-#endif
-}
-
-
-/* Add padding and return the message digest. */
-static void SHA1_Final(SHA1_CTX* context, uint8_t digest[SHA1_DIGEST_SIZE])
-{
-    uint32_t i;
-    uint8_t  finalcount[8];
-
-    for (i = 0; i < 8; i++) {
-        finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)]
-         >> ((3-(i & 3)) * 8) ) & 255);  /* Endian independent */
-    }
-    SHA1_Update(context, (uint8_t *)"\200", 1);
-    while ((context->count[0] & 504) != 448) {
-        SHA1_Update(context, (uint8_t *)"\0", 1);
-    }
-    SHA1_Update(context, finalcount, 8);  /* Should cause a SHA1_Transform() */
-    for (i = 0; i < SHA1_DIGEST_SIZE; i++) {
-        digest[i] = (uint8_t)
-         ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255);
-    }
-    
-    /* Wipe variables */
-    i = 0;
-    memset(context->buffer, 0, 64);
-    memset(context->state, 0, 20);
-    memset(context->count, 0, 8);
-    memset(finalcount, 0, 8);	/* SWR */
-
-#ifdef SHA1HANDSOFF  /* make SHA1Transform overwrite its own static vars */
-    SHA1_Transform(context->state, context->buffer);
-#endif
-}
-
-static inline unsigned long sum(void *data, int len)
-{
-    SHA1_CTX sha;
-    uint8_t digest[20];
-
-    SHA1_Init(&sha);
-    SHA1_Update(&sha, data, len);
-
-    SHA1_Final(&sha, digest);
-    return digest[0] << 24 | digest[1] << 16 | digest[2] << 8 | digest[3];
-}
-#if 0
-int main(int argc, char** argv)
-{
-int i, j;
-SHA1_CTX context;
-unsigned char digest[SHA1_DIGEST_SIZE], buffer[16384];
-FILE* file;
-
-    if (argc > 2) {
-        puts("Public domain SHA-1 implementation - by Steve Reid <sreid@sea-to-sky.net>");
-        puts("Modified for 16 bit environments 7/98 - by James H. Brown <jbrown@burgoyne.com>");	/* JHB */
-        puts("Produces the SHA-1 hash of a file, or stdin if no file is specified.");
-        return(0);
-    }
-    if (argc < 2) {
-        file = stdin;
-    }
-    else {
-        if (!(file = fopen(argv[1], "rb"))) {
-            fputs("Unable to open file.", stderr);
-            return(-1);
-        }
-    } 
-    SHA1_Init(&context);
-    while (!feof(file)) {  /* note: what if ferror(file) */
-        i = fread(buffer, 1, 16384, file);
-        SHA1_Update(&context, buffer, i);
-    }
-    SHA1_Final(&context, digest);
-    fclose(file);
-    for (i = 0; i < SHA1_DIGEST_SIZE/4; i++) {
-        for (j = 0; j < 4; j++) {
-            printf("%02X", digest[i*4+j]);
-        }
-        putchar(' ');
-    }
-    putchar('\n');
-    return(0);	/* JHB */
-}
-#endif
-#if 0
-/* self test */
-#define TEST
-#ifdef TEST
-
-static char *test_data[] = {
-    "abc",
-    "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
-    "A million repetitions of 'a'"};
-static char *test_results[] = {
-    "A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D",
-    "84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1",
-    "34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F"};
-    
-
-void digest_to_hex(const uint8_t digest[SHA1_DIGEST_SIZE], char *output)
-{
-    int i,j;
-    char *c = output;
-    
-    for (i = 0; i < SHA1_DIGEST_SIZE/4; i++) {
-        for (j = 0; j < 4; j++) {
-            sprintf(c,"%02X", digest[i*4+j]);
-            c += 2;
-        }
-        sprintf(c, " ");
-        c += 1;
-    }
-    *(c - 1) = '\0';
-}
-    
-int main(int argc, char** argv)
-{
-    int k;
-    SHA1_CTX context;
-    uint8_t digest[20];
-    char output[80];
-
-    fprintf(stdout, "verifying SHA-1 implementation... ");
-    
-    for (k = 0; k < 2; k++){ 
-        SHA1_Init(&context);
-        SHA1_Update(&context, (uint8_t*)test_data[k], strlen(test_data[k]));
-        SHA1_Final(&context, digest);
-	digest_to_hex(digest, output);
-
-        if (strcmp(output, test_results[k])) {
-            fprintf(stdout, "FAIL\n");
-            fprintf(stderr,"* hash of \"%s\" incorrect:\n", test_data[k]);
-            fprintf(stderr,"\t%s returned\n", output);
-            fprintf(stderr,"\t%s is correct\n", test_results[k]);
-            return (1);
-        }    
-    }
-    /* million 'a' vector we feed separately */
-    SHA1_Init(&context);
-    for (k = 0; k < 1000000; k++)
-        SHA1_Update(&context, (uint8_t*)"a", 1);
-    SHA1_Final(&context, digest);
-    digest_to_hex(digest, output);
-    if (strcmp(output, test_results[2])) {
-        fprintf(stdout, "FAIL\n");
-        fprintf(stderr,"* hash of \"%s\" incorrect:\n", test_data[2]);
-        fprintf(stderr,"\t%s returned\n", output);
-        fprintf(stderr,"\t%s is correct\n", test_results[2]);
-        return (1);
-    }
-
-    /* success */
-    fprintf(stdout, "ok\n");
-    return(0);
-}
-#endif /* TEST */
-#endif
diff --git a/test-invalid.c b/test-invalid.c
deleted file mode 100644
index 7a1b9a3..0000000
--- a/test-invalid.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdlib.h>
-#include <assert.h>
-#include "qcms.h"
-
-
-int main()
-{
-	assert(!qcms_profile_from_path("bad-profiles/rand.icc"));
-	assert(!qcms_profile_from_path("bad-profiles/curve.icc"));
-	return 0;
-}
diff --git a/test-transform.c b/test-transform.c
deleted file mode 100644
index 611cabc..0000000
--- a/test-transform.c
+++ /dev/null
@@ -1,37 +0,0 @@
-#include <stdlib.h>
-#include <time.h>
-#include "sum.h"
-#include "lcms.h"
-#include "qcms.h"
-
-int main(int argc, char **argv)
-{
-	char *input_path = argv[1];
-	char *output_path = argv[2];
-
-	qcms_profile *input_profile, *output_profile;
-	qcms_transform *transform;
-#define LENGTH (256*256*256)
-	static unsigned char src[LENGTH*3];
-	static unsigned char qoutput[LENGTH*3];
-
-	int i,j,k,l=0;
-	for (i=0; i<256; i++) {
-		for (j=0; j<256; j++) {
-			for (k=0; k<256; k++) {
-				src[l++] = i;
-				src[l++] = j;
-				src[l++] = k;
-			}
-		}
-	}
-	input_profile = qcms_profile_from_path(input_path);
-	output_profile = qcms_profile_from_path(output_path);
-	qcms_profile_precache_output_transform(output_profile);
-
-	transform = qcms_transform_create(input_profile, QCMS_DATA_RGB_8, output_profile, QCMS_DATA_RGB_8, QCMS_INTENT_PERCEPTUAL);
-	qcms_transform_data(transform, src, qoutput, LENGTH);
-	qcms_profile_release(input_profile);
-	qcms_profile_release(output_profile);
-	return 0;
-}
diff --git a/test.c b/test.c
deleted file mode 100644
index f9c6955..0000000
--- a/test.c
+++ /dev/null
@@ -1,51 +0,0 @@
-#include <stdlib.h>
-#include "qcms.h"
-#include "sum.h"
-
-int main()
-{
-	unsigned char srct[3] = { 221, 79, 129};
-	unsigned char outt[3];
-#define LENGTH 256*256*256
-	static unsigned char src[LENGTH*3];
-	static unsigned char output[LENGTH*3];
-	int i,j,k,l=0;
-	qcms_profile *input_profile, *output_profile;
-	qcms_transform *transform;
-	input_profile = qcms_profile_from_path("lcms_test/input.icc");
-	output_profile = qcms_profile_from_path("lcms_test/output.icc");
-
-	transform = qcms_transform_create(input_profile, QCMS_DATA_RGB_8, output_profile, QCMS_DATA_RGB_8, QCMS_INTENT_PERCEPTUAL);
-	//transform = qcms_create_transform(output_profile, input_profile);
-
-	for (i=0; i<256; i++) {
-		for (j=0; j<256; j++) {
-			for (k=0; k<256; k++) {
-				src[l++] = i;
-				src[l++] = j;
-				src[l++] = k;
-			}
-		}
-	}
-
-	qcms_transform_data(transform, srct, outt, 1);
-
-	qcms_transform_data(transform, src, output, LENGTH);
-
-	for (i=256*40*3; i<30+256*40*3; i+=3) {
-	printf("(%d %d %d) -> output (%d %d %d)\n", src[i], src[i+1], src[i+2],
-			output[i],
-			output[i+1],
-			output[i+2]);
-	}
-
-	qcms_transform_release(transform);
-	qcms_profile_release(input_profile);
-	qcms_profile_release(output_profile);
-
-	if (sum(output, LENGTH*3) != 0xca89c51c) {
-		printf("DATA CHANGED: %lx\n", sum(output, LENGTH*3));
-		abort();
-	}
-	return 0;
-}
diff --git a/transform-sse1.c b/transform-sse1.c
deleted file mode 100644
index ecca4cc..0000000
--- a/transform-sse1.c
+++ /dev/null
@@ -1,275 +0,0 @@
-//  qcms
-//  Copyright (C) 2009 Mozilla Foundation
-//  Copyright (C) 2010 Steve Snyder
-//
-// 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 <xmmintrin.h>
-
-#include "qcmsint.h"
-
-/* pre-shuffled: just load these into XMM reg instead of load-scalar/shufps sequence */
-#define FLOATSCALE  (float)(PRECACHE_OUTPUT_SIZE)
-#define CLAMPMAXVAL ( ((float) (PRECACHE_OUTPUT_SIZE - 1)) / PRECACHE_OUTPUT_SIZE )
-static const ALIGN float floatScaleX4[4] =
-    { FLOATSCALE, FLOATSCALE, FLOATSCALE, FLOATSCALE};
-static const ALIGN float clampMaxValueX4[4] =
-    { CLAMPMAXVAL, CLAMPMAXVAL, CLAMPMAXVAL, CLAMPMAXVAL};
-
-void qcms_transform_data_rgb_out_lut_sse1(qcms_transform *transform,
-                                          unsigned char *src,
-                                          unsigned char *dest,
-                                          size_t length)
-{
-    unsigned int i;
-    float (*mat)[4] = transform->matrix;
-    char input_back[32];
-    /* Ensure we have a buffer that's 16 byte aligned regardless of the original
-     * stack alignment. We can't use __attribute__((aligned(16))) or __declspec(align(32))
-     * because they don't work on stack variables. gcc 4.4 does do the right thing
-     * on x86 but that's too new for us right now. For more info: gcc bug #16660 */
-    float const * input = (float*)(((uintptr_t)&input_back[16]) & ~0xf);
-    /* share input and output locations to save having to keep the
-     * locations in separate registers */
-    uint32_t const * output = (uint32_t*)input;
-
-    /* deref *transform now to avoid it in loop */
-    const float *igtbl_r = transform->input_gamma_table_r;
-    const float *igtbl_g = transform->input_gamma_table_g;
-    const float *igtbl_b = transform->input_gamma_table_b;
-
-    /* deref *transform now to avoid it in loop */
-    const uint8_t *otdata_r = &transform->output_table_r->data[0];
-    const uint8_t *otdata_g = &transform->output_table_g->data[0];
-    const uint8_t *otdata_b = &transform->output_table_b->data[0];
-
-    /* input matrix values never change */
-    const __m128 mat0  = _mm_load_ps(mat[0]);
-    const __m128 mat1  = _mm_load_ps(mat[1]);
-    const __m128 mat2  = _mm_load_ps(mat[2]);
-
-    /* these values don't change, either */
-    const __m128 max   = _mm_load_ps(clampMaxValueX4);
-    const __m128 min   = _mm_setzero_ps();
-    const __m128 scale = _mm_load_ps(floatScaleX4);
-
-    /* working variables */
-    __m128 vec_r, vec_g, vec_b, result;
-
-    /* CYA */
-    if (!length)
-        return;
-
-    /* one pixel is handled outside of the loop */
-    length--;
-
-    /* setup for transforming 1st pixel */
-    vec_r = _mm_load_ss(&igtbl_r[src[0]]);
-    vec_g = _mm_load_ss(&igtbl_g[src[1]]);
-    vec_b = _mm_load_ss(&igtbl_b[src[2]]);
-    src += 3;
-
-    /* transform all but final pixel */
-
-    for (i=0; i<length; i++)
-    {
-        /* position values from gamma tables */
-        vec_r = _mm_shuffle_ps(vec_r, vec_r, 0);
-        vec_g = _mm_shuffle_ps(vec_g, vec_g, 0);
-        vec_b = _mm_shuffle_ps(vec_b, vec_b, 0);
-
-        /* gamma * matrix */
-        vec_r = _mm_mul_ps(vec_r, mat0);
-        vec_g = _mm_mul_ps(vec_g, mat1);
-        vec_b = _mm_mul_ps(vec_b, mat2);
-
-        /* crunch, crunch, crunch */
-        vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
-        vec_r  = _mm_max_ps(min, vec_r);
-        vec_r  = _mm_min_ps(max, vec_r);
-        result = _mm_mul_ps(vec_r, scale);
-
-        /* store calc'd output tables indices */
-        *((__m64 *)&output[0]) = _mm_cvtps_pi32(result);
-        result = _mm_movehl_ps(result, result);
-        *((__m64 *)&output[2]) = _mm_cvtps_pi32(result) ;
-
-        /* load for next loop while store completes */
-        vec_r = _mm_load_ss(&igtbl_r[src[0]]);
-        vec_g = _mm_load_ss(&igtbl_g[src[1]]);
-        vec_b = _mm_load_ss(&igtbl_b[src[2]]);
-        src += 3;
-
-        /* use calc'd indices to output RGB values */
-        dest[OUTPUT_R_INDEX] = otdata_r[output[0]];
-        dest[OUTPUT_G_INDEX] = otdata_g[output[1]];
-        dest[OUTPUT_B_INDEX] = otdata_b[output[2]];
-        dest += RGB_OUTPUT_COMPONENTS;
-    }
-
-    /* handle final (maybe only) pixel */
-
-    vec_r = _mm_shuffle_ps(vec_r, vec_r, 0);
-    vec_g = _mm_shuffle_ps(vec_g, vec_g, 0);
-    vec_b = _mm_shuffle_ps(vec_b, vec_b, 0);
-
-    vec_r = _mm_mul_ps(vec_r, mat0);
-    vec_g = _mm_mul_ps(vec_g, mat1);
-    vec_b = _mm_mul_ps(vec_b, mat2);
-
-    vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
-    vec_r  = _mm_max_ps(min, vec_r);
-    vec_r  = _mm_min_ps(max, vec_r);
-    result = _mm_mul_ps(vec_r, scale);
-
-    *((__m64 *)&output[0]) = _mm_cvtps_pi32(result);
-    result = _mm_movehl_ps(result, result);
-    *((__m64 *)&output[2]) = _mm_cvtps_pi32(result);
-
-    dest[OUTPUT_R_INDEX] = otdata_r[output[0]];
-    dest[OUTPUT_G_INDEX] = otdata_g[output[1]];
-    dest[OUTPUT_B_INDEX] = otdata_b[output[2]];
-
-    _mm_empty();
-}
-
-void qcms_transform_data_rgba_out_lut_sse1(qcms_transform *transform,
-                                           unsigned char *src,
-                                           unsigned char *dest,
-                                           size_t length)
-{
-    unsigned int i;
-    float (*mat)[4] = transform->matrix;
-    char input_back[32];
-    /* Ensure we have a buffer that's 16 byte aligned regardless of the original
-     * stack alignment. We can't use __attribute__((aligned(16))) or __declspec(align(32))
-     * because they don't work on stack variables. gcc 4.4 does do the right thing
-     * on x86 but that's too new for us right now. For more info: gcc bug #16660 */
-    float const * input = (float*)(((uintptr_t)&input_back[16]) & ~0xf);
-    /* share input and output locations to save having to keep the
-     * locations in separate registers */
-    uint32_t const * output = (uint32_t*)input;
-
-    /* deref *transform now to avoid it in loop */
-    const float *igtbl_r = transform->input_gamma_table_r;
-    const float *igtbl_g = transform->input_gamma_table_g;
-    const float *igtbl_b = transform->input_gamma_table_b;
-
-    /* deref *transform now to avoid it in loop */
-    const uint8_t *otdata_r = &transform->output_table_r->data[0];
-    const uint8_t *otdata_g = &transform->output_table_g->data[0];
-    const uint8_t *otdata_b = &transform->output_table_b->data[0];
-
-    /* input matrix values never change */
-    const __m128 mat0  = _mm_load_ps(mat[0]);
-    const __m128 mat1  = _mm_load_ps(mat[1]);
-    const __m128 mat2  = _mm_load_ps(mat[2]);
-
-    /* these values don't change, either */
-    const __m128 max   = _mm_load_ps(clampMaxValueX4);
-    const __m128 min   = _mm_setzero_ps();
-    const __m128 scale = _mm_load_ps(floatScaleX4);
-
-    /* working variables */
-    __m128 vec_r, vec_g, vec_b, result;
-    unsigned char alpha;
-
-    /* CYA */
-    if (!length)
-        return;
-
-    /* one pixel is handled outside of the loop */
-    length--;
-
-    /* setup for transforming 1st pixel */
-    vec_r = _mm_load_ss(&igtbl_r[src[0]]);
-    vec_g = _mm_load_ss(&igtbl_g[src[1]]);
-    vec_b = _mm_load_ss(&igtbl_b[src[2]]);
-    alpha = src[3];
-    src += 4;
-
-    /* transform all but final pixel */
-
-    for (i=0; i<length; i++)
-    {
-        /* position values from gamma tables */
-        vec_r = _mm_shuffle_ps(vec_r, vec_r, 0);
-        vec_g = _mm_shuffle_ps(vec_g, vec_g, 0);
-        vec_b = _mm_shuffle_ps(vec_b, vec_b, 0);
-
-        /* gamma * matrix */
-        vec_r = _mm_mul_ps(vec_r, mat0);
-        vec_g = _mm_mul_ps(vec_g, mat1);
-        vec_b = _mm_mul_ps(vec_b, mat2);
-
-        /* store alpha for this pixel; load alpha for next */
-        dest[OUTPUT_A_INDEX] = alpha;
-        alpha   = src[3];
-
-        /* crunch, crunch, crunch */
-        vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
-        vec_r  = _mm_max_ps(min, vec_r);
-        vec_r  = _mm_min_ps(max, vec_r);
-        result = _mm_mul_ps(vec_r, scale);
-
-        /* store calc'd output tables indices */
-        *((__m64 *)&output[0]) = _mm_cvtps_pi32(result);
-        result = _mm_movehl_ps(result, result);
-        *((__m64 *)&output[2]) = _mm_cvtps_pi32(result);
-
-        /* load gamma values for next loop while store completes */
-        vec_r = _mm_load_ss(&igtbl_r[src[0]]);
-        vec_g = _mm_load_ss(&igtbl_g[src[1]]);
-        vec_b = _mm_load_ss(&igtbl_b[src[2]]);
-        src += 4;
-
-        /* use calc'd indices to output RGB values */
-        dest[OUTPUT_R_INDEX] = otdata_r[output[0]];
-        dest[OUTPUT_G_INDEX] = otdata_g[output[1]];
-        dest[OUTPUT_B_INDEX] = otdata_b[output[2]];
-        dest += 4;
-    }
-
-    /* handle final (maybe only) pixel */
-
-    vec_r = _mm_shuffle_ps(vec_r, vec_r, 0);
-    vec_g = _mm_shuffle_ps(vec_g, vec_g, 0);
-    vec_b = _mm_shuffle_ps(vec_b, vec_b, 0);
-
-    vec_r = _mm_mul_ps(vec_r, mat0);
-    vec_g = _mm_mul_ps(vec_g, mat1);
-    vec_b = _mm_mul_ps(vec_b, mat2);
-
-    dest[OUTPUT_A_INDEX] = alpha;
-
-    vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
-    vec_r  = _mm_max_ps(min, vec_r);
-    vec_r  = _mm_min_ps(max, vec_r);
-    result = _mm_mul_ps(vec_r, scale);
-
-    *((__m64 *)&output[0]) = _mm_cvtps_pi32(result);
-    result = _mm_movehl_ps(result, result);
-    *((__m64 *)&output[2]) = _mm_cvtps_pi32(result);
-
-    dest[OUTPUT_R_INDEX] = otdata_r[output[0]];
-    dest[OUTPUT_G_INDEX] = otdata_g[output[1]];
-    dest[OUTPUT_B_INDEX] = otdata_b[output[2]];
-
-    _mm_empty();
-}
diff --git a/transform-sse2.c b/transform-sse2.c
index 7c814e4..c06db69 100644
--- a/transform-sse2.c
+++ b/transform-sse2.c
@@ -1,33 +1,33 @@
 //  qcms
 //  Copyright (C) 2009 Mozilla Foundation
-//  Copyright (C) 2010 Steve Snyder
+//  Copyright (C) 2015 Intel Corporation
 //
-// 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 
+// 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 
+// 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 
+// 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 <emmintrin.h>
 
 #include "qcmsint.h"
 
 /* pre-shuffled: just load these into XMM reg instead of load-scalar/shufps sequence */
-#define FLOATSCALE  (float)(PRECACHE_OUTPUT_SIZE)
-#define CLAMPMAXVAL ( ((float) (PRECACHE_OUTPUT_SIZE - 1)) / PRECACHE_OUTPUT_SIZE )
+#define FLOATSCALE  (float)(PRECACHE_OUTPUT_SIZE - 1)
+#define CLAMPMAXVAL 1.0f
+
 static const ALIGN float floatScaleX4[4] =
     { FLOATSCALE, FLOATSCALE, FLOATSCALE, FLOATSCALE};
 static const ALIGN float clampMaxValueX4[4] =
@@ -36,7 +36,8 @@
 void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform,
                                           unsigned char *src,
                                           unsigned char *dest,
-                                          size_t length)
+                                          size_t length,
+                                          qcms_format_type output_format)
 {
     unsigned int i;
     float (*mat)[4] = transform->matrix;
@@ -72,6 +73,8 @@
 
     /* working variables */
     __m128 vec_r, vec_g, vec_b, result;
+    const int r_out = output_format.r;
+    const int b_out = output_format.b;
 
     /* CYA */
     if (!length)
@@ -101,7 +104,7 @@
         vec_b = _mm_mul_ps(vec_b, mat2);
 
         /* crunch, crunch, crunch */
-        vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
+        vec_r  = _mm_add_ps(vec_g, _mm_add_ps(vec_r, vec_b));
         vec_r  = _mm_max_ps(min, vec_r);
         vec_r  = _mm_min_ps(max, vec_r);
         result = _mm_mul_ps(vec_r, scale);
@@ -116,10 +119,10 @@
         src += 3;
 
         /* use calc'd indices to output RGB values */
-        dest[OUTPUT_R_INDEX] = otdata_r[output[0]];
-        dest[OUTPUT_G_INDEX] = otdata_g[output[1]];
-        dest[OUTPUT_B_INDEX] = otdata_b[output[2]];
-        dest += RGB_OUTPUT_COMPONENTS;
+        dest[r_out] = otdata_r[output[0]];
+        dest[1]     = otdata_g[output[1]];
+        dest[b_out] = otdata_b[output[2]];
+        dest += 3;
     }
 
     /* handle final (maybe only) pixel */
@@ -132,22 +135,23 @@
     vec_g = _mm_mul_ps(vec_g, mat1);
     vec_b = _mm_mul_ps(vec_b, mat2);
 
-    vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
+    vec_r  = _mm_add_ps(vec_g, _mm_add_ps(vec_r, vec_b));
     vec_r  = _mm_max_ps(min, vec_r);
     vec_r  = _mm_min_ps(max, vec_r);
     result = _mm_mul_ps(vec_r, scale);
 
     _mm_store_si128((__m128i*)output, _mm_cvtps_epi32(result));
 
-    dest[OUTPUT_R_INDEX] = otdata_r[output[0]];
-    dest[OUTPUT_G_INDEX] = otdata_g[output[1]];
-    dest[OUTPUT_B_INDEX] = otdata_b[output[2]];
+    dest[r_out] = otdata_r[output[0]];
+    dest[1]     = otdata_g[output[1]];
+    dest[b_out] = otdata_b[output[2]];
 }
 
 void qcms_transform_data_rgba_out_lut_sse2(qcms_transform *transform,
                                            unsigned char *src,
                                            unsigned char *dest,
-                                           size_t length)
+                                           size_t length,
+                                           qcms_format_type output_format)
 {
     unsigned int i;
     float (*mat)[4] = transform->matrix;
@@ -183,6 +187,8 @@
 
     /* working variables */
     __m128 vec_r, vec_g, vec_b, result;
+    const int r_out = output_format.r;
+    const int b_out = output_format.b;
     unsigned char alpha;
 
     /* CYA */
@@ -214,11 +220,11 @@
         vec_b = _mm_mul_ps(vec_b, mat2);
 
         /* store alpha for this pixel; load alpha for next */
-        dest[OUTPUT_A_INDEX] = alpha;
+        dest[3] = alpha;
         alpha   = src[3];
 
         /* crunch, crunch, crunch */
-        vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
+        vec_r  = _mm_add_ps(vec_g, _mm_add_ps(vec_r, vec_b));
         vec_r  = _mm_max_ps(min, vec_r);
         vec_r  = _mm_min_ps(max, vec_r);
         result = _mm_mul_ps(vec_r, scale);
@@ -233,10 +239,10 @@
         src += 4;
 
         /* use calc'd indices to output RGB values */
-        dest[OUTPUT_R_INDEX] = otdata_r[output[0]];
-        dest[OUTPUT_G_INDEX] = otdata_g[output[1]];
-        dest[OUTPUT_B_INDEX] = otdata_b[output[2]];
-        dest += RGBA_OUTPUT_COMPONENTS;
+        dest[r_out] = otdata_r[output[0]];
+        dest[1]     = otdata_g[output[1]];
+        dest[b_out] = otdata_b[output[2]];
+        dest += 4;
     }
 
     /* handle final (maybe only) pixel */
@@ -249,18 +255,204 @@
     vec_g = _mm_mul_ps(vec_g, mat1);
     vec_b = _mm_mul_ps(vec_b, mat2);
 
-    dest[OUTPUT_A_INDEX] = alpha;
+    dest[3] = alpha;
 
-    vec_r  = _mm_add_ps(vec_r, _mm_add_ps(vec_g, vec_b));
+    vec_r  = _mm_add_ps(vec_g, _mm_add_ps(vec_r, vec_b));
     vec_r  = _mm_max_ps(min, vec_r);
     vec_r  = _mm_min_ps(max, vec_r);
     result = _mm_mul_ps(vec_r, scale);
 
     _mm_store_si128((__m128i*)output, _mm_cvtps_epi32(result));
 
-    dest[OUTPUT_R_INDEX] = otdata_r[output[0]];
-    dest[OUTPUT_G_INDEX] = otdata_g[output[1]];
-    dest[OUTPUT_B_INDEX] = otdata_b[output[2]];
+    dest[r_out] = otdata_r[output[0]];
+    dest[1]     = otdata_g[output[1]];
+    dest[b_out] = otdata_b[output[2]];
 }
 
+static inline __m128i __mm_swizzle_epi32(__m128i value, int bgra)
+{
+    return bgra ? _mm_shuffle_epi32(value, _MM_SHUFFLE(0, 1, 2, 3)) :
+                  _mm_shuffle_epi32(value, _MM_SHUFFLE(0, 3, 2, 1)) ;
+}
 
+void qcms_transform_data_tetra_clut_rgba_sse2(qcms_transform *transform,
+                                              unsigned char *src,
+                                              unsigned char *dest,
+                                              size_t length,
+                                              qcms_format_type output_format)
+{
+    const int bgra = output_format.r;
+
+    size_t i;
+
+    const int xy_len_3 = 3 * 1;
+    const int x_len_3 = 3 * transform->grid_size;
+    const int len_3 = x_len_3 * transform->grid_size;
+
+    const __m128 __255 = _mm_set1_ps(255.0f);
+    const __m128 __one = _mm_set1_ps(1.0f);
+    const __m128 __000 = _mm_setzero_ps();
+
+    const float* r_table = transform->r_clut;
+    const float* g_table = transform->g_clut;
+    const float* b_table = transform->b_clut;
+
+    int i3, i2, i1, i0;
+
+    __m128 c3;
+    __m128 c2;
+    __m128 c1;
+    __m128 c0;
+
+    if (!(transform->transform_flags & TRANSFORM_FLAG_CLUT_CACHE))
+        qcms_transform_build_clut_cache(transform);
+
+    for (i = 0; i < length; ++i) {
+        unsigned char in_r = *src++;
+        unsigned char in_g = *src++;
+        unsigned char in_b = *src++;
+
+        // initialize the output result with the alpha channel only
+
+        __m128i result = _mm_setr_epi32(*src++, 0, 0, 0);
+
+        // get the input point r.xyz relative to the subcube origin
+
+        float rx = transform->r_cache[in_r];
+        float ry = transform->r_cache[in_g];
+        float rz = transform->r_cache[in_b];
+
+        // load and LUT scale the subcube maximum vertex
+
+        int xn = transform->ceil_cache[in_r] * len_3;
+        int yn = transform->ceil_cache[in_g] * x_len_3;
+        int zn = transform->ceil_cache[in_b] * xy_len_3;
+
+        // load and LUT scale the subcube origin vertex
+
+        int x0 = transform->floor_cache[in_r] * len_3;
+        int y0 = transform->floor_cache[in_g] * x_len_3;
+        int z0 = transform->floor_cache[in_b] * xy_len_3;
+
+        // tetrahedral interpolate the input color r.xyz
+
+#define TETRA_LOOKUP_CLUT(i3, i2, i1, i0) \
+        c0 = _mm_set_ps(b_table[i0], g_table[i0], r_table[i0], 0.f), \
+        c1 = _mm_set_ps(b_table[i1], g_table[i1], r_table[i1], 0.f), \
+        c2 = _mm_set_ps(b_table[i2], g_table[i2], r_table[i2], 0.f), \
+        c3 = _mm_set_ps(b_table[i3], g_table[i3], r_table[i3], 0.f)
+
+        i0 = x0 + y0 + z0;
+
+        if (rx >= ry) {
+
+            if (ry >= rz) {         // rx >= ry && ry >= rz
+
+                i3 = yn + (i1 = xn);
+                i1 += i0 - x0;
+                i2 = i3 + z0;
+                i3 += zn;
+
+                TETRA_LOOKUP_CLUT(i3, i2, i1, i0);
+
+                c3 = _mm_sub_ps(c3, c2);
+                c2 = _mm_sub_ps(c2, c1);
+                c1 = _mm_sub_ps(c1, c0);
+
+            } else if (rx >= rz) {  // rx >= rz && rz >= ry
+
+                i3 = zn + (i1 = xn);
+                i1 += i0 - x0;
+                i2 = i3 + yn;
+                i3 += y0;
+
+                TETRA_LOOKUP_CLUT(i3, i2, i1, i0);
+
+                c2 = _mm_sub_ps(c2, c3);
+                c3 = _mm_sub_ps(c3, c1);
+                c1 = _mm_sub_ps(c1, c0);
+
+            } else {                // rz > rx && rx >= ry
+
+                i2 = xn + (i3 = zn);
+                i3 += i0 - z0;
+                i1 = i2 + y0;
+                i2 += yn;
+
+                TETRA_LOOKUP_CLUT(i3, i2, i1, i0);
+
+                c2 = _mm_sub_ps(c2, c1);
+                c1 = _mm_sub_ps(c1, c3);
+                c3 = _mm_sub_ps(c3, c0);
+            }
+        } else {
+
+            if (rx >= rz) {         // ry > rx && rx >= rz
+
+                i3 = xn + (i2 = yn);
+                i2 += i0 - y0;
+                i1 = i3 + z0;
+                i3 += zn;
+
+                TETRA_LOOKUP_CLUT(i3, i2, i1, i0);
+
+                c3 = _mm_sub_ps(c3, c1);
+                c1 = _mm_sub_ps(c1, c2);
+                c2 = _mm_sub_ps(c2, c0);
+
+            } else if (ry >= rz) {  // ry >= rz && rz > rx
+
+                i3 = zn + (i2 = yn);
+                i2 += i0 - y0;
+                i1 = i3 + xn;
+                i3 += x0;
+
+                TETRA_LOOKUP_CLUT(i3, i2, i1, i0);
+
+                c1 = _mm_sub_ps(c1, c3);
+                c3 = _mm_sub_ps(c3, c2);
+                c2 = _mm_sub_ps(c2, c0);
+
+            } else {                // rz > ry && ry > rx
+
+                i2 = yn + (i3 = zn);
+                i3 += i0 - z0;
+                i1 = i2 + xn;
+                i2 += x0;
+
+                TETRA_LOOKUP_CLUT(i3, i2, i1, i0);
+
+                c1 = _mm_sub_ps(c1, c2);
+                c2 = _mm_sub_ps(c2, c3);
+                c3 = _mm_sub_ps(c3, c0);
+            }
+        }
+
+        // output.xyz = column_matrix(c1, c2, c3) x r.xyz + c0.xyz
+
+        c0 = _mm_add_ps(c0, _mm_mul_ps(c1, _mm_set1_ps(rx)));
+        c0 = _mm_add_ps(c0, _mm_mul_ps(c2, _mm_set1_ps(ry)));
+        c0 = _mm_add_ps(c0, _mm_mul_ps(c3, _mm_set1_ps(rz)));
+
+        // clamp to [0.0..1.0], then scale by 255
+
+        c0 = _mm_max_ps(c0, __000);
+        c0 = _mm_min_ps(c0, __one);
+        c0 = _mm_mul_ps(c0, __255);
+
+        // int(c0) with float rounding, add alpha
+
+        result = _mm_add_epi32(result, _mm_cvtps_epi32(c0));
+
+        // swizzle and repack in result low bytes
+
+        result = __mm_swizzle_epi32(result, bgra);
+        result = _mm_packus_epi16(result, result);
+        result = _mm_packus_epi16(result, result);
+
+        // store into uint32_t* pixel destination
+
+        *(uint32_t *)dest = _mm_cvtsi128_si32(result);
+        dest += 4;
+    }
+}
diff --git a/transform.c b/transform.c
index 51ab83f..17c6555 100644
--- a/transform.c
+++ b/transform.c
@@ -3,22 +3,22 @@
 //  Copyright (C) 2009 Mozilla Corporation
 //  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 
+// 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 
+// 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 
+// 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 <stdlib.h>
@@ -27,6 +27,7 @@
 #include <string.h> //memcpy
 #include "qcmsint.h"
 #include "chain.h"
+#include "halffloat.h"
 #include "matrix.h"
 #include "transform_util.h"
 
@@ -181,32 +182,44 @@
 static struct matrix
 adaption_matrix(struct CIE_XYZ source_illumination, struct CIE_XYZ target_illumination)
 {
+#if defined (_MSC_VER)
+#pragma warning(push)
+/* Disable double to float truncation warning 4305 */
+#pragma warning(disable:4305)
+#endif
 	struct matrix lam_rigg = {{ // Bradford matrix
 	                         {  0.8951,  0.2664, -0.1614 },
 	                         { -0.7502,  1.7135,  0.0367 },
-	                         {  0.0389, -0.0685,  1.0296 }
-	                         }};
+	                         {  0.0389, -0.0685,  1.0296 }},
+											 		 false};
+#if defined (_MSC_VER)
+/* Restore warnings */
+#pragma warning(pop)
+#endif
 	return compute_chromatic_adaption(source_illumination, target_illumination, lam_rigg);
 }
 
 /* from lcms: cmsAdaptMatrixToD50 */
-static struct matrix adapt_matrix_to_D50(struct matrix r, qcms_CIE_xyY source_white_pt)
+static struct matrix adapt_matrix_to_D50(struct matrix r, qcms_CIE_xyY source_white_point)
 {
-	struct CIE_XYZ Dn;
+	struct CIE_XYZ DNN_XYZ;
 	struct matrix Bradford;
 
-	if (source_white_pt.y == 0.0)
+	if (source_white_point.y == 0.0)
 		return matrix_invalid();
 
-	Dn = xyY2XYZ(source_white_pt);
+	DNN_XYZ = xyY2XYZ(source_white_point);
 
-	Bradford = adaption_matrix(Dn, D50_XYZ);
+	Bradford = adaption_matrix(DNN_XYZ, D50_XYZ);
+
 	return matrix_multiply(Bradford, r);
 }
 
 qcms_bool set_rgb_colorants(qcms_profile *profile, qcms_CIE_xyY white_point, qcms_CIE_xyYTRIPLE primaries)
 {
+	struct CIE_XYZ source_white;
 	struct matrix colorants;
+
 	colorants = build_RGB_to_XYZ_transfer_matrix(white_point, primaries);
 	colorants = adapt_matrix_to_D50(colorants, white_point);
 
@@ -226,12 +239,21 @@
 	profile->blueColorant.Y = double_to_s15Fixed16Number(colorants.m[1][2]);
 	profile->blueColorant.Z = double_to_s15Fixed16Number(colorants.m[2][2]);
 
+	/* Store the media white point */
+	source_white = xyY2XYZ(white_point);
+	profile->mediaWhitePoint.X = double_to_s15Fixed16Number(source_white.X);
+	profile->mediaWhitePoint.Y = double_to_s15Fixed16Number(source_white.Y);
+	profile->mediaWhitePoint.Z = double_to_s15Fixed16Number(source_white.Z);
+
 	return true;
 }
 
 #if 0
-static void qcms_transform_data_rgb_out_pow(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
+static void qcms_transform_data_rgb_out_pow(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 {
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	int i;
 	float (*mat)[4] = transform->matrix;
 	for (i=0; i<length; i++) {
@@ -251,16 +273,19 @@
 		float out_device_g = pow(out_linear_g, transform->out_gamma_g);
 		float out_device_b = pow(out_linear_b, transform->out_gamma_b);
 
-		dest[OUTPUT_R_INDEX] = clamp_u8(255*out_device_r);
-		dest[OUTPUT_G_INDEX] = clamp_u8(255*out_device_g);
-		dest[OUTPUT_B_INDEX] = clamp_u8(255*out_device_b);
-		dest += RGB_OUTPUT_COMPONENTS;
+		dest[r_out] = clamp_u8(out_device_r*255);
+		dest[1]     = clamp_u8(out_device_g*255);
+		dest[b_out] = clamp_u8(out_device_b*255);
+		dest += 3;
 	}
 }
 #endif
 
-static void qcms_transform_data_gray_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
+static void qcms_transform_data_gray_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 {
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	for (i = 0; i < length; i++) {
 		float out_device_r, out_device_g, out_device_b;
@@ -268,14 +293,14 @@
 
 		float linear = transform->input_gamma_table_gray[device];
 
-                out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length);
+		out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length);
 		out_device_g = lut_interp_linear(linear, transform->output_gamma_lut_g, transform->output_gamma_lut_g_length);
 		out_device_b = lut_interp_linear(linear, transform->output_gamma_lut_b, transform->output_gamma_lut_b_length);
 
-		dest[OUTPUT_R_INDEX] = clamp_u8(out_device_r*255);
-		dest[OUTPUT_G_INDEX] = clamp_u8(out_device_g*255);
-		dest[OUTPUT_B_INDEX] = clamp_u8(out_device_b*255);
-		dest += RGB_OUTPUT_COMPONENTS;
+		dest[r_out] = clamp_u8(out_device_r*255);
+		dest[1]     = clamp_u8(out_device_g*255);
+		dest[b_out] = clamp_u8(out_device_b*255);
+		dest += 3;
 	}
 }
 
@@ -285,8 +310,11 @@
 	See: ftp://ftp.alvyray.com/Acrobat/17_Nonln.pdf
 */
 
-static void qcms_transform_data_graya_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
+static void qcms_transform_data_graya_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 {
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	for (i = 0; i < length; i++) {
 		float out_device_r, out_device_g, out_device_b;
@@ -295,21 +323,24 @@
 
 		float linear = transform->input_gamma_table_gray[device];
 
-                out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length);
+		out_device_r = lut_interp_linear(linear, transform->output_gamma_lut_r, transform->output_gamma_lut_r_length);
 		out_device_g = lut_interp_linear(linear, transform->output_gamma_lut_g, transform->output_gamma_lut_g_length);
 		out_device_b = lut_interp_linear(linear, transform->output_gamma_lut_b, transform->output_gamma_lut_b_length);
 
-		dest[OUTPUT_R_INDEX] = clamp_u8(out_device_r*255);
-		dest[OUTPUT_G_INDEX] = clamp_u8(out_device_g*255);
-		dest[OUTPUT_B_INDEX] = clamp_u8(out_device_b*255);
-		dest[OUTPUT_A_INDEX] = alpha;
-		dest += RGBA_OUTPUT_COMPONENTS;
+		dest[r_out] = clamp_u8(out_device_r*255);
+		dest[1]     = clamp_u8(out_device_g*255);
+		dest[b_out] = clamp_u8(out_device_b*255);
+		dest[3]     = alpha;
+		dest += 4;
 	}
 }
 
 
-static void qcms_transform_data_gray_out_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
+static void qcms_transform_data_gray_out_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 {
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	for (i = 0; i < length; i++) {
 		unsigned char device = *src++;
@@ -320,15 +351,19 @@
 		/* we could round here... */
 		gray = linear * PRECACHE_OUTPUT_MAX;
 
-		dest[OUTPUT_R_INDEX] = transform->output_table_r->data[gray];
-		dest[OUTPUT_G_INDEX] = transform->output_table_g->data[gray];
-		dest[OUTPUT_B_INDEX] = transform->output_table_b->data[gray];
-		dest += RGB_OUTPUT_COMPONENTS;
+		dest[r_out] = transform->output_table_r->data[gray];
+		dest[1]     = transform->output_table_g->data[gray];
+		dest[b_out] = transform->output_table_b->data[gray];
+		dest += 3;
 	}
 }
 
-static void qcms_transform_data_graya_out_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
+
+static void qcms_transform_data_graya_out_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 {
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	for (i = 0; i < length; i++) {
 		unsigned char device = *src++;
@@ -340,16 +375,19 @@
 		/* we could round here... */
 		gray = linear * PRECACHE_OUTPUT_MAX;
 
-		dest[OUTPUT_R_INDEX] = transform->output_table_r->data[gray];
-		dest[OUTPUT_G_INDEX] = transform->output_table_g->data[gray];
-		dest[OUTPUT_B_INDEX] = transform->output_table_b->data[gray];
-		dest[OUTPUT_A_INDEX] = alpha;
-		dest += RGBA_OUTPUT_COMPONENTS;
+		dest[r_out] = transform->output_table_r->data[gray];
+		dest[1]     = transform->output_table_g->data[gray];
+		dest[b_out] = transform->output_table_b->data[gray];
+		dest[3]     = alpha;
+		dest += 4;
 	}
 }
 
-static void qcms_transform_data_rgb_out_lut_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
+static void qcms_transform_data_rgb_out_lut_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 {
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	float (*mat)[4] = transform->matrix;
 	for (i = 0; i < length; i++) {
@@ -375,15 +413,18 @@
 		g = out_linear_g * PRECACHE_OUTPUT_MAX;
 		b = out_linear_b * PRECACHE_OUTPUT_MAX;
 
-		dest[OUTPUT_R_INDEX] = transform->output_table_r->data[r];
-		dest[OUTPUT_G_INDEX] = transform->output_table_g->data[g];
-		dest[OUTPUT_B_INDEX] = transform->output_table_b->data[b];
-		dest += RGB_OUTPUT_COMPONENTS;
+		dest[r_out] = transform->output_table_r->data[r];
+		dest[1]     = transform->output_table_g->data[g];
+		dest[b_out] = transform->output_table_b->data[b];
+		dest += 3;
 	}
 }
 
-static void qcms_transform_data_rgba_out_lut_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
+void qcms_transform_data_rgba_out_lut_precache(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 {
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	float (*mat)[4] = transform->matrix;
 	for (i = 0; i < length; i++) {
@@ -410,17 +451,21 @@
 		g = out_linear_g * PRECACHE_OUTPUT_MAX;
 		b = out_linear_b * PRECACHE_OUTPUT_MAX;
 
-		dest[OUTPUT_R_INDEX] = transform->output_table_r->data[r];
-		dest[OUTPUT_G_INDEX] = transform->output_table_g->data[g];
-		dest[OUTPUT_B_INDEX] = transform->output_table_b->data[b];
-		dest[OUTPUT_A_INDEX] = alpha;
-		dest += RGBA_OUTPUT_COMPONENTS;
+		dest[r_out] = transform->output_table_r->data[r];
+		dest[1]     = transform->output_table_g->data[g];
+		dest[b_out] = transform->output_table_b->data[b];
+		dest[3]     = alpha;
+		dest += 4;
 	}
 }
 
 // Not used
-/* 
-static void qcms_transform_data_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) {
+/*
+static void qcms_transform_data_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
+{
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	int xy_len = 1;
 	int x_len = transform->grid_size;
@@ -428,7 +473,7 @@
 	float* r_table = transform->r_clut;
 	float* g_table = transform->g_clut;
 	float* b_table = transform->b_clut;
-  
+
 	for (i = 0; i < length; i++) {
 		unsigned char in_r = *src++;
 		unsigned char in_g = *src++;
@@ -441,9 +486,9 @@
 		int x_n = ceil(linear_r * (transform->grid_size-1));
 		int y_n = ceil(linear_g * (transform->grid_size-1));
 		int z_n = ceil(linear_b * (transform->grid_size-1));
-		float x_d = linear_r * (transform->grid_size-1) - x; 
+		float x_d = linear_r * (transform->grid_size-1) - x;
 		float y_d = linear_g * (transform->grid_size-1) - y;
-		float z_d = linear_b * (transform->grid_size-1) - z; 
+		float z_d = linear_b * (transform->grid_size-1) - z;
 
 		float r_x1 = lerp(CLU(r_table,x,y,z), CLU(r_table,x_n,y,z), x_d);
 		float r_x2 = lerp(CLU(r_table,x,y_n,z), CLU(r_table,x_n,y_n,z), x_d);
@@ -469,15 +514,20 @@
 		float b_y2 = lerp(b_x3, b_x4, y_d);
 		float clut_b = lerp(b_y1, b_y2, z_d);
 
-		*dest++ = clamp_u8(clut_r*255.0f);
-		*dest++ = clamp_u8(clut_g*255.0f);
-		*dest++ = clamp_u8(clut_b*255.0f);
-	}	
+		dest[r_out] = clamp_u8(clut_r*255.0f);
+		dest[1]     = clamp_u8(clut_g*255.0f);
+		dest[b_out] = clamp_u8(clut_b*255.0f);
+		dest += 3;
+	}
 }
 */
 
 // Using lcms' tetra interpolation algorithm.
-static void qcms_transform_data_tetra_clut_rgba(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) {
+void qcms_transform_data_tetra_clut_rgba(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
+{
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	int xy_len = 1;
 	int x_len = transform->grid_size;
@@ -489,22 +539,27 @@
 	float c0_g, c1_g, c2_g, c3_g;
 	float c0_b, c1_b, c2_b, c3_b;
 	float clut_r, clut_g, clut_b;
+
+	if (!(transform->transform_flags & TRANSFORM_FLAG_CLUT_CACHE))
+		qcms_transform_build_clut_cache(transform);
+
 	for (i = 0; i < length; i++) {
 		unsigned char in_r = *src++;
 		unsigned char in_g = *src++;
 		unsigned char in_b = *src++;
 		unsigned char in_a = *src++;
-		float linear_r = in_r/255.0f, linear_g=in_g/255.0f, linear_b = in_b/255.0f;
 
-		int x = floor(linear_r * (transform->grid_size-1));
-		int y = floor(linear_g * (transform->grid_size-1));
-		int z = floor(linear_b * (transform->grid_size-1));
-		int x_n = ceil(linear_r * (transform->grid_size-1));
-		int y_n = ceil(linear_g * (transform->grid_size-1));
-		int z_n = ceil(linear_b * (transform->grid_size-1));
-		float rx = linear_r * (transform->grid_size-1) - x; 
-		float ry = linear_g * (transform->grid_size-1) - y;
-		float rz = linear_b * (transform->grid_size-1) - z; 
+		int x = transform->floor_cache[in_r];
+		int y = transform->floor_cache[in_g];
+		int z = transform->floor_cache[in_b];
+
+		int x_n = transform->ceil_cache[in_r];
+		int y_n = transform->ceil_cache[in_g];
+		int z_n = transform->ceil_cache[in_b];
+
+		float rx = transform->r_cache[in_r];
+		float ry = transform->r_cache[in_g];
+		float rz = transform->r_cache[in_b];
 
 		c0_r = CLU(r_table, x, y, z);
 		c0_g = CLU(g_table, x, y, z);
@@ -521,7 +576,7 @@
 				c1_b = CLU(b_table, x_n, y, z) - c0_b;
 				c2_b = CLU(b_table, x_n, y_n, z) - CLU(b_table, x_n, y, z);
 				c3_b = CLU(b_table, x_n, y_n, z_n) - CLU(b_table, x_n, y_n, z);
-			} else { 
+			} else {
 				if (rx >= rz) { //rx >= rz && rz >= ry
 					c1_r = CLU(r_table, x_n, y, z) - c0_r;
 					c2_r = CLU(r_table, x_n, y_n, z_n) - CLU(r_table, x_n, y, z_n);
@@ -556,7 +611,7 @@
 				c2_b = CLU(b_table, x, y_n, z) - c0_b;
 				c3_b = CLU(b_table, x_n, y_n, z_n) - CLU(b_table, x_n, y_n, z);
 			} else {
-				if (ry >= rz) { //ry >= rz && rz > rx 
+				if (ry >= rz) { //ry >= rz && rz > rx
 					c1_r = CLU(r_table, x_n, y_n, z_n) - CLU(r_table, x, y_n, z_n);
 					c2_r = CLU(r_table, x, y_n, z) - c0_r;
 					c3_r = CLU(r_table, x, y_n, z_n) - CLU(r_table, x, y_n, z);
@@ -579,21 +634,25 @@
 				}
 			}
 		}
-				
+
 		clut_r = c0_r + c1_r*rx + c2_r*ry + c3_r*rz;
 		clut_g = c0_g + c1_g*rx + c2_g*ry + c3_g*rz;
 		clut_b = c0_b + c1_b*rx + c2_b*ry + c3_b*rz;
 
-		dest[OUTPUT_R_INDEX] = clamp_u8(clut_r*255.0f);
-		dest[OUTPUT_G_INDEX] = clamp_u8(clut_g*255.0f);
-		dest[OUTPUT_B_INDEX] = clamp_u8(clut_b*255.0f);
-		dest[OUTPUT_A_INDEX] = in_a;
-		dest += RGBA_OUTPUT_COMPONENTS;
-	}	
+		dest[r_out] = clamp_u8(clut_r*255.0f);
+		dest[1]     = clamp_u8(clut_g*255.0f);
+		dest[b_out] = clamp_u8(clut_b*255.0f);
+		dest[3]     = in_a;
+		dest += 4;
+	}
 }
 
 // Using lcms' tetra interpolation code.
-static void qcms_transform_data_tetra_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length) {
+static void qcms_transform_data_tetra_clut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
+{
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	int xy_len = 1;
 	int x_len = transform->grid_size;
@@ -605,21 +664,26 @@
 	float c0_g, c1_g, c2_g, c3_g;
 	float c0_b, c1_b, c2_b, c3_b;
 	float clut_r, clut_g, clut_b;
+
+	if (!(transform->transform_flags & TRANSFORM_FLAG_CLUT_CACHE))
+		qcms_transform_build_clut_cache(transform);
+
 	for (i = 0; i < length; i++) {
 		unsigned char in_r = *src++;
 		unsigned char in_g = *src++;
 		unsigned char in_b = *src++;
-		float linear_r = in_r/255.0f, linear_g=in_g/255.0f, linear_b = in_b/255.0f;
 
-		int x = floor(linear_r * (transform->grid_size-1));
-		int y = floor(linear_g * (transform->grid_size-1));
-		int z = floor(linear_b * (transform->grid_size-1));
-		int x_n = ceil(linear_r * (transform->grid_size-1));
-		int y_n = ceil(linear_g * (transform->grid_size-1));
-		int z_n = ceil(linear_b * (transform->grid_size-1));
-		float rx = linear_r * (transform->grid_size-1) - x; 
-		float ry = linear_g * (transform->grid_size-1) - y;
-		float rz = linear_b * (transform->grid_size-1) - z; 
+		int x = transform->floor_cache[in_r];
+		int y = transform->floor_cache[in_g];
+		int z = transform->floor_cache[in_b];
+
+		int x_n = transform->ceil_cache[in_r];
+		int y_n = transform->ceil_cache[in_g];
+		int z_n = transform->ceil_cache[in_b];
+
+		float rx = transform->r_cache[in_r];
+		float ry = transform->r_cache[in_g];
+		float rz = transform->r_cache[in_b];
 
 		c0_r = CLU(r_table, x, y, z);
 		c0_g = CLU(g_table, x, y, z);
@@ -636,7 +700,7 @@
 				c1_b = CLU(b_table, x_n, y, z) - c0_b;
 				c2_b = CLU(b_table, x_n, y_n, z) - CLU(b_table, x_n, y, z);
 				c3_b = CLU(b_table, x_n, y_n, z_n) - CLU(b_table, x_n, y_n, z);
-			} else { 
+			} else {
 				if (rx >= rz) { //rx >= rz && rz >= ry
 					c1_r = CLU(r_table, x_n, y, z) - c0_r;
 					c2_r = CLU(r_table, x_n, y_n, z_n) - CLU(r_table, x_n, y, z_n);
@@ -671,7 +735,7 @@
 				c2_b = CLU(b_table, x, y_n, z) - c0_b;
 				c3_b = CLU(b_table, x_n, y_n, z_n) - CLU(b_table, x_n, y_n, z);
 			} else {
-				if (ry >= rz) { //ry >= rz && rz > rx 
+				if (ry >= rz) { //ry >= rz && rz > rx
 					c1_r = CLU(r_table, x_n, y_n, z_n) - CLU(r_table, x, y_n, z_n);
 					c2_r = CLU(r_table, x, y_n, z) - c0_r;
 					c3_r = CLU(r_table, x, y_n, z_n) - CLU(r_table, x, y_n, z);
@@ -694,20 +758,23 @@
 				}
 			}
 		}
-				
+
 		clut_r = c0_r + c1_r*rx + c2_r*ry + c3_r*rz;
 		clut_g = c0_g + c1_g*rx + c2_g*ry + c3_g*rz;
 		clut_b = c0_b + c1_b*rx + c2_b*ry + c3_b*rz;
 
-		dest[OUTPUT_R_INDEX] = clamp_u8(clut_r*255.0f);
-		dest[OUTPUT_G_INDEX] = clamp_u8(clut_g*255.0f);
-		dest[OUTPUT_B_INDEX] = clamp_u8(clut_b*255.0f);
-		dest += RGB_OUTPUT_COMPONENTS;
-	}	
+		dest[r_out] = clamp_u8(clut_r*255.0f);
+		dest[1]     = clamp_u8(clut_g*255.0f);
+		dest[b_out] = clamp_u8(clut_b*255.0f);
+		dest += 3;
+	}
 }
 
-static void qcms_transform_data_rgb_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
+static void qcms_transform_data_rgb_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 {
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	float (*mat)[4] = transform->matrix;
 	for (i = 0; i < length; i++) {
@@ -728,22 +795,25 @@
 		out_linear_g = clamp_float(out_linear_g);
 		out_linear_b = clamp_float(out_linear_b);
 
-		out_device_r = lut_interp_linear(out_linear_r, 
+		out_device_r = lut_interp_linear(out_linear_r,
 				transform->output_gamma_lut_r, transform->output_gamma_lut_r_length);
-		out_device_g = lut_interp_linear(out_linear_g, 
+		out_device_g = lut_interp_linear(out_linear_g,
 				transform->output_gamma_lut_g, transform->output_gamma_lut_g_length);
-		out_device_b = lut_interp_linear(out_linear_b, 
+		out_device_b = lut_interp_linear(out_linear_b,
 				transform->output_gamma_lut_b, transform->output_gamma_lut_b_length);
 
-		dest[OUTPUT_R_INDEX] = clamp_u8(out_device_r*255);
-		dest[OUTPUT_G_INDEX] = clamp_u8(out_device_g*255);
-		dest[OUTPUT_B_INDEX] = clamp_u8(out_device_b*255);
-		dest += RGB_OUTPUT_COMPONENTS;
+		dest[r_out] = clamp_u8(out_device_r*255);
+		dest[1]     = clamp_u8(out_device_g*255);
+		dest[b_out] = clamp_u8(out_device_b*255);
+		dest += 3;
 	}
 }
 
-static void qcms_transform_data_rgba_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
+static void qcms_transform_data_rgba_out_lut(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 {
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	unsigned int i;
 	float (*mat)[4] = transform->matrix;
 	for (i = 0; i < length; i++) {
@@ -765,24 +835,27 @@
 		out_linear_g = clamp_float(out_linear_g);
 		out_linear_b = clamp_float(out_linear_b);
 
-		out_device_r = lut_interp_linear(out_linear_r, 
+		out_device_r = lut_interp_linear(out_linear_r,
 				transform->output_gamma_lut_r, transform->output_gamma_lut_r_length);
-		out_device_g = lut_interp_linear(out_linear_g, 
+		out_device_g = lut_interp_linear(out_linear_g,
 				transform->output_gamma_lut_g, transform->output_gamma_lut_g_length);
-		out_device_b = lut_interp_linear(out_linear_b, 
+		out_device_b = lut_interp_linear(out_linear_b,
 				transform->output_gamma_lut_b, transform->output_gamma_lut_b_length);
 
-		dest[OUTPUT_R_INDEX] = clamp_u8(out_device_r*255);
-		dest[OUTPUT_G_INDEX] = clamp_u8(out_device_g*255);
-		dest[OUTPUT_B_INDEX] = clamp_u8(out_device_b*255);
-		dest[OUTPUT_A_INDEX] = alpha;
-		dest += RGBA_OUTPUT_COMPONENTS;
+		dest[r_out] = clamp_u8(out_device_r*255);
+		dest[1]     = clamp_u8(out_device_g*255);
+		dest[b_out] = clamp_u8(out_device_b*255);
+		dest[3]     = alpha;
+		dest += 4;
 	}
 }
 
 #if 0
-static void qcms_transform_data_rgb_out_linear(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length)
+static void qcms_transform_data_rgb_out_linear(qcms_transform *transform, unsigned char *src, unsigned char *dest, size_t length, qcms_format_type output_format)
 {
+	const int r_out = output_format.r;
+	const int b_out = output_format.b;
+
 	int i;
 	float (*mat)[4] = transform->matrix;
 	for (i = 0; i < length; i++) {
@@ -798,16 +871,25 @@
 		float out_linear_g = mat[0][1]*linear_r + mat[1][1]*linear_g + mat[2][1]*linear_b;
 		float out_linear_b = mat[0][2]*linear_r + mat[1][2]*linear_g + mat[2][2]*linear_b;
 
-		*dest++ = clamp_u8(out_linear_r*255);
-		*dest++ = clamp_u8(out_linear_g*255);
-		*dest++ = clamp_u8(out_linear_b*255);
+		dest[r_out] = clamp_u8(out_linear_r*255);
+		dest[1]     = clamp_u8(out_linear_g*255);
+		dest[b_out] = clamp_u8(out_linear_b*255);
+		dest += 3;
 	}
 }
 #endif
 
+/*
+ * If users create and destroy objects on different threads, even if the same
+ * objects aren't used on different threads at the same time, we can still run
+ * in to trouble with refcounts if they aren't atomic.
+ *
+ * This can lead to us prematurely deleting the precache if threads get unlucky
+ * and write the wrong value to the ref count.
+ */
 static struct precache_output *precache_reference(struct precache_output *p)
 {
-	p->ref_count++;
+	qcms_atomic_increment(p->ref_count);
 	return p;
 }
 
@@ -821,12 +903,12 @@
 
 void precache_release(struct precache_output *p)
 {
-	if (--p->ref_count == 0) {
+	if (qcms_atomic_decrement(p->ref_count) == 0) {
 		free(p);
 	}
 }
 
-#ifdef HAS_POSIX_MEMALIGN
+#ifdef HAVE_POSIX_MEMALIGN
 static qcms_transform *transform_alloc(void)
 {
 	qcms_transform *t;
@@ -930,7 +1012,7 @@
 static void cpuid(uint32_t fxn, uint32_t *a, uint32_t *b, uint32_t *c, uint32_t *d) {
 
 	uint32_t a_, b_, c_, d_;
-       __asm__ __volatile__ ("xchgl %%ebx, %%esi; cpuid; xchgl %%ebx, %%esi;" 
+       __asm__ __volatile__ ("xchgl %%ebx, %%esi; cpuid; xchgl %%ebx, %%esi;"
                              : "=a" (a_), "=S" (b_), "=c" (c_), "=d" (d_) : "a" (fxn));
 	   *a = a_;
 	   *b = b_;
@@ -979,12 +1061,12 @@
 
 static const struct matrix bradford_matrix = {{	{ 0.8951f, 0.2664f,-0.1614f},
 						{-0.7502f, 1.7135f, 0.0367f},
-						{ 0.0389f,-0.0685f, 1.0296f}}, 
+						{ 0.0389f,-0.0685f, 1.0296f}},
 						false};
 
 static const struct matrix bradford_matrix_inv = {{ { 0.9869929f,-0.1470543f, 0.1599627f},
 						    { 0.4323053f, 0.5183603f, 0.0492912f},
-						    {-0.0085287f, 0.0400428f, 0.9684867f}}, 
+						    {-0.0085287f, 0.0400428f, 0.9684867f}},
 						    false};
 
 // See ICCv4 E.3
@@ -1046,7 +1128,7 @@
 }
 
 /* Replace the current transformation with a LUT transformation using a given number of sample points */
-qcms_transform* qcms_transform_precacheLUT_float(qcms_transform *transform, qcms_profile *in, qcms_profile *out, 
+qcms_transform* qcms_transform_precacheLUT_float(qcms_transform *transform, qcms_profile *in, qcms_profile *out,
                                                  int samples, qcms_data_type in_type)
 {
 	/* The range between which 2 consecutive sample points can be used to interpolate */
@@ -1056,39 +1138,51 @@
 	float* src = NULL;
 	float* dest = NULL;
 	float* lut = NULL;
+	float inverse;
 
 	src = malloc(lutSize*sizeof(float));
 	dest = malloc(lutSize*sizeof(float));
 
 	if (src && dest) {
-		/* Prepare a list of points we want to sample */
+		/* Prepare a list of points we want to sample: x, y, z order */
 		l = 0;
+		inverse = 1 / (float)(samples-1);
 		for (x = 0; x < samples; x++) {
 			for (y = 0; y < samples; y++) {
 				for (z = 0; z < samples; z++) {
-					src[l++] = x / (float)(samples-1);
-					src[l++] = y / (float)(samples-1);
-					src[l++] = z / (float)(samples-1);
+					src[l++] = x * inverse; // r
+					src[l++] = y * inverse; // g
+					src[l++] = z * inverse; // b
 				}
 			}
 		}
 
 		lut = qcms_chain_transform(in, out, src, dest, lutSize);
+
 		if (lut) {
-			transform->r_clut = &lut[0];
-			transform->g_clut = &lut[1];
-			transform->b_clut = &lut[2];
+			transform->r_clut = &lut[0]; // r
+			transform->g_clut = &lut[1]; // g
+			transform->b_clut = &lut[2]; // b
 			transform->grid_size = samples;
+
 			if (in_type == QCMS_DATA_RGBA_8) {
+#if defined(SSE2_ENABLE)
+				if (sse_version_available() >= 2) {
+					transform->transform_fn = qcms_transform_data_tetra_clut_rgba_sse2;
+				} else {
+					transform->transform_fn = qcms_transform_data_tetra_clut_rgba;
+				}
+#else
 				transform->transform_fn = qcms_transform_data_tetra_clut_rgba;
+#endif
 			} else {
 				transform->transform_fn = qcms_transform_data_tetra_clut;
 			}
 		}
 	}
 
-
-	//XXX: qcms_modular_transform_data may return either the src or dest buffer. If so it must not be free-ed
+	// XXX: qcms_modular_transform_data may return the lut in either the src or the
+	// dest buffer. If so, it must not be free-ed.
 	if (src && lut != src) {
 		free(src);
 	}
@@ -1102,6 +1196,89 @@
 	return transform;
 }
 
+/* Create a transform LUT using the given number of sample points. The transform LUT data is stored
+   in the output (cube) in bgra format in zyx sample order. */
+qcms_bool qcms_transform_create_LUT_zyx_bgra(qcms_profile *in, qcms_profile *out, qcms_intent intent,
+                                             int samples, unsigned char* cube)
+{
+	uint16_t z,y,x;
+	uint32_t l,index;
+	uint32_t lutSize = 3 * samples * samples * samples;
+
+	float* src = NULL;
+	float* dest = NULL;
+	float* lut = NULL;
+	float inverse;
+
+	src = malloc(lutSize*sizeof(float));
+	dest = malloc(lutSize*sizeof(float));
+
+	if (src && dest) {
+		/* Prepare a list of points we want to sample: z, y, x order */
+		l = 0;
+		inverse = 1 / (float)(samples-1);
+		for (z = 0; z < samples; z++) {
+			for (y = 0; y < samples; y++) {
+				for (x = 0; x < samples; x++) {
+					src[l++] = x * inverse; // r
+					src[l++] = y * inverse; // g
+					src[l++] = z * inverse; // b
+				}
+			}
+		}
+
+		lut = qcms_chain_transform(in, out, src, dest, lutSize);
+
+		if (lut) {
+			index = l = 0;
+			for (z = 0; z < samples; z++) {
+				for (y = 0; y < samples; y++) {
+					for (x = 0; x < samples; x++) {
+						cube[index++] = (int)floorf(lut[l + 2] * 255.0f + 0.5f); // b
+						cube[index++] = (int)floorf(lut[l + 1] * 255.0f + 0.5f); // g
+						cube[index++] = (int)floorf(lut[l + 0] * 255.0f + 0.5f); // r
+						cube[index++] = 255;                                     // a
+						l += 3;
+					}
+				}
+			}
+		}
+	}
+
+	// XXX: qcms_modular_transform_data may return the lut data in either the src or
+	// dest buffer so free src, dest, and lut with care.
+
+	if (src && lut != src)
+		free(src);
+	if (dest && lut != dest)
+		free(dest);
+
+	if (lut) {
+		free(lut);
+		return true;
+	}
+
+	return false;
+}
+
+void qcms_transform_build_clut_cache(qcms_transform* transform) {
+	const int grid_factor = transform->grid_size - 1;
+	const float grid_scaled = (1.0f / 255.0f) * grid_factor;
+	int i;
+
+#define div_255_ceiling(value) (((value) + 254) / 255)
+
+	for (i = 0; i < 256; i++) {
+		transform->ceil_cache[i] = div_255_ceiling(i * grid_factor);
+		transform->floor_cache[i] = i * grid_factor / 255;
+		transform->r_cache[i] = (i * grid_scaled) - transform->floor_cache[i];
+	}
+
+#undef div_255_ceil
+
+	transform->transform_flags |= TRANSFORM_FLAG_CLUT_CACHE;
+}
+
 #define NO_MEM_TRANSFORM NULL
 
 qcms_transform* qcms_transform_create(
@@ -1109,40 +1286,49 @@
 		qcms_profile *out, qcms_data_type out_type,
 		qcms_intent intent)
 {
+	qcms_transform *transform = NULL;
 	bool precache = false;
+	int i, j;
 
-        qcms_transform *transform = transform_alloc();
-        if (!transform) {
+	transform = transform_alloc();
+	if (!transform) {
 		return NULL;
 	}
-	if (out_type != QCMS_DATA_RGB_8 &&
-                out_type != QCMS_DATA_RGBA_8) {
-            assert(0 && "output type");
-	    transform_free(transform);
-            return NULL;
-        }
 
-	if (out->output_table_r &&
-			out->output_table_g &&
-			out->output_table_b) {
+	if (out_type != QCMS_DATA_RGB_8 && out_type != QCMS_DATA_RGBA_8) {
+		assert(0 && "output type");
+		qcms_transform_release(transform);
+		return NULL;
+	}
+
+	transform->transform_flags = 0;
+
+	if (out->output_table_r && out->output_table_g && out->output_table_b) {
 		precache = true;
 	}
 
 	if (qcms_supports_iccv4 && (in->A2B0 || out->B2A0 || in->mAB || out->mAB)) {
 		// Precache the transformation to a CLUT 33x33x33 in size.
-		// 33 is used by many profiles and works well in pratice. 
+		// 33 is used by many profiles and works well in practice.
 		// This evenly divides 256 into blocks of 8x8x8.
 		// TODO For transforming small data sets of about 200x200 or less
 		// precaching should be avoided.
 		qcms_transform *result = qcms_transform_precacheLUT_float(transform, in, out, 33, in_type);
 		if (!result) {
-            		assert(0 && "precacheLUT failed");
-			transform_free(transform);
+			assert(0 && "precacheLUT failed");
+			qcms_transform_release(transform);
 			return NULL;
 		}
 		return result;
 	}
 
+	/* A matrix-based transform will be selected: check that the PCS
+	   of the input/output profiles are the same, crbug.com/5120682 */
+	if (in->pcs != out->pcs) {
+		qcms_transform_release(transform);
+		return NULL;
+	}
+
 	if (precache) {
 		transform->output_table_r = precache_reference(out->output_table_r);
 		transform->output_table_g = precache_reference(out->output_table_g);
@@ -1152,43 +1338,34 @@
 			qcms_transform_release(transform);
 			return NO_MEM_TRANSFORM;
 		}
+
 		build_output_lut(out->redTRC, &transform->output_gamma_lut_r, &transform->output_gamma_lut_r_length);
 		build_output_lut(out->greenTRC, &transform->output_gamma_lut_g, &transform->output_gamma_lut_g_length);
 		build_output_lut(out->blueTRC, &transform->output_gamma_lut_b, &transform->output_gamma_lut_b_length);
+
 		if (!transform->output_gamma_lut_r || !transform->output_gamma_lut_g || !transform->output_gamma_lut_b) {
 			qcms_transform_release(transform);
 			return NO_MEM_TRANSFORM;
 		}
 	}
 
-        if (in->color_space == RGB_SIGNATURE) {
+	if (in->color_space == RGB_SIGNATURE) {
 		struct matrix in_matrix, out_matrix, result;
 
-		if (in_type != QCMS_DATA_RGB_8 &&
-                    in_type != QCMS_DATA_RGBA_8){
-                	assert(0 && "input type");
-			transform_free(transform);
-                	return NULL;
-            	}
-		if (precache) {
-#ifdef X86
-		    if (sse_version_available() >= 2) {
-			    if (in_type == QCMS_DATA_RGB_8)
-				    transform->transform_fn = qcms_transform_data_rgb_out_lut_sse2;
-			    else
-				    transform->transform_fn = qcms_transform_data_rgba_out_lut_sse2;
+		if (in_type != QCMS_DATA_RGB_8 && in_type != QCMS_DATA_RGBA_8) {
+			assert(0 && "input type");
+			qcms_transform_release(transform);
+			return NULL;
+		}
 
-#if !(defined(_MSC_VER) && defined(_M_AMD64))
-                    /* Microsoft Compiler for x64 doesn't support MMX.
-                     * SSE code uses MMX so that we disable on x64 */
-		    } else
-		    if (sse_version_available() >= 1) {
-			    if (in_type == QCMS_DATA_RGB_8)
-				    transform->transform_fn = qcms_transform_data_rgb_out_lut_sse1;
-			    else
-				    transform->transform_fn = qcms_transform_data_rgba_out_lut_sse1;
-#endif
-		    } else
+		if (precache) {
+#if defined(SSE2_ENABLE)
+			if (sse_version_available() >= 2) {
+				if (in_type == QCMS_DATA_RGB_8)
+					transform->transform_fn = qcms_transform_data_rgb_out_lut_sse2;
+				else
+					transform->transform_fn = qcms_transform_data_rgba_out_lut_sse2;
+			} else
 #endif
 			{
 				if (in_type == QCMS_DATA_RGB_8)
@@ -1207,12 +1384,12 @@
 		transform->input_gamma_table_r = build_input_gamma_table(in->redTRC);
 		transform->input_gamma_table_g = build_input_gamma_table(in->greenTRC);
 		transform->input_gamma_table_b = build_input_gamma_table(in->blueTRC);
+
 		if (!transform->input_gamma_table_r || !transform->input_gamma_table_g || !transform->input_gamma_table_b) {
 			qcms_transform_release(transform);
 			return NO_MEM_TRANSFORM;
 		}
 
-
 		/* build combined colorant matrix */
 		in_matrix = build_colorant_matrix(in);
 		out_matrix = build_colorant_matrix(out);
@@ -1223,6 +1400,17 @@
 		}
 		result = matrix_multiply(out_matrix, in_matrix);
 
+		/* check for NaN values in the matrix and bail if we find any
+		   see also https://bugzilla.mozilla.org/show_bug.cgi?id=1170316 */
+		for (i = 0 ; i < 3 ; ++i) {
+			for (j = 0 ; j < 3 ; ++j) {
+				if (result.m[i][j] != result.m[i][j]) {
+					qcms_transform_release(transform);
+					return NULL;
+				}
+			}
+		}
+
 		/* store the results in column major mode
 		 * this makes doing the multiplication with sse easier */
 		transform->matrix[0][0] = result.m[0][0];
@@ -1235,15 +1423,18 @@
 		transform->matrix[1][2] = result.m[2][1];
 		transform->matrix[2][2] = result.m[2][2];
 
+		/* Flag transform as matrix. */
+		transform->transform_flags |= TRANSFORM_FLAG_MATRIX;
+
 	} else if (in->color_space == GRAY_SIGNATURE) {
-		if (in_type != QCMS_DATA_GRAY_8 &&
-				in_type != QCMS_DATA_GRAYA_8){
+		if (in_type != QCMS_DATA_GRAY_8 && in_type != QCMS_DATA_GRAYA_8) {
 			assert(0 && "input type");
-			transform_free(transform);
+			qcms_transform_release(transform);
 			return NULL;
 		}
 
 		transform->input_gamma_table_gray = build_input_gamma_table(in->grayTRC);
+
 		if (!transform->input_gamma_table_gray) {
 			qcms_transform_release(transform);
 			return NO_MEM_TRANSFORM;
@@ -1264,23 +1455,187 @@
 		}
 	} else {
 		assert(0 && "unexpected colorspace");
-		transform_free(transform);
+		qcms_transform_release(transform);
 		return NULL;
 	}
+
 	return transform;
 }
 
-#if defined(__GNUC__) && !defined(__x86_64__) && !defined(__amd64__)
+/* __force_align_arg_pointer__ is an x86-only attribute, and gcc/clang warns on unused
+ * attributes. Don't use this on ARM or AMD64. __has_attribute can detect the presence
+ * of the attribute but is currently only supported by clang */
+#if defined(__has_attribute)
+#define HAS_FORCE_ALIGN_ARG_POINTER __has_attribute(__force_align_arg_pointer__)
+#elif defined(__GNUC__) && defined(__i386__)
+#define HAS_FORCE_ALIGN_ARG_POINTER 1
+#else
+#define HAS_FORCE_ALIGN_ARG_POINTER 0
+#endif
+
+#if HAS_FORCE_ALIGN_ARG_POINTER
 /* we need this to avoid crashes when gcc assumes the stack is 128bit aligned */
 __attribute__((__force_align_arg_pointer__))
 #endif
 void qcms_transform_data(qcms_transform *transform, void *src, void *dest, size_t length)
 {
-	transform->transform_fn(transform, src, dest, length);
+	static const struct _qcms_format_type output_rgbx = { 0, 2 };
+
+	transform->transform_fn(transform, src, dest, length, output_rgbx);
 }
 
-qcms_bool qcms_supports_iccv4;
+void qcms_transform_data_type(qcms_transform *transform, void *src, void *dest, size_t length, qcms_output_type type)
+{
+	static const struct _qcms_format_type output_rgbx = { 0, 2 };
+	static const struct _qcms_format_type output_bgrx = { 2, 0 };
+
+	transform->transform_fn(transform, src, dest, length, type == QCMS_OUTPUT_BGRX ? output_bgrx : output_rgbx);
+}
+
+#define ENABLE_ICC_V4_PROFILE_SUPPORT false
+
+qcms_bool qcms_supports_iccv4 = ENABLE_ICC_V4_PROFILE_SUPPORT;
+
 void qcms_enable_iccv4()
 {
 	qcms_supports_iccv4 = true;
 }
+
+static inline qcms_bool transform_is_matrix(qcms_transform *t)
+{
+	return (t->transform_flags & TRANSFORM_FLAG_MATRIX) ? true : false;
+}
+
+qcms_bool qcms_transform_is_matrix(qcms_transform *t)
+{
+	return transform_is_matrix(t);
+}
+
+float qcms_transform_get_matrix(qcms_transform *t, unsigned i, unsigned j)
+{
+	assert(transform_is_matrix(t) && i < 3 && j < 3);
+
+	// Return transform matrix element in row major order (permute i and j)
+
+	return t->matrix[j][i];
+}
+
+static inline qcms_bool supported_trc_type(qcms_trc_type type)
+{
+	return (type == QCMS_TRC_HALF_FLOAT || type == QCMS_TRC_USHORT);
+}
+
+const uint16_t half_float_one = 0x3c00;
+
+size_t qcms_transform_get_input_trc_rgba(qcms_transform *t, qcms_profile *in, qcms_trc_type type, unsigned short *data)
+{
+	const size_t size = 256; // The input gamma tables always have 256 entries.
+
+	size_t i;
+
+	if (in->color_space != RGB_SIGNATURE || !supported_trc_type(type))
+		return 0;
+
+	// qcms_profile *in is assumed to be the profile on the input-side of the color transform t.
+	// When a transform is created, the input gamma curve data is stored in the transform ...
+
+	if (!t->input_gamma_table_r || !t->input_gamma_table_g || !t->input_gamma_table_b)
+		return 0;
+
+	// Report the size if no output data is requested. This allows callers to first work out the
+	// the curve size, then provide allocated memory sufficient to store the curve rgba data.
+
+	if (!data)
+		return size;
+
+	switch(type) {
+		case QCMS_TRC_HALF_FLOAT:
+			for (i = 0; i < size; ++i) {
+				*data++ = float_to_half_float(t->input_gamma_table_r[i]); // r
+				*data++ = float_to_half_float(t->input_gamma_table_g[i]); // g
+				*data++ = float_to_half_float(t->input_gamma_table_b[i]); // b
+				*data++ = half_float_one;                                 // a
+			}
+			break;
+		case QCMS_TRC_USHORT:
+			for (i = 0; i < size; ++i) {
+				*data++ = roundf(t->input_gamma_table_r[i] * 65535.0); // r
+				*data++ = roundf(t->input_gamma_table_g[i] * 65535.0); // g
+				*data++ = roundf(t->input_gamma_table_b[i] * 65535.0); // b
+				*data++ = 65535;                                       // a
+			}
+			break;
+		default:
+			/* should not be reached */
+			assert(0);
+	}
+
+	return size;
+}
+
+const float inverse65535 = (float) (1.0 / 65535.0);
+
+size_t qcms_transform_get_output_trc_rgba(qcms_transform *t, qcms_profile *out, qcms_trc_type type, unsigned short *data)
+{
+	size_t size, i;
+
+	if (out->color_space != RGB_SIGNATURE || !supported_trc_type(type))
+		return 0;
+
+	// qcms_profile *out is assumed to be the profile on the output-side of the transform t.
+	// If the transform output gamma curves need building, do that. They're usually built when
+	// the transform was created, but sometimes not due to the output gamma precache ...
+
+	if (!out->redTRC || !out->greenTRC || !out->blueTRC)
+		return 0;
+	if (!t->output_gamma_lut_r)
+		build_output_lut(out->redTRC, &t->output_gamma_lut_r, &t->output_gamma_lut_r_length);
+	if (!t->output_gamma_lut_g)
+		build_output_lut(out->greenTRC, &t->output_gamma_lut_g, &t->output_gamma_lut_g_length);
+	if (!t->output_gamma_lut_b)
+		build_output_lut(out->blueTRC, &t->output_gamma_lut_b, &t->output_gamma_lut_b_length);
+
+	if (!t->output_gamma_lut_r || !t->output_gamma_lut_g || !t->output_gamma_lut_b)
+		return 0;
+
+	// Output gamma tables should have the same size and should have 4096 entries at most (the
+	// minimum is 256). Larger tables are rare and ignored here: fail by returning 0.
+
+	size = t->output_gamma_lut_r_length;
+	if (size != t->output_gamma_lut_g_length)
+		return 0;
+	if (size != t->output_gamma_lut_b_length)
+		return 0;
+	if (size < 256 || size > 4096)
+		return 0;
+
+	// Report the size if no output data is requested. This allows callers to first work out the
+	// the curve size, then provide allocated memory sufficient to store the curve rgba data.
+
+	if (!data)
+		return size;
+
+	switch (type) {
+		case QCMS_TRC_HALF_FLOAT:
+			for (i = 0; i < size; ++i) {
+				*data++ = float_to_half_float(t->output_gamma_lut_r[i] * inverse65535); // r
+				*data++ = float_to_half_float(t->output_gamma_lut_g[i] * inverse65535); // g
+				*data++ = float_to_half_float(t->output_gamma_lut_b[i] * inverse65535); // b
+				*data++ = half_float_one;                                               // a
+			}
+			break;
+		case QCMS_TRC_USHORT:
+			for (i = 0; i < size; ++i) {
+				*data++ = t->output_gamma_lut_r[i]; // r
+				*data++ = t->output_gamma_lut_g[i]; // g
+				*data++ = t->output_gamma_lut_b[i]; // b
+				*data++ = 65535;                    // a
+			}
+			break;
+		default:
+			/* should not be reached */
+			assert(0);
+	}
+
+	return size;
+}
diff --git a/transform_util.c b/transform_util.c
index 1ff8a1e..8b9703d 100644
--- a/transform_util.c
+++ b/transform_util.c
@@ -1,3 +1,24 @@
+//  qcms
+//  Copyright (C) 2009 Mozilla Foundation
+//
+// 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.
+
 #define _ISOC99_SOURCE  /* for INFINITY */
 
 #include <math.h>
@@ -15,8 +36,8 @@
 
 /* value must be a value between 0 and 1 */
 //XXX: is the above a good restriction to have?
-// the output range of this functions is 0..1
-float lut_interp_linear(double input_value, uint16_t *table, int length)
+// the output range of this function is 0..1
+float lut_interp_linear(double input_value, uint16_t *table, size_t length)
 {
 	int upper, lower;
 	float value;
@@ -30,11 +51,11 @@
 }
 
 /* same as above but takes and returns a uint16_t value representing a range from 0..1 */
-uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, int length)
+uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, size_t length)
 {
 	/* Start scaling input_value to the length of the array: 65535*(length-1).
 	 * We'll divide out the 65535 next */
-	uint32_t value = (input_value * (length - 1));
+	uintptr_t value = (input_value * (length - 1));
 	uint32_t upper = (value + 65534) / 65535; /* equivalent to ceil(value/65535) */
 	uint32_t lower = value / 65535;           /* equivalent to floor(value/65535) */
 	/* interp is the distance from upper to value scaled to 0..65535 */
@@ -48,11 +69,11 @@
 /* same as above but takes an input_value from 0..PRECACHE_OUTPUT_MAX
  * and returns a uint8_t value representing a range from 0..1 */
 static
-uint8_t lut_interp_linear_precache_output(uint32_t input_value, uint16_t *table, int length)
+uint8_t lut_interp_linear_precache_output(uint32_t input_value, uint16_t *table, size_t length)
 {
 	/* Start scaling input_value to the length of the array: PRECACHE_OUTPUT_MAX*(length-1).
 	 * We'll divide out the PRECACHE_OUTPUT_MAX next */
-	uint32_t value = (input_value * (length - 1));
+	uintptr_t value = (input_value * (length - 1));
 
 	/* equivalent to ceil(value/PRECACHE_OUTPUT_MAX) */
 	uint32_t upper = (value + PRECACHE_OUTPUT_MAX-1) / PRECACHE_OUTPUT_MAX;
@@ -72,7 +93,7 @@
 
 /* value must be a value between 0 and 1 */
 //XXX: is the above a good restriction to have?
-float lut_interp_linear_float(float value, float *table, int length)
+float lut_interp_linear_float(float value, float *table, size_t length)
 {
         int upper, lower;
         value = value * (length - 1);
@@ -106,12 +127,12 @@
 	unsigned int i;
 	float gamma_float = u8Fixed8Number_to_float(gamma);
 	for (i = 0; i < 256; i++) {
-                // 0..1^(0..255 + 255/256) will always be between 0 and 1
+		// 0..1^(0..255 + 255/256) will always be between 0 and 1
 		gamma_table[i] = pow(i/255., gamma_float);
 	}
 }
 
-void compute_curve_gamma_table_type2(float gamma_table[256], uint16_t *table, int length)
+void compute_curve_gamma_table_type2(float gamma_table[256], uint16_t *table, size_t length)
 {
 	unsigned int i;
 	for (i = 0; i < 256; i++) {
@@ -168,15 +189,16 @@
                 e = 0;
                 f = 0;
                 interval = -INFINITY;
-        }       
+        }
         for (X = 0; X < 256; X++) {
-                if (X >= interval) {
+                float x = X / 255.0;
+                if (x >= interval) {
                         // XXX The equations are not exactly as definied in the spec but are
                         //     algebraic equivilent.
                         // TODO Should division by 255 be for the whole expression.
-                        gamma_table[X] = clamp_float(pow(a * X / 255. + b, y) + c + e);
+                        gamma_table[X] = clamp_float(pow(a * x + b, y) + c + e);
                 } else {
-                        gamma_table[X] = clamp_float(c * X / 255. + f);
+                        gamma_table[X] = clamp_float(c * x + f);
                 }
         }
 }
@@ -229,6 +251,21 @@
 	return x/256.;
 }
 
+/* The SSE2 code uses min & max which let NaNs pass through.
+   We want to try to prevent that here by ensuring that
+   gamma table is within expected values. */
+void validate_gamma_table(float gamma_table[256])
+{
+	int i;
+	for (i = 0; i < 256; i++) {
+		// Note: we check that the gamma is not in range
+		// instead of out of range so that we catch NaNs
+		if (!(gamma_table[i] >= 0.f && gamma_table[i] <= 1.f)) {
+			gamma_table[i] = 0.f;
+		}
+	}
+}
+
 float *build_input_gamma_table(struct curveType *TRC)
 {
 	float *gamma_table;
@@ -248,7 +285,10 @@
 			}
 		}
 	}
-        return gamma_table;
+
+	validate_gamma_table(gamma_table);
+
+	return gamma_table;
 }
 
 struct matrix build_colorant_matrix(qcms_profile *p)
@@ -271,25 +311,19 @@
  * I think it could be much better. For example, Argyll seems to have better code in
  * icmTable_lookup_bwd and icmTable_setup_bwd. However, for now this is a quick way
  * to a working solution and allows for easy comparing with lcms. */
-uint16_fract_t lut_inverse_interp16(uint16_t Value, uint16_t LutTable[], int length)
+uint16_fract_t lut_inverse_interp16(uint16_t Value, uint16_t LutTable[], int length, int NumZeroes, int NumPoles)
 {
         int l = 1;
         int r = 0x10000;
         int x = 0, res;       // 'int' Give spacing for negative values
-        int NumZeroes, NumPoles;
         int cell0, cell1;
         double val2;
         double y0, y1, x0, x1;
         double a, b, f;
 
         // July/27 2001 - Expanded to handle degenerated curves with an arbitrary
-        // number of elements containing 0 at the begining of the table (Zeroes)
+        // number of elements containing 0 at the beginning of the table (Zeroes)
         // and another arbitrary number of poles (FFFFh) at the end.
-        // First the zero and pole extents are computed, then value is compared.
-
-        NumZeroes = 0;
-        while (LutTable[NumZeroes] == 0 && NumZeroes < length-1)
-                        NumZeroes++;
 
         // There are no zeros at the beginning and we are trying to find a zero, so
         // return anything. It seems zero would be the less destructive choice
@@ -297,28 +331,48 @@
         if (NumZeroes == 0 && Value == 0)
             return 0;
 
-        NumPoles = 0;
-        while (LutTable[length-1- NumPoles] == 0xFFFF && NumPoles < length-1)
-                        NumPoles++;
-
         // Does the curve belong to this case?
         if (NumZeroes > 1 || NumPoles > 1)
-        {               
-                int a, b;
+        {
+                int a, b, sample;
 
-                // Identify if value fall downto 0 or FFFF zone             
+                // Identify if value fall downto 0 or FFFF zone
                 if (Value == 0) return 0;
-               // if (Value == 0xFFFF) return 0xFFFF;
+                // if (Value == 0xFFFF) return 0xFFFF;
+                sample = (length-1) * ((double) Value * (1./65535.));
+                if (LutTable[sample] == 0xffff)
+                    return 0xffff;
 
                 // else restrict to valid zone
 
-                a = ((NumZeroes-1) * 0xFFFF) / (length-1);               
+                a = ((NumZeroes-1) * 0xFFFF) / (length-1);
                 b = ((length-1 - NumPoles) * 0xFFFF) / (length-1);
-                                                                
+
                 l = a - 1;
                 r = b + 1;
+
+                // Ensure a valid binary search range
+
+                if (l < 1)
+                    l = 1;
+                if (r > 0x10000)
+                    r = 0x10000;
+
+                // If the search range is inverted due to degeneracy,
+                // deem LutTable non-invertible in this search range.
+                // Refer to https://bugzil.la/1132467
+
+                if (r <= l)
+                    return 0;
         }
 
+        // For input 0, return that to maintain black level. Note the binary search
+        // does not. For example, it inverts the standard sRGB gamma curve to 7 at
+        // the origin, causing a black level error.
+
+        if (Value == 0 && NumZeroes) {
+            return 0;
+        }
 
         // Seems not a degenerated case... apply binary search
 
@@ -326,12 +380,12 @@
 
                 x = (l + r) / 2;
 
-		res = (int) lut_interp_linear16((uint16_fract_t) (x-1), LutTable, length);
+                res = (int) lut_interp_linear16((uint16_fract_t) (x-1), LutTable, length);
 
                 if (res == Value) {
 
-                    // Found exact match. 
-                    
+                    // Found exact match.
+
                     return (uint16_fract_t) (x - 1);
                 }
 
@@ -341,18 +395,24 @@
 
         // Not found, should we interpolate?
 
-                
         // Get surrounding nodes
-        
+
+        assert(x >= 1);
+
         val2 = (length-1) * ((double) (x - 1) / 65535.0);
 
         cell0 = (int) floor(val2);
         cell1 = (int) ceil(val2);
-           
+
+        assert(cell0 >= 0);
+        assert(cell1 >= 0);
+        assert(cell0 < length);
+        assert(cell1 < length);
+
         if (cell0 == cell1) return (uint16_fract_t) x;
 
         y0 = LutTable[cell0] ;
-        x0 = (65535.0 * cell0) / (length-1); 
+        x0 = (65535.0 * cell0) / (length-1);
 
         y1 = LutTable[cell1] ;
         x1 = (65535.0 * cell1) / (length-1);
@@ -367,8 +427,22 @@
         if (f < 0.0) return (uint16_fract_t) 0;
         if (f >= 65535.0) return (uint16_fract_t) 0xFFFF;
 
-        return (uint16_fract_t) floor(f + 0.5);                        
+        return (uint16_fract_t) floor(f + 0.5);
+}
 
+// December/16 2015 - Moved this code out of lut_inverse_interp16
+// in order to save computation in invert_lut loop.
+static void count_zeroes_and_poles(uint16_t *LutTable, int length, int *NumZeroes, int *NumPoles)
+{
+    int z = 0, p = 0;
+
+    while (LutTable[z] == 0 && z < length - 1)
+    	z++;
+    *NumZeroes = z;
+
+    while (LutTable[length - 1 - p] == 0xFFFF && p < length - 1)
+    	p++;
+    *NumPoles = p;
 }
 
 /*
@@ -384,20 +458,27 @@
  which has an maximum error of about 9855 (pixel difference of ~38.346)
 
  For now, we punt the decision of output size to the caller. */
-static uint16_t *invert_lut(uint16_t *table, int length, int out_length)
+static uint16_t *invert_lut(uint16_t *table, int length, size_t out_length)
 {
-        int i;
+        int NumZeroes;
+        int NumPoles;
+        size_t i;
         /* for now we invert the lut by creating a lut of size out_length
          * and attempting to lookup a value for each entry using lut_inverse_interp16 */
         uint16_t *output = malloc(sizeof(uint16_t)*out_length);
         if (!output)
                 return NULL;
 
+        // December/16 2015 - Compute the input curve zero and pole extents outside
+        // the loop and pass them to lut_inverse_interp16.
+        count_zeroes_and_poles(table, length, &NumZeroes, &NumPoles);
+
         for (i = 0; i < out_length; i++) {
                 double x = ((double) i * 65535.) / (double) (out_length - 1);
                 uint16_fract_t input = floor(x + .5);
-                output[i] = lut_inverse_interp16(input, table, length);
+                output[i] = lut_inverse_interp16(input, table, length, NumZeroes, NumPoles);
         }
+
         return output;
 }
 
@@ -429,7 +510,7 @@
 
 qcms_bool compute_precache(struct curveType *trc, uint8_t *output)
 {
-        
+
         if (trc->type == PARAMETRIC_CURVE_TYPE) {
                         float gamma_table[256];
                         uint16_t gamma_table_uint[256];
@@ -442,9 +523,9 @@
                                 gamma_table_uint[i] = (uint16_t)(gamma_table[i] * 65535);
                         }
 
-                        //XXX: the choice of a minimum of 256 here is not backed by any theory, 
+                        //XXX: the choice of a minimum of 256 here is not backed by any theory,
                         //     measurement or data, howeve r it is what lcms uses.
-                        //     the maximum number we would need is 65535 because that's the 
+                        //     the maximum number we would need is 65535 because that's the
                         //     accuracy used for computing the pre cache table
                         if (inverted_size < 256)
                                 inverted_size = 256;
@@ -462,9 +543,9 @@
                 } else {
                         uint16_t *inverted;
                         int inverted_size = trc->count;
-                        //XXX: the choice of a minimum of 256 here is not backed by any theory, 
+                        //XXX: the choice of a minimum of 256 here is not backed by any theory,
                         //     measurement or data, howeve r it is what lcms uses.
-                        //     the maximum number we would need is 65535 because that's the 
+                        //     the maximum number we would need is 65535 because that's the
                         //     accuracy used for computing the pre cache table
                         if (inverted_size < 256)
                                 inverted_size = 256;
@@ -517,20 +598,25 @@
 {
         if (trc->type == PARAMETRIC_CURVE_TYPE) {
                 float gamma_table[256];
+                uint16_t gamma_table_uint[256];
                 uint16_t i;
-                uint16_t *output = malloc(sizeof(uint16_t)*256);
-
-                if (!output) {
-                        *output_gamma_lut = NULL;
-                        return;
-                }
+                uint16_t *inverted;
+                int inverted_size = 4096;
 
                 compute_curve_gamma_table_type_parametric(gamma_table, trc->parameter, trc->count);
-                *output_gamma_lut_length = 256;
                 for(i = 0; i < 256; i++) {
-                        output[i] = (uint16_t)(gamma_table[i] * 65535);
+                        gamma_table_uint[i] = (uint16_t)(gamma_table[i] * 65535);
                 }
-                *output_gamma_lut = output;
+
+                //XXX: the choice of a minimum of 256 here is not backed by any theory,
+                //     measurement or data, however it is what lcms uses.
+                //     the maximum number we would need is 65535 because that's the
+                //     accuracy used for computing the pre cache table
+                inverted = invert_lut(gamma_table_uint, 256, inverted_size);
+                if (!inverted)
+                        return;
+                *output_gamma_lut = inverted;
+                *output_gamma_lut_length = inverted_size;
         } else {
                 if (trc->count == 0) {
                         *output_gamma_lut = build_linear_table(4096);
@@ -540,7 +626,7 @@
                         *output_gamma_lut = build_pow_table(gamma, 4096);
                         *output_gamma_lut_length = 4096;
                 } else {
-                        //XXX: the choice of a minimum of 256 here is not backed by any theory, 
+                        //XXX: the choice of a minimum of 256 here is not backed by any theory,
                         //     measurement or data, however it is what lcms uses.
                         *output_gamma_lut_length = trc->count;
                         if (*output_gamma_lut_length < 256)
@@ -552,3 +638,36 @@
 
 }
 
+size_t qcms_profile_get_parametric_curve(qcms_profile *profile, qcms_trc_channel channel, float data[7])
+{
+    static const uint32_t COUNT_TO_LENGTH[5] = {1, 3, 4, 5, 7};
+    struct curveType *curve = NULL;
+    size_t size;
+
+    if (profile->color_space != RGB_SIGNATURE)
+        return 0;
+
+    switch(channel) {
+    case QCMS_TRC_RED:
+        curve = profile->redTRC;
+        break;
+    case QCMS_TRC_GREEN:
+        curve = profile->greenTRC;
+        break;
+    case QCMS_TRC_BLUE:
+        curve = profile->blueTRC;
+        break;
+    default:
+        return 0;
+    }
+
+    if (!curve || curve->type != PARAMETRIC_CURVE_TYPE)
+        return 0;
+
+    size = COUNT_TO_LENGTH[curve->count];
+
+    if (data)
+        memcpy(data, curve->parameter, size * sizeof(float));
+
+    return size;
+}
diff --git a/transform_util.h b/transform_util.h
index 8f358a8..f83477a 100644
--- a/transform_util.h
+++ b/transform_util.h
@@ -31,14 +31,14 @@
 //XXX: could use a bettername
 typedef uint16_t uint16_fract_t;
 
-float lut_interp_linear(double value, uint16_t *table, int length);
-float lut_interp_linear_float(float value, float *table, int length);
-uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, int length);
+float lut_interp_linear(double input_value, uint16_t *table, size_t length);
+float lut_interp_linear_float(float input_value, float *table, size_t length);
+uint16_t lut_interp_linear16(uint16_t input_value, uint16_t *table, size_t length);
 
 
 static inline float lerp(float a, float b, float t)
 {
-        return a*(1.f-t) + b*t;
+	return a*(1.f-t) + b*t;
 }
 
 unsigned char clamp_u8(float v);
@@ -55,5 +55,4 @@
 struct matrix matrix_invert(struct matrix mat);
 qcms_bool compute_precache(struct curveType *trc, uint8_t *output);
 
-
 #endif
diff --git a/util/Makefile b/util/Makefile
deleted file mode 100644
index 5adee94..0000000
--- a/util/Makefile
+++ /dev/null
@@ -1,3 +0,0 @@
-LDFLAGS= -Wl,-framework,ApplicationServices
-CFLAGS=-g
-all: colorsync-perf
diff --git a/util/colorsync-perf.c b/util/colorsync-perf.c
deleted file mode 100644
index fb1fd6d..0000000
--- a/util/colorsync-perf.c
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <ApplicationServices/ApplicationServices.h>
-#include <dlfcn.h>
-#include <stdio.h>
-
-#define BITMAP_INFO (kCGBitmapByteOrder32Big | kCGImageAlphaNoneSkipLast)
-
-
-int main(int argc, char **argv) {
-	int width = 256;
-	int height = 256*256;
-	char *input_profile_file = "input.icc";
-	char *output_profile_file = "output.icc";
-	if (argc >= 3) {
-		input_profile_file = argv[1];
-		output_profile_file = argv[2];
-	}
-	CGDataProviderRef input_file = CGDataProviderCreateWithFilename(input_profile_file);
-	CGDataProviderRef output_file = CGDataProviderCreateWithFilename(output_profile_file);
-	float range[] = {0, 1., 0, 1., 0, 1.};
-	CGColorSpaceRef output_profile = CGColorSpaceCreateICCBased(3, range, output_file, NULL);
-	CGColorSpaceRef input_profile = CGColorSpaceCreateICCBased(3, range, input_file, NULL);
-	CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();
-
-	CGContextRef cin = CGBitmapContextCreate(NULL, width, height,
-			8, 4*width, input_profile, BITMAP_INFO);
-	CGContextRef cout = CGBitmapContextCreate(NULL, width, height,
-			8, 4*width, output_profile, BITMAP_INFO);
-
-	CGRect rect = {{0,0},{width, height}};
-	CGImageRef copy = CGBitmapContextCreateImage(cin);
-#define LENGTH 256*256*256
-	static unsigned char src[LENGTH*3];
-	static unsigned char qoutput[LENGTH*3];
-	static unsigned char loutput[LENGTH*3];
-	int i,j,k,l=0;
-	for (i=0; i<256; i++) {
-		for (j=0; j<256; j++) {
-			for (k=0; k<256; k++) {
-				src[l++] = i;
-				src[l++] = j;
-				src[l++] = k;
-			}
-		}
-	}
-
-	CGDataProviderRef dp = CGDataProviderCreateWithData(NULL, src, height * width * 3, NULL);
-	CGImageRef ref = CGImageCreate(width, height, 8, 24, width * 3, input_profile, BITMAP_INFO, dp, NULL, 1, kCGRenderingIntentDefault);
-	clock_t qcms_start = clock();
-	CGContextDrawImage(cout, rect, ref);
-	clock_t qcms_time = clock() - qcms_start;
-	printf("ColorSync: %ld\n", qcms_time);
-}