Add bgra (z,y,x) sampled transform lookup table api

third_party/qcms/src/transform.c

Index: third_party/qcms/src/transform.c
diff --git a/third_party/qcms/src/transform.c b/third_party/qcms/src/transform.c
index 9fd82389f84c0aef8a0515a6f4616836c9df1b43..947f1fad00df069388314fecbe31e1bca6eb5ba1 100644
--- a/third_party/qcms/src/transform.c
+++ b/third_party/qcms/src/transform.c
@@ -1167,6 +1167,69 @@ qcms_transform* qcms_transform_precacheLUT_float(qcms_transform *transform, qcms
 	return transform;
 }
 
+qcms_bool qcms_transform_create_color_cube_skia(qcms_profile *in, qcms_profile *out,
+                                                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

[Ken Russell (switch to Gerrit), 2015/02/04 22:23:05]

Not sure, but I thought the way to do this conversion was clamp(ubyte*256.0f, 0,
255).

[Noel Gordon, 2015/02/05 16:28:52]

Interesting thought, not sure of the correct answer here.

The LUT data produced by qcms_chain_transform is clamped on [ 0.0 .. 1.0 ] for
reference. I've mapped that to 0 .. 255 with rounding.  Need the rounding, but I
think your question is should the multiplier be 256.0f or 255.0f as I've used?

Do you know how GPU map there [ 0.0 .. 1.0 ] pixel data onto 0 .. 255 when
writing pixels?  Does it round somehow?.

Also, I assume clamp() is the GLSL one? It returns a float, computed as
min(max(x, minVal), maxVal) per [1]

[1] https://www.opengl.org/sdk/docs/man/html/clamp.xhtml

[Ken Russell (switch to Gerrit), 2015/02/06 02:49:54]

My understanding is that the formulation above (multiply by 256.0 and clamp to
between 0..255) provides a more equal mapping of the values between 0.0 ... 1.0
and 0..255.
Good question. This was actually changed in the OpenGL ES 3.0 spec. See OpenGL
ES 3.0.3, appendix F.2 "Differences in Runtime Behavior", and the reference to
section 2.1.6 of that spec. That formulation is actually different than both
yours and the one I suggested above.
No, I was just talking about an abstract clamp operation.

[Mike Lawther (Google), 2015/02/06 03:20:06]

My understanding was the same as Ken's. With "mult by 255 and round", 0 and 255
have half as many values that map to them as do 1-254. 
Interesting! The difference mentioned was for signed floating point conversions
rather than unsigned? I interpreted eqn 2.3 as being "mult by 255 and prefer to
round" which sounds like what Noel originally proposed?

[Ken Russell (switch to Gerrit), 2015/02/06 03:31:35]

That's correct. The unsigned conversions were unchanged.
I'm not a floating point expert and am not sure whether "add 0.5 and floor" is
the same as "round to nearest".

+                        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;
+}
+
 #define NO_MEM_TRANSFORM NULL
 
 qcms_transform* qcms_transform_create(