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

third_party/qcms/src/transform.c

 /* vim: set ts=8 sw=8 noexpandtab: */
 //  qcms
 //  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 
@@ skipping 1149 matching lines @@
         if (dest && lut != dest) {
                 free(dest);
         }
 
         if (lut == NULL) {
                 return NULL;
         }
         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(
                 qcms_profile *in, qcms_data_type in_type,
                 qcms_profile *out, qcms_data_type out_type,
                 qcms_intent intent)
 {
         bool precache = false;
 
         qcms_transform *transform = transform_alloc();
@@ skipping 183 matching lines @@
         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);
 }
 
 qcms_bool qcms_supports_iccv4;
 void qcms_enable_iccv4()
 {
         qcms_supports_iccv4 = true;
 }