Avoid divisions creating sample points in the float cube LUT builder

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 1100 matching lines @@
 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 */
         uint16_t x,y,z;
         uint32_t l;
         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 */
+                /* 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) {
                                 transform->transform_fn = qcms_transform_data_tetra_clut_rgba;
                         } 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);
         }
         if (dest && lut != dest) {
                 free(dest);
         }
 
         if (lut == NULL) {
                 return NULL;
         }
@@ skipping 196 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;
 }