/* See LICENSE file for copyright and license details. */
#ifndef LIBCLUT_H
#define LIBCLUT_H
#include <stddef.h>
#include <string.h>
#include <math.h>
/* Not documented, may be removed or modified in the future. */
#define LIBCLUT_ILLUMINANT_A .white_x = 0.44757, .white_y = 0.40745, .white_Y = 1
#define LIBCLUT_ILLUMINANT_B .white_x = 0.34842, .white_y = 0.35161, .white_Y = 1
#define LIBCLUT_ILLUMINANT_C .white_x = 0.31006, .white_y = 0.31616, .white_Y = 1
#define LIBCLUT_ILLUMINANT_D50 .white_x = 0.34567, .white_y = 0.35850, .white_Y = 1
#define LIBCLUT_ILLUMINANT_D55 .white_x = 0.33242, .white_y = 0.34743, .white_Y = 1
#define LIBCLUT_ILLUMINANT_D65 .white_x = 0.31271, .white_y = 0.32902, .white_Y = 1
#define LIBCLUT_ILLUMINANT_D75 .white_x = 0.29902, .white_y = 0.31485, .white_Y = 1
#define LIBCLUT_ILLUMINANT_E .white_x = 1. / 3, .white_y = 1. / 3, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F1 .white_x = 0.31310, .white_y = 0.33727, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F2 .white_x = 0.37208, .white_y = 0.37529, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F3 .white_x = 0.40910, .white_y = 0.39430, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F4 .white_x = 0.44018, .white_y = 0.40329, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F5 .white_x = 0.31379, .white_y = 0.34531, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F6 .white_x = 0.37790, .white_y = 0.38835, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F7 .white_x = 0.31292, .white_y = 0.32933, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F8 .white_x = 0.34588, .white_y = 0.35875, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F9 .white_x = 0.37417, .white_y = 0.37281, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F10 .white_x = 0.34609, .white_y = 0.35986, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F11 .white_x = 0.38052, .white_y = 0.37713, .white_Y = 1
#define LIBCLUT_ILLUMINANT_F12 .white_x = 0.43695, .white_y = 0.40441, .white_Y = 1
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the sRGB colour space
*
* sRGB does not use a regular gamma function, but rather two different
* functions. `libclut_model_linear_to_standard1` and
* and `libclut_model_standard_to_linear1` can be used so to convert
* between sRGB and linear sRGB
*/
#define LIBCLUT_RGB_COLOUR_SPACE_SRGB_INITIALISER {\
.red_x = 0.6400, .red_y = 0.3300, .red_Y = 0.212656,\
.green_x = 0.3000, .green_y = 0.6000, .green_Y = 0.715158,\
.blue_x = 0.1500, .blue_y = 0.0600, .blue_Y = 0.072186,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the Adobe RGB (1998) colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_ADOBE_RGB_INITIALISER {\
.red_x = 0.6400, .red_y = 0.3300, .red_Y = 0.297361,\
.green_x = 0.2100, .green_y = 0.7100, .green_Y = 0.627355,\
.blue_x = 0.1500, .blue_y = 0.0600, .blue_Y = 0.075285,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the Apple RGB colour space
*
* This colour space's gamma is 1.8. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_APPLE_RGB_INITIALISER {\
.red_x = 0.6250, .red_y = 0.3400, .red_Y = 0.244634,\
.green_x = 0.2800, .green_y = 0.5950, .green_Y = 0.672034,\
.blue_x = 0.1550, .blue_y = 0.0700, .blue_Y = 0.083332,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the Best RGB colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_BEST_RGB_INITIALISER {\
.red_x = 0.7347, .red_y = 0.2653, .red_Y = 0.228457,\
.green_x = 0.2150, .green_y = 0.7750, .green_Y = 0.737352,\
.blue_x = 0.1300, .blue_y = 0.0350, .blue_Y = 0.034191,\
LIBCLUT_ILLUMINANT_D50}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the Beta RGB colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_BETA_RGB_INITIALISER {\
.red_x = 0.6888, .red_y = 0.3112, .red_Y = 0.303273,\
.green_x = 0.1986, .green_y = 0.7551, .green_Y = 0.663786,\
.blue_x = 0.1265, .blue_y = 0.0352, .blue_Y = 0.032941,\
LIBCLUT_ILLUMINANT_D50}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the Bruce RGB colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_BRUCE_RGB_INITIALISER {\
.red_x = 0.6400, .red_y = 0.3300, .red_Y = 0.240995,\
.green_x = 0.2800, .green_y = 0.6500, .green_Y = 0.683554,\
.blue_x = 0.1500, .blue_y = 0.0600, .blue_Y = 0.075452,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the CIE RGB colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_CIE_RGB_INITIALISER {\
.red_x = 0.7350, .red_y = 0.2650, .red_Y = 0.176204,\
.green_x = 0.2740, .green_y = 0.7170, .green_Y = 0.812985,\
.blue_x = 0.1670, .blue_y = 0.0090, .blue_Y = 0.010811,\
LIBCLUT_ILLUMINANT_E}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the ColorMatch RGB colour space
*
* This colour space's gamma is 1.8. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_COLORMATCH_RGB_INITIALISER {\
.red_x = 0.6300, .red_y = 0.3400, .red_Y = 0.274884,\
.green_x = 0.2950, .green_y = 0.6050, .green_Y = 0.658132,\
.blue_x = 0.1500, .blue_y = 0.0750, .blue_Y = 0.066985,\
LIBCLUT_ILLUMINANT_D50}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the DCI-P3 D65 colour space
*
* This colour space's gamma is 2.6. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_DCI_P3_D65_INITIALISER {\
.red_x = 0.680, .red_y = 0.320, .red_Y = 0.22897344,\
.green_x = 0.265, .green_y = 0.690, .green_Y = 0.69175166,\
.blue_x = 0.150, .blue_y = 0.060, .blue_Y = 0.07927490,\
LIBCLUT_ILLUMINANT_D50}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the DCI-P3 Theater colour space
*
* This colour space's gamma is 2.6. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_DCI_P3_THEATER_INITIALISER {\
.red_x = 0.680, .red_y = 0.320, .red_Y = 0.20949168,\
.green_x = 0.265, .green_y = 0.690, .green_Y = 0.72159525,\
.blue_x = 0.150, .blue_y = 0.060, .blue_Y = 0.06891307,\
.white_x = 0.314, .white_y = 0.351, .white_Y = 1}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the Don RGB 4 colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_DON_RGB_4_INITIALISER {\
.red_x = 0.6960, .red_y = 0.3000, .red_Y = 0.278350,\
.green_x = 0.2150, .green_y = 0.7650, .green_Y = 0.687970,\
.blue_x = 0.1300, .blue_y = 0.0350, .blue_Y = 0.033680,\
LIBCLUT_ILLUMINANT_D50}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the ECI RGB v2 colour space
*
* This colour space's used the L* gamma function. It cannot
* be used with RGB colour space conversion unless the values are
* tranlated into using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_ECI_RGB_V2_INITIALISER {\
.red_x = 0.6700, .red_y = 0.3300, .red_Y = 0.320250,\
.green_x = 0.2100, .green_y = 0.7100, .green_Y = 0.602071,\
.blue_x = 0.1400, .blue_y = 0.0800, .blue_Y = 0.077679,\
LIBCLUT_ILLUMINANT_D50}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the Ekta Space PS5 colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_EKTA_SPACE_PS5_INITIALISER {\
.red_x = 0.6950, .red_y = 0.3050, .red_Y = 0.260629,\
.green_x = 0.2600, .green_y = 0.7000, .green_Y = 0.734946,\
.blue_x = 0.1100, .blue_y = 0.0050, .blue_Y = 0.004425,\
LIBCLUT_ILLUMINANT_D50}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the ITU-R Recommendation BT.601 (ITU-R BT.601), 625 line colour
* space
*
* This colour space uses a custom gamma function. It cannot be used
* with RGB colour space conversion unless the values are tranlated
* into using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_ITU_R_BT_601_625_LINE_INITIALISER {\
.red_x = 0.640, .red_y = 0.330, .red_Y = 0.2220023,\
.green_x = 0.290, .green_y = 0.600, .green_Y = 0.7066689,\
.blue_x = 0.150, .blue_y = 0.060, .blue_Y = 0.0713288,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the ITU-R Recommendation BT.601 (ITU-R BT.601), 525 line colour
* space
*
* This colour space uses a custom gamma function. It cannot be used
* with RGB colour space conversion unless the values are tranlated
* into using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_ITU_R_BT_601_525_LINE_INITIALISER {\
.red_x = 0.630, .red_y = 0.340, .red_Y = 0.2220023,\
.green_x = 0.310, .green_y = 0.595, .green_Y = 0.7066689,\
.blue_x = 0.155, .blue_y = 0.070, .blue_Y = 0.0713288,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the ITU-R Recommendation BT.709 (ITU-R BT.709) colour space
*
* This colour space's gamma is 2._. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_ITU_R_BT_709_INITIALISER {\
.red_x = 0.6400, .red_y = 0.3300, .red_Y = 0.212656,\
.green_x = 0.3000, .green_y = 0.6000, .green_Y = 0.715158,\
.blue_x = 0.1500, .blue_y = 0.0600, .blue_Y = 0.072186,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the ITU-R Recommendation BT.2020 (ITU-R BT.2020) colour space
*
* This colour space uses a custom gamma function. It cannot be used
* with RGB colour space conversion unless the values are tranlated
* into using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_ITU_R_BT_2020_INITIALISER {\
.red_x = 0.7080, .red_y = 0.2920, .red_Y = 0.2627296,\
.green_x = 0.1700, .green_y = 0.7970, .green_Y = 0.6767483,\
.blue_x = 0.1310, .blue_y = 0.0460, .blue_Y = 0.0605221,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the ITU-R Recommendation BT.2100 (ITU-R BT.2100) colour space
*
* This colour space uses a custom gamma function. It cannot be used
* with RGB colour space conversion unless the values are tranlated
* into using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_ITU_R_BT_2100_INITIALISER {\
.red_x = 0.7080, .red_y = 0.2920, .red_Y = 0.2627296,\
.green_x = 0.1700, .green_y = 0.7970, .green_Y = 0.6767483,\
.blue_x = 0.1310, .blue_y = 0.0460, .blue_Y = 0.0605221,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the Lightroom RGB colour space
*
* This colour space's gamma is 1 (linear). It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_LIGHTROOM_RGB_INITIALISER {\
.red_x = 0.7347, .red_y = 0.2653, .red_Y = 0.288040,\
.green_x = 0.1596, .green_y = 0.8404, .green_Y = 0.711874,\
.blue_x = 0.0366, .blue_y = 0.0001, .blue_Y = 0.000086,\
LIBCLUT_ILLUMINANT_D50}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the NTSC RGB colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_NTSC_RGB_INITIALISER {\
.red_x = 0.6700, .red_y = 0.3300, .red_Y = 0.298839,\
.green_x = 0.2100, .green_y = 0.7100, .green_Y = 0.586811,\
.blue_x = 0.1400, .blue_y = 0.0800, .blue_Y = 0.114350,\
LIBCLUT_ILLUMINANT_C}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the PAL/SECAM RGB colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_PAL_SECAM_RGB_INITIALISER {\
.red_x = 0.6400, .red_y = 0.3300, .red_Y = 0.222021,\
.green_x = 0.2900, .green_y = 0.6000, .green_Y = 0.706645,\
.blue_x = 0.1500, .blue_y = 0.0600, .blue_Y = 0.071334,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the ProPhoto RGB colour space
*
* This colour space's gamma is 1.8. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_PROPHOTO_RGB_INITIALISER {\
.red_x = 0.7347, .red_y = 0.2653, .red_Y = 0.288040,\
.green_x = 0.1596, .green_y = 0.8404, .green_Y = 0.711874,\
.blue_x = 0.0366, .blue_y = 0.0001, .blue_Y = 0.000086,\
LIBCLUT_ILLUMINANT_D50}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the SMPTE-C RGB colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_SMPTE_C_RGB_INITIALISER {\
.red_x = 0.6300, .red_y = 0.3400, .red_Y = 0.212395,\
.green_x = 0.3100, .green_y = 0.5950, .green_Y = 0.701049,\
.blue_x = 0.1550, .blue_y = 0.0700, .blue_Y = 0.086556,\
LIBCLUT_ILLUMINANT_D65}
/**
* Initialiser for `struct libclut_rgb_colour_space` with the values
* of the Wide Gamut RGB colour space
*
* This colour space's gamma is 2.2. It cannot be used with
* RGB colour space conversion unless the values are tranlated into
* using the sRGB gamma function.
*/
#define LIBCLUT_RGB_COLOUR_SPACE_WIDE_GAMUT_RGB_INITIALISER {\
.red_x = 0.7350, .red_y = 0.2650, .red_Y = 0.258187,\
.green_x = 0.1150, .green_y = 0.8260, .green_Y = 0.724938,\
.blue_x = 0.1570, .blue_y = 0.0180, .blue_Y = 0.016875,\
LIBCLUT_ILLUMINANT_D50}
/*
* TODO gamma functions:
* https://en.wikipedia.org/wiki/Rec._2020#Transfer_characteristics
* http://www.itu.int/dms_pubrec/itu-r/rec/bt/R-REC-BT.2100-0-201607-I!!PDF-E.pdf
* https://en.wikipedia.org/wiki/Rec._601
*/
/**
* RGB colour space structure
*/
typedef struct libclut_rgb_colour_space {
/**
* The x-component of the red colour's xyY value
*/
double red_x;
/**
* The y-component of the red colour's xyY value
*/
double red_y;
/**
* The Y-component of the red colour's xyY value
*/
double red_Y;
/**
* The x-component of the green colour's xyY value
*/
double green_x;
/**
* The y-component of the green colour's xyY value
*/
double green_y;
/**
* The Y-component of the green colour's xyY value
*/
double green_Y;
/**
* The x-component of the blue colour's xyY value
*/
double blue_x;
/**
* The y-component of the blue colour's xyY value
*/
double blue_y;
/**
* The Y-component of the blue colour's xyY value
*/
double blue_Y;
/**
* The x-component of the white point's xyY value
*/
double white_x;
/**
* The y-component of the white point's xyY value
*/
double white_y;
/**
* The Y-component of the white point's xyY value
*/
double white_Y;
} libclut_rgb_colour_space_t;
/**
* Matrix date-type for colour space conversion
*/
typedef double libclut_colour_space_conversion_matrix_t[3][3];
/* This is to avoid warnings about comparing double, These are only
* used when it is safe, for example to test whether optimisations
* are possible. { */
#if defined(__GNUC__) || defined(__clang__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wfloat-equal"
#endif
static inline int libclut_eq__(double a, double b) { return a == b; }
static inline int libclut_1__(double x) { return libclut_eq__(x, 1); }
static inline int libclut_0__(double x) { return libclut_eq__(x, 0); }
#if defined(__GNUC__) || defined(__clang__)
# pragma GCC diagnostic pop
#endif
/* } */
#if defined(__clang__)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wdocumentation"
#endif
/**
* Apply contrast correction on the colour curves using sRGB
*
* In this context, contrast is a measure of difference between
* the whitepoint and blackpoint, if the difference is 0 than
* they are both grey
*
* None of the parameter may have side-effects
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r The contrast parameter for the red curve
* @param g The contrast parameter for the green curve
* @param b The contrast parameter for the blue curve
*/
#define libclut_rgb_contrast(clut, max, type, r, g, b)\
do {\
const double h__ = (double)5 / 10;\
if (!libclut_1__(r)) libclut__(clut, red, type, (LIBCLUT_VALUE - (max) * h__) * (r) + (max) * h__);\
if (!libclut_1__(g)) libclut__(clut, green, type, (LIBCLUT_VALUE - (max) * h__) * (g) + (max) * h__);\
if (!libclut_1__(b)) libclut__(clut, blue, type, (LIBCLUT_VALUE - (max) * h__) * (b) + (max) * h__);\
} while (0)
/**
* Apply contrast correction on the colour curves using CIE xyY
*
* In this context, contrast is a measure of difference between
* the whitepoint and blackpoint, if the difference is 0 than
* they are both grey
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut'
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r The contrast parameter for the red curve
* @param g The contrast parameter for the green curve
* @param b The contrast parameter for the blue curve
*/
#define libclut_cie_contrast(clut, max, type, r, g, b)\
do {\
const double h__ = (double)5 / 10;\
libclut_cie__(clut, max, type, libclut_eq__((r), (g)) && libclut_eq__((g), (b)),\
!libclut_1__(r), !libclut_1__(g), !libclut_1__(b),\
(Y__ - h__) * (r) + h__, (Y__ - h__) * (g) + h__, (Y__ - h__) * (b) + h__);\
} while (0)
/**
* Apply brightness correction on the colour curves using sRGB
*
* In this context, brightness is a measure of the whiteness of the whitepoint
*
* None of the parameter may have side-effects
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r The brightness parameter for the red curve
* @param g The brightness parameter for the green curve
* @param b The brightness parameter for the blue curve
*/
#define libclut_rgb_brightness(clut, max, type, r, g, b)\
do {\
if (!libclut_1__(r)) libclut__(clut, red, type, LIBCLUT_VALUE * (r));\
if (!libclut_1__(g)) libclut__(clut, green, type, LIBCLUT_VALUE * (g));\
if (!libclut_1__(b)) libclut__(clut, blue, type, LIBCLUT_VALUE * (b));\
} while (0)
/**
* Apply brightness correction on the colour curves using CIE xyY
*
* In this context, brightness is a measure of the whiteness of the whitepoint
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut'
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r The brightness parameter for the red curve
* @param g The brightness parameter for the green curve
* @param b The brightness parameter for the blue curve
*/
#define libclut_cie_brightness(clut, max, type, r, g, b)\
libclut_cie__(clut, max, type, libclut_eq__((r), (g)) && libclut_eq__((g), (b)),\
!libclut_1__(r), !libclut_1__(g), !libclut_1__(b),\
Y__ * (r), Y__ * (g), Y__ * (b))
/**
* Convert the curves from formatted in standard RGB to linear sRGB
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_standard_to_linear1` is not undefined
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r Whether to convert the red colour curve
* @param g Whether to convert the green colour curve
* @param b Whether to convert the blue colour curve
*/
#define libclut_linearise(clut, max, type, r, g, b)\
do {\
double m__ = (double)(max);\
if (r) libclut__(clut, red, type, m__ * libclut_model_standard_to_linear1(LIBCLUT_VALUE / m__));\
if (g) libclut__(clut, green, type, m__ * libclut_model_standard_to_linear1(LIBCLUT_VALUE / m__));\
if (b) libclut__(clut, blue, type, m__ * libclut_model_standard_to_linear1(LIBCLUT_VALUE / m__));\
} while (0)
/**
* Convert the curves from formatted in linear sRGB to standard RGB
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_linear_to_standard1` is not undefined
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r Whether to convert the red colour curve
* @param g Whether to convert the green colour curve
* @param b Whether to convert the blue colour curve
*/
#define libclut_standardise(clut, max, type, r, g, b)\
do {\
double m__ = (double)(max);\
if (r) libclut__(clut, red, type, m__ * libclut_model_linear_to_standard1(LIBCLUT_VALUE / m__));\
if (g) libclut__(clut, green, type, m__ * libclut_model_linear_to_standard1(LIBCLUT_VALUE / m__));\
if (b) libclut__(clut, blue, type, m__ * libclut_model_linear_to_standard1(LIBCLUT_VALUE / m__));\
} while (0)
/**
* Convert the curves between two RGB colour spaces
*
* Both RGB colour spaces must have same gamma functions as sRGB
*
* Requires that `clut->red_size`, `clut->green_size`
* and `clut->blue_size` are equal
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_linear_to_standard1`,
* `libclut_model_standard_to_linear1`, or
* `libclut_model_convert_rgb` is not undefined
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param m Conversion matrix. Can be created with
* `libclut_model_get_rgb_conversion_matrix`
* @param trunc Truncate values that are out of gamut
*/
#define libclut_convert_rgb_inplace(clut, max, type, m, trunc)\
do {\
double m__ = (double)(max), r__, g__, b__;\
size_t i__, n__ = (clut)->red_size;\
for (i__ = 0; i__ < n__; i__++) {\
r__ = (clut)->red[i__] / m__;\
g__ = (clut)->green[i__] / m__;\
b__ = (clut)->blue[i__] / m__;\
libclut_model_convert_rgb(r__, g__, b__, m, &r__, &g__, &b__);\
r__ *= m__;\
g__ *= m__;\
b__ *= m__;\
if (trunc) {\
if (r__ < 0)\
r__ = 0;\
else if (r__ > m__)\
r__ = m__;\
if (g__ < 0)\
g__ = 0;\
else if (g__ > m__)\
g__ = m__;\
if (b__ < 0)\
b__ = 0;\
else if (b__ > m__)\
b__ = m__;\
}\
(clut)->red[i__] = (type)r__;\
(clut)->green[i__] = (type)g__;\
(clut)->blue[i__] = (type)b__;\
}\
} while (0)
/**
* Convert the curves between two RGB colour spaces
*
* Both RGB colour spaces must have same gamma functions as sRGB
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut' if
* `libclut_model_linear_to_standard1`,
* `libclut_model_standard_to_linear1`, or
* `libclut_model_convert_rgb` is not undefined.
* Always requires linking with '-lm'.
*
* @param clut Pointer to the input gamma ramps, must have the
* arrays `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param m Conversion matrix. Can be created with
* `libclut_model_get_rgb_conversion_matrix`
* @param trunc Truncate values that are out of gamut
* @param out Pointer to the output gamma ramps, must have the
* arrays `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
*/
#define libclut_convert_rgb(clut, max, type, m, trunc, out)\
do {\
double m__ = (double)(max), r__, g__, b__, x__, y__;\
size_t rn__ = (clut)->red_size;\
size_t gn__ = (clut)->green_size;\
size_t bn__ = (clut)->blue_size;\
double w__;\
size_t i__, j__, jj__;\
for (i__ = 0; i__ < rn__; i__++) {\
w__ = (double)i__ * gn__ / rn__;\
j__ = (size_t)w__;\
jj__ = j__ == gn__ ? j__ : (j__ + 1);\
w__ = fmod(j__, (double)1);\
x__ = (clut)->green[j__] / m__;\
y__ = (clut)->green[jj__] / m__;\
x__ = libclut_model_standard_to_linear1(x__);\
y__ = libclut_model_standard_to_linear1(y__);\
g__ = x__ * (1 - w__) + y__ * w__;\
\
w__ = (double)i__ * bn__ / rn__;\
j__ = (size_t)w__;\
jj__ = j__ == bn__ ? j__ : (j__ + 1);\
w__ = fmod(j__, (double)1);\
x__ = (clut)->blue[j__] / m__;\
y__ = (clut)->blue[jj__] / m__;\
x__ = libclut_model_standard_to_linear1(x__);\
y__ = libclut_model_standard_to_linear1(y__);\
b__ = x__ * (1 - w__) + y__ * w__;\
\
r__ = (M)[0][0] * r__ + (M)[0][1] * g__ + (M)[0][2] * b__;\
r__ = libclut_model_linear_to_standard1(r__);\
r__ *= m__;\
if (trunc) {\
if (r__ < 0)\
r__ = 0;\
else if (r__ > m__)\
r__ = m__;\
}\
(out)->red[i__] = (type)r__;\
}\
for (i__ = 0; i__ < gn__; i__++) {\
w__ = (double)i__ * rn__ / gn__;\
j__ = (size_t)w__;\
jj__ = j__ == rn__ ? j__ : (j__ + 1);\
w__ = fmod(j__, (double)1);\
x__ = (clut)->red[j__] / m__;\
y__ = (clut)->red[jj__] / m__;\
x__ = libclut_model_standard_to_linear1(x__);\
y__ = libclut_model_standard_to_linear1(y__);\
r__ = x__ * (1 - w__) + y__ * w__;\
\
w__ = (double)i__ * bn__ / gn__;\
j__ = (size_t)w__;\
jj__ = j__ == bn__ ? j__ : (j__ + 1);\
w__ = fmod(j__, (double)1);\
x__ = (clut)->blue[j__] / m__;\
y__ = (clut)->blue[jj__] / m__;\
x__ = libclut_model_standard_to_linear1(x__);\
y__ = libclut_model_standard_to_linear1(y__);\
b__ = x__ * (1 - w__) + y__ * w__;\
\
g__ = (M)[1][0] * r__ + (M)[0][1] * g__ + (M)[1][2] * b__;\
g__ = libclut_model_linear_to_standard1(g__);\
g__ *= m__;\
if (trunc) {\
if (g__ < 0)\
g__ = 0;\
else if (g__ > m__)\
g__ = m__;\
}\
(out)->green[i__] = (type)g__;\
}\
for (i__ = 0; i__ < bn__; i__++) {\
w__ = (double)i__ * rn__ / bn__;\
j__ = (size_t)w__;\
jj__ = j__ == rn__ ? j__ : (j__ + 1);\
w__ = fmod(j__, (double)1);\
x__ = (clut)->red[j__] / m__;\
y__ = (clut)->red[jj__] / m__;\
x__ = libclut_model_standard_to_linear1(x__);\
y__ = libclut_model_standard_to_linear1(y__);\
r__ = x__ * (1 - w__) + y__ * w__;\
\
w__ = (double)i__ * gn__ / bn__;\
j__ = (size_t)w__;\
jj__ = j__ == gn__ ? j__ : (j__ + 1);\
w__ = fmod(j__, (double)1);\
x__ = (clut)->green[j__] / m__;\
y__ = (clut)->green[jj__] / m__;\
x__ = libclut_model_standard_to_linear1(x__);\
y__ = libclut_model_standard_to_linear1(y__);\
g__ = x__ * (1 - w__) + y__ * w__;\
\
b__ = (M)[2][0] * r__ + (M)[2][1] * g__ + (M)[2][2] * b__;\
b__ = libclut_model_linear_to_standard1(b__);\
b__ *= m__;\
if (trunc) {\
if (b__ < 0)\
b__ = 0;\
else if (b__ > m__)\
b__ = m__;\
}\
(out)->blue[i__] = (type)b__;\
}\
} while (0)
/**
* Apply gamma correction on the colour curves
*
* None of the parameter may have side-effects
*
* Requires linking with '-lm'
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r The gamma parameter the red colour curve
* @param g The gamma parameter the green colour curve
* @param b The gamma parameter the blue colour curve
*/
#define libclut_gamma(clut, max, type, r, g, b)\
do {\
double m__ = (double)(max);\
if (!libclut_1__(r)) libclut__(clut, red, type, m__ * pow(LIBCLUT_VALUE / m__, 1 / (double)(r)));\
if (!libclut_1__(g)) libclut__(clut, green, type, m__ * pow(LIBCLUT_VALUE / m__, 1 / (double)(g)));\
if (!libclut_1__(b)) libclut__(clut, blue, type, m__ * pow(LIBCLUT_VALUE / m__, 1 / (double)(b)));\
} while (0)
/**
* Reverse the colour curves (negative image with gamma preservation)
*
* None of the parameter may have side-effects
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps.
* This parameter is not used, it is just a dummy, to unify
* the API with the other functions
* @param type The data type used for each stop in the ramps
* @param r Whether to invert the red colour curve
* @param g Whether to invert the green colour curve
* @param b Whether to invert the blue colour curve
*/
#define libclut_negative(clut, max, type, r, g, b)\
do {\
size_t i__, n__;\
type t__;\
if (r) {\
for (i__ = 0, n__ = (clut)->red_size; i__ < (n__ >> 1); i__++) {\
t__ = (clut)->red[i__];\
(clut)->red[i__] = (clut)->red[n__ - i__ - 1];\
(clut)->red[n__ - i__ - 1] = t__;\
}\
}\
if (g) {\
for (i__ = 0, n__ = (clut)->green_size; i__ < (n__ >> 1); i__++) {\
t__ = (clut)->green[i__];\
(clut)->green[i__] = (clut)->green[n__ - i__ - 1];\
(clut)->green[n__ - i__ - 1] = t__;\
}\
}\
if (b) {\
for (i__ = 0, n__ = (clut)->blue_size; i__ < (n__ >> 1); i__++) {\
t__ = (clut)->blue[i__];\
(clut)->blue[i__] = (clut)->blue[n__ - i__ - 1];\
(clut)->blue[n__ - i__ - 1] = t__;\
}\
}\
} while (0)
/**
* Invert the colour curves (negative image with gamma invertion), using sRGB
*
* None of the parameter may have side-effects
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r Whether to invert the red colour curve
* @param g Whether to invert the green colour curve
* @param b Whether to invert the blue colour curve
*/
#define libclut_rgb_invert(clut, max, type, r, g, b)\
do {\
if (r) libclut__(clut, red, type, (max) - LIBCLUT_VALUE);\
if (g) libclut__(clut, green, type, (max) - LIBCLUT_VALUE);\
if (b) libclut__(clut, blue, type, (max) - LIBCLUT_VALUE);\
} while (0)
/**
* Invert the colour curves (negative image with gamma invertion), using CIE xyY
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut'
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r Whether to invert the red colour curve
* @param g Whether to invert the green colour curve
* @param b Whether to invert the blue colour curve
*/
#define libclut_cie_invert(clut, max, type, r, g, b)\
libclut_cie__(clut, max, type, (r) && (g) && (b), r, g, b, 1 - Y__, 1 - Y__, 1 - Y__)
/**
* Apply S-curve correction on the colour curves.
* This is intended for fine tuning LCD monitors,
* 4.5 is good value start start testing at.
* You would probably like to use rgb_limits before
* this to adjust the blackpoint as that is the
* only way to adjust the blackpoint on many LCD
* monitors.
*
* None of the parameter may have side-effects
*
* Requires linking with '-lm'
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param rp Pointer to the sigmoid parameter for the red curve. `NULL` for no adjustment
* @param gp Pointer to the sigmoid parameter for the green curve. `NULL` for no adjustment
* @param bp Pointer to the sigmoid parameter for the blue curve. `NULL` for no adjustment
*/
#define libclut_sigmoid(clut, max, type, rp, gp, bp)\
do {\
double *gcc_6_1_1_workaround, m__ = (double)(max);\
const double h__ = (double)5 / 10;\
gcc_6_1_1_workaround = rp;\
if (gcc_6_1_1_workaround)\
libclut_sigmoid__(clut, max, type, red);\
gcc_6_1_1_workaround = gp;\
if (gcc_6_1_1_workaround)\
libclut_sigmoid__(clut, max, type, green);\
gcc_6_1_1_workaround = bp;\
if (gcc_6_1_1_workaround)\
libclut_sigmoid__(clut, max, type, blue);\
}\
while (0)
/**
* Apply S-curve correction on the colour curves.
* This is intended for fine tuning LCD monitors,
* 4.5 is good value start start testing at.
* You would probably like to use rgb_limits before
* this to adjust the blackpoint as that is the
* only way to adjust the blackpoint on many LCD
* monitors.
*
* None of the parameter may have side-effects
*
* Requires linking with '-lm'
*
* Intended for internal use
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param channel The channel, must be either "red", "green", or "blue"
*/
#define libclut_sigmoid__(clut, max, type, channel)\
do {\
double s__ = *gcc_6_1_1_workaround, l__;\
size_t i__;\
for (i__ = 0; i__ < (clut)->channel##_size; i__++) {\
l__ = log(m__ / (clut)->channel[i__] - 1);\
if (isnan(l__) || isinf(l__))\
l__ = 37.024483 * (isinf(l__) > 0 ? +1 : -1);\
(clut)->channel[i__] = (type)(m__ * (h__ - l__ / s__));\
}\
} while (0)
/**
* Changes the blackpoint and the whitepoint, using sRGB
*
* None of the parameter may have side-effects
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param rmin The red component value of the blackpoint
* @param rmax The red component value of the whitepoint
* @param gmin The green component value of the blackpoint
* @param gmax The green component value of the whitepoint
* @param bmin The blue component value of the blackpoint
* @param bmax The blue component value of the whitepoint
*/
#define libclut_rgb_limits(clut, max, type, rmin, rmax, gmin, gmax, bmin, bmax)\
do {\
double diff__;\
if (!libclut_0__(rmin) || !libclut_1__(rmax)) {\
diff__ = (double)(rmax) - (double)(rmin);\
libclut__(clut, red, type, LIBCLUT_VALUE / (double)(max) * diff__ + (rmin));\
}\
if (!libclut_0__(gmin) || !libclut_1__(gmax)) {\
diff__ = (double)(gmax) - (double)(gmin);\
libclut__(clut, green, type, LIBCLUT_VALUE / (double)(max) * diff__ + (gmin));\
}\
if (!libclut_0__(bmin) || !libclut_1__(bmax)) {\
diff__ = (double)(bmax) - (double)(bmin);\
libclut__(clut, blue, type, LIBCLUT_VALUE / (double)(max) * diff__ + (bmin));\
}\
} while (0)
/**
* Changes the blackpoint and the whitepoint, using CIE xyY
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut'
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param rmin The red component value of the blackpoint
* @param rmax The red component value of the whitepoint
* @param gmin The green component value of the blackpoint
* @param gmax The green component value of the whitepoint
* @param bmin The blue component value of the blackpoint
* @param bmax The blue component value of the whitepoint
*/
#define libclut_cie_limits(clut, max, type, rmin, rmax, gmin, gmax, bmin, bmax)\
do {\
double rd__ = (rmax) - (rmin), gd__ = (gmax) - (gmin), bd__ = (bmax) - (bmin);\
libclut_cie__(clut, max, type,\
libclut_eq__((rmin), (gmin)) && libclut_eq__((gmin), (bmin)) &&\
libclut_eq__((rmax), (gmax)) && libclut_eq__((gmax), (bmax)),\
!libclut_0__(rmin) || !libclut_1__(rmax),\
!libclut_0__(gmin) || !libclut_1__(gmax),\
!libclut_0__(bmin) || !libclut_1__(bmax),\
Y__ * rd__ + (rmin), Y__ * gd__ + (gmin), Y__ * bd__ + (bmin));\
} while (0)
/**
* Manipulate the colour curves using a function on the sRGB colour space
*
* None of the parameter may have side-effects
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r Function to manipulate the red colour curve, should either
* be `NULL` or map a [0, 1] `double` to a [0, 1] `double`
* @param g Function to manipulate the green colour curve, should either
* be `NULL` or map a [0, 1] `double` to a [0, 1] `double`
* @param b Function to manipulate the blue colour curve, should either
* be `NULL` or map a [0, 1] `double` to a [0, 1] `double`
*/
#define libclut_manipulate(clut, max, type, r, g, b)\
do {\
double m__ = (double)(max);\
double (*gcc_6_1_1_workaround__)(double);\
gcc_6_1_1_workaround__ = r;\
if (gcc_6_1_1_workaround__)\
libclut__(clut, red, type, m__ * (gcc_6_1_1_workaround__)(LIBCLUT_VALUE / m__));\
gcc_6_1_1_workaround__ = g;\
if (gcc_6_1_1_workaround__)\
libclut__(clut, green, type, m__ * (gcc_6_1_1_workaround__)(LIBCLUT_VALUE / m__));\
gcc_6_1_1_workaround__ = b;\
if (gcc_6_1_1_workaround__)\
libclut__(clut, blue, type, m__ * (gcc_6_1_1_workaround__)(LIBCLUT_VALUE / m__));\
} while (0)
/**
* Manipulate the colour curves using a function on the CIE xyY colour space
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut'
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r Function to manipulate the red colour curve, should either
* be `NULL` or map a [0, 1] `double` to a [0, 1] `double`
* @param g Function to manipulate the green colour curve, should either
* be `NULL` or map a [0, 1] `double` to a [0, 1] `double`
* @param b Function to manipulate the blue colour curve, should either
* be `NULL` or map a [0, 1] `double` to a [0, 1] `double`
*/
#define libclut_cie_manipulate(clut, max, type, r, g, b)\
libclut_cie__(clut, max, type, (r) && (g) && (b), r, g, b, (r)(Y__), (g)(Y__), (b)(Y__))
/**
* Resets colour curvers to linear mappings
* (Identity mapping if imaginged to map from [0, 1] to [0, 1])
*
* None of the parameter may have side-effects
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r Whether to reset the red colour curve
* @param g Whether to reset the green colour curve
* @param b Whether to reset the blue colour curve
*/
#define libclut_start_over(clut, max, type, r, g, b)\
do {\
size_t i__;\
double m__, max__ = (double)(max);\
if (r) {\
m__ = (double)((clut)->red_size - 1);\
for (i__ = 0; i__ < (clut)->red_size; i__++)\
(clut)->red[i__] = (type)(((double)i__ / m__) * max__);\
}\
if (g) {\
m__ = (double)((clut)->green_size - 1);\
for (i__ = 0; i__ < (clut)->green_size; i__++)\
(clut)->green[i__] = (type)(((double)i__ / m__) * max__);\
}\
if (b) {\
m__ = (double)((clut)->blue_size - 1);\
for (i__ = 0; i__ < (clut)->blue_size; i__++)\
(clut)->blue[i__] = (type)(((double)i__ / m__) * max__);\
}\
} while (0)
/**
* Clip colour curves to only map to values between the minimum and maximum.
* This should be done, before apply the curves, and before applying changes
* with limited domain.
*
* Values below 0 are set to 0, and values above `max` are set to `max`
*
* None of the parameter may have side-effects
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param r Whether to clip the red colour curve
* @param g Whether to clip the green colour curve
* @param b Whether to clip the blue colour curve
*/
#define libclut_clip(clut, max, type, r, g, b)\
do {\
if (r) libclut__(clut, red, type, libclut_clip__(0, LIBCLUT_VALUE, max));\
if (g) libclut__(clut, green, type, libclut_clip__(0, LIBCLUT_VALUE, max));\
if (b) libclut__(clut, blue, type, libclut_clip__(0, LIBCLUT_VALUE, max));\
} while (0)
/**
* Truncates a value to fit a boundary
*
* None of the parameter may have side-effects
*
* Intended for internal use
*
* @param min The minimum allowed value
* @param val The current value
* @param max The maximum allowed value
* @return The value truncated into its boundary
*/
#define libclut_clip__(min, val, max)\
(LIBCLUT_VALUE < (min) ? (min) : LIBCLUT_VALUE > (max) ? (max) : LIBCLUT_VALUE)
/**
* Emulates low colour resolution
*
* None of the parameter may have side-effects
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param rx The desired emulated red encoding resolution, 0 for unchanged
* @param ry The desired emulated red output resolution, 0 for unchanged
* @param gx The desired emulated green encoding resolution, 0 for unchanged
* @param gy The desired emulated green output resolution, 0 for unchanged
* @param bx The desired emulated blue encoding resolution, 0 for unchanged
* @param by The desired emulated blue output resolution, 0 for unchanged
*/
#define libclut_lower_resolution(clut, max, type, rx, ry, gx, gy, bx, by)\
do {\
libclut_lower_resolution__(clut, red, max, type, rx, ry);\
libclut_lower_resolution__(clut, green, max, type, gx, gy);\
libclut_lower_resolution__(clut, blue, max, type, bx, by);\
} while (0)
/**
* Emulates low colour resolution of a channel
*
* None of the parameter may have side-effects
*
* Intended for internal use
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param channel The channel, must be either "red", "green", or "blue"
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param x The desired emulated encoding resolution, 0 for unchanged
* @param y The desired emulated output resolution, 0 for unchanged
*/
#define libclut_lower_resolution__(clut, channel, max, type, x, y)\
do {\
if ((x) || (y)) {\
size_t x__, y__, i__, n__ = (clut)->channel##_size;\
double xm__ = (double)((x) - 1), ym__ = (double)((y) - 1);\
double m__ = (double)(max), nm__ = (double)(n__ - 1);\
type c__[n__]; /* Do not use alloca! */\
const double h__ = (double)5 / 10;\
for (i__ = 0; i__ < n__; i__++) {\
if ((x__ = i__), (x)) {\
x__ = (size_t)((double)i__ * (double)(x) / (double)n__);\
x__ = (size_t)((double)x__ * nm__ / xm__);\
}\
if (!(y)) {\
c__[i__] = (clut)->channel[x__];\
} else {\
y__ = (size_t)((double)((clut)->channel[x__]) / (max) * ym__ + h__);\
c__[i__] = (type)((double)y__ / ym__ * m__);\
}\
}\
memcpy((clut)->channel, c__, n__ * sizeof(type));\
}\
} while (0)
/**
* Translates a gamma ramp structure to another gamma ramp structure type
*
* None of the parameter may have side-effects
*
* @param dclut Pointer to the desired gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars `red_size`,
* `green_size`, and `blue_size`. Ramp structures from
* libgamma or libcoopgamma can be used.
* @param dmax The maximum value on each stop in the ramps in `dclut`
* @param dtype The data type used for each stop in the ramps in `dclut`
* @param sclut Pointer to the set gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars `red_size`,
* `green_size`, and `blue_size`. Ramp structures from
* libgamma or libcoopgamma can be used
* @param smax The maximum value on each stop in the ramps in `sclut`
* @param stype The data type used for each stop in the ramps in `sclut`
* (Not actually used)
*/
#define libclut_translate(dclut, dmax, dtype, sclut, smax, stype)\
do {\
libclut_translate__(dclut, dmax, dtype, sclut, smax, stype, red);\
libclut_translate__(dclut, dmax, dtype, sclut, smax, stype, green);\
libclut_translate__(dclut, dmax, dtype, sclut, smax, stype, blue);\
} while (0)
/**
* Translates a gamma ramp structure to another gamma ramp structure type
*
* None of the parameter may have side-effects
*
* This is intended for internal use
*
* @param dclut Pointer to the desired gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars `red_size`,
* `green_size`, and `blue_size`. Ramp structures from
* libgamma or libcoopgamma can be used.
* @param dmax The maximum value on each stop in the ramps in `dclut`
* @param dtype The data type used for each stop in the ramps in `dclut`
* @param sclut Pointer to the set gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars `red_size`,
* `green_size`, and `blue_size`. Ramp structures from
* libgamma or libcoopgamma can be used.
* @param smax The maximum value on each stop in the ramps in `sclut`
* @param stype The data type used for each stop in the ramps in `sclut`.
* (Not actually used)
* @param channel The channel, must be either "red", "green", or "blue"
*/
#define libclut_translate__(dclut, dmax, dtype, sclut, smax, stype, channel)\
do {\
size_t di__, si__, sj__;\
size_t dn__ = (dclut)->channel##_size;\
size_t sn__ = (sclut)->channel##_size;\
double dm__ = (double)(dmax);\
double sm__ = (double)(smax);\
double dmsm__ = dm__ / sm__;\
double x__, y__;\
if (dn__ == sn__) {\
for (di__ = 0; di__ < dn__; di__++) {\
y__ = (double)((sclut)->channel[di__]) * dmsm__;\
(dclut)->channel[di__] = (dtype)y__;\
}\
} else {\
for (di__ = 0; di__ < dn__; di__++) {\
x__ = di__ / (dn__ - 1) * (sn__ - 1);\
si__ = (size_t)(x__);\
sj__ = si__ + (si__ != sn__);\
x__ -= (double)si__;\
y__ = (double)((sclut)->channel[si__]) * (1 - x__);\
y__ += (double)((sclut)->channel[sj__]) * (x__);\
y__ *= dmsm__;\
(dclut)->channel[di__] = (dtype)y__;\
}\
}\
} while (0)
/**
* Applies a filter or calibration
*
* None of the parameter may have side-effects
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param filter Same as `clut`, but for the filter to apply
* @param fmax Same as `max`, but for the filter to apply
* @param ftype Same as `type`, but for the filter to apply (Not actually used)
* @param r Whether to apply the filter for the red curve
* @param g Whether to apply the filter for the green curve
* @param b Whether to apply the filter for the blue curve
*/
#define libclut_apply(clut, max, type, filter, fmax, ftype, r, g, b)\
do {\
if (r) libclut_apply__(clut, max, type, filter, fmax, ftype, red);\
if (g) libclut_apply__(clut, max, type, filter, fmax, ftype, green);\
if (b) libclut_apply__(clut, max, type, filter, fmax, ftype, blue);\
} while (0)
/**
* Applies a filter or calibration for one channel
*
* None of the parameter may have side-effects
*
* Intended for internal use
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param filter Same as `clut`, but for the filter to apply
* @param fmax Same as `max`, but for the filter to apply
* @param ftype Same as `type`, but for the filter to apply (Not actually used)
* @param channel The channel, must be either "red", "green", or "blue"
*/
#define libclut_apply__(clut, max, type, filter, fmax, ftype, channel)\
do {\
size_t i__, rn__ = (clut)->channel##_size, fn__ = (filter)->channel##_size - 1;\
double x__, rm__ = (double)(max), m__ = (double)(max) / (double)(fmax);\
for (i__ = 0; i__ < rn__; i__++) {\
x__ = (double)((clut)->channel[i__]) / rm__ * (double)fn__;\
(clut)->channel[i__] = (type)((double)((filter)->channel[(size_t)x__]) * m__);\
}\
} while (0)
/**
* Applies a filter or calibration, using CIE xyY
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut'
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param filter Same as `clut`, but for the filter to apply
* @param fmax Same as `max`, but for the filter to apply
* @param ftype Same as `type`, but for the filter to apply (Not actually used)
* @param r Whether to apply the filter for the red curve
* @param g Whether to apply the filter for the green curve
* @param b Whether to apply the filter for the blue curve
*/
#define libclut_cie_apply(clut, max, type, filter, fmax, ftype, r, g, b)\
do {\
size_t rfn__ = (filter)->red_size - 1, gfn__ = (filter)->green_size - 1;\
size_t bfn__ = (filter)->blue_size - 1, x__;\
size_t rm__ = (double)(max), fm__ = (double)(fmax);\
libclut_cie__(clut, max, type, 0, r, g, b,\
(x__ = (size_t)(Y__ / rm__ * rfn__), (double)((filter)->red[x__]) / fm__),\
(x__ = (size_t)(Y__ / rm__ * gfn__), (double)((filter)->green[x__]) / fm__),\
(x__ = (size_t)(Y__ / rm__ * bfn__), (double)((filter)->blue[x__]) / fm__));\
} while (0)
/**
* Modify a ramp
*
* None of the parameter may have side-effects
*
* This is intended for internal use
*
* @param clut Pointer to the gamma ramps, must have and array
* named `channel` and a scalar named `channel` followed
* by "_size"
* @param channel The channel, must be either "red", "green", or "blue"
* @param type The data type used for each stop in the ramps
* @param expr Expression that evalutes the value a stop should have.
* It can use the variable `LIBCLUT_VALUE` to get the
* current value of the stop.
*/
#define libclut__(clut, channel, type, expr)\
do {\
size_t i__, n__ = (clut)->channel##_size;\
type LIBCLUT_VALUE;\
for (i__ = 0; i__ < n__; i__++) {\
LIBCLUT_VALUE = (clut)->channel[i__];\
(clut)->channel[i__] = (type)(expr);\
}\
} while (0)
/**
* Modify a ramp set in CIE xyY
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut'
*
* This is intended for internal use
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param utest Whether all channels can be modified at the same time
* This test does not have to include the ramp size
* @param rtest Whether the red channel have to be modified
* @param gtest Whether the green channel have to be modified
* @param btest Whether the blue channel have to be modified
* @param rexpr Expression calculating the intensity of the red channel.
* The current value is stored in `Y__`.
* @param gexpr Expression calculating the intensity of the green channel.
* The current value is stored in `Y__`.
* @param bexpr Expression calculating the intensity of the blue channel.
* The current value is stored in `Y__`.
*/
#define libclut_cie__(clut, max, type, utest, rtest, gtest, btest, rexpr, gexpr, bexpr)\
do {\
size_t rn__ = (clut)->red_size;\
size_t gn__ = (clut)->green_size;\
size_t bn__ = (clut)->blue_size;\
size_t i__;\
double x__, y__, Y__, r__, g__, b__;\
double m__ = (double)(max);\
type* rs__ = (clut)->red;\
type* gs__ = (clut)->green;\
type* bs__ = (clut)->blue;\
if ((rn__ == gn__) && (gn__ == bn__) && (utest)) {\
if (!(rtest))\
break;\
for (i__ = 0; i__ < rn__; i__++) {\
libclut_model_srgb_to_ciexyy(rs__[i__] / m__, gs__[i__] / m__,\
bs__[i__] / m__, &x__, &y__, &Y__);\
libclut_model_ciexyy_to_srgb(x__, y__, rexpr, &r__, &g__, &b__);\
rs__[i__] = (type)(r__ * m__);\
gs__[i__] = (type)(g__ * m__);\
bs__[i__] = (type)(b__ * m__);\
}\
} else if ((rn__ == gn__) && (gn__ == bn__)) {\
if (!(rtest) && !(gtest) && !(btest))\
break;\
for (i__ = 0; i__ < rn__; i__++) {\
libclut_model_srgb_to_ciexyy(rs__[i__] / m__, gs__[i__] / m__,\
bs__[i__] / m__, &x__, &y__, &Y__);\
if (rtest) {\
libclut_model_ciexyy_to_srgb(x__, y__, rexpr, &r__, &g__, &b__);\
rs__[i__] = (type)(r__ * m__);\
}\
if (gtest) {\
libclut_model_ciexyy_to_srgb(x__, y__, gexpr, &r__, &g__, &b__);\
gs__[i__] = (type)(g__ * m__);\
}\
if (btest) {\
libclut_model_ciexyy_to_srgb(x__, y__, bexpr, &r__, &g__, &b__);\
bs__[i__] = (type)(b__ * m__);\
}\
}\
} else {\
if (rtest) {\
for (i__ = 0; i__ < rn__; i__++) {\
libclut_cie___(clut, max, type, r, rexpr, i__,\
libclut_i__(i__, rn__, gn__),\
libclut_i__(i__, rn__, bn__));\
}\
}\
if (gtest) {\
for (i__ = 0; i__ < rn__; i__++) {\
libclut_cie___(clut, max, type, g, gexpr,\
libclut_i__(i__, gn__, rn__), i__,\
libclut_i__(i__, gn__, bn__));\
}\
}\
if (btest) {\
for (i__ = 0; i__ < rn__; i__++) {\
libclut_cie___(clut, max, type, b, bexpr,\
libclut_i__(i__, bn__, rn__),\
libclut_i__(i__, bn__, gn__), i__);\
}\
}\
}\
} while (0)
/**
* Modify a ramp stop in CIE xyY
*
* None of the parameter may have side-effects
*
* Requires linking with '-lclut'
*
* This is intended for internal use.
* Assumes the existence of variables defined in `libclut_cie__`.
*
* @param clut Pointer to the gamma ramps, must have the arrays
* `red`, `green`, and `blue`, and the scalars
* `red_size`, `green_size`, and `blue_size`. Ramp
* structures from libgamma or libcoopgamma can be used.
* @param max The maximum value on each stop in the ramps
* @param type The data type used for each stop in the ramps
* @param c Either "r" for red, "g" for green, or "b" for blue
* @param expr Expression calculating the intensity of the channel
* @param ri The index of the stop translated to the red channel
* @param gi The index of the stop translated to the green channel
* @param bi The index of the stop translated to the blue channel
*/
#define libclut_cie___(clut, max, type, c, expr, ri, gi, bi)\
do {\
for (i__ = 0; i__ < c##n__; i__++) {\
libclut_model_srgb_to_ciexyy(rs__[(ri)] / m__, gs__[(gi)] / m__,\
bs__[(bi)] / m__, &x__, &y__, &Y__);\
libclut_model_ciexyy_to_srgb(x__, y__, expr, &r__, &g__, &b__);\
c##s__[i__] = (type)(c##__ * m__);\
}\
} while (0)
/**
* Translate an index from one channel to another
*
* @param i The index in the input channel
* @param in The size of the input channel
* @param out The size of the output channel
* @return The index in the output channel
*/
#define libclut_i__(i, in, out)\
(size_t)((double)(i) * (double)(out) / (double)(in))
#if defined(__GNUC__) && !defined(__clang__)
# define LIBCLUT_GCC_ONLY__(x) x
#else
# define LIBCLUT_GCC_ONLY__(x) /* do nothing */
#endif
/**
* Convert one component from [0, 1] linear sRGB to [0, 1] sRGB
*
* If the macro variant is used, the argument must not have
* any side-effects. The macro variant requires linking with
* '-lm'
*
* @param c The linear sRGB value
* @return Corresponding sRGB value
*/
LIBCLUT_GCC_ONLY__(__attribute__((__const__, __leaf__)))
double (libclut_model_linear_to_standard1)(double);
#define libclut_model_linear_to_standard1(c)\
(((double)(c) <= 0.0031308) ? (12.92 * (double)(c)) : ((1.055) * pow((double)(c), 1 / 2.4) - 0.055))
/**
* Convert [0, 1] linear sRGB to [0, 1] sRGB
*
* The macro variant requires linking with '-lm',
* if the 'libclut_model_linear_to_standard1' is defined,
* otherwise it requires linking with '-lclut'
*
* @param r Pointer to the linear red component,
* and output parameter for the red component
* @param g Pointer to the linear green component,
* and output parameter for the green component
* @param b Pointer to the linear blue component,
* and output parameter for the blue component
*/
void (libclut_model_linear_to_standard)(double *, double *, double *);
#define libclut_model_linear_to_standard(r, g, b)\
do {\
double *r__ = (r), *g__ = (g), *b__ = (b);\
*r__ = libclut_model_linear_to_standard1(*r__);\
*g__ = libclut_model_linear_to_standard1(*g__);\
*b__ = libclut_model_linear_to_standard1(*b__);\
} while (0)
/**
* Convert one component from [0, 1] sRGB to [0, 1] linear sRGB
*
* If the macro variant is used, the argument must not have
* any side-effects. The macro variant requires linking with
* '-lm'
*
* @param c The sRGB value
* @return Corresponding linear sRGB value
*/
LIBCLUT_GCC_ONLY__(__attribute__((__const__, __leaf__)))
double (libclut_model_standard_to_linear1)(double);
#define libclut_model_standard_to_linear1(c) \
(((double)(c) <= 0.04045) ? ((double)(c) / 12.92) : pow(((double)(c) + 0.055) / 1.055, 2.4))
/**
* Convert [0, 1] sRGB to [0, 1] linear sRGB
*
* The macro variant requires linking with '-lm',
* if the 'libclut_model_standard_to_linear1' is defined,
* otherwise it requires linking with '-lclut'
*
* @param r Pointer to the red component, and output
* parameter for the linear red component
* @param g Pointer to the green component, and output
* parameter for the linear green component
* @param b Pointer to the blue component, and output
* parameter for the linear blue component
*/
void (libclut_model_standard_to_linear)(double *, double *, double *);
#define libclut_model_standard_to_linear(r, g, b)\
do {\
double *r__ = (r), *g__ = (g), *b__ = (b);\
*r__ = libclut_model_standard_to_linear1(*r__);\
*g__ = libclut_model_standard_to_linear1(*g__);\
*b__ = libclut_model_standard_to_linear1(*b__);\
} while (0)
/**
* Convert CIE xyY to CIE XYZ
*
* @param x The x parameter
* @param y The y parameter
* @param Y The Y parameter; this is also the Y (middle) parameter for the CIE XYZ colour
* @param X Output parameter for the X parameter
* @param Z Output parameter for the Z parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_ciexyy_to_ciexyz)(double, double, double, double *, double *);
#define libclut_model_ciexyy_to_ciexyz(x, y, Y, X, Z)\
do {\
double x__ = (x), y__ = (y), Y__ = (Y), *X__ = (X), *Z__ = (Z);\
*X__ = libclut_0__(y__) ? Y__ : (Y__ * x__ / y__);\
*Z__ = libclut_0__(y__) ? Y__ : (Y__ * (1 - x__ - y__) / y__);\
} while (0)
/**
* Convert CIE XYZ to CIE xyY
*
* @param X The X parameter
* @param Y The Y parameter; this is also the Y (last) parameter for the CIE xyY colour
* @param Z The Z parameter
* @param x Output parameter for the x parameter
* @param y Output parameter for the y parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_ciexyz_to_ciexyy)(double, double, double, double *, double *);
#define libclut_model_ciexyz_to_ciexyy(X, Y, Z, x, y)\
do {\
double X__ = (X), Y__ = (Y), Z__ = (Z), *x__ = (x), *y__ = (y);\
double s__ = X__ + Y__ + Z__;\
if (libclut_0__(s__))\
*x__ = *y__ = 0;\
else\
*x__ = X__ / s__, *y__ = Y__ / s__;\
} while (0)
/**
* Convert CIE XYZ to [0, 1] linear sRGB
*
* @param X The X parameter
* @param Y The Y parameter
* @param Z The Z parameter
* @param r Output parameter for the red component
* @param g Output parameter for the green component
* @param b Output parameter for the blue component
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_ciexyz_to_linear)(double, double, double, double *, double *, double *);
#define libclut_model_ciexyz_to_linear(X, Y, Z, r, g, b)\
do {\
double X__ = (X), Y__ = (Y), Z__ = (Z);\
*(r) = ( 3.2404500 * X__) + (-1.537140 * Y__) + (-0.4985320 * Z__);\
*(g) = (-0.9692660 * X__) + ( 1.876010 * Y__) + ( 0.0415561 * Z__);\
*(b) = ( 0.0556434 * X__) + (-0.204026 * Y__) + ( 1.0572300 * Z__);\
} while (0)
/**
* Convert [0, 1] linear sRGB to CIE XYZ
*
* @param r The red component
* @param g The green component
* @param b The blue component
* @param X Output parameter for the X parameter
* @param Y Output parameter for the Y parameter
* @param Z Output parameter for the Z parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_linear_to_ciexyz)(double, double, double, double *, double *, double *);
#define libclut_model_linear_to_ciexyz(r, g, b, X, Y, Z)\
do {\
double r__ = (r), g__ = (g), b__ = (b);\
*(X) = (0.4124564 * r__) + (0.3575761 * g__) + (0.1804375 * b__);\
*(Y) = (0.2126729 * r__) + (0.7151522 * g__) + (0.0721750 * b__);\
*(Z) = (0.0193339 * r__) + (0.1191920 * g__) + (0.9503041 * b__);\
} while (0)
/**
* Convert [0, 1] sRGB to CIE xyY
*
* The macro variant requires linking with '-lclut'
* if any of `libclut_model_ciexyz_to_ciexyy`,
* `libclut_model_linear_to_ciexyz`, and
* `libclut_model_standard_to_linear` are undefined.
* The macro variant requires linking with '-lm' if
* neither `libclut_model_standard_to_linear` nor
* `libclut_model_standard_to_linear1` are undefined.
*
* @param r The red component
* @param g The green component
* @param b The blue component
* @param x Output parameter for the x parameter
* @param y Output parameter for the y parameter
* @param Y Output parameter for the Y parameter
*/
void (libclut_model_srgb_to_ciexyy)(double, double, double, double *, double *, double *);
#define libclut_model_srgb_to_ciexyy(r, g, b, x, y, Y)\
do {\
double r___ = (r), g___ = (g), b___ = (b);\
double *x___ = (x), *y___ = (y), *Y___ = (Y);\
double X___, Z___;\
libclut_model_standard_to_linear(&r___, &g___, &b___);\
libclut_model_linear_to_ciexyz(r___, g___, b___, &X___, Y___, &Z___);\
libclut_model_ciexyz_to_ciexyy(X___, *Y___, Z___, x___, y___);\
} while (0)
/**
* Convert CIE xyY to [0, 1] sRGB
*
* The macro variant requires linking with '-lclut'
* if any of `libclut_model_ciexyy_to_ciexyz`,
* `libclut_model_ciexyz_to_linear`, and
* `libclut_model_linear_to_standard` are undefined.
* The macro variant requires linking with '-lm' if
* neither `libclut_model_linear_to_standard` nor
* `libclut_model_linear_to_standard1` are undefined.
*
* @param x The x parameter
* @param y The y parameter
* @param Y The Y parameter
* @param r Output parameter for the red component
* @param g Output parameter for the green component
* @param b Output parameter for the blue component
*/
void (libclut_model_ciexyy_to_srgb)(double, double, double, double *, double *, double *);
#define libclut_model_ciexyy_to_srgb(x, y, Y, r, g, b)\
do {\
double x___ = (x), y___ = (y), Y___ = (Y);\
double *r___ = (r), *g___ = (g), *b___ = (b);\
double X___, Z___;\
libclut_model_ciexyy_to_ciexyz(x___, y___, Y___, &X___, &Z___);\
libclut_model_ciexyz_to_linear(X___, Y___, Z___, r___, g___, b___);\
libclut_model_linear_to_standard(r___, g___, b___);\
} while(0)
/**
* Convert from CIE XYZ to CIE L*a*b*
*
* The macro variant requires linking with '-lm'
*
* @param X The X parameter
* @param Y The Y parameter
* @param Z The Z parameter
* @param L Output parameter for the L* component
* @param a Output parameter for the a* component
* @param b Output parameter for the b* component
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_ciexyz_to_cielab)(double, double, double, double *, double *, double *);
#define libclut_model_ciexyz_to_cielab(X, Y, Z, L, a, b)\
do {\
double X__ = (X), Y__ = (Y), Z__ = (Z);\
X__ /= 0.95047, Z__ /= 1.08883;\
X__ = LIBCLUT_MODEL_CIEXYZ_TO_CIELAB__(X__);\
Y__ = LIBCLUT_MODEL_CIEXYZ_TO_CIELAB__(Y__);\
Z__ = LIBCLUT_MODEL_CIEXYZ_TO_CIELAB__(Z__);\
*(L) = 116 * Y__ - 16;\
*(a) = 500 * (X__ - Y__);\
*(b) = 200 * (Y__ - Z__);\
} while (0)
#define LIBCLUT_MODEL_CIEXYZ_TO_CIELAB__(C)\
(((C) > 0.00885642) ? pow((C), 1.0 / 3) : ((7.78 + 703.0 / 99900) * (C) + 0.1379310))
/**
* Convert from CIE L*a*b* to CIE XYZ
*
* @param L The L* component
* @param a The a* component
* @param b The b* component
* @param X Output parameter for the X parameter
* @param Y Output parameter for the Y parameter
* @param Z Output parameter for the Z parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_cielab_to_ciexyz)(double, double, double, double *, double *, double *);
#define libclut_model_cielab_to_ciexyz(L, a, b, X, Y, Z)\
do {\
double L__ = (L), a__ = (a), b__ = (b);\
double *X__ = (X), *Y__ = (Y), *Z__ = (Z);\
*Y__ = (L__ + 16) / 116;\
*X__ = a__ / 500 + *Y__;\
*Z__ = *Y__ - b__ / 200;\
*X__ = LIBCLUT_MODEL_CIELAB_TO_CIEXYZ__(*X__) * 0.95047;\
*Y__ = LIBCLUT_MODEL_CIELAB_TO_CIEXYZ__(*Y__) * 1.08883;\
*Z__ = LIBCLUT_MODEL_CIELAB_TO_CIEXYZ__(*Z__);\
} while (0)
#define LIBCLUT_MODEL_CIELAB_TO_CIEXYZ__(C)\
(((C)*(C)*(C) > 0.00885642) ? ((C)*(C)*(C)) : (((C) - 0.1379310) / (7.78 + 703.0 / 99900)))
/**
* Convert from CIE XYZ to CIELUV
*
* Requires linking with `-lm`
*
* @param X The X component
* @param Y The Y component
* @param Z The Z component
* @param Xn The X component of the specified white object (white point)
* @param Yn The Y component of the specified white object (white point)
* @param Zn The Z component of the specified white object (white point)
* @param L Output parameter for the L* parameter
* @param u Output parameter for the u* parameter
* @param v Output parameter for the v* parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_ciexyz_to_cieluv)(double, double, double, double, double, double, double *, double *, double *);
#define libclut_model_ciexyz_to_cieluv(X, Y, Z, Xn, Yn, Zn, L, u, v)\
do {\
double xn__ = (Xn), yn__ = (Yn);\
double t__ = xn__ + 15 * yn__ + 3 * (Zn);\
double u__ = 4 * xn__ / t__;\
double v__ = 9 * yn__ / t__;\
double x__ = (X), y__ = (Y);\
t__ = x__ + 15 * y__ + 3 * (Z);\
u__ = 4 * x__ / t__ - u__;\
v__ = 9 * y__ / t__ - v__;\
y__ /= yn__;\
if (y__ * 24389 <= (double)216)\
y__ *= 24389, y__ /= 27;\
else\
y__ = cbrt(y__) * 116 - 16;\
*(L) = y__;\
y__ *= 13;\
*(u) = y__ * u__;\
*(v) = y__ * v__;\
} while (0)
/**
* Convert from CIELUV to CIE XYZ
*
* @param L The L* component
* @param u The u* component
* @param v The v* component
* @param Xn The X component of the specified white object (white point)
* @param Yn The Y component of the specified white object (white point)
* @param Zn The Z component of the specified white object (white point)
* @param X Output parameter for the X parameter
* @param Y Output parameter for the Y parameter
* @param Z Output parameter for the Z parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_cieluv_to_ciexyz)(double, double, double, double, double, double, double *, double *, double *);
#define libclut_model_cieluv_to_ciexyz(L, u, v, Xn, Yn, Zn, X, Y, Z)\
do {\
double x__ = (Xn), y__ = (Yn), l__ = (L), l13__ = l__ * 13;\
double t__ = x__ + 15 * y__ + 3 * (Zn);\
double u__ = 4 * x__ / t__;\
double v__ = 9 * y__ / t__;\
u__ = (u) / l13__ + u__;\
v__ = (v) / l13__ + v__;\
if (l__ <= (double)8) {\
y__ *= l__ * 27 / 24389;\
} else {\
l__ += 16, l__ /= 116;\
y__ *= l__ *= l__ * l__;\
}\
*(Y) = y__;\
*(X) = y__ * 9 * u__ / (4 * v__);\
*(Z) = y__ * (12 - 3 * u__ - 20 * v__) / (4 * v__);\
} while (0)
/**
* Convert from CIELCh to CIE L*u*v*
*
* Requires linking with `-lm`
*
* @param C The C*_uv component
* @param h The h_uv component
* @param u Output parameter for the u* parameter
* @param v Output parameter for the v* parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_cielch_to_cieluv)(double, double, double *, double *);
#define libclut_model_cielch_to_cieluv(C, h, u, v)\
do {\
double h__ = (h), C__ = (C);\
*(v) = sin(h__) * C__;\
*(u) = cos(h__) * C__;\
} while (0)
/**
* Convert from CIE L*u*v* to CIELCh
*
* Requires linking with `-lm`
*
* @param u The u* component
* @param v The v* component
* @param C Output parameter for the C*_uv parameter
* @param h Output parameter for the h_uv parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_cieluv_to_cielch)(double, double, double *, double *);
#define libclut_model_cieluv_to_cielch(u, v, C, h)\
do {\
double u__ = (u), v__ = (v);\
*(C) = sqrt(u__ * u__ + v__ * v__);\
*(h) = atan2(v__, u__); \
} while (0)
/**
* Convert from sRGB to YIQ
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_standard_to_linear1` is not undefined
*
* @param r The R component
* @param g The G component
* @param b The B component
* @param y Output parameter for the Y parameter
* @param i Output parameter for the I parameter
* @param q Output parameter for the Q parameter
*/
void (libclut_model_srgb_to_yiq)(double, double, double, double *, double *, double *);
#define libclut_model_srgb_to_yiq(r, g, b, y, i, q)\
do {\
double r__ = libclut_model_standard_to_linear1(r) / 100000000000000000ULL;\
double g__ = libclut_model_standard_to_linear1(g) / 10000000000000000ULL;\
double b__ = libclut_model_standard_to_linear1(b) / 100000000000000000ULL;\
*(y) = r__ * 29893602129377540ULL + g__ * 5870430744511212ULL + b__ * 11402090425510336ULL;\
*(i) = r__ * 59594574307079930ULL - g__ * 2743886357457892ULL - b__ * 32155710732501010ULL;\
*(q) = r__ * 21149734030682846ULL - g__ * 5229106903029739ULL + b__ * 31141334999614540ULL;\
} while (0)
/**
* Convert from YIQ to sRGB
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_linear_to_standard1` is not undefined
*
* @param y The Y component
* @param i The I component
* @param q The Q component
* @param r Output parameter for the R parameter
* @param g Output parameter for the G parameter
* @param b Output parameter for the B parameter
*/
void (libclut_model_yiq_to_srgb)(double, double, double, double *, double *, double *);
#define libclut_model_yiq_to_srgb(y, i, q, r, g, b)\
do {\
double y__ = (y), i__ = (i), q__ = (q), r__, g__, b__;\
r__ = y__ + i__ * 956 / 1000 + q__ * 621 / 1000;\
g__ = y__ - i__ * 272 / 1000 - q__ * 647 / 1000;\
b__ = y__ - i__ * 1106 / 1000 + q__ * 1703 / 1000;\
*(r) = libclut_model_linear_to_standard1(r__);\
*(g) = libclut_model_linear_to_standard1(g__);\
*(b) = libclut_model_linear_to_standard1(b__);\
} while (0)
/**
* Convert from sRGB to YDbDr
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_standard_to_linear1` is not undefined
*
* @param r The R component
* @param g The G component
* @param b The B component
* @param y Output parameter for the Y parameter
* @param db Output parameter for the Db parameter
* @param dr Output parameter for the Dr parameter
*/
void (libclut_model_srgb_to_ydbdr)(double, double, double, double *, double *, double *);
#define libclut_model_srgb_to_ydbdr(r, g, b, y, db, dr)\
do {\
double r__ = libclut_model_standard_to_linear1(r);\
double g__ = libclut_model_standard_to_linear1(g);\
double b__ = libclut_model_standard_to_linear1(b);\
*(y) = r__ * 299 / 1000 + g__ * 587 / 1000 + b__ * 114 / 1000;\
*(db) = -r__ * 450 / 1000 - g__ * 883 / 1000 + b__ * 1333 / 1000;\
*(dr) = -r__ * 1333 / 1000 + g__ * 1116 / 1000 + b__ * 217 / 1000;\
} while (0)
/**
* Convert from YDbDr to sRGB
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_linear_to_standard1` is not undefined
*
* @param y The Y component
* @param db The Db component
* @param dr The Dr component
* @param r Output parameter for the R parameter
* @param g Output parameter for the G parameter
* @param b Output parameter for the B parameter
*/
void (libclut_model_ydbdr_to_srgb)(double, double, double, double *, double *, double *);
#define libclut_model_ydbdr_to_srgb(y, db, dr, r, g, b)\
do {\
double y__ = (y), db__ = (db), dr__ = (dr), r__, g__, b__;\
db__ /= 1000000000000000ULL;\
dr__ /= 1000000000000000ULL;\
r__ = y__ + db__ * 92303716148ULL - dr__ * 525912630661865ULL;\
g__ = y__ - db__ * 129132898890509ULL + dr__ * 267899328207599ULL;\
b__ = y__ + db__ * 664679059978955ULL - dr__ * 79202543533ULL;\
*(r) = libclut_model_linear_to_standard1(r__);\
*(g) = libclut_model_linear_to_standard1(g__);\
*(b) = libclut_model_linear_to_standard1(b__);\
} while (0)
/**
* Convert from YUV to YDbDr
*
* @param u The U component
* @param v The V component
* @param db Output parameter for the Db parameter
* @param dr Output parameter for the Dr parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_yuv_to_ydbdr)(double, double, double *, double *);
#define libclut_model_yuv_to_ydbdr(u, v, db, dr)\
do {\
*(db) = 3069 * (u) / 1000;\
*(dr) = -2169 * (v) / 1000;\
} while (0)
/**
* Convert from YDbDr to YUV
*
* @param db The Db component
* @param dr The Dr component
* @param u Output parameter for the U parameter
* @param v Output parameter for the V parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_ydbdr_to_yuv)(double, double, double *, double *);
#define libclut_model_ydbdr_to_yuv(db, dr, u, v)\
do {\
*(u) = (db) * 1000 / 3069;\
*(v) = (dr) * 1000 / -2169;\
} while (0)
/**
* Convert from sRGB to YPbPr
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_standard_to_linear1` is not undefined
*
* @param r The R component
* @param g The G component
* @param b The B component
* @param y Output parameter for the Y parameter
* @param pb Output parameter for the Pb parameter
* @param pr Output parameter for the Pr parameter
*/
void (libclut_model_srgb_to_ypbpr)(double, double, double, double *, double *, double *);
#define libclut_model_srgb_to_ypbpr(r, g, b, y, pb, pr)\
do {\
double r__ = libclut_model_standard_to_linear1(r);\
double g__ = libclut_model_standard_to_linear1(g);\
double b__ = libclut_model_standard_to_linear1(b);\
double y__;\
y__ = r__ * 2126 / 10000;\
y__ += g__ * 7152 / 10000;\
y__ += b__ * 722 / 10000;\
*(y) = y__;\
*(pb) = b__ - y__;\
*(pr) = r__ - y__;\
} while (0)
/**
* Convert from YPbPr to sRGB
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_linear_to_standard1` is not undefined
*
* @param y The Y component
* @param pb The Pb component
* @param pr The Pr component
* @param r Output parameter for the R parameter
* @param g Output parameter for the G parameter
* @param b Output parameter for the B parameter
*/
void (libclut_model_ypbpr_to_srgb)(double, double, double, double *, double *, double *);
#define libclut_model_ypbpr_to_srgb(y, pb, pr, r, g, b)\
do {\
double y__ = (y), r__ = (pr) + y__, g__, b__ = (pb) + y__;\
y__ -= r__ * 2126 / 10000;\
y__ -= b__ * 722 / 10000;\
g__ = y__ * 10000 / 7152;\
*(r) = libclut_model_linear_to_standard1(r__);\
*(g) = libclut_model_linear_to_standard1(g__);\
*(b) = libclut_model_linear_to_standard1(b__);\
} while (0)
/**
* Convert from sRGB to YCgCo
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_standard_to_linear1` is not undefined
*
* @param r The R component
* @param g The G component
* @param b The B component
* @param y Output parameter for the Y parameter
* @param cg Output parameter for the Cg parameter
* @param co Output parameter for the Co parameter
*/
void (libclut_model_srgb_to_ycgco)(double, double, double, double *, double *, double *);
#define libclut_model_srgb_to_ycgco(r, g, b, y, cg, co)\
do {\
double r__ = libclut_model_standard_to_linear1(r);\
double g__ = libclut_model_standard_to_linear1(g);\
double b__ = libclut_model_standard_to_linear1(b);\
*(y) = r__ / 4 + g__ / 2 + b__ / 4;\
*(cg) = r__ / -4 + g__ / 2 - b__ / 4;\
*(co) = r__ / 2 - b__ / 2;\
} while (0)
/**
* Convert from YCgCo to sRGB
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_linear_to_standard1` is not undefined
*
* @param y The Y component
* @param cg The Cg component
* @param co The Co component
* @param r Output parameter for the R parameter
* @param g Output parameter for the G parameter
* @param b Output parameter for the B parameter
*/
void (libclut_model_ycgco_to_srgb)(double, double, double, double *, double *, double *);
#define libclut_model_ycgco_to_srgb(y, cg, co, r, g, b)\
do {\
double y__ = (y), cg__ = (cg), co__ = (co);\
double r__ = y__ - cg__ + co__;\
double g__ = y__ + cg__;\
double b__ = y__ - cg__ - co__;\
*(r) = libclut_model_linear_to_standard1(r__);\
*(g) = libclut_model_linear_to_standard1(g__);\
*(b) = libclut_model_linear_to_standard1(b__);\
} while (0)
/**
* Convert from CIE 1960 UCS to CIE XYZ
*
* @param u The u component
* @param v The v component
* @param Y The Y component
* @param x Output parameter for the X parameter
* @param y Output parameter for the Y parameter
* @param z Output parameter for the Z parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_cie_1960_ucs_to_ciexyz)(double, double, double, double *, double *, double *);
#define libclut_model_cie_1960_ucs_to_ciexyz(u, v, Y, x, y, z)\
do {\
double u__ = (u), v__ = (v), y__ = (Y);\
*(y) = y__;\
*(x) = 3 * y__ * u__ / (2 * v__);\
*(z) = (4 * y__ - y__ * u__ - 10 * y__ * v__) / (2 * v__);\
} while (0)
/**
* Convert from CIE XYZ to CIE 1960 UCS
*
* @param x The X component
* @param y The Y component
* @param z The Z component
* @param u Output parameter for the u parameter
* @param v Output parameter for the v parameter
* @param Y Output parameter for the Y parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_ciexyz_to_cie_1960_ucs)(double, double, double, double *, double *, double *);
#define libclut_model_ciexyz_to_cie_1960_ucs(x, y, z, u, v, Y)\
do {\
double x__ = (x), y__ = (y);\
double d__ = x__ + 15 * y__ + 3 * (z);\
*(u) = 4 * x__ / d__;\
*(v) = 6 * y__ / d__;\
*(Y) = y__;\
} while (0)
/**
* Convert from CIEUVW to CIE 1960 UCS
*
* @param U:double The U* component
* @param V:double The V* component
* @param W:double The W* component
* @param u0:double The u parameter for the white point
* @param v0:double The v parameter for the white point
* @param u:double* Output parameter for the u parameter
* @param v:double* Output parameter for the v parameter
* @param Y:double* Output parameter for the Y parameter
*/
LIBCLUT_GCC_ONLY__(__attribute__((__leaf__)))
void (libclut_model_cieuvw_to_cie_1960_ucs)(double, double, double, double, double, double *, double *, double *);
#define libclut_model_cieuvw_to_cie_1960_ucs(U, V, W, u0, v0, u, v, Y)\
do {\
double w__ = (W), y__ = (w__ + 17) / 25;\
*(Y) = y__ *= y__ * y__;\
w__ *= 13;\
*(u) = (U) / w__ + (u0);\
*(v) = (V) / w__ + (v0);\
} while (0)
/**
* Convert from CIE 1960 UCS to CIEUVW
*
* Requires linking with `-lm`
*
* @param u:double The u component
* @param v:double The v component
* @param Y:double The Y component
* @param u0:double The u parameter for the white point
* @param v0:double The v parameter for the white point
* @param U:double* Output parameter for the U* parameter
* @param V:double* Output parameter for the V* parameter
* @param W:double* Output parameter for the W* parameter
*/
void (libclut_model_cie_1960_ucs_to_cieuvw)(double, double, double, double, double, double *, double *, double *);
#define libclut_model_cie_1960_ucs_to_cieuvw(u, v, Y, u0, v0, U, V, W)\
do {\
double w__ = 25 * cbrt(Y) - 17;\
*(W) = w__;\
w__ *= 13;\
*(U) = w__ * ((u) - (u0));\
*(V) = w__ * ((v) - (v0));\
} while (0)
/**
* Create a matrix for converting values between
* two RGB colour spaces
*
* @param from The input colour space, the Y-component is only necessary
* for the white point, `NULL` for CIE XYZ
* @param to The output colour space, the Y-component is only necessary
* for the white point, `NULL` for CIE XYZ
* @param M Output matrix for conversion from `from` to `to`
* @param Minv Output matrix for conversion from `to` to `from`, may be `NULL`
* @return Zero on success, -1 on error
*
* @throws EINVAL The colour space cannot be used
*/
int libclut_model_get_rgb_conversion_matrix(const libclut_rgb_colour_space_t *, const libclut_rgb_colour_space_t *,
libclut_colour_space_conversion_matrix_t, libclut_colour_space_conversion_matrix_t);
/**
* Convert an RGB colour into another RGB colour space
*
* Both RGB colour spaces must have same gamma functions as sRGB
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_standard_to_linear1` or
* `libclut_model_linear_to_standard1` is not undefined
*
* @param r The red component of the colour to convert
* @param g The green component of the colour to convert
* @param b The blue component of the colour to convert
* @param M Conversion matrix, create with `libclut_model_get_rgb_conversion_matrix`,
* must not have side-effects
* @param out_r Output parameter for the new red component
* @param out_g Output parameter for the new green component
* @param out_b Output parameter for the new blue component
*/
void (libclut_model_convert_rgb)(double, double, double, libclut_colour_space_conversion_matrix_t, double *, double *, double *);
#define libclut_model_convert_rgb(r, g, b, M, out_r, out_g, out_b)\
do {\
double r__ = libclut_model_standard_to_linear1(r);\
double g__ = libclut_model_standard_to_linear1(g);\
double b__ = libclut_model_standard_to_linear1(b);\
*(out_r) = libclut_model_linear_to_standard1((M)[0][0] * r__ + (M)[0][1] * g__ + (M)[0][2] * b__);\
*(out_g) = libclut_model_linear_to_standard1((M)[1][0] * r__ + (M)[1][1] * g__ + (M)[1][2] * b__);\
*(out_b) = libclut_model_linear_to_standard1((M)[2][0] * r__ + (M)[2][1] * g__ + (M)[2][2] * b__);\
} while (0)
/**
* Convert an RGB colour of a custom RGB colour space to CIE XYZ
*
* The RGB colour space must have same gamma functions as sRGB
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_standard_to_linear1` is not undefined
*
* @param r The red component
* @param g The green component
* @param b The blue component
* @param M Conversion matrix, create with `libclut_model_get_rgb_conversion_matrix`,
* must not have side-effects
* @param x Output parameter for the X component
* @param y Output parameter for the Y component
* @param z Output parameter for the Z component
*/
void (libclut_model_rgb_to_ciexyz)(double, double, double, libclut_colour_space_conversion_matrix_t, double *, double *, double *);
#define libclut_model_rgb_to_ciexyz(r, g, b, M, x, y, z)\
do {\
double r__ = libclut_model_standard_to_linear1(r);\
double g__ = libclut_model_standard_to_linear1(g);\
double b__ = libclut_model_standard_to_linear1(b);\
*(x) = (M)[0][0] * r__ + (M)[0][1] * g__ + (M)[0][2] * b__;\
*(y) = (M)[1][0] * r__ + (M)[1][1] * g__ + (M)[1][2] * b__;\
*(z) = (M)[2][0] * r__ + (M)[2][1] * g__ + (M)[2][2] * b__;\
} while (0)
/**
* Convert a CIE XYZ colour to a custom RGB colour space
*
* The RGB colour space must have same gamma functions as sRGB
*
* Requires linking with '-lclut', or '-lm' if
* `libclut_model_linear_to_standard1` is not undefined
*
* @param x The X component
* @param y The Y component
* @param z The Z component
* @param M Conversion matrix, create with `libclut_model_get_rgb_conversion_matrix`,
* must not have side-effects.
* @param r Output parameter for the red component
* @param g Output parameter for the green component
* @param b Output parameter for the blue component
*/
void (libclut_model_ciexyz_to_rgb)(double, double, double, libclut_colour_space_conversion_matrix_t, double *, double *, double *);
#define libclut_model_ciexyz_to_rgb(x, y, z, M, r, g, b)\
do {\
double x__ = (x), y__ = (y), z__ = (z);\
*(r) = libclut_model_linear_to_standard1((M)[0][0] * x__ + (M)[0][1] * y__ + (M)[0][2] * z__);\
*(g) = libclut_model_linear_to_standard1((M)[1][0] * x__ + (M)[1][1] * y__ + (M)[1][2] * z__);\
*(b) = libclut_model_linear_to_standard1((M)[2][0] * x__ + (M)[2][1] * y__ + (M)[2][2] * z__);\
} while (0)
#if defined(__clang__)
# pragma GCC diagnostic pop
#endif
#endif
