[babl] babl: add more missing SIMD build related files

[Øyvind "pippin" Kolås <ok src gnome org>]

commit 6012c648899745fcfd641b6e204d02802e1efdb5
Author: Øyvind Kolås <pippin gimp org>
Date:   Sun Jan 23 02:48:02 2022 +0100

    babl: add more missing SIMD build related files

 babl/base/babl-rgb-converter.c | 647 +++++++++++++++++++++++++++++++++++++++++
 extensions/babl-verify-cpu.inc |  63 ++++
 2 files changed, 710 insertions(+)
---
diff --git a/babl/base/babl-rgb-converter.c b/babl/base/babl-rgb-converter.c
new file mode 100644
index 000000000..90ea22085
--- /dev/null
+++ b/babl/base/babl-rgb-converter.c
@@ -0,0 +1,647 @@
+#include "config.h"
+#include "babl-internal.h"
+#include "base/util.h"
+#include "babl-trc.h"
+#include "babl-base.h"
+///////////////////
+
+
+static void
+prep_conversion (const Babl *babl)
+{
+  Babl *conversion = (void*) babl;
+  const Babl *source_space = babl_conversion_get_source_space (conversion);
+  float *matrixf;
+  unsigned int i;
+  float *lut_red;
+  float *lut_green;
+  float *lut_blue;
+
+  double matrix[9];
+  babl_matrix_mul_matrix (
+     (conversion->conversion.destination)->format.space->space.XYZtoRGB,
+     (conversion->conversion.source)->format.space->space.RGBtoXYZ,
+     matrix);
+
+  matrixf = babl_calloc (sizeof (float), 9 + 256 * 3); // we leak this matrix , which is a singleton
+  babl_matrix_to_float (matrix, matrixf);
+  conversion->conversion.data = matrixf;
+
+  lut_red = matrixf + 9;
+  lut_green = lut_red + 256;
+  lut_blue = lut_green + 256;
+  for (i = 0; i < 256; i++)
+  {
+    lut_red[i] = babl_trc_to_linear (source_space->space.trc[0], i/255.0);
+    lut_green[i] = babl_trc_to_linear (source_space->space.trc[1], i/255.0);
+    lut_blue[i] = babl_trc_to_linear (source_space->space.trc[2], i/255.0);
+  }
+}
+
+#define TRC_IN(rgba_in, rgba_out)  do{ int i;\
+  for (i = 0; i < samples; i++) \
+  { \
+    rgba_out[i*4+3] = rgba_in[i*4+3]; \
+  } \
+  if ((source_space->space.trc[0] == source_space->space.trc[1]) && \
+      (source_space->space.trc[1] == source_space->space.trc[2])) \
+  { \
+    const Babl *trc = (void*)source_space->space.trc[0]; \
+    babl_trc_to_linear_buf(trc, rgba_in, rgba_out, 4, 4, 3, samples); \
+  } \
+  else \
+  { \
+    unsigned int c; \
+    for (c = 0; c < 3; c ++) \
+    { \
+      const Babl *trc = (void*)source_space->space.trc[c]; \
+      babl_trc_to_linear_buf(trc, rgba_in + c, rgba_out + c, 4, 4, 1, samples); \
+    } \
+  } \
+}while(0)
+
+#define TRC_OUT(rgba_in, rgba_out)  do{\
+  { \
+    unsigned int c; \
+    if ((destination_space->space.trc[0] == destination_space->space.trc[1]) && \
+        (destination_space->space.trc[1] == destination_space->space.trc[2])) \
+    { \
+      const Babl *trc = (void*)destination_space->space.trc[0]; \
+      babl_trc_from_linear_buf(trc, rgba_in, rgba_out, 4, 4, 3, samples); \
+    } \
+    else \
+    { \
+      for (c = 0; c < 3; c ++) \
+      { \
+        const Babl *trc = (void*)destination_space->space.trc[c]; \
+        babl_trc_from_linear_buf(trc, rgba_in + c, rgba_out + c, 4, 4, 1, samples); \
+      } \
+    } \
+  }\
+} while(0)
+
+
+
+
+static inline void
+universal_nonlinear_rgba_converter (const Babl    *conversion,
+                                    unsigned char *__restrict__ src_char,
+                                    unsigned char *__restrict__ dst_char,
+                                    long           samples,
+                                    void          *data)
+{
+  const Babl *source_space = babl_conversion_get_source_space (conversion);
+  const Babl *destination_space = babl_conversion_get_destination_space (conversion);
+
+  float * matrixf = data;
+  float *rgba_in = (void*)src_char;
+  float *rgba_out = (void*)dst_char;
+
+  TRC_IN(rgba_in, rgba_out);
+
+  babl_matrix_mul_vectorff_buf4 (matrixf, rgba_out, rgba_out, samples);
+
+  TRC_OUT(rgba_out, rgba_out);
+}
+
+static inline void
+universal_nonlinear_rgb_linear_converter (const Babl    *conversion,
+                                          unsigned char *__restrict__ src_char,
+                                          unsigned char *__restrict__ dst_char,
+                                          long           samples,
+                                          void          *data)
+{
+  const Babl *source_space = babl_conversion_get_source_space (conversion);
+  float * matrixf = data;
+  float *rgba_in = (void*)src_char;
+  float *rgba_out = (void*)dst_char;
+
+  TRC_IN(rgba_in, rgba_out);
+
+  babl_matrix_mul_vectorff_buf4 (matrixf, rgba_out, rgba_out, samples);
+}
+
+static inline void
+universal_linear_rgb_nonlinear_converter (const Babl    *conversion,
+                                          unsigned char *__restrict__ src_char,
+                                          unsigned char *__restrict__ dst_char,
+                                          long           samples,
+                                          void          *data)
+{
+  const Babl *destination_space = conversion->conversion.destination->format.space;
+  float * matrixf = data;
+  float *rgba_in = (void*)src_char;
+  float *rgba_out = (void*)dst_char;
+
+  babl_matrix_mul_vectorff_buf4 (matrixf, rgba_in, rgba_out, samples);
+
+  TRC_OUT(rgba_out, rgba_out);
+}
+
+static inline void
+universal_nonlinear_rgba_u8_converter (const Babl    *conversion,
+                                       unsigned char *__restrict__ src_char,
+                                       unsigned char *__restrict__ dst_char,
+                                       long           samples,
+                                       void          *data)
+{
+  const Babl *destination_space = conversion->conversion.destination->format.space;
+
+  float * matrixf = data;
+  float * in_trc_lut_red = matrixf + 9;
+  float * in_trc_lut_green  = in_trc_lut_red + 256;
+  float * in_trc_lut_blue  = in_trc_lut_green + 256;
+  unsigned int i;
+  uint8_t *rgba_in_u8 = (void*)src_char;
+  uint8_t *rgba_out_u8 = (void*)dst_char;
+
+  float *rgb = babl_malloc (sizeof(float) * 4 * samples);
+
+  for (i = 0; i < samples; i++)
+  {
+    rgb[i*4+0]=in_trc_lut_red[rgba_in_u8[i*4+0]];
+    rgb[i*4+1]=in_trc_lut_green[rgba_in_u8[i*4+1]];
+    rgb[i*4+2]=in_trc_lut_blue[rgba_in_u8[i*4+2]];
+    rgba_out_u8[i*4+3] = rgba_in_u8[i*4+3];
+  }
+
+  babl_matrix_mul_vectorff_buf4 (matrixf, rgb, rgb, samples);
+
+  {
+    const Babl *from_trc_red   = (void*)destination_space->space.trc[0];
+    const Babl *from_trc_green = (void*)destination_space->space.trc[1];
+    const Babl *from_trc_blue  = (void*)destination_space->space.trc[2];
+    for (i = 0; i < samples * 4; i+=4)
+    {
+      rgba_out_u8[i+0] = babl_trc_from_linear (from_trc_red,   rgb[i+0]) * 255.5f;
+      rgba_out_u8[i+1] = babl_trc_from_linear (from_trc_green, rgb[i+1]) * 255.5f;
+      rgba_out_u8[i+2] = babl_trc_from_linear (from_trc_blue,  rgb[i+2]) * 255.5f;
+    }
+  }
+  babl_free (rgb);
+}
+
+
+static inline void
+universal_rgba_converter (const Babl    *conversion,
+                          unsigned char *__restrict__ src_char,
+                          unsigned char *__restrict__ dst_char,
+                          long           samples,
+                          void          *data)
+{
+  float *matrixf = data;
+  float *rgba_in = (void*)src_char;
+  float *rgba_out = (void*)dst_char;
+
+  babl_matrix_mul_vectorff_buf4 (matrixf, rgba_in, rgba_out, samples);
+}
+
+static inline void
+universal_rgb_converter (const Babl    *conversion,
+                         unsigned char *__restrict__ src_char,
+                         unsigned char *__restrict__ dst_char,
+                         long           samples,
+                         void          *data)
+{
+  float *matrixf = data;
+  float *rgb_in = (void*)src_char;
+  float *rgb_out = (void*)dst_char;
+
+  babl_matrix_mul_vectorff_buf3 (matrixf, rgb_in, rgb_out, samples);
+}
+
+
+static inline void
+universal_ya_converter (const Babl    *conversion,
+                        unsigned char *__restrict__ src_char,
+                        unsigned char *__restrict__ dst_char,
+                        long           samples,
+                        void          *data)
+{
+  memcpy (dst_char, src_char, samples * 4 * 2);
+}
+
+static inline void
+universal_y_converter (const Babl    *conversion,
+                       unsigned char *__restrict__ src_char,
+                       unsigned char *__restrict__ dst_char,
+                       long           samples,
+                       void          *data)
+{
+  memcpy (dst_char, src_char, samples * 4);
+}
+
+
+static inline void
+universal_nonlinear_rgb_u8_converter (const Babl    *conversion,
+                                      unsigned char *__restrict__ src_char,
+                                      unsigned char *__restrict__ dst_char,
+                                      long           samples,
+                                      void          *data)
+{
+  const Babl *destination_space = conversion->conversion.destination->format.space;
+
+  float * matrixf = data;
+  float * in_trc_lut_red = matrixf + 9;
+  float * in_trc_lut_green = in_trc_lut_red + 256;
+  float * in_trc_lut_blue = in_trc_lut_green + 256;
+  unsigned int i;
+  uint8_t *rgb_in_u8 = (void*)src_char;
+  uint8_t *rgb_out_u8 = (void*)dst_char;
+
+  float *rgba_out = babl_malloc (sizeof(float) * 4 * samples);
+
+  for (i = 0; i < samples; i++)
+  {
+    rgba_out[i*4+0]=in_trc_lut_red[rgb_in_u8[i*3+0]];
+    rgba_out[i*4+1]=in_trc_lut_green[rgb_in_u8[i*3+1]];
+    rgba_out[i*4+2]=in_trc_lut_blue[rgb_in_u8[i*3+2]];
+    rgba_out[i*4+3]=rgb_in_u8[i*3+2] * 255.5f;
+  }
+
+  babl_matrix_mul_vectorff_buf4 (matrixf, rgba_out, rgba_out, samples);
+
+  {
+    TRC_OUT(rgba_out, rgba_out);
+
+    for (i = 0; i < samples; i++)
+      for (unsigned int c = 0; c < 3; c ++)
+        rgb_out_u8[i*3+c] = rgba_out[i*4+c] * 255.5f;
+  }
+
+  babl_free (rgba_out);
+}
+
+
+#if defined(USE_SSE2)
+
+#define m(matr, j, i)  matr[j*3+i]
+
+#include <emmintrin.h>
+
+static inline void babl_matrix_mul_vectorff_buf4_sse2 (const float *mat,
+                                                       const float *v_in,
+                                                       float       *v_out,
+                                                       unsigned int samples)
+{
+  const __v4sf m___0 = {m(mat, 0, 0), m(mat, 1, 0), m(mat, 2, 0), 0};
+  const __v4sf m___1 = {m(mat, 0, 1), m(mat, 1, 1), m(mat, 2, 1), 0};
+  const __v4sf m___2 = {m(mat, 0, 2), m(mat, 1, 2), m(mat, 2, 2), 1};
+  unsigned int i;
+  for (i = 0; i < samples; i ++)
+  {
+    __v4sf a, b, c = _mm_load_ps(&v_in[0]);
+    a = (__v4sf) _mm_shuffle_epi32((__m128i)c, _MM_SHUFFLE(0,0,0,0));
+    b = (__v4sf) _mm_shuffle_epi32((__m128i)c, _MM_SHUFFLE(1,1,1,1));
+    c = (__v4sf) _mm_shuffle_epi32((__m128i)c, _MM_SHUFFLE(3,2,2,2));
+    _mm_store_ps (v_out, m___0 * a + m___1 * b + m___2 * c);
+    v_out += 4;
+    v_in  += 4;
+  }
+  _mm_empty ();
+}
+
+#undef m
+
+
+static inline void
+universal_nonlinear_rgba_converter_sse2 (const Babl    *conversion,
+                                         unsigned char *__restrict__ src_char,
+                                         unsigned char *__restrict__ dst_char,
+                                         long           samples,
+                                         void          *data)
+{
+  const Babl *source_space = babl_conversion_get_source_space (conversion);
+  const Babl *destination_space = babl_conversion_get_destination_space (conversion);
+  float * matrixf = data;
+  float *rgba_in = (void*)src_char;
+  float *rgba_out = (void*)dst_char;
+
+  TRC_IN(rgba_in, rgba_out);
+
+  babl_matrix_mul_vectorff_buf4_sse2 (matrixf, rgba_out, rgba_out, samples);
+
+  TRC_OUT(rgba_out, rgba_out);
+}
+
+
+static inline void
+universal_rgba_converter_sse2 (const Babl *conversion,
+                               unsigned char *__restrict__ src_char,
+                               unsigned char *__restrict__ dst_char,
+                               long samples,
+                               void *data)
+{
+  float *matrixf = data;
+  float *rgba_in = (void*)src_char;
+  float *rgba_out = (void*)dst_char;
+
+  babl_matrix_mul_vectorff_buf4_sse2 (matrixf, rgba_in, rgba_out, samples);
+}
+
+static inline void
+universal_nonlinear_rgba_u8_converter_sse2 (const Babl    *conversion,
+                                            unsigned char *__restrict__ src_char,
+                                            unsigned char *__restrict__ dst_char,
+                                            long           samples,
+                                            void          *data)
+{
+  const Babl *destination_space = conversion->conversion.destination->format.space;
+
+  float * matrixf = data;
+  float * in_trc_lut_red = matrixf + 9;
+  float * in_trc_lut_green = in_trc_lut_red + 256;
+  float * in_trc_lut_blue = in_trc_lut_green + 256;
+  unsigned int i;
+  uint8_t *rgba_in_u8 = (void*)src_char;
+  uint8_t *rgba_out_u8 = (void*)dst_char;
+
+  float *rgba_out = babl_malloc (sizeof(float) * 4 * samples);
+
+  for (i = 0; i < samples * 4; i+= 4)
+  {
+    rgba_out[i+0]=in_trc_lut_red[rgba_in_u8[i+0]];
+    rgba_out[i+1]=in_trc_lut_green[rgba_in_u8[i+1]];
+    rgba_out[i+2]=in_trc_lut_blue[rgba_in_u8[i+2]];
+    rgba_out_u8[i+3] = rgba_in_u8[i+3];
+  }
+
+  babl_matrix_mul_vectorff_buf4_sse2 (matrixf, rgba_out, rgba_out, samples);
+
+  {
+    int c;
+    TRC_OUT(rgba_out, rgba_out);
+
+    for (i = 0; i < samples * 4; i+= 4)
+      for (c = 0; c < 3; c ++)
+        rgba_out_u8[i+c] = rgba_out[i+c] * 255.5f;
+  }
+
+  babl_free (rgba_out);
+}
+
+static inline void
+universal_nonlinear_rgb_u8_converter_sse2 (const Babl    *conversion,
+                                           unsigned char *__restrict__ src_char,
+                                           unsigned char *__restrict__ dst_char,
+                                           long           samples,
+                                           void          *data)
+{
+  const Babl *destination_space = conversion->conversion.destination->format.space;
+
+  float * matrixf = data;
+  float * in_trc_lut_red = matrixf + 9;
+  float * in_trc_lut_green = in_trc_lut_red + 256;
+  float * in_trc_lut_blue = in_trc_lut_green + 256;
+  unsigned int i;
+  uint8_t *rgb_in_u8 = (void*)src_char;
+  uint8_t *rgb_out_u8 = (void*)dst_char;
+
+  float *rgba_out = babl_malloc (sizeof(float) * 4 * samples);
+
+  for (i = 0; i < samples; i++)
+  {
+    rgba_out[i*4+0]=in_trc_lut_red[rgb_in_u8[i*3+0]];
+    rgba_out[i*4+1]=in_trc_lut_green[rgb_in_u8[i*3+1]];
+    rgba_out[i*4+2]=in_trc_lut_blue[rgb_in_u8[i*3+2]];
+  }
+
+  babl_matrix_mul_vectorff_buf4_sse2 (matrixf, rgba_out, rgba_out, samples);
+
+  {
+    TRC_OUT(rgba_out, rgba_out);
+
+    for (i = 0; i < samples; i++)
+      for (unsigned c = 0; c < 3; c ++)
+        rgb_out_u8[i*3+c] = rgba_out[i*4+c] * 255.5f;
+  }
+
+  babl_free (rgba_out);
+}
+
+
+static inline void
+universal_nonlinear_rgb_linear_converter_sse2 (const Babl    *conversion,
+                                               unsigned char *__restrict__ src_char,
+                                               unsigned char *__restrict__ dst_char,
+                                               long           samples,
+                                               void          *data)
+{
+  const Babl *source_space = babl_conversion_get_source_space (conversion);
+  float * matrixf = data;
+  float *rgba_in  = (void*)src_char;
+  float *rgba_out = (void*)dst_char;
+
+  TRC_IN(rgba_in, rgba_out);
+
+  babl_matrix_mul_vectorff_buf4_sse2 (matrixf, rgba_out, rgba_out, samples);
+}
+
+
+static inline void
+universal_linear_rgb_nonlinear_converter_sse2 (const Babl    *conversion,
+                                               unsigned char *__restrict__ src_char,
+                                               unsigned char *__restrict__ dst_char,
+                                               long           samples,
+                                               void          *data)
+{
+  const Babl *destination_space = conversion->conversion.destination->format.space;
+  float * matrixf = data;
+  float *rgba_in = (void*)src_char;
+  float *rgba_out = (void*)dst_char;
+
+  babl_matrix_mul_vectorff_buf4_sse2 (matrixf, rgba_in, rgba_out, samples);
+
+  TRC_OUT(rgba_out, rgba_out);
+}
+#endif
+
+
+static int
+add_rgb_adapter (Babl *babl,
+                 void *space)
+{
+  if (babl != space)
+  {
+
+#if defined(USE_SSE2)
+    if ((babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE) &&
+        (babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE2))
+    {
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("RGBA float", space),
+                       babl_format_with_space("RGBA float", babl),
+                       "linear", universal_rgba_converter_sse2,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("RGBA float", babl),
+                       babl_format_with_space("RGBA float", space),
+                       "linear", universal_rgba_converter_sse2,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A float", space),
+                       babl_format_with_space("R'G'B'A float", babl),
+                       "linear", universal_nonlinear_rgba_converter_sse2,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A float", babl),
+                       babl_format_with_space("R'G'B'A float", space),
+                       "linear", universal_nonlinear_rgba_converter_sse2,
+                       NULL));
+
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A float", space),
+                       babl_format_with_space("RGBA float", babl),
+                       "linear", universal_nonlinear_rgb_linear_converter_sse2,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A float", babl),
+                       babl_format_with_space("RGBA float", space),
+                       "linear", universal_nonlinear_rgb_linear_converter_sse2,
+                       NULL));
+
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("RGBA float", babl),
+                       babl_format_with_space("R'G'B'A float", space),
+                       "linear", universal_linear_rgb_nonlinear_converter_sse2,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("RGBA float", space),
+                       babl_format_with_space("R'G'B'A float", babl),
+                       "linear", universal_linear_rgb_nonlinear_converter_sse2,
+                       NULL));
+
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A u8", space),
+                       babl_format_with_space("R'G'B'A u8", babl),
+                       "linear", universal_nonlinear_rgba_u8_converter_sse2,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A u8", babl),
+                       babl_format_with_space("R'G'B'A u8", space),
+                       "linear", universal_nonlinear_rgba_u8_converter_sse2,
+                       NULL));
+
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B' u8", space),
+                       babl_format_with_space("R'G'B' u8", babl),
+                       "linear", universal_nonlinear_rgb_u8_converter_sse2,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B' u8", babl),
+                       babl_format_with_space("R'G'B' u8", space),
+                       "linear", universal_nonlinear_rgb_u8_converter_sse2,
+                       NULL));
+    }
+    else
+#endif
+    {
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("RGBA float", space),
+                       babl_format_with_space("RGBA float", babl),
+                       "linear", universal_rgba_converter,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("RGBA float", babl),
+                       babl_format_with_space("RGBA float", space),
+                       "linear", universal_rgba_converter,
+                       NULL));
+
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A float", space),
+                       babl_format_with_space("R'G'B'A float", babl),
+                       "linear", universal_nonlinear_rgba_converter,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A float", babl),
+                       babl_format_with_space("R'G'B'A float", space),
+                       "linear", universal_nonlinear_rgba_converter,
+                       NULL));
+
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A float", space),
+                       babl_format_with_space("RGBA float", babl),
+                       "linear", universal_nonlinear_rgb_linear_converter,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A float", babl),
+                       babl_format_with_space("RGBA float", space),
+                       "linear", universal_nonlinear_rgb_linear_converter,
+                       NULL));
+
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A u8", space),
+                       babl_format_with_space("R'G'B'A u8", babl),
+                       "linear", universal_nonlinear_rgba_u8_converter,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B'A u8", babl),
+                       babl_format_with_space("R'G'B'A u8", space),
+                       "linear", universal_nonlinear_rgba_u8_converter,
+                       NULL));
+
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B' u8", space),
+                       babl_format_with_space("R'G'B' u8", babl),
+                       "linear", universal_nonlinear_rgb_u8_converter,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("R'G'B' u8", babl),
+                       babl_format_with_space("R'G'B' u8", space),
+                       "linear", universal_nonlinear_rgb_u8_converter,
+                       NULL));
+
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("RGBA float", babl),
+                       babl_format_with_space("R'G'B'A float", space),
+                       "linear", universal_linear_rgb_nonlinear_converter,
+                       NULL));
+       prep_conversion(babl_conversion_new(
+                       babl_format_with_space("RGBA float", space),
+                       babl_format_with_space("R'G'B'A float", babl),
+                       "linear", universal_linear_rgb_nonlinear_converter,
+                       NULL));
+    }
+#if 0
+    prep_conversion(babl_conversion_new(
+                    babl_format_with_space("RGB float", space),
+                    babl_format_with_space("RGB float", babl),
+                    "linear", universal_rgb_converter,
+                    NULL));
+    prep_conversion(babl_conversion_new(
+                    babl_format_with_space("RGB float", babl),
+                    babl_format_with_space("RGB float", space),
+                    "linear", universal_rgb_converter,
+                    NULL));
+#endif
+    prep_conversion(babl_conversion_new(
+                    babl_format_with_space("Y float", space),
+                    babl_format_with_space("Y float", babl),
+                    "linear", universal_y_converter,
+                    NULL));
+    prep_conversion(babl_conversion_new(
+                    babl_format_with_space("YaA float", babl),
+                    babl_format_with_space("YaA float", space),
+                    "linear", universal_ya_converter,
+                    NULL));
+    prep_conversion(babl_conversion_new(
+                    babl_format_with_space("YA float", babl),
+                    babl_format_with_space("YA float", space),
+                    "linear", universal_ya_converter,
+                    NULL));
+  }
+  return 0;
+}
+
+/* The first time a new Babl space is used - for creation of a fish, is when
+ * this function is called, it adds conversions hooks that provides its formats
+ * with conversions internally as well as for conversions to and from other RGB
+ * spaces.
+ */
+void
+BABL_SIMD_SUFFIX(_babl_space_add_universal_rgb) (const Babl *space);
+void
+BABL_SIMD_SUFFIX(_babl_space_add_universal_rgb) (const Babl *space)
+{
+  babl_space_class_for_each (add_rgb_adapter, (void*)space);
+}
diff --git a/extensions/babl-verify-cpu.inc b/extensions/babl-verify-cpu.inc
new file mode 100644
index 000000000..d65644598
--- /dev/null
+++ b/extensions/babl-verify-cpu.inc
@@ -0,0 +1,63 @@
+#include "babl-cpuaccel.h"
+
+#ifdef X86_64_V2
+#define BABL_SIMD_x86_64_v2
+#define BABL_SIMD_SUFFIX(symbol) symbol##_x86_64_v2
+#else
+#ifdef X86_64_V3
+#define BABL_SIMD_x86_64_v3
+#define BABL_SIMD_SUFFIX(symbol) symbol##_x86_64_v3
+#else
+#define BABL_SIMD_generic
+#define BABL_SIMD_SUFFIX(symbol) symbol##_generic
+#endif
+#endif
+
+#define BABL_VERIFY_CPU()  do{}while(0)
+
+
+#ifdef BABL_SIMDFREE
+
+#ifdef ARCH_X86_64
+  
+#undef BABL_VERIFY_CPU
+#define BABL_VERIFY_CPU()\
+  if ((babl_cpu_accel_get_support() & BABL_CPU_ACCEL_X86_64_V2)\
+                                       == BABL_CPU_ACCEL_X86_64_V2) return 0;\
+  if ((babl_cpu_accel_get_support() & BABL_CPU_ACCEL_X86_64_V3)\
+                                       == BABL_CPU_ACCEL_X86_64_V3) return 0;
+
+#endif
+
+#ifdef ARCH_ARM
+#undef BABL_VERIFY_CPU
+#define BABL_VERIFY_CPU()\
+  if ((babl_cpu_accel_get_support() & BABL_CPU_ACCEL_ARM_NEON)\
+                                       == BABL_CPU_ACCEL_ARM_NEON) return 0;
+
+#endif
+#endif
+
+#ifdef X86_64_V2
+#undef BABL_VERIFY_CPU
+#define BABL_VERIFY_CPU()\
+  if ((babl_cpu_accel_get_support() & BABL_CPU_ACCEL_X86_64_V2)\
+                                       != BABL_CPU_ACCEL_X86_64_V2) return 0;\
+  if ((babl_cpu_accel_get_support() & BABL_CPU_ACCEL_X86_64_V3)\
+                                       == BABL_CPU_ACCEL_X86_64_V3) return 0;
+#endif
+
+#ifdef X86_64_V3
+#undef BABL_VERIFY_CPU
+#define BABL_VERIFY_CPU()\
+  if ((babl_cpu_accel_get_support() & BABL_CPU_ACCEL_X86_64_V3)\
+                                       != BABL_CPU_ACCEL_X86_64_V3) return 0;
+#endif
+
+
+#ifdef ARM_NEON
+#undef BABL_VERIFY_CPU
+#define BABL_VERIFY_CPU()\
+  if ((babl_cpu_accel_get_support() & BABL_CPU_ACCEL_ARM_NEON)\
+                                       != BABL_CPU_ACCEL_ARM_NEON) return 0;
+#endif