misc

Signed-off-by: Mattias Andrée <maandree@kth.se>

1 files changed, 605 insertions, 203 deletions

diff --git a/src/libcolour.c b/src/libcolour.c
index e613280..32ef6c8 100644
--- a/src/libcolour.c
+++ b/src/libcolour.c
@@ -18,6 +18,8 @@
 
 #include <errno.h>
 #include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
 #include <string.h>
 
 
@@ -52,33 +54,72 @@ static void ciexyz_to_rgb(const libcolour_ciexyz_t* restrict from, libcolour_rgb
 static void to_rgb(const libcolour_colour_t* restrict from, libcolour_rgb_t* restrict to)
 {
   int have_gamma = 0, with_gamma = to->with_gamma;
-  libcolour_colour_t tmp;
+  libcolour_ciexyz_t tmp;
   switch (from->model) {
   case LIBCOLOUR_CIEXYZ:
     ciexyz_to_rgb(&from->ciexyz, to);
     break;
   case LIBCOLOUR_RGB:
-    if (!memcmp(from->M, to->M, sizeof(double[3][3]))) {
-      have_gamma = from->with_gamma;
-      *to = *from;
+    if (!memcmp(from->rgb.M, to->M, sizeof(double[3][3]))) {
+      have_gamma = from->rgb.with_gamma;
+      *to = from->rgb;
       break;
     }
     /* fall through */
   default:
     tmp.model = LIBCOLOUR_CIEXYZ;
-    to_ciexyz(from, &tmp.ciexyz);
-    ciexyz_to_rgb(&tmp.ciexyz, to);
+    to_ciexyz(from, &tmp);
+    ciexyz_to_rgb(&tmp, to);
     break;
   }
+
   if (have_gamma != with_gamma) {
     if (with_gamma) {
-      to->R = to->regular_gamma ? pow(to->R, 1 / to->gamma) : (to->to_encoded_red)(to->R);
-      to->G = to->regular_gamma ? pow(to->G, 1 / to->gamma) : (to->to_encoded_green)(to->G);
-      to->B = to->regular_gamma ? pow(to->B, 1 / to->gamma) : (to->to_encoded_blue)(to->B);
+      switch (to->encoding_type) {
+      case LIBCOLOUR_ENCODING_TYPE_LINEAR:
+	break;
+      case LIBCOLOUR_ENCODING_TYPE_SIMPLE:
+	to->R = pow(to->R, 1 / to->gamma);
+	to->G = pow(to->G, 1 / to->gamma);
+	to->B = pow(to->B, 1 / to->gamma);
+	break;
+      case LIBCOLOUR_ENCODING_TYPE_REGULAR:
+	to->R <= to->transition ? to->slope * to->R : (1 + to->offset) * pow(to->R, 1 / to->gamma) - to->offset;
+	to->G <= to->transition ? to->slope * to->G : (1 + to->offset) * pow(to->G, 1 / to->gamma) - to->offset;
+	to->B <= to->transition ? to->slope * to->B : (1 + to->offset) * pow(to->B, 1 / to->gamma) - to->offset;
+	break;
+      case LIBCOLOUR_ENCODING_TYPE_CUSTOM:
+	to->R = (to->to_encoded_red)(to->R);
+	to->G = (to->to_encoded_green)(to->G);
+	to->B = (to->to_encoded_blue)(to->B);
+	break;
+      default:
+	fprintf(stderr, "libcolour: invalid encoding type\n");
+	abort();
+      }
     } else {
-      to->R = to->regular_gamma ? pow(to->R, to->gamma) : (to->to_decoded_red)(to->R);
-      to->G = to->regular_gamma ? pow(to->G, to->gamma) : (to->to_decoded_green)(to->G);
-      to->B = to->regular_gamma ? pow(to->B, to->gamma) : (to->to_decoded_blue)(to->B);
+      switch (to->encoding_type) {
+      case LIBCOLOUR_ENCODING_TYPE_LINEAR:
+	break;
+      case LIBCOLOUR_ENCODING_TYPE_SIMPLE:
+	to->R = pow(to->R, to->gamma);
+	to->G = pow(to->G, to->gamma);
+	to->B = pow(to->B, to->gamma);
+	break;
+      case LIBCOLOUR_ENCODING_TYPE_REGULAR:
+	to->R <= to->transitioninv ? to->R * to->slope : pow((to->R + to->offset) / (1 + to->offset), to->gamma);
+	to->G <= to->transitioninv ? to->G * to->slope : pow((to->G + to->offset) / (1 + to->offset), to->gamma);
+	to->B <= to->transitioninv ? to->B * to->slope : pow((to->B + to->offset) / (1 + to->offset), to->gamma);
+	break;
+      case LIBCOLOUR_ENCODING_TYPE_CUSTOM:
+	to->R = (to->to_decoded_red)(to->R);
+	to->G = (to->to_decoded_green)(to->G);
+	to->B = (to->to_decoded_blue)(to->B);
+	break;
+      default:
+	fprintf(stderr, "libcolour: invalid encoding type\n");
+	abort();
+      }
     }
   }
 }
@@ -97,13 +138,13 @@ static void srgb_to_srgb(const libcolour_srgb_t* restrict from, libcolour_srgb_t
   if (from->with_gamma == to->with_gamma) {
     *to = *from;
   } else if (to->with_gamma) {
-    from->R = libcolour_srgb_encode(to->R);
-    from->G = libcolour_srgb_encode(to->G);
-    from->B = libcolour_srgb_encode(to->B);
+    to->R = libcolour_srgb_encode(from->R);
+    to->G = libcolour_srgb_encode(from->G);
+    to->B = libcolour_srgb_encode(from->B);
   } else {
-    from->R = libcolour_srgb_decode(to->R);
-    from->G = libcolour_srgb_decode(to->G);
-    from->B = libcolour_srgb_decode(to->B);
+    to->R = libcolour_srgb_decode(from->R);
+    to->G = libcolour_srgb_decode(from->G);
+    to->B = libcolour_srgb_decode(from->B);
   }
 }
 
@@ -141,10 +182,10 @@ static void ycgco_to_srgb(const libcolour_ycgco_t* restrict from, libcolour_srgb
 
 static void other_to_srgb(const libcolour_colour_t* restrict from, libcolour_srgb_t* restrict to)
 {
-  libcolour_colour_t tmp;
+  libcolour_ciexyz_t tmp;
   tmp.model = LIBCOLOUR_CIEXYZ;
-  to_ciexyz(from, &tmp.ciexyz);
-  ciexyz_to_srgb(&tmp.ciexyz, to);
+  to_ciexyz(from, &tmp);
+  ciexyz_to_srgb(&tmp, to);
 }
 
 static void to_srgb(const libcolour_colour_t* restrict from, libcolour_srgb_t* restrict to)
@@ -175,7 +216,7 @@ static void to_srgb(const libcolour_colour_t* restrict from, libcolour_srgb_t* r
   }
   if (to->with_gamma) {
     tmp = *to;
-    tmp->with_gamma = 0;
+    tmp.with_gamma = 0;
     srgb_to_srgb(&tmp, to);
   }
 }
@@ -192,39 +233,39 @@ static void ciexyz_to_ciexyy(const libcolour_ciexyz_t* restrict from, libcolour_
     to->x = to->y = 0;
 }
 
+static void other_to_ciexyy(const libcolour_colour_t* restrict from, libcolour_ciexyy_t* restrict to)
+{
+  libcolour_ciexyz_t tmp;
+  tmp.model = LIBCOLOUR_CIEXYZ;
+  to_ciexyz(from, &tmp);
+  ciexyz_to_ciexyy(&tmp, to);
+}
+
 static void srgb_to_ciexyy(const libcolour_srgb_t* restrict from, libcolour_ciexyy_t* restrict to)
 {
-  libcolour_colour_t tmp;
+  libcolour_srgb_t tmp;
   tmp.model = LIBCOLOUR_SRGB;
   if (from->with_gamma) {
-    tmp.srgb.with_gamma = 0;
-    to_srgb((const libcolour_colour_t *)from, &tmp.srgb);
+    tmp.with_gamma = 0;
+    to_srgb((const libcolour_colour_t*)from, &tmp);
   } else {
-    tmp.srgb = *from;
+    tmp = *from;
   }
   if (tmp.R == 0 && tmp.G == 0 && tmp.B == 0) {
     to->x = 0.31272660439158;
     to->y = 0.32902315240275;
     to->Y = 0;
   } else {
-    other_to_ciexyy(&tmp, to);
+    other_to_ciexyy((const libcolour_colour_t*)&tmp, to);
   }
 }
 
-static void other_to_ciexyy(const libcolour_colour_t* restrict from, libcolour_ciexyy_t* restrict to)
-{
-  libcolour_colour_t tmp;
-  tmp.model = LIBCOLOUR_CIEXYZ;
-  to_ciexyz(from, &tmp.ciexyz);
-  ciexyz_to_ciexyy(&tmp.ciexyz, to);
-}
-
 static void to_ciexyy(const libcolour_colour_t* restrict from, libcolour_ciexyy_t* restrict to)
 {
   switch (from->model) {
   case LIBCOLOUR_CIEXYY:
-    *to = *from;
-    return
+    *to = from->ciexyy;
+    return;
   case LIBCOLOUR_CIEXYZ:
     ciexyz_to_ciexyy(&from->ciexyz, to);
     return;
@@ -240,29 +281,29 @@ static void to_ciexyy(const libcolour_colour_t* restrict from, libcolour_ciexyy_
 
 static void rgb_to_ciexyz(const libcolour_rgb_t* restrict from, libcolour_ciexyz_t* restrict to)
 {
-  libcolour_colour_t tmp;
+  libcolour_rgb_t tmp;
   double R, G, B;
   if (from->with_gamma) {
     tmp = *from;
-    tmp.rgb.with_gamma = 0;
-    to_rgb(from, &tmp);
+    tmp.with_gamma = 0;
+    to_rgb((const libcolour_colour_t*)from, &tmp);
     R = tmp.R, G = tmp.G, B = tmp.B;
   } else {
     R = from->R, G = from->G, B = from->B;
   }
-  to->X = to->M[0][0] * R + to->M[0][1] * G + to->M[0][2] * B;
-  to->Y = to->M[1][0] * R + to->M[1][1] * G + to->M[1][2] * B;
-  to->Z = to->M[2][0] * R + to->M[2][1] * G + to->M[2][2] * B;
+  to->X = from->M[0][0] * R + from->M[0][1] * G + from->M[0][2] * B;
+  to->Y = from->M[1][0] * R + from->M[1][1] * G + from->M[1][2] * B;
+  to->Z = from->M[2][0] * R + from->M[2][1] * G + from->M[2][2] * B;
 }
 
 static void srgb_to_ciexyz(const libcolour_srgb_t* restrict from, libcolour_ciexyz_t* restrict to)
 {
-  libcolour_colour_t tmp;
+  libcolour_srgb_t tmp;
   double R, G, B;
   if (from->with_gamma) {
     tmp.model = LIBCOLOUR_SRGB;
-    tmp.srgb.with_gamma = 0;
-    to_srgb(from, &tmp);
+    tmp.with_gamma = 0;
+    to_srgb((const libcolour_colour_t*)from, &tmp);
     R = tmp.R, G = tmp.G, B = tmp.B;
   } else {
     R = from->R, G = from->G, B = from->B;
@@ -281,7 +322,7 @@ static void ciexyy_to_ciexyz(const libcolour_ciexyy_t* restrict from, libcolour_
   } else {
     to->X = x * Yy;
     to->Y = Y;
-    to->Z = (1 - x - y) * Yy
+    to->Z = (1 - x - y) * Yy;
   }
 }
 
@@ -321,19 +362,19 @@ static void cieluv_to_ciexyz(const libcolour_cieluv_t* restrict from, libcolour_
 
 static void cielch_to_ciexyz(const libcolour_cielch_t* restrict from, libcolour_ciexyz_t* restrict to)
 {
-  libcolour_colour_t tmp;
-  tmp.model = LIBCOLOUR_YUV;
-  tmp.yuv.white = from.white;
-  to_yuv((const libcolour_colour_t*)from, &tmp.yuv);
-  yuv_to_ciexyz(&tmp.yuv, to);
+  libcolour_cieluv_t tmp;
+  tmp.model = LIBCOLOUR_CIELUV;
+  tmp.white = from->white;
+  to_cieluv((const libcolour_colour_t*)from, &tmp);
+  cieluv_to_ciexyz(&tmp, to);
 }
 
 static void yuv_to_ciexyz(const libcolour_yuv_t* restrict from, libcolour_ciexyz_t* restrict to)
 {
-  libcolour_colour_t tmp;
+  libcolour_ydbdr_t tmp;
   tmp.model = LIBCOLOUR_YDBDR;
-  to_ydbdr((const libcolour_colour_t*)from, &tmp.ydbdr);
-  ydbdr_to_ciexyz(&tmp.ydbdr, to);
+  to_ydbdr((const libcolour_colour_t*)from, &tmp);
+  to_ciexyz((const libcolour_colour_t*)&tmp, to);
 }
 
 static void cie1960ucs_to_ciexyz(const libcolour_cie1960ucs_t* restrict from, libcolour_ciexyz_t* restrict to)
@@ -346,19 +387,19 @@ static void cie1960ucs_to_ciexyz(const libcolour_cie1960ucs_t* restrict from, li
 
 static void cieuvw_to_ciexyz(const libcolour_cieuvw_t* restrict from, libcolour_ciexyz_t* restrict to)
 {
-  libcolour_colour_t tmp;
-  tmp.model = LIBCOLOUR_CIE1969UCS;
-  to_cie1960ucs((const libcolour_cieuvw_t*)from, &tmp.cie1960ucs);
-  cie1960ucs_to_ciexyz(&tmp.cie1960ucs, to);
+  libcolour_cie1960ucs_t tmp;
+  tmp.model = LIBCOLOUR_CIE1960UCS;
+  to_cie1960ucs((const libcolour_colour_t*)from, &tmp);
+  cie1960ucs_to_ciexyz(&tmp, to);
 }
 
 static void other_to_ciexyz(const libcolour_colour_t* restrict from, libcolour_ciexyz_t* restrict to)
 {
-  libcolour_colour_t tmp;
+  libcolour_srgb_t tmp;
   tmp.model = LIBCOLOUR_SRGB;
-  tmp.srgb.with_gamma = 0;
-  to_srgb(from, &tmp.srgb);
-  srgb_to_ciexyz(&tmp.srgb, to);
+  tmp.with_gamma = 0;
+  to_srgb(from, &tmp);
+  srgb_to_ciexyz(&tmp, to);
 }
 
 static void to_ciexyz(const libcolour_colour_t* restrict from, libcolour_ciexyz_t* restrict to)
@@ -366,7 +407,7 @@ static void to_ciexyz(const libcolour_colour_t* restrict from, libcolour_ciexyz_
   switch (from->model) {
   case LIBCOLOUR_RGB:
     rgb_to_ciexyz(&from->rgb, to);
-    return
+    return;
   case LIBCOLOUR_SRGB:
     srgb_to_ciexyz(&from->srgb, to);
     return;
@@ -374,7 +415,7 @@ static void to_ciexyz(const libcolour_colour_t* restrict from, libcolour_ciexyz_
     ciexyy_to_ciexyz(&from->ciexyy, to);
     return;
   case LIBCOLOUR_CIEXYZ:
-    *to = *from
+    *to = from->ciexyz;
     return;
   case LIBCOLOUR_CIELAB:
     cielab_to_ciexyz(&from->cielab, to);
@@ -419,10 +460,10 @@ static void ciexyz_to_cielab(const libcolour_ciexyz_t* restrict from, libcolour_
 
 static void other_to_cielab(const libcolour_colour_t* restrict from, libcolour_cielab_t* restrict to)
 {
-  libcolour_colour_t tmp;
+  libcolour_ciexyz_t tmp;
   tmp.model = LIBCOLOUR_CIEXYZ;
-  to_ciexyz(from, &tmp.ciexyz);
-  ciexyz_to_cielab(&tmp.ciexyz, to);
+  to_ciexyz(from, &tmp);
+  ciexyz_to_cielab(&tmp, to);
 }
 
 static void to_cielab(const libcolour_colour_t* restrict from, libcolour_cielab_t* restrict to)
@@ -432,7 +473,7 @@ static void to_cielab(const libcolour_colour_t* restrict from, libcolour_cielab_
     ciexyz_to_cielab(&from->ciexyz, to);
     return;
   case LIBCOLOUR_CIELAB:
-    *to = *from;
+    *to = from->cielab;
     return;
   default:
     other_to_cielab(from, to);
@@ -443,21 +484,14 @@ static void to_cielab(const libcolour_colour_t* restrict from, libcolour_cielab_
 
 static void ciexyz_to_cieluv(const libcolour_ciexyz_t* restrict from, libcolour_cieluv_t* restrict to)
 {
-  libcolour_ciexyz_t white;
   double t, u, v, y, y2;
-  if (to->white.model == LIBCOLOUR_CIEXYZ) {
-    white = to->white.ciexyz;
-  } else {
-    white.model = LIBCOLOUR_CIEXYZ;
-    to_ciexyz(&to->white, &white);
-  }
-  t = white.X + 15 * white.Y + 3 * white.Z;
-  u = 4 * white.x / t;
-  v = 9 * white.y / t;
+  t = to->white.X + 15 * to->white.Y + 3 * to->white.Z;
+  u = 4 * to->white.X / t;
+  v = 9 * to->white.Y / t;
   t = from->X + 15 * from->Y + 4 * from->Z;
-  u = 4 * from->x / t - u;
-  v = 9 * from->y / t - v;
-  y = from->Y = white.Y;
+  u = 4 * from->X / t - u;
+  v = 9 * from->Y / t - v;
+  y = from->Y / to->white.Y;
   y2 = y * 24389;
   y = y2 <= 216 ? y2 / 27 : cbrt(y) * 116 - 16;
   to->L = y;
@@ -468,28 +502,16 @@ static void ciexyz_to_cieluv(const libcolour_ciexyz_t* restrict from, libcolour_
 
 static void cielch_to_cieluv(const libcolour_cielch_t* restrict from, libcolour_cieluv_t* restrict to)
 {
-  libcolour_ciexyz_t from_white, to_white;
-  libcolour_colour_t tmp, tmp2;
+  libcolour_ciexyz_t tmp;
+  libcolour_cielch_t tmp2;
   double L, C, h;
-  if (from->white.model == LIBCOLOUR_CIEXYZ) {
-    from_white = from->white.ciexyz;
-  } else {
-    from_white.model = LIBCOLOUR_CIEXYZ;
-    to_ciexyz(&from->white, &from_white);
-  }
-  if (to->white.model == LIBCOLOUR_CIEXYZ) {
-    to_white = to->white.ciexyz;
-  } else {
-    to_white.model = LIBCOLOUR_CIEXYZ;
-    to_ciexyz(&to->white, &to_white);
-  }
-  if (to_white.X != from_white.X || to_white.Y != from_white.Y || to_white.Z != from_white.Z) {
+  if (to->white.X != from->white.X || to->white.Y != from->white.Y || to->white.Z != from->white.Z) {
     tmp.model = LIBCOLOUR_CIEXYZ;
     tmp2.model = LIBCOLOUR_CIELCH;
-    tmp2.cielch.white.ciexyz = to_white;
-    to_ciexyz(from, &tmp.ciexyz);
-    to_cielch(&tmp, &tmp2.cielch);
-    L = tmp2.cielch.L, C = tmp2.cielch.C, h = tmp2.cielch.h;
+    tmp2.white = to->white;
+    to_ciexyz((const libcolour_colour_t*)from, &tmp);
+    to_cielch((const libcolour_colour_t*)&tmp, &tmp2);
+    L = tmp2.L, C = tmp2.C, h = tmp2.h;
   } else {
     L = from->L, C = from->C, h = from->h;
   }
@@ -500,25 +522,23 @@ static void cielch_to_cieluv(const libcolour_cielch_t* restrict from, libcolour_
 
 static void other_to_cieluv(const libcolour_colour_t* restrict from, libcolour_cieluv_t* restrict to)
 {
-  libcolour_colour_t tmp;
+  libcolour_ciexyz_t tmp;
   tmp.model = LIBCOLOUR_CIEXYZ;
-  to_ciexyz(from, &tmp.ciexyz);
-  ciexyz_to_cieluv(&tmp.ciexyz, to);
+  to_ciexyz(from, &tmp);
+  ciexyz_to_cieluv(&tmp, to);
 }
 
 static void to_cieluv(const libcolour_colour_t* restrict from, libcolour_cieluv_t* restrict to)
 {
   switch (from->model) {
   case LIBCOLOUR_CIELCH:
-    cielch_to_cielab(&from->cielch, to);
+    cielch_to_cieluv(&from->cielch, to);
     return;
   case LIBCOLOUR_CIELUV:
-    if (to->cieluv.model == LIBCOLOUR_CIEXYZ &&
-	from->cieluv.model == LIBCOLOUR_CIEXYZ &&
-	to->cieluv.white.X == from->cieluv.white.X &&
-	to->cieluv.white.Y == from->cieluv.white.Y &&
-	to->cieluv.white.Z == from->cieluv.white.Z) {
-      *to = *from;
+    if (to->white.X == from->cieluv.white.X &&
+	to->white.Y == from->cieluv.white.Y &&
+	to->white.Z == from->cieluv.white.Z) {
+      *to = from->cieluv;
       return;
     }
     /* fall through */
@@ -531,25 +551,12 @@ static void to_cieluv(const libcolour_colour_t* restrict from, libcolour_cieluv_
 
 static void cieluv_to_cielch(const libcolour_cieluv_t* restrict from, libcolour_cielch_t* restrict to)
 {
-  libcolour_ciexyz_t from_white, to_white;
   libcolour_cieluv_t tmp;
   double L, u, v;
-  if (from->white.model == LIBCOLOUR_CIEXYZ) {
-    from_white = from->white.ciexyz;
-  } else {
-    from_white.model = LIBCOLOUR_CIEXYZ;
-    to_ciexyz(&from->white, &from_white);
-  }
-  if (to->white.model == LIBCOLOUR_CIEXYZ) {
-    to_white = to->white.ciexyz;
-  } else {
-    to_white.model = LIBCOLOUR_CIEXYZ;
-    to_ciexyz(&to->white, &to_white);
-  }
-  if (to_white.X != from_white.X || to_white.Y != from_white.Y || to_white.Z != from_white.Z) {
+  if (to->white.X != from->white.X || to->white.Y != from->white.Y || to->white.Z != from->white.Z) {
     tmp.model = LIBCOLOUR_CIELUV;
-    tmp.white.ciexyz = to_white;
-    to_cieluv(from, &tmp);
+    tmp.white = to->white;
+    to_cieluv((const libcolour_colour_t*)from, &tmp);
     L = tmp.L, u = tmp.u, v = tmp.v;
   } else {
     L = from->L, u = from->u, v = from->u;
@@ -561,11 +568,11 @@ static void cieluv_to_cielch(const libcolour_cieluv_t* restrict from, libcolour_
 
 static void other_to_cielch(const libcolour_colour_t* restrict from, libcolour_cielch_t* restrict to)
 {
-  libcolour_colour_t tmp;
+  libcolour_cieluv_t tmp;
   tmp.model = LIBCOLOUR_CIELUV;
-  tmp.white = to.white;
-  to_cieluv(from, &tmp.cieluv);
-  cieluv_to_cielch(&tmp.cieluv, to);
+  tmp.white = to->white;
+  to_cieluv(from, &tmp);
+  cieluv_to_cielch(&tmp, to);
 }
 
 static void to_cielch(const libcolour_colour_t* restrict from, libcolour_cielch_t* restrict to)
@@ -575,12 +582,10 @@ static void to_cielch(const libcolour_colour_t* restrict from, libcolour_cielch_
     cieluv_to_cielch(&from->cieluv, to);
     return;
   case LIBCOLOUR_CIELCH:
-    if (to->cielch.model == LIBCOLOUR_CIEXYZ &&
-	from->cielch.model == LIBCOLOUR_CIEXYZ &&
-	to->cielch.white.X == from->cielcg.white.X &&
-	to->cielch.white.Y == from->cielch.white.Y &&
-	to->cielch.white.Z == from->cielch.white.Z) {
-      *to = *from;
+    if (to->white.X == from->cielch.white.X &&
+	to->white.Y == from->cielch.white.Y &&
+	to->white.Z == from->cielch.white.Z) {
+      *to = from->cielch;
       return;
     }
     /* fall through */
@@ -597,16 +602,16 @@ static void to_yiq(const libcolour_colour_t* restrict from, libcolour_yiq_t* res
   libcolour_colour_t tmp = *from;
   switch (from->model) {
   case LIBCOLOUR_YIQ:
-    *to = *from;
+    *to = from->yiq;
     return;
   default:
     tmp.model = LIBCOLOUR_SRGB;
     to_srgb(from, &tmp.srgb);
     /* fall through */
   case LIBCOLOUR_SRGB:
-    r = tmp->srgb.R;
-    g = tmp->srgb.G;
-    b = tmp->srgb.B;
+    r = tmp.srgb.R;
+    g = tmp.srgb.G;
+    b = tmp.srgb.B;
     to->Y = r * 0.29893602129377540 + g * 0.5870430744511212 + b * 0.11402090425510336;
     to->I = r * 0.59594574307079930 - g * 0.2743886357457892 - b * 0.32155710732501010;
     to->Q = r * 0.21149734030682846 - g * 0.5229106903029739 + b * 0.31141334999614540;
@@ -621,25 +626,26 @@ static void to_ydbdr(const libcolour_colour_t* restrict from, libcolour_ydbdr_t*
   libcolour_colour_t tmp = *from;
   switch (from->model) {
   case LIBCOLOUR_YDBDR:
-    *to = *from;
+    *to = from->ydbdr;
     return;
   case LIBCOLOUR_YUV:
-    to->Y  =  tmp->yuv.Y;
-    to->Db =  tmp->yuv.U * 3.069;
-    to->Dr = -tmp->yuv.V * 2.169;
+    to->Y  =  tmp.yuv.Y;
+    to->Db =  tmp.yuv.U * 3.069;
+    to->Dr = -tmp.yuv.V * 2.169;
     return;
   default:
     tmp.model = LIBCOLOUR_SRGB;
     to_srgb(from, &tmp.srgb);
     /* fall through */
   case LIBCOLOUR_SRGB:
-    r = tmp->srgb.R;
-    g = tmp->srgb.G;
-    b = tmp->srgb.B;
+    r = tmp.srgb.R;
+    g = tmp.srgb.G;
+    b = tmp.srgb.B;
     to->Y  =  r * 0.299 + g * 0.587 + b * 0.114;
     to->Db = -r * 0.450 - g * 0.883 + b * 1.333;
     to->Dr = -r * 1.333 + g * 1.116 + b * 0.217;
     return;
+  }
 }
 
 
@@ -648,7 +654,7 @@ static void to_yuv(const libcolour_colour_t* restrict from, libcolour_yuv_t* res
   libcolour_colour_t tmp = *from;
   switch (from->model) {
   case LIBCOLOUR_YUV:
-    *to = *from;
+    *to = from->yuv;
     return;
   default:
     tmp.model = LIBCOLOUR_YDBDR;
@@ -659,6 +665,7 @@ static void to_yuv(const libcolour_colour_t* restrict from, libcolour_yuv_t* res
     to->U =  tmp.ydbdr.Db / 3.069;
     to->V = -tmp.ydbdr.Dr / 2.169;
     return;
+  }
 }
 
 
@@ -667,7 +674,7 @@ static void to_ypbpr(const libcolour_colour_t* restrict from, libcolour_ypbpr_t*
   libcolour_colour_t tmp = *from;
   switch (from->model) {
   case LIBCOLOUR_YPBPR:
-    *to = *from;
+    *to = from->ypbpr;
     return;
   default:
     tmp.model = LIBCOLOUR_SRGB;
@@ -678,6 +685,7 @@ static void to_ypbpr(const libcolour_colour_t* restrict from, libcolour_ypbpr_t*
     to->Pb = tmp.srgb.B - to->Y;
     to->Pr = tmp.srgb.R - to->Y;
     return;
+  }
 }
 
 
@@ -686,7 +694,7 @@ static void to_ycgco(const libcolour_colour_t* restrict from, libcolour_ycgco_t*
   libcolour_colour_t tmp = *from;
   switch (from->model) {
   case LIBCOLOUR_YCGCO:
-    *to = *from;
+    *to = from->ycgco;
     return;
   default:
     tmp.model = LIBCOLOUR_SRGB;
@@ -697,6 +705,7 @@ static void to_ycgco(const libcolour_colour_t* restrict from, libcolour_ycgco_t*
     to->Cg = -tmp.srgb.R / 4 + tmp.srgb.G / 2 - tmp.srgb.B / 4;
     to->Co =  tmp.srgb.R / 2 - tmp.srgb.B / 2;
     return;
+  }
 }
 
 
@@ -706,7 +715,7 @@ static void to_cie1960ucs(const libcolour_colour_t* restrict from, libcolour_cie
   double u, v, w, y;
   switch (from->model) {
   case LIBCOLOUR_CIE1960UCS:
-    *to = *from;
+    *to = from->cie1960ucs;
     return;
   case LIBCOLOUR_CIEUVW:
     u = from->cieuvw.U, v = from->cieuvw.V, w = from->cieuvw.W;
@@ -819,22 +828,22 @@ int libcolour_convert(const libcolour_colour_t* restrict from, libcolour_colour_
 
 double libcolour_srgb_encode(double x)
 {
-  return x <= 0.0031308 ? 12.92 * x : 1.055 * pow(x, 1 / 2.4) - 0.055;
+  return x <= 0.0031306684425217108 ? 12.92 * x : 1.055 * pow(x, 1 / 2.4) - 0.055;
 }
 
 double libcolour_srgb_decode(double x)
 {
-  return x <= 0.04045 ? x / 12.92 : pow((x + 0.055) / 1.055, 2.4);
+  return x <= 0.040448236277380506 ? x / 12.92 : pow((x + 0.055) / 1.055, 2.4);
 }
 
 
 int libcolour_delta_e(const libcolour_colour_t* a, const libcolour_colour_t* b, double* e)
 {
-  libcolour_colour_t u, v;
+  libcolour_cielab_t u, v;
   u.model = v.model = LIBCOLOUR_CIELAB;
-  if (libcolour_convert(a, &u))
+  if (libcolour_convert(a, (libcolour_colour_t*)&u))
     return -1;
-  if (libcolour_convert(b, &v))
+  if (libcolour_convert(b, (libcolour_colour_t*)&v))
     return -1;
   u.L -= v.L, u.L *= u.L;
   u.a -= v.a, u.a *= u.a;
@@ -890,59 +899,35 @@ static int eliminate(double** M, size_t n, size_t m)
 int libcolour_proper(libcolour_colour_t* colour)
 {
   libcolour_colour_t tmp, r, g, b;
-  double m[3][4]
+  double m[3][4];
   switch (colour->model) {
+  case LIBCOLOUR_CIELUV:
+    colour->cieluv.white.model = LIBCOLOUR_CIEXYZ;
+    break;
+  case LIBCOLOUR_CIELCH:
+    colour->cielch.white.model = LIBCOLOUR_CIEXYZ;
+    break;
   case LIBCOLOUR_RGB:
-    if (colour->rgb.red.model != LIBCOLOUR_CIEXYY) {
-      tmp.model = LIBCOLOUR_CIEXYY;
-      libcolour_convert(&colour->rgb.red, &tmp);
-      colour->rgb.red = tmp;
-    }
-    if (colour->rgb.green.model != LIBCOLOUR_CIEXYY) {
-      tmp.model = LIBCOLOUR_CIEXYY;
-      libcolour_convert(&colour->rgb.green, &tmp);
-      colour->rgb.green = tmp;
-    }
-    if (colour->rgb.blue.model != LIBCOLOUR_CIEXYY) {
-      tmp.model = LIBCOLOUR_CIEXYY;
-      libcolour_convert(&colour->rgb.blue, &tmp);
-      colour->rgb.blue = tmp;
-    }
-    if (colour->rgb.white.model != LIBCOLOUR_CIEXYY) {
-      tmp.model = LIBCOLOUR_CIEXYY;
-      libcolour_convert(&colour->rgb.white, &tmp);
-      colour->rgb.white = tmp;
-    }
-    colour->rgb.red.ciexyy.Y = 1;
-    colour->rgb.green.ciexyy.Y = 1;
-    colour->rgb.blue.ciexyy.Y = 1;
+    colour->rgb.red.model   = LIBCOLOUR_CIEXYY;
+    colour->rgb.green.model = LIBCOLOUR_CIEXYY;
+    colour->rgb.blue.model  = LIBCOLOUR_CIEXYY;
+    colour->rgb.white.model = LIBCOLOUR_CIEXYY;
+    colour->rgb.red.Y   = 1;
+    colour->rgb.green.Y = 1;
+    colour->rgb.blue.Y  = 1;
     r.model = g.model = b.model = tmp.model = LIBCOLOUR_CIEXYZ;
-    libcolour_convert(&colour->rgb.red, &r);
-    libcolour_convert(&colour->rgb.green, &g);
-    libcolour_convert(&colour->rgb.blue, &b);
-    libcolour_convert(&colour->rgb.white, &tmp);
+    libcolour_convert((const libcolour_colour_t*)&colour->rgb.red, &r);
+    libcolour_convert((const libcolour_colour_t*)&colour->rgb.green, &g);
+    libcolour_convert((const libcolour_colour_t*)&colour->rgb.blue, &b);
+    libcolour_convert((const libcolour_colour_t*)&colour->rgb.white, &tmp);
     m[0][0] = r.ciexyz.X, m[0][1] = g.ciexyz.X, m[0][2] = b.ciexyz.X, m[0][3] = tmp.ciexyz.X;
     m[1][0] = r.ciexyz.Y, m[1][1] = g.ciexyz.Y, m[1][2] = b.ciexyz.Y, m[1][3] = tmp.ciexyz.Y;
     m[2][0] = r.ciexyz.Z, m[2][1] = g.ciexyz.Z, m[2][2] = b.ciexyz.Z, m[2][3] = tmp.ciexyz.Z;
-    if (eliminate(m, 3, 4))
+    if (eliminate((double**)m, 3, 4))
       return -1;
-    colour->rgb.red.ciexyy.Y = m[0][3];
-    colour->rgb.green.ciexyy.Y = m[1][3];
-    colour->rgb.blue.ciexyy.Y = m[2][3];
-    break;
-  case LIBCOLOUR_CIELUV:
-    if (colour->cieluv.white.model != LIBCOLOUR_CIEXYZ) {
-      tmp.model = LIBCOLOUR_CIEXYZ;
-      libcolour_convert(&colour->cieluv.white, &tmp);
-      colour->cieluv.white = tmp;
-    }
-    break;
-  case LIBCOLOUR_CIELCH:
-    if (colour->cielch.white.model != LIBCOLOUR_CIEXYZ) {
-      tmp.model = LIBCOLOUR_CIEXYZ;
-      libcolour_convert(&colour->cielch.white, &tmp);
-      colour->cielch.white = tmp;
-    }
+    colour->rgb.red.Y   = m[0][3];
+    colour->rgb.green.Y = m[1][3];
+    colour->rgb.blue.Y  = m[2][3];
     break;
   default:
     break;
@@ -950,3 +935,420 @@ int libcolour_proper(libcolour_colour_t* colour)
   return 0;
 }
 
+
+static int get_primaries(libcolour_rgb_t* cs)
+{
+  libcolour_colour_t r, g, b, w;
+  double Sr, Sg, Sb;
+  double M[3][6];
+
+  r.model = g.model = b.model = w.model = LIBCOLOUR_CIEXYZ;
+  r.ciexyz.Y = 1;
+  g.ciexyz.Y = 1;
+  b.ciexyz.Y = 1;
+
+  Sr = cs->M[1][0] * cs->white_r;
+  Sg = cs->M[1][1] * cs->white_g;
+  Sb = cs->M[1][2] * cs->white_b;
+
+  r.ciexyz.X = cs->M[0][0] / Sr, r.ciexyz.Z = cs->M[2][0] / Sr;
+  g.ciexyz.X = cs->M[0][1] / Sg, g.ciexyz.Z = cs->M[2][1] / Sg;
+  b.ciexyz.X = cs->M[0][2] / Sb, b.ciexyz.Z = cs->M[2][2] / Sb;
+
+  M[0][0] = r.ciexyz.X, M[0][1] = g.ciexyz.X, M[0][2] = b.ciexyz.X, M[0][3] = 1, M[0][4] = 0, M[0][5] = 0;
+  M[1][0] = r.ciexyz.Y, M[1][1] = g.ciexyz.Y, M[1][2] = b.ciexyz.Y, M[1][3] = 0, M[1][4] = 1, M[1][5] = 0;
+  M[2][0] = r.ciexyz.Z, M[2][1] = g.ciexyz.Z, M[2][2] = b.ciexyz.Z, M[2][3] = 0, M[2][4] = 0, M[2][5] = 1;
+
+  if (eliminate((double**)M, 3, 6))
+    return -1;
+
+  memcpy(M[0], M[0] + 3, 3 * sizeof(double)), M[0][3] = Sr;
+  memcpy(M[1], M[1] + 3, 3 * sizeof(double)), M[1][3] = Sg;
+  memcpy(M[2], M[2] + 3, 3 * sizeof(double)), M[2][3] = Sb;
+
+  if (eliminate((double**)M, 3, 4))
+    return -1;
+
+  w.ciexyz.X = M[0][3];
+  w.ciexyz.Y = M[1][3];
+  w.ciexyz.Z = M[2][3];
+
+  cs->red.model   = LIBCOLOUR_CIEXYY;
+  cs->green.model = LIBCOLOUR_CIEXYY;
+  cs->blue.model  = LIBCOLOUR_CIEXYY;
+  cs->white.model = LIBCOLOUR_CIEXYY;
+
+  libcolour_convert(&r, (libcolour_colour_t*)&cs->red);
+  libcolour_convert(&g, (libcolour_colour_t*)&cs->green);
+  libcolour_convert(&b, (libcolour_colour_t*)&cs->blue);
+  libcolour_convert(&w, (libcolour_colour_t*)&cs->white);
+
+  return 0;
+}
+
+
+static int get_matrices(libcolour_rgb_t* cs)
+{
+  libcolour_colour_t r, g, b, w;
+  double M[3][6];
+  double Sr, Sg, Sb;
+
+  r.model = g.model = b.model = LIBCOLOUR_CIEXYZ;
+  w.model = LIBCOLOUR_CIEXYY;
+  libcolour_convert((const libcolour_colour_t*)&cs->red,   &w), w.ciexyy.Y = 1, libcolour_convert(&w, &r);
+  libcolour_convert((const libcolour_colour_t*)&cs->green, &w), w.ciexyy.Y = 1, libcolour_convert(&w, &g);
+  libcolour_convert((const libcolour_colour_t*)&cs->blue,  &w), w.ciexyy.Y = 1, libcolour_convert(&w, &b);
+  w.model = LIBCOLOUR_CIEXYZ;
+  libcolour_convert((const libcolour_colour_t*)&cs->white, &w);
+
+  M[0][0] = r.ciexyz.X, M[0][1] = g.ciexyz.X, M[0][2] = b.ciexyz.X, M[0][3] = 1, M[0][4] = 0, M[0][5] = 0;
+  M[1][0] = r.ciexyz.Y, M[1][1] = g.ciexyz.Y, M[1][2] = b.ciexyz.Y, M[1][3] = 0, M[1][4] = 1, M[1][5] = 0;
+  M[2][0] = r.ciexyz.Z, M[2][1] = g.ciexyz.Z, M[2][2] = b.ciexyz.Z, M[2][3] = 0, M[2][4] = 0, M[2][5] = 1;
+
+  if (eliminate((double**)M, 3, 6))
+    return -1;
+
+  Sr = M[0][3] * w.ciexyz.X + M[0][4] * w.ciexyz.Y + M[0][5] * w.ciexyz.Z;
+  Sg = M[1][3] * w.ciexyz.X + M[1][4] * w.ciexyz.Y + M[1][5] * w.ciexyz.Z;
+  Sb = M[2][3] * w.ciexyz.X + M[2][4] * w.ciexyz.Y + M[2][5] * w.ciexyz.Z;
+
+  Sr /= cs->white_r;
+  Sg /= cs->white_g;
+  Sb /= cs->white_b;
+
+  cs->M[0][0] = Sr * r.ciexyz.X, cs->M[0][1] = Sg * g.ciexyz.X, cs->M[0][2] = Sb * b.ciexyz.X;
+  cs->M[1][0] = Sr * r.ciexyz.Y, cs->M[1][1] = Sg * g.ciexyz.Y, cs->M[1][2] = Sb * b.ciexyz.Y;
+  cs->M[2][0] = Sr * r.ciexyz.Z, cs->M[2][1] = Sg * g.ciexyz.Z, cs->M[2][2] = Sb * b.ciexyz.Z;
+
+  memcpy(M[0], cs->M[0], 3 * sizeof(double)), M[0][3] = 1, M[0][4] = 0, M[0][5] = 0;
+  memcpy(M[1], cs->M[1], 3 * sizeof(double)), M[1][3] = 0, M[1][4] = 1, M[1][5] = 0;
+  memcpy(M[2], cs->M[2], 3 * sizeof(double)), M[2][3] = 0, M[2][4] = 0, M[2][5] = 1;
+
+  if (eliminate((double**)M, 3, 6))
+    return -1;
+
+  memcpy(cs->Minv[0], M[0] + 3, 3 * sizeof(double));
+  memcpy(cs->Minv[1], M[1] + 3, 3 * sizeof(double));
+  memcpy(cs->Minv[2], M[2] + 3, 3 * sizeof(double));
+
+  return 0;
+}
+
+
+static int invert(double **Minv, double **M, size_t n)
+{
+  double J[3][6];
+  size_t i;
+  for (i = 0; i < n; i++) {
+    memcpy(J[i], M[i], n * sizeof(double));
+    memset(J[i] + n, 0, n * sizeof(double));
+    J[i][n + i] = 1;
+  }
+  if (eliminate((double**)J, n, 2 * n))
+    return -1;
+  for (i = 0; i < n; i++)
+    memcpy(M[i], J[i] + n, n * sizeof(double));
+  return 0;
+}
+
+
+int libcolour_get_rgb_colour_space(libcolour_colour_t* cs_, libcolour_rgb_colour_space_t space)
+{
+#define XYY(XVALUE, YVALUE)  (libcolour_ciexyy_t){ .model = LIBCOLOUR_CIEXYY, .x = XVALUE, .y = YVALUE, .Y = 1}
+
+  libcolour_rgb_t* cs = &cs_->rgb;
+
+  switch (space) {
+  case LIBCOLOUR_RGB_COLOUR_SPACE_CUSTOM_FROM_MEASUREMENTS:
+    if (get_matrices(cs))
+      return -1;
+    return 0;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_CUSTOM_FROM_MATRIX:
+    if (invert((double**)(cs->Minv), (double**)(cs->M), 3) || get_primaries(cs))
+      return -1;
+    return 0;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_CUSTOM_FROM_INV_MATRIX:
+    if (invert((double**)(cs->M), (double**)(cs->Minv), 3) || get_primaries(cs))
+      return -1;
+    return 0;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_SRGB:
+    cs->red   = XYY(0.6400, 0.3300);
+    cs->green = XYY(0.3000, 0.6000);
+    cs->blue  = XYY(0.1500, 0.0600);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_REGULAR;
+    cs->offset = 0.055;
+    cs->gamma = 2.4;
+    cs->slope = 12.92;
+    cs->transition = 0.0031306684425217108;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ADOBE_RGB:
+    cs->red   = XYY(0.6400, 0.3300);
+    cs->green = XYY(0.2100, 0.7100);
+    cs->blue  = XYY(0.1500, 0.0600);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 2.2;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_APPLE_RGB:
+    cs->red   = XYY(0.6250, 0.3400);
+    cs->green = XYY(0.2800, 0.5950);
+    cs->blue  = XYY(0.1550, 0.0700);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 1.8;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_BEST_RGB:
+    cs->red   = XYY(0.7347, 0.2653);
+    cs->green = XYY(0.2150, 0.7750);
+    cs->blue  = XYY(0.1300, 0.0350);
+    cs->white = LIBCOLOUR_ILLUMINANT_D50;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 2.2;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_BETA_RGB:
+    cs->red   = XYY(0.6888, 0.3112);
+    cs->green = XYY(0.1986, 0.7551);
+    cs->blue  = XYY(0.1265, 0.0352);
+    cs->white = LIBCOLOUR_ILLUMINANT_D50;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 2.2;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_BRUCE_RGB:
+    cs->red   = XYY(0.6400, 0.3300);
+    cs->green = XYY(0.2800, 0.6500);
+    cs->blue  = XYY(0.1500, 0.0600);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 2.2;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_CIE_RGB:
+    cs->red   = XYY(0.7350, 0.2650);
+    cs->green = XYY(0.2640, 0.7170);
+    cs->blue  = XYY(0.1670, 0.0090);
+    cs->white = LIBCOLOUR_ILLUMINANT_E;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 2.2;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_COLORMATCH_RGB:
+    cs->red   = XYY(0.6300, 0.3400);
+    cs->green = XYY(0.2950, 0.6050);
+    cs->blue  = XYY(0.1500, 0.0750);
+    cs->white = LIBCOLOUR_ILLUMINANT_D50;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 1.8;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_DCI_P3_D65:
+    cs->red   = XYY(0.6380, 0.3200);
+    cs->green = XYY(0.2650, 0.6900);
+    cs->blue  = XYY(0.1500, 0.0600);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 2.6;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_DCI_P3_THEATER:
+    cs->red   = XYY(0.6380, 0.3200);
+    cs->green = XYY(0.2650, 0.6900);
+    cs->blue  = XYY(0.1500, 0.0600);
+    cs->white = XYY(0.314, 0.351);
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 2.6;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_DON_RGB_4:
+    cs->red   = XYY(0.6960, 0.3000);
+    cs->green = XYY(0.2150, 0.7650);
+    cs->blue  = XYY(0.1300, 0.0350);
+    cs->white = LIBCOLOUR_ILLUMINANT_D50;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 2.2;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ECI_RGB_V2:
+    cs->red   = XYY(0.6700, 0.3300);
+    cs->green = XYY(0.2100, 0.7100);
+    cs->blue  = XYY(0.1400, 0.0800);
+    cs->white = LIBCOLOUR_ILLUMINANT_D50;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_CUSTOM; /* TODO L* */
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_EKTA_SPACE_PS5:
+    cs->red   = XYY(0.6950, 0.3050);
+    cs->green = XYY(0.2600, 0.7000);
+    cs->blue  = XYY(0.1100, 0.0050);
+    cs->white = LIBCOLOUR_ILLUMINANT_D50;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 2.2;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ITU_R_BT_601_625_LINE:
+    cs->red   = XYY(0.6400, 0.3300);
+    cs->green = XYY(0.2900, 0.6000);
+    cs->blue  = XYY(0.1500, 0.0060);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_REGULAR;
+    cs->gamma = 1 / 0.45;
+    cs->offset = 0.09929682680944;
+    cs->slope = 4.5;
+    cs->transition = 0.018053968510807;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ITU_R_BT_601_525_LINE:
+    cs->red   = XYY(0.6300, 0.3400);
+    cs->green = XYY(0.3100, 0.5950);
+    cs->blue  = XYY(0.1550, 0.0700);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_REGULAR;
+    cs->gamma = 1 / 0.45;
+    cs->offset = 0.09929682680944;
+    cs->slope = 4.5;
+    cs->transition = 0.018053968510807;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ITU_R_BT_709:
+    cs->red   = XYY(0.6300, 0.3300);
+    cs->green = XYY(0.3000, 0.6000);
+    cs->blue  = XYY(0.1500, 0.0600);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_REGULAR;
+    cs->gamma = 1 / 0.45;
+    cs->offset = 0.09929682680944;
+    cs->slope = 4.5;
+    cs->transition = 0.018053968510807;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ITU_R_BT_2020:
+    cs->red   = XYY(0.7080, 0.2920);
+    cs->green = XYY(0.1700, 0.7970);
+    cs->blue  = XYY(0.1310, 0.0460);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_REGULAR;
+    cs->gamma = 1 / 0.45;
+    cs->offset = 0.09929682680944;
+    cs->slope = 4.5;
+    cs->transition = 0.018053968510807;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ITU_R_BT_2100_EOTF_PQ:
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ITU_R_BT_2100_OOTF_PQ:
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ITU_R_BT_2100_OETF_PQ:
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ITU_R_BT_2100_EOTF_HLG:
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ITU_R_BT_2100_OOTF_HLG:
+  case LIBCOLOUR_RGB_COLOUR_SPACE_ITU_R_BT_2100_OETF_HLG:
+    cs->red   = XYY(0.7080, 0.2920);
+    cs->green = XYY(0.1700, 0.7970);
+    cs->blue  = XYY(0.1310, 0.0460);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_CUSTOM;
+    /* TODO http://www.itu.int/dms_pubrec/itu-r/rec/bt/R-REC-BT.2100-0-201607-I!!PDF-E.pdf */
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_LIGHTROOM_RGB:
+    cs->red   = XYY(0.7347, 0.2653);
+    cs->green = XYY(0.1596, 0.8404);
+    cs->blue  = XYY(0.0366, 0.0001);
+    cs->white = LIBCOLOUR_ILLUMINANT_D50;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_LINEAR;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_NTSC_RGB:
+    cs->red   = XYY(0.6700, 0.3300);
+    cs->green = XYY(0.2100, 0.7100);
+    cs->blue  = XYY(0.1400, 0.0800);
+    cs->white = LIBCOLOUR_ILLUMINANT_C;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_REGULAR;
+    cs->gamma = 1 / 0.45;
+    cs->offset = 0.09929682680944;
+    cs->slope = 4.5;
+    cs->transition = 0.018053968510807;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_PAL_SECAM_RGB:
+    cs->red   = XYY(0.6400, 0.3300);
+    cs->green = XYY(0.2900, 0.6000);
+    cs->blue  = XYY(0.1500, 0.0600);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_REGULAR;
+    cs->gamma = 1 / 0.45;
+    cs->offset = 0.09929682680944;
+    cs->slope = 4.5;
+    cs->transition = 0.018053968510807;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_PROPHOTO_RGB:
+    cs->red   = XYY(0.7347, 0.2653);
+    cs->green = XYY(0.1596, 0.8404);
+    cs->blue  = XYY(0.0366, 0.0001);
+    cs->white = LIBCOLOUR_ILLUMINANT_D50;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 1.8;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_SGI_RGB:
+    cs->red   = XYY(0.6250, 0.3400);
+    cs->green = XYY(0.2800, 0.5950);
+    cs->blue  = XYY(0.1550, 0.0700);
+    cs->white = LIBCOLOUR_ILLUMINANT_D50;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 1.47;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_SMPTE_240M_RGB:
+    cs->red   = XYY(0.6300, 0.3400);
+    cs->green = XYY(0.3100, 0.5950);
+    cs->blue  = XYY(0.1550, 0.0700);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_REGULAR;
+    cs->gamma = 1 / 0.45;
+    cs->offset = 0.1115721957735072;
+    cs->slope = 4.0;
+    cs->transition = 0.022821585552393633;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_SMPTE_C_RGB:
+    cs->red   = XYY(0.6300, 0.3400);
+    cs->green = XYY(0.3100, 0.5950);
+    cs->blue  = XYY(0.1550, 0.0700);
+    cs->white = LIBCOLOUR_ILLUMINANT_D65;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_REGULAR;
+    cs->gamma = 1 / 0.45;
+    cs->offset = 0.09929682680944;
+    cs->slope = 4.5;
+    cs->transition = 0.018053968510807;
+    break;
+
+  case LIBCOLOUR_RGB_COLOUR_SPACE_WIDE_GAMUT_RGB:
+    cs->red   = XYY(0.7350, 0.2650);
+    cs->green = XYY(0.1150, 0.8260);
+    cs->blue  = XYY(0.1570, 0.0180);
+    cs->white = LIBCOLOUR_ILLUMINANT_D50;
+    cs->encoding_type = LIBCOLOUR_ENCODING_TYPE_SIMPLE;
+    cs->gamma = 2.19921875;
+    break;
+
+  default:
+    errno = EINVAL;
+    return -1;
+  }
+  if (cs->encoding_type == LIBCOLOUR_ENCODING_TYPE_REGULAR)
+    cs->transitioninv = cs->transition * cs->slope;
+  cs->colour_space = space;
+  cs->white_r = cs->white_g = cs->white_b = 1;
+  if (get_matrices(cs) || libcolour_proper(cs_))
+    return -1;
+  return 0;
+
+#undef XYY
+}