[qcms] Reduce RMS color error for qcms_transform_data_rgb(a)_out_lut

third_party/qcms/src/transform-sse2.c

 //  qcms
 //  Copyright (C) 2009 Mozilla Foundation
 //  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
 // 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 <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] =
     { CLAMPMAXVAL, CLAMPMAXVAL, CLAMPMAXVAL, CLAMPMAXVAL};
 
 void qcms_transform_data_rgb_out_lut_sse2(qcms_transform *transform,
                                           unsigned char *src,
                                           unsigned char *dest,
                                           size_t length,
                                           qcms_format_type output_format)
@@ skipping 56 matching lines @@
         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_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);
 
         /* store calc'd output tables indices */
-        _mm_store_si128((__m128i*)output, _mm_cvtps_epi32(result));
+        _mm_store_si128((__m128i*)output, _mm_cvttps_epi32(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[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 */
 
     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_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));
+    _mm_store_si128((__m128i*)output, _mm_cvttps_epi32(result));
 
     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,
@@ skipping 63 matching lines @@
         /* 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[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);
 
         /* store calc'd output tables indices */
-        _mm_store_si128((__m128i*)output, _mm_cvtps_epi32(result));
+        _mm_store_si128((__m128i*)output, _mm_cvttps_epi32(result));

[Noel Gordon, 2015/11/04 13:01:28]

Now we match the s/w case, one question: if you rounded here, would that reduce
the RMS error?

[radu.velea, 2015/11/04 13:12:19]

Using SSE round (_mm_cvtps_epi32) generates the following output for SSE code:

Input profile sRGB IEC61966-2.1
Output profile Adobe RGB (1998) (using qcms precache)
RMS color error 2.66

Input profile Adobe RGB (1998)
Output profile sRGB IEC61966-2.1 (using qcms precache)
RMS color error 0.87

 
         /* 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[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 */
 
     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[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));
+    _mm_store_si128((__m128i*)output, _mm_cvttps_epi32(result));
 
     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)) ;
@@ skipping 173 matching lines @@
         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;
     }
 }