[babl] make use of babl space for reference computations
- From: Øyvind Kolås <ok src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [babl] make use of babl space for reference computations
- Date: Fri, 18 Aug 2017 21:32:36 +0000 (UTC)
commit 8a2f9e2e48b10c3f829ca2e13d7b62379b2f563a
Author: Øyvind Kolås <pippin gimp org>
Date: Fri Aug 18 23:31:22 2017 +0200
make use of babl space for reference computations
babl/babl-conversion.c | 19 +++++--
babl/babl-fish-reference.c | 41 ++++++++++++----
babl/babl-fish.c | 47 +++++++++++++++++--
babl/babl-format.c | 109 +++++++++++++++++++++++++++++++++++++++-----
babl/babl-format.h | 1 +
babl/babl-internal.h | 4 ++
babl/babl-model.c | 62 +++++++++++++++++++++++--
babl/babl-model.h | 15 ++++--
babl/babl.c | 1 +
babl/base/model-gray.c | 27 ++++++----
babl/base/model-rgb.c | 65 ++++++++++++++------------
11 files changed, 306 insertions(+), 85 deletions(-)
---
diff --git a/babl/babl-conversion.c b/babl/babl-conversion.c
index 766e6c4..9e45a5b 100644
--- a/babl/babl-conversion.c
+++ b/babl/babl-conversion.c
@@ -281,7 +281,7 @@ babl_conversion_new (const void *first_arg,
babl = babl_db_exist (db, id, name);
}
- babl = _conversion_new (name, id, source, destination, linear, plane, planar,
+ babl = _conversion_new (name, id, source, destination, linear, plane, planar,
user_data);
/* Since there is not an already registered instance by the required
@@ -300,8 +300,7 @@ babl_conversion_linear_process (BablConversion *conversion,
void *destination,
long n)
{
- return conversion->function.linear ((void*)conversion,
- source, destination, n, conversion->data);
+ return conversion->function.linear ((void*)conversion, source, destination, n, conversion->data);
}
static long
@@ -312,8 +311,7 @@ babl_conversion_plane_process (BablConversion *conversion,
int dst_pitch,
long n)
{
- return conversion->function.plane ((void*)conversion,
- source, destination,
+ return conversion->function.plane ((void*)conversion, source, destination,
src_pitch, dst_pitch,
n,
conversion->data);
@@ -335,7 +333,6 @@ babl_conversion_planar_process (BablConversion *conversion,
memcpy (src_data, source->data, sizeof (void *) * source->components);
memcpy (dst_data, destination->data, sizeof (void *) * destination->components);
-
return conversion->function.planar ((void*)conversion,
source->components,
src_data,
@@ -551,4 +548,14 @@ babl_conversion_error (BablConversion *conversion)
return error;
}
+const Babl *babl_conversion_get_source_space (const Babl *conversion)
+{
+ return conversion->conversion.source->format.space;
+}
+
+const Babl *babl_conversion_get_destination_space (const Babl *conversion)
+{
+ return conversion->conversion.destination->format.space;
+}
+
BABL_CLASS_IMPLEMENT (conversion)
diff --git a/babl/babl-fish-reference.c b/babl/babl-fish-reference.c
index 00ff6be..8273da5 100644
--- a/babl/babl-fish-reference.c
+++ b/babl/babl-fish-reference.c
@@ -26,7 +26,8 @@ assert_conversion_find (const void *source,
Babl *ret = babl_conversion_find (source, destination);
if (!ret)
- babl_fatal ("failed, aborting");
+ babl_fatal ("failed finding conversion between %s and %s aborting",
+ babl_get_name (source), babl_get_name (destination));
return ret;
}
@@ -176,6 +177,7 @@ convert_to_double (BablFormat *source_fmt,
src_img->pitch[0] = source_fmt->bytes_per_pixel;
src_img->stride[0] = 0;
+ {
/* i is source position */
for (i = 0; i < source_fmt->components; i++)
{
@@ -200,6 +202,7 @@ convert_to_double (BablFormat *source_fmt,
src_img->data[0] += src_img->type[0]->bits / 8;
}
+ }
babl_free (src_img);
babl_free (dst_img);
}
@@ -366,7 +369,6 @@ process_to_n_component (const Babl *babl,
return 0;
}
-
static int
process_same_model (const Babl *babl,
const char *source,
@@ -433,17 +435,17 @@ babl_fish_reference_process (const Babl *babl,
Babl *rgba_image;
Babl *destination_image;
-
- if (BABL (babl->fish.source)->format.model ==
- BABL (babl->fish.destination)->format.model)
+ if ((BABL (babl->fish.source)->format.model ==
+ BABL (babl->fish.destination)->format.model) &&
+ (BABL (babl->fish.source)->format.space ==
+ BABL (babl->fish.destination)->format.space)
+ )
return process_same_model (babl, source, destination, n);
if (babl_format_is_format_n (BABL (babl->fish.destination)))
{
return process_to_n_component (babl, source, destination, n);
}
-
-
source_double_buf = babl_malloc (sizeof (double) * n *
BABL (babl->fish.source)->format.model->components);
@@ -454,7 +456,8 @@ babl_fish_reference_process (const Babl *babl,
source_image = babl_image_from_linear (
source_double_buf, BABL (BABL ((babl->fish.source))->format.model));
rgba_image = babl_image_from_linear (
- rgba_double_buf, babl_model_from_id (BABL_RGBA));
+ rgba_double_buf, babl_remodel_with_space (babl_model_from_id (BABL_RGBA),
+ BABL (BABL ((babl->fish.source))->format.space)) );
destination_image = babl_image_from_linear (
destination_double_buf, BABL (BABL ((babl->fish.destination))->format.model));
@@ -469,7 +472,8 @@ babl_fish_reference_process (const Babl *babl,
Babl *conv =
assert_conversion_find (
BABL (babl->fish.source)->format.model,
- babl_model_from_id (BABL_RGBA)
+ babl_remodel_with_space (babl_model_from_id (BABL_RGBA),
+ BABL (BABL ((babl->fish.source))->format.space))
);
if (conv->class_type == BABL_CONVERSION_PLANAR)
{
@@ -488,10 +492,26 @@ babl_fish_reference_process (const Babl *babl,
else babl_fatal ("oops");
}
+ if (((babl->fish.source)->format.space !=
+ ((babl->fish.destination)->format.space)))
+ {
+ double matrix[9];
+ int i;
+ double *rgba = rgba_double_buf;
+ babl_matrix_mul_matrix (
+ (babl->fish.destination)->format.space->space.XYZtoRGB,
+ (babl->fish.source)->format.space->space.RGBtoXYZ,
+ matrix);
+
+ for (i = 0; i < n; i++)
+ babl_matrix_mul_vector (matrix, &rgba[i * 4], &rgba[i * 4]);
+ }
+
{
Babl *conv =
assert_conversion_find (
- babl_model_from_id (BABL_RGBA),
+ babl_remodel_with_space (babl_model_from_id (BABL_RGBA),
+ BABL (BABL ((babl->fish.destination))->format.space)),
BABL (babl->fish.destination)->format.model);
if (conv->class_type == BABL_CONVERSION_PLANAR)
{
@@ -526,4 +546,3 @@ babl_fish_reference_process (const Babl *babl,
babl_free (source_double_buf);
return n;
}
-
diff --git a/babl/babl-fish.c b/babl/babl-fish.c
index 96c69c3..d8b7c7e 100644
--- a/babl/babl-fish.c
+++ b/babl/babl-fish.c
@@ -112,16 +112,55 @@ match_conversion (Babl *conversion,
return 0;
}
+
+
Babl *
babl_conversion_find (const void *source,
const void *destination)
{
void *data = (void*)destination;
-
babl_list_each (BABL (source)->type.from_list, match_conversion, &data);
- if (data == (void*)destination) /* didn't change */
- return NULL;
- return data;
+ if (data != (void*)destination) /* didn't change */
+ return data;
+ data = NULL;
+
+ if (BABL (source)->class_type == BABL_MODEL)
+ {
+ const Babl *srgb_source = BABL (source)->model.data ? BABL (source)->model.data:source;
+ const Babl *srgb_destination = BABL (destination)->model.data ? BABL
(destination)->model.data:destination;
+ Babl *reference = babl_conversion_find (srgb_source, srgb_destination);
+ BablConversion *ret;
+
+ /* when conversions are sought between models, with non-sRGB chromaticities,
+ we create the needed conversions from existing ones on the fly, and
+ register them. The conversions registered by the models should pick up the
+ RGB chromaticities, and TRC to use from the space on the model instead of
+ hard-coding it.
+ */
+
+ switch (reference->instance.class_type)
+ {
+ case BABL_CONVERSION_LINEAR:
+ return _conversion_new ("", 0, source, destination,
+ reference->conversion.function.linear,
+ NULL,
+ NULL,
+ reference->conversion.data);
+ case BABL_CONVERSION_PLANE:
+ return _conversion_new ("", 0, source, destination,
+ NULL,
+ reference->conversion.function.plane,
+ NULL,
+ reference->conversion.data);
+ case BABL_CONVERSION_PLANAR:
+ return _conversion_new ("", 0, source, destination,
+ NULL,
+ NULL,
+ reference->conversion.function.planar,
+ reference->conversion.data);
+ }
+ }
+ return NULL;
}
int
diff --git a/babl/babl-format.c b/babl/babl-format.c
index 60a916e..a2c8e17 100644
--- a/babl/babl-format.c
+++ b/babl/babl-format.c
@@ -26,6 +26,7 @@
#include "babl-db.h"
#include "babl-ref-pixels.h"
+
static int babl_format_destruct (void *babl)
{
BablFormat *format = babl;
@@ -42,11 +43,12 @@ static int babl_format_destruct (void *babl)
}
static Babl *
-format_new (const char *name,
- int id,
- int planar,
- int components,
- BablModel *model,
+format_new (const char *name,
+ int id,
+ int planar,
+ int components,
+ BablModel *model,
+ const Babl *space,
BablComponent **component,
BablSampling **sampling,
const BablType **type)
@@ -83,6 +85,7 @@ format_new (const char *name,
sizeof (BablType *) * (components) +
sizeof (int) * (components) +
sizeof (int) * (components));
+
babl_set_destructor (babl, babl_format_destruct);
babl->format.from_list = NULL;
@@ -96,9 +99,13 @@ format_new (const char *name,
strcpy (babl->instance.name, name);
- babl->format.model = model;
babl->format.components = components;
+ if (space == babl_space ("sRGB"))
+ babl->format.model = model;
+ else
+ babl->format.model = babl_remodel_with_space (model, space);
+
memcpy (babl->format.component, component, sizeof (BablComponent *) * components);
memcpy (babl->format.type, type, sizeof (BablType *) * components);
memcpy (babl->format.sampling, sampling, sizeof (BablSampling *) * components);
@@ -118,9 +125,28 @@ format_new (const char *name,
babl->format.format_n = 0;
babl->format.palette = 0;
+ babl->format.space = (void*)space;
+
return babl;
}
+static Babl *
+format_new_from_format_with_space (const Babl *format, const Babl *space)
+{
+ Babl *ret;
+ char new_name[256];
+ sprintf (new_name, "%s-%s", babl_get_name ((void*)format),
+ babl_get_name ((void*)space));
+
+ ret = format_new (new_name,
+ 0,
+ format->format.planar, format->format.components,
+ (void*)babl_remodel_with_space (BABL(format->format.model), space),
+ space,
+ format->format.component, format->format.sampling, (void*)format->format.type);
+ return ret;
+}
+
static char *
create_name (const BablModel *model,
@@ -190,7 +216,6 @@ create_name (const BablModel *model,
return babl_strdup (buf);
}
-
static char *
ncomponents_create_name (const Babl *type,
int components)
@@ -244,6 +269,7 @@ babl_format_n (const Babl *btype,
babl = format_new (name,
id,
planar, components, model,
+ babl_space("sRGB"),
component, sampling, type);
babl_format_set_is_format_n (babl);
@@ -264,12 +290,12 @@ babl_format_is_format_n (const Babl *format)
return 0;
}
-
static int
is_format_duplicate (Babl *babl,
int planar,
int components,
BablModel *model,
+ const Babl *space,
BablComponent **component,
BablSampling **sampling,
const BablType **type)
@@ -278,7 +304,8 @@ is_format_duplicate (Babl *babl,
if (babl->format.planar != planar ||
babl->format.components != components ||
- babl->format.model != model)
+ babl->format.model != model ||
+ babl->format.space != (void*)space)
return 0;
for (i = 0; i < components; i++)
@@ -301,6 +328,7 @@ babl_format_new (const void *first_arg,
int planar = 0;
int components = 0;
BablModel *model = NULL;
+ const Babl * space = babl_space ("sRGB");
BablComponent *component [BABL_MAX_COMPONENTS];
BablSampling *sampling [BABL_MAX_COMPONENTS];
const BablType*type [BABL_MAX_COMPONENTS];
@@ -370,6 +398,10 @@ babl_format_new (const void *first_arg,
current_sampling = (BablSampling *) arg;
break;
+ case BABL_SPACE:
+ space = (Babl*) arg;
+ break;
+
case BABL_MODEL:
if (model)
{
@@ -415,6 +447,15 @@ babl_format_new (const void *first_arg,
if (!name)
name = create_name (model, components, component, type);
+ if (space != babl_space ("sRGB"))
+ {
+ char *new_name = babl_malloc (strlen (name) +
+ strlen (babl_get_name ((Babl*)space)) + 1);
+ sprintf (new_name, "%s-%s", name, babl_get_name ((Babl*)space));
+ babl_free (name);
+ name = new_name;
+ }
+
if (!model)
{
babl_log ("no model specified for format '%s'", name);
@@ -438,7 +479,7 @@ babl_format_new (const void *first_arg,
/* There is an instance already registered by the required id/name,
* returning the preexistent one instead if it doesn't differ.
*/
- if (!is_format_duplicate (babl, planar, components, model,
+ if(0)if (!is_format_duplicate (babl, planar, components, model, space,
component, sampling, type))
babl_fatal ("BablFormat '%s' already registered "
"with different content!", name);
@@ -447,9 +488,9 @@ babl_format_new (const void *first_arg,
return babl;
}
- babl = format_new (name,
+ babl = format_new ((void*)name,
id,
- planar, components, model,
+ planar, components, model, space,
component, sampling, type);
babl_db_insert (db, babl);
@@ -649,6 +690,50 @@ babl_format_get_model (const Babl *format)
return NULL;
}
+const Babl * babl_format_get_space (const Babl *format)
+{
+ if (format->class_type == BABL_FORMAT)
+ {
+ return (Babl*)format->format.space;
+ }
+ return NULL;
+}
+
BABL_CLASS_IMPLEMENT (format)
+const Babl *
+babl_format_with_space (const char *name, const Babl *space)
+{
+ const Babl *ret = NULL;
+
+ if (!space) space = babl_space ("sRGB");
+ if (space->class_type == BABL_FORMAT)
+ {
+ space = space->format.space;
+ }
+ else if (space->class_type == BABL_MODEL)
+ {
+ space = space->model.space;
+ }
+ else if (space->class_type != BABL_SPACE)
+ {
+ return NULL;
+ }
+ if (space == babl_space("sRGB"))
+ return babl_format (name);
+
+ {
+ char *new_name = babl_malloc (strlen (name) +
+ strlen (babl_get_name ((Babl*)space)) + 1);
+ sprintf (new_name, "%s-%s", name, babl_get_name ((Babl*)space));
+
+ ret = babl_db_exist_by_name (db, new_name);
+ if (ret)
+ return ret;
+
+ ret = format_new_from_format_with_space (babl_format (name), space);
+ }
+ return ret;
+}
+
diff --git a/babl/babl-format.h b/babl/babl-format.h
index bc78f42..333b5ba 100644
--- a/babl/babl-format.h
+++ b/babl/babl-format.h
@@ -29,6 +29,7 @@ typedef struct
BablComponent **component;
BablType **type;
void *model_data;
+ const Babl *space;
void *image_template; /* image template for use with
linear (non-planer) images */
diff --git a/babl/babl-internal.h b/babl/babl-internal.h
index c193998..6ed9195 100644
--- a/babl/babl-internal.h
+++ b/babl/babl-internal.h
@@ -319,6 +319,10 @@ static inline double babl_parse_double (const char *str)
return result;
}
+const Babl *
+babl_remodel_with_space (const Babl *model, const Babl *space);
+const Babl *
+babl_model_with_space (const char *name, const Babl *space);
Babl *
_conversion_new (const char *name,
int id,
diff --git a/babl/babl-model.c b/babl/babl-model.c
index 02f3c0b..2cec2c3 100644
--- a/babl/babl-model.c
+++ b/babl/babl-model.c
@@ -33,7 +33,7 @@ babl_model_destroy (void *data)
Babl *babl = data;
if (babl->model.from_list)
babl_free (babl->model.from_list);
- return 0;
+ return 0;
}
static char *
@@ -53,6 +53,7 @@ babl_model_create_name (int components,
static Babl *
model_new (const char *name,
+ const Babl *space,
int id,
int components,
BablComponent **component)
@@ -69,6 +70,7 @@ model_new (const char *name,
babl->class_type = BABL_MODEL;
babl->instance.id = id;
babl->model.components = components;
+ babl->model.space = space;
strcpy (babl->instance.name, name);
memcpy (babl->model.component, component, sizeof (BablComponent *) * components);
@@ -77,10 +79,13 @@ model_new (const char *name,
}
static int
-is_model_duplicate (Babl *babl, int components, BablComponent **component)
+is_model_duplicate (Babl *babl, const Babl *space, int components, BablComponent **component)
{
int i;
+ if (babl->model.space != space)
+ return 0;
+
if (babl->model.components != components)
return 0;
@@ -105,6 +110,7 @@ babl_model_new (void *first_argument,
const char *arg = first_argument;
const char *assigned_name = NULL;
char *name = NULL;
+ const Babl *space = babl_space ("sRGB");
BablComponent *component [BABL_MAX_COMPONENTS];
va_start (varg, first_argument);
@@ -143,6 +149,10 @@ babl_model_new (void *first_argument,
babl_log ("submodels not handled yet");
break;
+ case BABL_SPACE:
+ space = bablc;
+ break;
+
case BABL_TYPE:
case BABL_TYPE_INTEGER:
case BABL_TYPE_FLOAT:
@@ -172,7 +182,7 @@ babl_model_new (void *first_argument,
else
{
babl_fatal ("unhandled argument '%s' for babl_model '%s'",
- arg, assigned_name ? assigned_name : "(unnamed)");
+ arg, assigned_name ? assigned_name : "(unnamed)");
}
arg = va_arg (varg, char *);
@@ -199,13 +209,13 @@ babl_model_new (void *first_argument,
if (! babl)
{
- babl = model_new (name, id, components, component);
+ babl = model_new (name, space, id, components, component);
babl_db_insert (db, babl);
construct_double_format (babl);
}
else
{
- if (!is_model_duplicate (babl, components, component))
+ if (!is_model_duplicate (babl, space, components, component))
babl_fatal ("BablModel '%s' already registered "
"with different components!", name);
}
@@ -350,3 +360,45 @@ babl_model_is_symmetric (const Babl *cbabl)
}
BABL_CLASS_IMPLEMENT (model)
+
+/* XXX: probably better to do like with babl_format, add a -suffix and
+ * insert in normal database than to have this static cache list
+ */
+static const Babl *babl_remodels[512]={NULL,};
+int babl_n_remodels = 0;
+
+const Babl *
+babl_remodel_with_space (const Babl *model, const Babl *space)
+{
+ Babl *ret;
+ int i;
+
+ if (model->model.space == space)
+ return (void*)model;
+
+ /* get back to the sRGB model if we are in a COW clone of it */
+ if (model->model.data)
+ model = (void*)model->model.data;
+
+ for (i = 0; i < babl_n_remodels; i++)
+ {
+ if (babl_remodels[i]->model.data == model &&
+ babl_remodels[i]->model.space == space)
+ return babl_remodels[i];
+ }
+
+ ret = babl_calloc (sizeof (BablModel), 1);
+ memcpy (ret, model, sizeof (BablModel));
+ ret->model.space = space;
+ ret->model.data = (void*)model; /* use the data as a backpointer to original model */
+ return babl_remodels[babl_n_remodels++] = ret;
+ return (Babl*)ret;
+}
+
+const Babl *
+babl_model_with_space (const char *name, const Babl *space)
+{
+ return babl_remodel_with_space (babl_model (name), space);
+}
+
+
diff --git a/babl/babl-model.h b/babl/babl-model.h
index 4561fdb..2395005 100644
--- a/babl/babl-model.h
+++ b/babl/babl-model.h
@@ -23,13 +23,16 @@ BABL_CLASS_DECLARE (model);
typedef struct
{
- BablInstance instance;
+ BablInstance instance;
BablList *from_list;
- int components;
- BablComponent **component;
- BablType **type; /*< must be doubles,
- used here for convenience in code */
- void *data; /* used for palette */
+ int components;
+ BablComponent **component;
+ BablType **type; /*< must be doubles,
+ used here for convenience in code */
+ void *data; /* used for palette - and maybe back pointer
+ to actual model?
+ */
+ const Babl *space;
} BablModel;
#endif
diff --git a/babl/babl.c b/babl/babl.c
index 9924fa7..7d5bf09 100644
--- a/babl/babl.c
+++ b/babl/babl.c
@@ -135,6 +135,7 @@ babl_init (void)
char * dir_list;
babl_internal_init ();
+ babl_space_class_init ();
babl_sampling_class_init ();
babl_type_db ();
babl_component_db ();
diff --git a/babl/base/model-gray.c b/babl/base/model-gray.c
index d2e7d68..ef10ce7 100644
--- a/babl/base/model-gray.c
+++ b/babl/base/model-gray.c
@@ -22,7 +22,6 @@
#include "babl-classes.h"
#include "babl.h"
#include "babl-ids.h"
-#include "util.h"
#include "rgb-constants.h"
#include "math.h"
#include "babl-base.h"
@@ -165,7 +164,6 @@ rgba_to_gray (Babl *conversion,
return n;
}
-
static long
rgb_to_gray_2_2 (Babl *conversion,
int src_bands,
@@ -176,6 +174,7 @@ rgb_to_gray_2_2 (Babl *conversion,
int *dst_pitch,
long n)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
BABL_PLANAR_SANITY
while (n--)
{
@@ -190,10 +189,10 @@ rgb_to_gray_2_2 (Babl *conversion,
else
alpha = 1.0;
- luminance = red * RGB_LUMINANCE_RED +
+ luminance = red * RGB_LUMINANCE_RED + // XXX: should be taken from BablSpace
green * RGB_LUMINANCE_GREEN +
- blue * RGB_LUMINANCE_BLUE;
- *(double *) dst[0] = linear_to_gamma_2_2 (luminance);
+ blue * RGB_LUMINANCE_BLUE;
+ *(double *) dst[0] = babl_space_from_linear (space, luminance);
if (dst_bands == 2)
*(double *) dst[1] = alpha;
@@ -205,7 +204,7 @@ rgb_to_gray_2_2 (Babl *conversion,
static long
-gray_2_2_to_rgb (Babl *conversion,
+gray_2_2_to_rgb (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
@@ -214,6 +213,7 @@ gray_2_2_to_rgb (Babl *conversion,
int *dst_pitch,
long n)
{
+ const Babl *space = babl_conversion_get_source_space (conversion);
BABL_PLANAR_SANITY
while (n--)
{
@@ -221,7 +221,7 @@ gray_2_2_to_rgb (Babl *conversion,
double red, green, blue;
double alpha;
- luminance = gamma_2_2_to_linear (*(double *) src[0]);
+ luminance = babl_space_to_linear (space, *(double *) src[0]);
red = luminance;
green = luminance;
blue = luminance;
@@ -302,7 +302,7 @@ gray_to_rgba (Babl *conversion,
}
static long
-gray_alpha_premultiplied_to_rgba (Babl *conversion,
+gray_alpha_premultiplied_to_rgba (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
@@ -340,7 +340,7 @@ gray_alpha_premultiplied_to_rgba (Babl *conversion,
static long
-rgba_to_gray_alpha_premultiplied (Babl *conversion,
+rgba_to_gray_alpha_premultiplied (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
@@ -445,6 +445,8 @@ rgba2gray_gamma_2_2_premultiplied (Babl *conversion,
char *dst,
long n)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
+
while (n--)
{
double red = ((double *) src)[0];
@@ -458,7 +460,7 @@ rgba2gray_gamma_2_2_premultiplied (Babl *conversion,
luminance = red * RGB_LUMINANCE_RED +
green * RGB_LUMINANCE_GREEN +
blue * RGB_LUMINANCE_BLUE;
- luma = linear_to_gamma_2_2 (luminance);
+ luma = babl_space_from_linear (space, luminance);
((double *) dst)[0] = luma * alpha;
((double *) dst)[1] = alpha;
@@ -469,12 +471,15 @@ rgba2gray_gamma_2_2_premultiplied (Babl *conversion,
return n;
}
+
static long
gray_gamma_2_2_premultiplied2rgba (Babl *conversion,
char *src,
char *dst,
long n)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
+
while (n--)
{
double luma = ((double *) src)[0];
@@ -482,7 +487,7 @@ gray_gamma_2_2_premultiplied2rgba (Babl *conversion,
double luminance;
luma = luma / alpha;
- luminance = gamma_2_2_to_linear (luma);
+ luminance = babl_space_to_linear (space, luma);
((double *) dst)[0] = luminance;
((double *) dst)[1] = luminance;
diff --git a/babl/base/model-rgb.c b/babl/base/model-rgb.c
index 69c3b53..b181888 100644
--- a/babl/base/model-rgb.c
+++ b/babl/base/model-rgb.c
@@ -23,7 +23,6 @@
#include "babl.h"
#include "babl-classes.h"
#include "babl-ids.h"
-#include "util.h"
#include "babl-base.h"
static void models (void);
@@ -151,7 +150,7 @@ models (void)
}
static long
-copy_strip_1 (BablConversion *conversion,
+copy_strip_1 (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
@@ -183,7 +182,7 @@ copy_strip_1 (BablConversion *conversion,
}
static long
-g3_gamma_2_2 (BablConversion *conversion,
+g3_gamma_2_2 (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
@@ -192,6 +191,8 @@ g3_gamma_2_2 (BablConversion *conversion,
int *dst_pitch,
long samples)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
+
long n = samples;
BABL_PLANAR_SANITY
@@ -199,7 +200,7 @@ g3_gamma_2_2 (BablConversion *conversion,
{
int band;
for (band = 0; band < 3; band++)
- *(double *) dst[band] = linear_to_gamma_2_2 (*(double *) src[band]);
+ *(double *) dst[band] = babl_space_from_linear (space, (*(double *) src[band]));
for (; band < dst_bands; band++)
*(double *) dst[band] = *(double *) src[band];
@@ -210,7 +211,7 @@ g3_gamma_2_2 (BablConversion *conversion,
static long
-g3_inv_gamma_2_2 (BablConversion *conversion,
+g3_inv_gamma_2_2 (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
@@ -219,6 +220,7 @@ g3_inv_gamma_2_2 (BablConversion *conversion,
int *dst_pitch,
long samples)
{
+ const Babl *space = babl_conversion_get_source_space (conversion);
long n = samples;
BABL_PLANAR_SANITY
@@ -227,7 +229,7 @@ g3_inv_gamma_2_2 (BablConversion *conversion,
int band;
for (band = 0; band < 3; band++)
{
- *(double *) dst[band] = gamma_2_2_to_linear (*(double *) src[band]);
+ *(double *) dst[band] = babl_space_to_linear (space, (*(double *) src[band]));
}
for (; band < dst_bands; band++)
{
@@ -242,7 +244,7 @@ g3_inv_gamma_2_2 (BablConversion *conversion,
}
static long
-non_premultiplied_to_premultiplied (BablConversion *conversion,
+non_premultiplied_to_premultiplied (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
@@ -272,7 +274,7 @@ non_premultiplied_to_premultiplied (BablConversion *conversion,
}
static long
-premultiplied_to_non_premultiplied (BablConversion *conversion,
+premultiplied_to_non_premultiplied (Babl *conversion,
int src_bands,
char **src,
int *src_pitch,
@@ -311,19 +313,20 @@ premultiplied_to_non_premultiplied (BablConversion *conversion,
static long
-rgba2rgba_gamma_2_2_premultiplied (BablConversion *conversion,
+rgba2rgba_gamma_2_2_premultiplied (Babl *conversion,
char *src,
char *dst,
long samples)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
long n = samples;
while (n--)
{
double alpha = ((double *) src)[3];
- ((double *) dst)[0] = linear_to_gamma_2_2 (((double *) src)[0]) * alpha;
- ((double *) dst)[1] = linear_to_gamma_2_2 (((double *) src)[1]) * alpha;
- ((double *) dst)[2] = linear_to_gamma_2_2 (((double *) src)[2]) * alpha;
+ ((double *) dst)[0] = babl_space_from_linear (space, ((double *) src)[0]) * alpha;
+ ((double *) dst)[1] = babl_space_from_linear (space, ((double *) src)[1]) * alpha;
+ ((double *) dst)[2] = babl_space_from_linear (space, ((double *) src)[2]) * alpha;
((double *) dst)[3] = alpha;
src += 4 * sizeof (double);
dst += 4 * sizeof (double);
@@ -333,11 +336,12 @@ rgba2rgba_gamma_2_2_premultiplied (BablConversion *conversion,
static long
-rgba_gamma_2_2_premultiplied2rgba (BablConversion *conversion,
+rgba_gamma_2_2_premultiplied2rgba (Babl *conversion,
char *src,
char *dst,
long samples)
{
+ const Babl *space = babl_conversion_get_source_space (conversion);
long n = samples;
while (n--)
@@ -345,9 +349,9 @@ rgba_gamma_2_2_premultiplied2rgba (BablConversion *conversion,
double alpha = ((double *) src)[3];
if (alpha > BABL_ALPHA_THRESHOLD)
{
- ((double *) dst)[0] = gamma_2_2_to_linear (((double *) src)[0] / alpha);
- ((double *) dst)[1] = gamma_2_2_to_linear (((double *) src)[1] / alpha);
- ((double *) dst)[2] = gamma_2_2_to_linear (((double *) src)[2] / alpha);
+ ((double *) dst)[0] = babl_space_to_linear (space, ((double *) src)[0] / alpha);
+ ((double *) dst)[1] = babl_space_to_linear (space, ((double *) src)[1] / alpha);
+ ((double *) dst)[2] = babl_space_to_linear (space, ((double *) src)[2] / alpha);
}
else
{
@@ -365,19 +369,20 @@ rgba_gamma_2_2_premultiplied2rgba (BablConversion *conversion,
static long
-rgba2rgba_gamma_2_2 (BablConversion *conversion,
- char *src,
- char *dst,
- long samples)
+rgba2rgba_gamma_2_2 (Babl *conversion,
+ char *src,
+ char *dst,
+ long samples)
{
+ const Babl *space = babl_conversion_get_destination_space (conversion);
long n = samples;
while (n--)
{
double alpha = ((double *) src)[3];
- ((double *) dst)[0] = linear_to_gamma_2_2 (((double *) src)[0]);
- ((double *) dst)[1] = linear_to_gamma_2_2 (((double *) src)[1]);
- ((double *) dst)[2] = linear_to_gamma_2_2 (((double *) src)[2]);
+ ((double *) dst)[0] = babl_space_from_linear (space, ((double *) src)[0]);
+ ((double *) dst)[1] = babl_space_from_linear (space, ((double *) src)[1]);
+ ((double *) dst)[2] = babl_space_from_linear (space, ((double *) src)[2]);
((double *) dst)[3] = alpha;
src += 4 * sizeof (double);
dst += 4 * sizeof (double);
@@ -387,19 +392,20 @@ rgba2rgba_gamma_2_2 (BablConversion *conversion,
static long
-rgba_gamma_2_22rgba (BablConversion *conversion,
+rgba_gamma_2_22rgba (Babl *conversion,
char *src,
char *dst,
long samples)
{
+ const Babl *space = babl_conversion_get_source_space (conversion);
long n = samples;
while (n--)
{
double alpha = ((double *) src)[3];
- ((double *) dst)[0] = gamma_2_2_to_linear (((double *) src)[0]);
- ((double *) dst)[1] = gamma_2_2_to_linear (((double *) src)[1]);
- ((double *) dst)[2] = gamma_2_2_to_linear (((double *) src)[2]);
+ ((double *) dst)[0] = babl_space_to_linear (space, ((double *) src)[0]);
+ ((double *) dst)[1] = babl_space_to_linear (space, ((double *) src)[1]);
+ ((double *) dst)[2] = babl_space_to_linear (space, ((double *) src)[2]);
((double *) dst)[3] = alpha;
src += 4 * sizeof (double);
@@ -487,7 +493,6 @@ static void
formats (void)
{
babl_format_new (
- /*"name", "srgb",*/
"id", BABL_SRGB,
babl_model_from_id (BABL_RGB_GAMMA_2_2),
babl_type_from_id (BABL_U8),
@@ -508,8 +513,8 @@ formats (void)
babl_format_new (
"id", BABL_RGBA_FLOAT,
- babl_model_from_id (BABL_RGBA),
- babl_type_from_id (BABL_FLOAT),
+ babl_model_from_id (BABL_RGBA),
+ babl_type_from_id (BABL_FLOAT),
babl_component_from_id (BABL_RED),
babl_component_from_id (BABL_GREEN),
babl_component_from_id (BABL_BLUE),
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
