[babl] replace gamma approximations
- From: Øyvind Kolås <ok src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [babl] replace gamma approximations
- Date: Thu, 31 Aug 2017 14:27:18 +0000 (UTC)
commit e01c1bf249735b5cc83efc12789b79d96ec46252
Author: Øyvind Kolås <pippin gimp org>
Date: Thu Aug 31 13:16:28 2017 +0200
replace gamma approximations
babl/babl-internal.h | 24 +-----
babl/babl-trc.c | 217 +++++++++++++++++++++---------------------------
babl/babl-trc.h | 18 ++++-
babl/base/model-gray.c | 8 +-
babl/base/model-rgb.c | 28 +++---
extensions/cairo.c | 17 ++--
extensions/float.c | 42 +++++-----
extensions/gimp-8bit.c | 2 +-
8 files changed, 161 insertions(+), 195 deletions(-)
---
diff --git a/babl/babl-internal.h b/babl/babl-internal.h
index 61d6e09..9ddb9c1 100644
--- a/babl/babl-internal.h
+++ b/babl/babl-internal.h
@@ -346,21 +346,6 @@ babl_trc_new (const char *name,
int n_lut,
float *lut);
-/**
- * babl_trc_from_linear:
- *
- * Makes linear data non-linear according to the trc.
- */
-float babl_trc_from_linear (const Babl *trc, float value);
-
-/**
- * babl_trc_from_linear:
- *
- * Makes non-linear data with the TRC linear data.
- */
-float babl_trc_to_linear (const Babl *trc, float value);
-
-
void babl_space_to_xyz (const Babl *space, const double *rgb, double *xyz);
void babl_space_from_xyz (const Babl *space, const double *xyz, double *rgb);
@@ -368,12 +353,11 @@ const Babl *babl_space_from_icc (const char *icc,
int length,
char **error);
const Babl *babl_trc_lut_find (float *lut, int lut_size);
-const Babl * babl_trc_lut (const char *name, int n, float *entries);
+const Babl *babl_trc_lut (const char *name, int n, float *entries);
-Babl *
-format_new_from_format_with_space (const Babl *format, const Babl *space);
-int
-babl_list_destroy (void *data);
+Babl * format_new_from_format_with_space (const Babl *format, const Babl *space);
+
+int babl_list_destroy (void *data);
const char *
babl_conversion_create_name (Babl *source, Babl *destination, int is_reference);
diff --git a/babl/babl-trc.c b/babl/babl-trc.c
index 6de0fd1..29c56db 100644
--- a/babl/babl-trc.c
+++ b/babl/babl-trc.c
@@ -24,6 +24,10 @@
static BablTRC trc_db[MAX_TRCS];
+static inline float _babl_trc_linear (const Babl *trc_, float value)
+{
+ return value;
+}
static inline float babl_trc_lut_from_linear (const Babl *trc_, float value)
{
@@ -49,11 +53,6 @@ static inline float babl_trc_lut_to_linear (const Babl *trc_, float value)
return ret;
}
-static inline float _babl_trc_linear (const Babl *trc_, float value)
-{
- return 1.0;
-}
-
/* origin: FreeBSD /usr/src/lib/msun/src/e_powf.c, copied from musl */
/*
* Conversion to float by Ian Lance Taylor, Cygnus Support, ian cygnus com.
@@ -356,137 +355,119 @@ static inline float _babl_trc_gamma_from_linear (const Babl *trc_, float value)
return babl_powf (value, trc->rgamma);
}
-#define POLY_DEGREE 9
-
static inline float _babl_trc_gamma_1_8_to_linear (const Babl *trc_, float x)
{
- if (x >= 0.01f && x <= 1.0f)
+ if (x >= 0.01f && x < 0.7f)
{
-#if POLY_DEGREE==9
- float u = -2.9976517e+1f;
- u = u * x + 1.2166704e+2f;
- u = u * x + -2.0336221e+2f;
- u = u * x + 1.8145976e+2f;
- u = u * x + -9.4187362e+1f;
- u = u * x + 2.9529147e+1f;
- u = u * x + -6.013473f;
- u = u * x + 1.8725695f;
- u = u * x + 9.9435057e-3f;
- return u * x + -3.0061697e-5f;
-#elif POLY_DEGREE==10
- float u = 7.7739437e+1f;
- u = u * x + -3.5356881e+2f;
- u = u * x + 6.7648456e+2f;
- u = u * x + -7.0946645e+2f;
- u = u * x + 4.4648413e+2f;
- u = u * x + -1.7452451e+2f;
- u = u * x + 4.3126128e+1f;
- u = u * x + -7.2036142f;
- u = u * x + 1.9207626f;
- u = u * x + 9.14659e-3f;
- return u * x + -2.575215e-5f;
-#endif
+ double u = -1.326432065236105e+1;
+ u = u * x + 7.7192973347868776e+1;
+ u = u * x + -1.9639662782311719e+2;
+ u = u * x + 2.8719828602066411e+2;
+ u = u * x + -2.6718118019754855e+2;
+ u = u * x + 1.6562450069335532e+2;
+ u = u * x + -6.9988172743274441e+1;
+ u = u * x + 2.0568254985551865e+1;
+ u = u * x + -4.5302829214271245;
+ u = u * x + 1.7636048338730889;
+ u = u * x + 1.3015451332543148e-2;
+ return u * x + -5.4445726922508747e-5;
+ }
+ else if (x >= 0.7f && x < 1.4f)
+ {
+ double u = 2.4212422421184617e-3;
+ u = u * x + -2.0853930731707795e-2;
+ u = u * x + 8.2416801461966525e-2;
+ u = u * x + -2.1755799369117727e-1;
+ u = u * x + 1.0503926510667593;
+ u = u * x + 1.1196374095271941e-1;
+ return u * x + -8.7825075945914206e-3;
}
- return babl_powf (x, 1.8);
+ return babl_powf (x, 1.8f);
}
static inline float _babl_trc_gamma_1_8_from_linear (const Babl *trc_, float x)
{
- if (x >= 0.01f && x <= 1.0f)
+ if (x >= 0.01f && x < 0.25f)
{
-#if POLY_DEGREE==9
- float u = 7.6987344e+2f;
- u = u * x + -3.4624161e+3f;
- u = u * x + 6.5169973e+3f;
- u = u * x + -6.6683502e+3f;
- u = u * x + 4.037826e+3f;
- u = u * x + -1.4810227e+3f;
- u = u * x + 3.2670293e+2f;
- u = u * x + -4.3240358e+1f;
- u = u * x + 4.6009555f;
- return u * x + 3.6000385e-2f;
-#elif POLY_DEGREE==10
- float u = -2.2269134e+3f;
- u = u * x + 1.1122916e+4f;
- u = u * x + -2.3689515e+4f;
- u = u * x + 2.8091743e+4f;
- u = u * x + -2.0332165e+4f;
- u = u * x + 9.2757293e+3f;
- u = u * x + -2.6697086e+3f;
- u = u * x + 4.7661489e+2f;
- u = u * x + -5.2577079e+1f;
- u = u * x + 4.8359543f;
- return u * x + 3.4288484e-2f;
-#endif
+ double u = -7.0287082190390287e+7;
+ u = u * x + 9.6393346352028194e+7;
+ u = u * x + -5.734540040993472e+7;
+ u = u * x + 1.9423130902481005e+7;
+ u = u * x + -4.1360185772523716e+6;
+ u = u * x + 5.7798684366021459e+5;
+ u = u * x + -5.3914765738125787e+4;
+ u = u * x + 3.3827381495697474e+3;
+ u = u * x + -1.4758049734050082e+2;
+ u = u * x + 6.34823684277896;
+ return u * x + 2.5853366952641552e-2;
+ } else if (x >= 0.25f && x < 1.1f)
+ {
+ double u = -1.0514013917303294;
+ u = u * x + 7.7742547018698687;
+ u = u * x + -2.5688463052927626e+1;
+ u = u * x + 5.009448068094152e+1;
+ u = u * x + -6.4160579394623318e+1;
+ u = u * x + 5.6890996491836047e+1;
+ u = u * x + -3.5956430472666212e+1;
+ u = u * x + 1.6565821666356617e+1;
+ u = u * x + -5.8508167212560416;
+ u = u * x + 2.2859969154731878;
+ return u * x + 9.6140522367339399e-2;
}
return babl_powf (x, 1.0f/1.8f);
}
static inline float _babl_trc_gamma_2_2_to_linear (const Babl *trc_, float x)
{
- if (x >= 0.01f && x <= 1.0f)
+ if (x >= 0.01f && x < 1.0f)
{
-#if POLY_DEGREE==9
- float u = 1.4519824e+1f;
- u = u * x + -5.6919938e+1f;
- u = u * x + 9.1404232e+1f;
- u = u * x + -7.7951568e+1f;
- u = u * x + 3.8593448e+1f;
- u = u * x + -1.1709313e+1f;
- u = u * x + 2.594042f;
- u = u * x + 4.716017e-1f;
- u = u * x + -1.478392e-3f;
- return u * x + 4.987805e-6f;
-#elif POLY_DEGREE==10
- float u = -3.6278814e+1f;
- u = u * x + 1.5984863e+2f;
- u = u * x + -2.9493194e+2f;
- u = u * x + 2.9678744e+2f;
- u = u * x + -1.7840175e+2f;
- u = u * x + 6.6563304e+1f;
- u = u * x + -1.5968574e+1f;
- u = u * x + 2.9224961f;
- u = u * x + 4.5996165e-1f;
- u = u * x + -1.306086e-3f;
- return u * x + 4.1278131e-6f;
-#endif
+ double u = -1.7565198334207539;
+ u = u * x + 9.4503605497836926;
+ u = u * x + -2.2016178903082791e+1;
+ u = u * x + 2.9177361786084179e+1;
+ u = u * x + -2.4368251609523336e+1;
+ u = u * x + 1.3522663223248737e+1;
+ u = u * x + -5.253344907664925;
+ u = u * x + 1.7182864905042889;
+ u = u * x + 5.2860458501353106e-1;
+ u = u * x + -3.0000031884069502e-3;
+ return u * x + 1.6952727496833812e-5;
}
return babl_powf (x, 2.2f);
}
static inline float _babl_trc_gamma_2_2_from_linear (const Babl *trc_, float x)
{
- if (x >= 0.01f && x <= 1.0f)
+ if (x >= 0.01f && x < 0.25f)
{
-#if POLY_DEGREE==9
- float u = 1.0084733e+3f;
- u = u * x + -4.5716932e+3f;
- u = u * x + 8.6843755e+3f;
- u = u * x + -8.9814293e+3f;
- u = u * x + 5.5060078e+3f;
- u = u * x + -2.0477969e+3f;
- u = u * x + 4.5804658e+2f;
- u = u * x + -6.0913328e+1f;
- u = u * x + 5.8668695f;
- return u * x + 7.1335777e-2f;
-#elif POLY_DEGREE==10
- float u = -2.9423332e+3f;
- u = u * x + 1.4803473e+4f;
- u = u * x + -3.1791125e+4f;
- u = u * x + 3.805972e+4f;
- u = u * x + -2.7850114e+4f;
- u = u * x + 1.2865342e+4f;
- u = u * x + -3.7543241e+3f;
- u = u * x + 6.7921578e+2f;
- u = u * x + -7.5167916e+1f;
- u = u * x + 6.239892f;
- return u * x + 6.8539291e-2f;
-#endif
+ double u = -1.1853049266795914e+8;
+ u = u * x + 1.6235355750617304e+8;
+ u = u * x + -9.6434183855508922e+7;
+ u = u * x + 3.2595749146174438e+7;
+ u = u * x + -6.9216734175519044e+6;
+ u = u * x + 9.6337373983643336e+5;
+ u = u * x + -8.9295299887376452e+4;
+ u = u * x + 5.5387559329470092e+3;
+ u = u * x + -2.3522564268245811e+2;
+ u = u * x + 8.8234901614165394;
+ return u * x + 5.3919966190648492e-2;
+ } else if (x >= 0.25f && x < 1.0f)
+ {
+ double u = -2.1065242890384543e-1;
+ u = u * x + 1.7554867367832886;
+ u = u * x + -6.6371047248064382;
+ u = u * x + 1.5049549954517457e+1;
+ u = u * x + -2.279671781745644e+1;
+ u = u * x + 2.4331499227325978e+1;
+ u = u * x + -1.8839523095731037e+1;
+ u = u * x + 1.0802279176589768e+1;
+ u = u * x + -4.7776729355620852;
+ u = u * x + 2.1410886948010769;
+ return u * x + 1.817672123838504e-1;
}
return babl_powf (x, 1.0/2.2);
}
-
static inline float _babl_trc_srgb_to_linear (const Babl *trc_, float value)
{
return babl_gamma_2_2_to_linear (value);
@@ -497,18 +478,6 @@ static inline float _babl_trc_srgb_from_linear (const Babl *trc_, float value)
return babl_linear_to_gamma_2_2f (value);
}
-static inline float _babl_trc_from_linear (const Babl *trc_, float value)
-{
- BablTRC *trc = (void*)trc_;
- return trc->fun_from_linear (trc_, value);
-}
-
-static inline float _babl_trc_to_linear (const Babl *trc_, float value)
-{
- BablTRC *trc = (void*)trc_;
- return trc->fun_to_linear (trc_, value);
-}
-
const Babl *
babl_trc (const char *name)
@@ -663,15 +632,17 @@ babl_trc_class_init (void)
babl_trc_new ("linear", BABL_TRC_LINEAR, 1.0, 0, NULL);
}
+#if 0
float babl_trc_from_linear (const Babl *trc_, float value)
{
- return _babl_trc_from_linear (trc_, value);
+ return babl_trc_from_linear (trc_, value);
}
float babl_trc_to_linear (const Babl *trc_, float value)
{
- return _babl_trc_to_linear (trc_, value);
+ return babl_trc_to_linear (trc_, value);
}
+#endif
const Babl *babl_trc_lut_find (float *lut, int lut_size)
{
diff --git a/babl/babl-trc.h b/babl/babl-trc.h
index 0c9c23a..dc1abf9 100644
--- a/babl/babl-trc.h
+++ b/babl/babl-trc.h
@@ -40,13 +40,25 @@ typedef struct
int lut_size;
double gamma;
float rgamma;
- char name[128];
+ float (*fun_to_linear)(const Babl *trc, float val);
+ float (*fun_from_linear)(const Babl *trc, float val);
float *lut;
float *inv_lut;
- float (*fun_to_linear)(const Babl *trc_, float val);
- float (*fun_from_linear)(const Babl *trc_, float val);
+ char name[128];
} BablTRC;
+static inline float babl_trc_from_linear (const Babl *trc_, float value)
+{
+ BablTRC *trc = (void*)trc_;
+ return trc->fun_from_linear (trc_, value);
+}
+
+static inline float babl_trc_to_linear (const Babl *trc_, float value)
+{
+ BablTRC *trc = (void*)trc_;
+ return trc->fun_to_linear (trc_, value);
+}
+
void
babl_trc_class_init (void);
diff --git a/babl/base/model-gray.c b/babl/base/model-gray.c
index a7ad2a6..adb9fd8 100644
--- a/babl/base/model-gray.c
+++ b/babl/base/model-gray.c
@@ -206,7 +206,7 @@ rgb_to_gray_2_2 (Babl *conversion,
luminance = red * RGB_LUMINANCE_RED + // XXX: should be taken from BablSpace
green * RGB_LUMINANCE_GREEN +
blue * RGB_LUMINANCE_BLUE;
- *(double *) dst[0] = trc->trc.fun_from_linear (trc, luminance);
+ *(double *) dst[0] = babl_trc_from_linear (trc, luminance);
if (dst_bands == 2)
*(double *) dst[1] = alpha;
@@ -237,7 +237,7 @@ gray_2_2_to_rgb (Babl *conversion,
double red, green, blue;
double alpha;
- luminance = trc->trc.fun_to_linear (trc, *(double *) src[0]);
+ luminance = babl_trc_to_linear (trc, *(double *) src[0]);
red = luminance;
green = luminance;
blue = luminance;
@@ -485,7 +485,7 @@ rgba2gray_gamma_2_2_premultiplied (Babl *conversion,
luminance = red * RGB_LUMINANCE_RED +
green * RGB_LUMINANCE_GREEN +
blue * RGB_LUMINANCE_BLUE;
- luma = trc->trc.fun_from_linear (trc, luminance);
+ luma = babl_trc_from_linear (trc, luminance);
((double *) dst)[0] = luma * alpha;
((double *) dst)[1] = alpha;
@@ -513,7 +513,7 @@ gray_gamma_2_2_premultiplied2rgba (Babl *conversion,
double luminance;
luma = luma / alpha;
- luminance = trc->trc.fun_to_linear (trc, luma);
+ luminance = babl_trc_to_linear (trc, luma);
((double *) dst)[0] = luminance;
((double *) dst)[1] = luminance;
diff --git a/babl/base/model-rgb.c b/babl/base/model-rgb.c
index 27a080e..4fcd2fb 100644
--- a/babl/base/model-rgb.c
+++ b/babl/base/model-rgb.c
@@ -201,7 +201,7 @@ g3_gamma_2_2 (Babl *conversion,
{
int band;
for (band = 0; band < 3; band++)
- *(double *) dst[band] = trc[band]->trc.fun_from_linear (trc[band], (*(double *) src[band]));
+ *(double *) dst[band] = babl_trc_from_linear (trc[band], (*(double *) src[band]));
for (; band < dst_bands; band++)
*(double *) dst[band] = *(double *) src[band];
@@ -231,7 +231,7 @@ g3_inv_gamma_2_2 (Babl *conversion,
int band;
for (band = 0; band < 3; band++)
{
- *(double *) dst[band] = trc[band]->trc.fun_to_linear (trc[band], (*(double *) src[band]));
+ *(double *) dst[band] = babl_trc_to_linear (trc[band], (*(double *) src[band]));
}
for (; band < dst_bands; band++)
{
@@ -327,9 +327,9 @@ rgba2rgba_gamma_2_2_premultiplied (Babl *conversion,
while (n--)
{
double alpha = ((double *) src)[3];
- ((double *) dst)[0] = trc[0]->trc.fun_from_linear (trc[0], ((double *) src)[0]) * alpha;
- ((double *) dst)[1] = trc[0]->trc.fun_from_linear (trc[1], ((double *) src)[1]) * alpha;
- ((double *) dst)[2] = trc[0]->trc.fun_from_linear (trc[2], ((double *) src)[2]) * alpha;
+ ((double *) dst)[0] = babl_trc_from_linear (trc[0], ((double *) src)[0]) * alpha;
+ ((double *) dst)[1] = babl_trc_from_linear (trc[1], ((double *) src)[1]) * alpha;
+ ((double *) dst)[2] = babl_trc_from_linear (trc[2], ((double *) src)[2]) * alpha;
((double *) dst)[3] = alpha;
src += 4 * sizeof (double);
dst += 4 * sizeof (double);
@@ -353,9 +353,9 @@ rgba_gamma_2_2_premultiplied2rgba (Babl *conversion,
double alpha = ((double *) src)[3];
if (alpha > BABL_ALPHA_THRESHOLD)
{
- ((double *) dst)[0] = trc[0]->trc.fun_to_linear (trc[0], ((double *) src)[0] / alpha);
- ((double *) dst)[1] = trc[1]->trc.fun_to_linear (trc[1], ((double *) src)[1] / alpha);
- ((double *) dst)[2] = trc[2]->trc.fun_to_linear (trc[2], ((double *) src)[2] / alpha);
+ ((double *) dst)[0] = babl_trc_to_linear (trc[0], ((double *) src)[0] / alpha);
+ ((double *) dst)[1] = babl_trc_to_linear (trc[1], ((double *) src)[1] / alpha);
+ ((double *) dst)[2] = babl_trc_to_linear (trc[2], ((double *) src)[2] / alpha);
}
else
{
@@ -385,9 +385,9 @@ rgba2rgba_gamma_2_2 (Babl *conversion,
while (n--)
{
double alpha = ((double *) src)[3];
- ((double *) dst)[0] = trc[0]->trc.fun_from_linear (trc[0], ((double *) src)[0]);
- ((double *) dst)[1] = trc[1]->trc.fun_from_linear (trc[1], ((double *) src)[1]);
- ((double *) dst)[2] = trc[2]->trc.fun_from_linear (trc[2], ((double *) src)[2]);
+ ((double *) dst)[0] = babl_trc_from_linear (trc[0], ((double *) src)[0]);
+ ((double *) dst)[1] = babl_trc_from_linear (trc[1], ((double *) src)[1]);
+ ((double *) dst)[2] = babl_trc_from_linear (trc[2], ((double *) src)[2]);
((double *) dst)[3] = alpha;
src += 4 * sizeof (double);
dst += 4 * sizeof (double);
@@ -409,9 +409,9 @@ rgba_gamma_2_22rgba (Babl *conversion,
while (n--)
{
double alpha = ((double *) src)[3];
- ((double *) dst)[0] = trc[0]->trc.fun_to_linear (trc[0], ((double *) src)[0]);
- ((double *) dst)[1] = trc[1]->trc.fun_to_linear (trc[1], ((double *) src)[1]);
- ((double *) dst)[2] = trc[2]->trc.fun_to_linear (trc[2], ((double *) src)[2]);
+ ((double *) dst)[0] = babl_trc_to_linear (trc[0], ((double *) src)[0]);
+ ((double *) dst)[1] = babl_trc_to_linear (trc[1], ((double *) src)[1]);
+ ((double *) dst)[2] = babl_trc_to_linear (trc[2], ((double *) src)[2]);
((double *) dst)[3] = alpha;
src += 4 * sizeof (double);
diff --git a/extensions/cairo.c b/extensions/cairo.c
index c53da2a..e96c74b 100644
--- a/extensions/cairo.c
+++ b/extensions/cairo.c
@@ -300,11 +300,11 @@ conv_rgbafloat_cairo32_le (const Babl *conversion,unsigned char *src,
float alpha = *fsrc++;
if (alpha >= 1.0)
{
- int val = trc[2]->trc.fun_from_linear (trc[2], blue) * 0xff + 0.5f;
+ int val = babl_trc_from_linear (trc[2], blue) * 0xff + 0.5f;
*cdst++ = val >= 0xff ? 0xff : val <= 0 ? 0 : val;
- val = trc[1]->trc.fun_from_linear (trc[1], green) * 0xff + 0.5f;
+ val = babl_trc_from_linear (trc[1], green) * 0xff + 0.5f;
*cdst++ = val >= 0xff ? 0xff : val <= 0 ? 0 : val;
- val = trc[0]->trc.fun_from_linear (trc[0], red) * 0xff + 0.5f;
+ val = babl_trc_from_linear (trc[0], red) * 0xff + 0.5f;
*cdst++ = val >= 0xff ? 0xff : val <= 0 ? 0 : val;
*cdst++ = 0xff;
}
@@ -316,11 +316,11 @@ conv_rgbafloat_cairo32_le (const Babl *conversion,unsigned char *src,
else
{
float balpha = alpha * 0xff;
- int val = trc[2]->trc.fun_from_linear (trc[2], blue) * balpha + 0.5f;
+ int val = babl_trc_from_linear (trc[2], blue) * balpha + 0.5f;
*cdst++ = val >= 0xff ? 0xff : val <= 0 ? 0 : val;
- val = trc[1]->trc.fun_from_linear (trc[1], green) * balpha + 0.5f;
+ val = babl_trc_from_linear (trc[1], green) * balpha + 0.5f;
*cdst++ = val >= 0xff ? 0xff : val <= 0 ? 0 : val;
- val = trc[0]->trc.fun_from_linear (trc[0], red) * balpha + 0.5f;
+ val = babl_trc_from_linear (trc[0], red) * balpha + 0.5f;
*cdst++ = val >= 0xff ? 0xff : val <= 0 ? 0 : val;
*cdst++ = balpha + 0.5f;
}
@@ -346,7 +346,7 @@ conv_yafloat_cairo32_le (const Babl *conversion,unsigned char *src,
float alpha = *fsrc++;
if (alpha >= 1.0)
{
- int val = trc[0]->trc.fun_from_linear (trc[0], gray) * 0xff + 0.5f;
+ int val = babl_trc_from_linear (trc[0], gray) * 0xff + 0.5f;
val = val >= 0xff ? 0xff : val <= 0 ? 0 : val;
*cdst++ = val;
*cdst++ = val;
@@ -361,7 +361,7 @@ conv_yafloat_cairo32_le (const Babl *conversion,unsigned char *src,
else
{
float balpha = alpha * 0xff;
- int val = trc[0]->trc.fun_from_linear (trc[0], gray) * balpha + 0.5f;
+ int val = babl_trc_from_linear (trc[0], gray) * balpha + 0.5f;
val = val >= 0xff ? 0xff : val <= 0 ? 0 : val;
*cdst++ = val;
*cdst++ = val;
@@ -424,7 +424,6 @@ init (void)
babl_conversion_new (babl_format ("Y'A u16"), f32, "linear",
conv_yA16_cairo32_le, NULL);
-
babl_conversion_new (babl_format ("Y' u8"), f32, "linear",
conv_y8_cairo32_le, NULL);
babl_conversion_new (babl_format ("Y' u16"), f32, "linear",
diff --git a/extensions/float.c b/extensions/float.c
index 0ebe81a..4eb26dd 100644
--- a/extensions/float.c
+++ b/extensions/float.c
@@ -45,9 +45,9 @@ conv_rgbaF_linear_rgbAF_gamma (const Babl *conversion,unsigned char *src,
while (n--)
{
float alpha = fsrc[3];
- *fdst++ = trc[0]->trc.fun_from_linear (trc[0], *fsrc++) * alpha;
- *fdst++ = trc[1]->trc.fun_from_linear (trc[1], *fsrc++) * alpha;
- *fdst++ = trc[2]->trc.fun_from_linear (trc[2], *fsrc++) * alpha;
+ *fdst++ = babl_trc_from_linear (trc[0], *fsrc++) * alpha;
+ *fdst++ = babl_trc_from_linear (trc[1], *fsrc++) * alpha;
+ *fdst++ = babl_trc_from_linear (trc[2], *fsrc++) * alpha;
*fdst++ = *fsrc++;
}
return samples;
@@ -78,17 +78,17 @@ conv_rgbAF_linear_rgbAF_gamma (const Babl *conversion,unsigned char *src,
}
else if (alpha >= 1.0)
{
- *fdst++ = trc[0]->trc.fun_from_linear (trc[0], *fsrc++) * alpha;
- *fdst++ = trc[1]->trc.fun_from_linear (trc[1], *fsrc++) * alpha;
- *fdst++ = trc[2]->trc.fun_from_linear (trc[2], *fsrc++) * alpha;
+ *fdst++ = babl_trc_from_linear (trc[0], *fsrc++) * alpha;
+ *fdst++ = babl_trc_from_linear (trc[1], *fsrc++) * alpha;
+ *fdst++ = babl_trc_from_linear (trc[2], *fsrc++) * alpha;
*fdst++ = *fsrc++;
}
else
{
float alpha_recip = 1.0 / alpha;
- *fdst++ = trc[0]->trc.fun_from_linear (trc[0], *fsrc++ * alpha_recip) * alpha;
- *fdst++ = trc[1]->trc.fun_from_linear (trc[1], *fsrc++ * alpha_recip) * alpha;
- *fdst++ = trc[2]->trc.fun_from_linear (trc[2], *fsrc++ * alpha_recip) * alpha;
+ *fdst++ = babl_trc_from_linear (trc[0], *fsrc++ * alpha_recip) * alpha;
+ *fdst++ = babl_trc_from_linear (trc[1], *fsrc++ * alpha_recip) * alpha;
+ *fdst++ = babl_trc_from_linear (trc[2], *fsrc++ * alpha_recip) * alpha;
*fdst++ = *fsrc++;
}
}
@@ -109,9 +109,9 @@ conv_rgbaF_linear_rgbaF_gamma (const Babl *conversion,unsigned char *src,
while (n--)
{
- *fdst++ = trc[0]->trc.fun_from_linear (trc[0], *fsrc++);
- *fdst++ = trc[1]->trc.fun_from_linear (trc[1], *fsrc++);
- *fdst++ = trc[2]->trc.fun_from_linear (trc[2], *fsrc++);
+ *fdst++ = babl_trc_from_linear (trc[0], *fsrc++);
+ *fdst++ = babl_trc_from_linear (trc[1], *fsrc++);
+ *fdst++ = babl_trc_from_linear (trc[2], *fsrc++);
*fdst++ = *fsrc++;
}
return samples;
@@ -130,9 +130,9 @@ conv_rgbF_linear_rgbF_gamma (const Babl *conversion,unsigned char *src,
while (n--)
{
- *fdst++ = trc[0]->trc.fun_from_linear (trc[0], *fsrc++);
- *fdst++ = trc[1]->trc.fun_from_linear (trc[1], *fsrc++);
- *fdst++ = trc[2]->trc.fun_from_linear (trc[2], *fsrc++);
+ *fdst++ = babl_trc_from_linear (trc[0], *fsrc++);
+ *fdst++ = babl_trc_from_linear (trc[1], *fsrc++);
+ *fdst++ = babl_trc_from_linear (trc[2], *fsrc++);
}
return samples;
}
@@ -151,9 +151,9 @@ conv_rgbaF_gamma_rgbaF_linear (const Babl *conversion,unsigned char *src,
while (n--)
{
- *fdst++ = trc[0]->trc.fun_to_linear (trc[0], *fsrc++);
- *fdst++ = trc[1]->trc.fun_to_linear (trc[1], *fsrc++);
- *fdst++ = trc[2]->trc.fun_to_linear (trc[2], *fsrc++);
+ *fdst++ = babl_trc_to_linear (trc[0], *fsrc++);
+ *fdst++ = babl_trc_to_linear (trc[1], *fsrc++);
+ *fdst++ = babl_trc_to_linear (trc[2], *fsrc++);
*fdst++ = *fsrc++;
}
return samples;
@@ -172,9 +172,9 @@ conv_rgbF_gamma_rgbF_linear (const Babl *conversion,unsigned char *src,
while (n--)
{
- *fdst++ = trc[0]->trc.fun_to_linear (trc[0], *fsrc++);
- *fdst++ = trc[1]->trc.fun_to_linear (trc[1], *fsrc++);
- *fdst++ = trc[2]->trc.fun_to_linear (trc[2], *fsrc++);
+ *fdst++ = babl_trc_to_linear (trc[0], *fsrc++);
+ *fdst++ = babl_trc_to_linear (trc[1], *fsrc++);
+ *fdst++ = babl_trc_to_linear (trc[2], *fsrc++);
}
return samples;
}
diff --git a/extensions/gimp-8bit.c b/extensions/gimp-8bit.c
index 3b66364..de0099a 100644
--- a/extensions/gimp-8bit.c
+++ b/extensions/gimp-8bit.c
@@ -63,7 +63,7 @@ tables_init (const Babl *space)
for (i = 0; i < 1 << 8; i++)
{
double value = i / 255.0;
- lut_gamma_2_2[j][i] = _babl_trc_to_linear (space->space.trc[0], value);
+ lut_gamma_2_2[j][i] = babl_trc_to_linear (space->space.trc[0], value);
}
return j;
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
