gegl: add gegl_babl_variant

This function returns a babl format derived from the passed in format,
based on which variant is requested it will at least be floating point
and possibly also premultiplied forced, the enum/bitflags available
as an argument is a work in progress.
parent 365e53a5
...@@ -107,3 +107,33 @@ gegl_orientation_get_type (void) ...@@ -107,3 +107,33 @@ gegl_orientation_get_type (void)
return etype; return etype;
} }
GType
gegl_babl_variant_get_type (void)
{
static GType etype = 0;
if (etype == 0)
{
static GEnumValue values[] = {
{ GEGL_BABL_VARIANT_FLOAT, N_("Float"), "float"},
{ GEGL_BABL_VARIANT_LINEAR, N_("Linear"), "linear"},
{ GEGL_BABL_VARIANT_NONLINEAR, N_("Non-linear"), "non-linear"},
{ GEGL_BABL_VARIANT_PERCEPTUAL, N_("Perceptual"), "perceptual"},
{ GEGL_BABL_VARIANT_LINEAR_PREMULTIPLIED, N_("Linear-premultiplied"), "linear-premultiplied"},
{ GEGL_BABL_VARIANT_PERCEPTUAL_PREMULTIPLIED, N_("Perceptual-premultiplied"), "perceptual-premultiplied"},
{ GEGL_BABL_VARIANT_LINEAR_PREMULTIPLIED_IF_ALPHA, N_("Linear-premultiplied-if-alpha"), "linear-premultiplied-if-alpha"},
{ GEGL_BABL_VARIANT_PERCEPTUAL_PREMULTIPLIED_IF_ALPHA, N_("Perceptual-premultiplied-if-alpha"), "perceptual-premultiplied-if-alpha"},
{ 0, NULL, NULL }
};
gint i;
for (i = 0; i < G_N_ELEMENTS (values); i++)
if (values[i].value_name)
values[i].value_name =
dgettext (GETTEXT_PACKAGE, values[i].value_name);
etype = g_enum_register_static ("GeglBablVariant", values);
}
return etype;
}
...@@ -72,6 +72,32 @@ GType gegl_orientation_get_type (void) G_GNUC_CONST; ...@@ -72,6 +72,32 @@ GType gegl_orientation_get_type (void) G_GNUC_CONST;
#define GEGL_TYPE_ORIENTATION (gegl_orientation_get_type ()) #define GEGL_TYPE_ORIENTATION (gegl_orientation_get_type ())
enum _GeglBablVariant
{
GEGL_BABL_VARIANT_FLOAT=0,
/* pass this one to just ensure a format is float */
GEGL_BABL_VARIANT_LINEAR,
/* Y YA RGB RGBA */
GEGL_BABL_VARIANT_NONLINEAR,
/* Y' Y'A R'G'B' R'G'B'A */
GEGL_BABL_VARIANT_PERCEPTUAL,
/* Y~ Y~A R~G~B~ R~G~B~A */
GEGL_BABL_VARIANT_LINEAR_PREMULTIPLIED,
/* YaA RaGaBaA */
GEGL_BABL_VARIANT_PERCEPTUAL_PREMULTIPLIED,
/* Y~aA R~aG~aB~aA */
GEGL_BABL_VARIANT_LINEAR_PREMULTIPLIED_IF_ALPHA,
/* Y YaA RGB RaGaBaA */
GEGL_BABL_VARIANT_PERCEPTUAL_PREMULTIPLIED_IF_ALPHA,
/* Y~ Y~aA R~G~B~A R~aG~aB~aA */
};
typedef enum _GeglBablVariant GeglBablVariant;
GType gegl_babl_variant_get_type (void) G_GNUC_CONST;
#define GEGL_TYPE_BABL_VARIANT (gegl_babl_variant_get_type ())
G_END_DECLS G_END_DECLS
#endif /* __GEGL_ENUMS_H__ */ #endif /* __GEGL_ENUMS_H__ */
...@@ -42,3 +42,299 @@ gegl_buffer_set_color (GeglBuffer *dst, ...@@ -42,3 +42,299 @@ gegl_buffer_set_color (GeglBuffer *dst,
gegl_buffer_set_color_from_pixel (dst, dst_rect, &pixel[0], format); gegl_buffer_set_color_from_pixel (dst, dst_rect, &pixel[0], format);
} }
static const Babl *gegl_babl_format_linear_float (const Babl *format)
{
const Babl *space = babl_format_get_space (format);
const Babl *model = NULL;
if (!format)
return babl_format ("RGBA float");
model = babl_format_get_model (format);
if (babl_model_is (model, "Y") ||
babl_model_is (model, "Y'") ||
babl_model_is (model, "Y~"))
{
format = babl_format_with_space ("Y float", space);
}
else if (babl_model_is (model, "YA") ||
babl_model_is (model, "Y'A") ||
babl_model_is (model, "Y~A") ||
babl_model_is (model, "YaA") ||
babl_model_is (model, "Y'aA"))
{
format = babl_format_with_space ("YA float", space);
}
else if (babl_model_is (model, "RGB") ||
babl_model_is (model, "R'G'B'") ||
babl_model_is (model, "R~G~B~"))
{
format = babl_format_with_space ("RGB float", space);
}
#if 0 // just treat as else
babl_model_is (model, "RGBA") ||
babl_model_is (model, "R'G'B'A") ||
babl_model_is (model, "R'G'B'") ||
babl_model_is (model, "R~G~B~A") ||
babl_model_is (model, "R~G~B~") ||
babl_model_is (model, "RaGaBaA") ||
babl_model_is (model, "R'aG'aB'aA"))
{
format = babl_format_with_space (use_srgb?"R~aG~aB~aA float":"RaGaBaA float", space);
}
#endif
else
{
format = babl_format_with_space ("RGBA float", space);
}
return format;
}
static const Babl *gegl_babl_format_perceptual_float (const Babl *format)
{
const Babl *space = babl_format_get_space (format);
const Babl *model = NULL;
if (!format)
return babl_format ("R~G~B~A float");
model = babl_format_get_model (format);
if (babl_model_is (model, "Y") ||
babl_model_is (model, "Y'") ||
babl_model_is (model, "Y~"))
{
format = babl_format_with_space ("Y~ float", space);
}
else if (babl_model_is (model, "YA") ||
babl_model_is (model, "Y'A") ||
babl_model_is (model, "Y~A") ||
babl_model_is (model, "YaA") ||
babl_model_is (model, "Y'aA"))
{
format = babl_format_with_space ("Y~A float", space);
}
else if (babl_model_is (model, "RGB") ||
babl_model_is (model, "R'G'B'") ||
babl_model_is (model, "R~G~B~"))
{
format = babl_format_with_space ("R~G~B~ float", space);
}
#if 0 // just treat as else
babl_model_is (model, "RGBA") ||
babl_model_is (model, "R'G'B'A") ||
babl_model_is (model, "R'G'B'") ||
babl_model_is (model, "R~G~B~A") ||
babl_model_is (model, "R~G~B~") ||
babl_model_is (model, "RaGaBaA") ||
babl_model_is (model, "R'aG'aB'aA"))
{
format = babl_format_with_space (use_srgb?"R~aG~aB~aA float":"RaGaBaA float", space);
}
#endif
else
{
format = babl_format_with_space ("R~G~B~A float", space);
}
return format;
}
static const Babl *gegl_babl_format_nonlinear_float (const Babl *format)
{
const Babl *space = babl_format_get_space (format);
const Babl *model = NULL;
if (!format)
return babl_format ("R'G'B'A float");
model = babl_format_get_model (format);
if (babl_model_is (model, "Y") ||
babl_model_is (model, "Y'") ||
babl_model_is (model, "Y~"))
{
format = babl_format_with_space ("Y' float", space);
}
else if (babl_model_is (model, "YA") ||
babl_model_is (model, "Y'A") ||
babl_model_is (model, "Y~A") ||
babl_model_is (model, "YaA") ||
babl_model_is (model, "Y'aA"))
{
format = babl_format_with_space ("Y'A float", space);
}
else if (babl_model_is (model, "RGB") ||
babl_model_is (model, "R'G'B'") ||
babl_model_is (model, "R~G~B~"))
{
format = babl_format_with_space ("R'G'B' float", space);
}
#if 0 // just treat as else
babl_model_is (model, "RGBA") ||
babl_model_is (model, "R'G'B'A") ||
babl_model_is (model, "R'G'B'") ||
babl_model_is (model, "R~G~B~A") ||
babl_model_is (model, "R~G~B~") ||
babl_model_is (model, "RaGaBaA") ||
babl_model_is (model, "R'aG'aB'aA"))
{
format = babl_format_with_space (use_srgb?"R~aG~aB~aA float":"RaGaBaA float", space);
}
#endif
else
{
format = babl_format_with_space ("R'G'B'A float", space);
}
return format;
}
static const Babl *gegl_babl_format_premultiplied_linear_float (const Babl *format)
{
const Babl *space = babl_format_get_space (format);
const Babl *model = NULL;
if (!format)
return babl_format ("RaGaBaA float");
model = babl_format_get_model (format);
if (babl_model_is (model, "Y") ||
babl_model_is (model, "Y'") ||
babl_model_is (model, "Y~") ||
babl_model_is (model, "YA") ||
babl_model_is (model, "Y'A") ||
babl_model_is (model, "Y~A") ||
babl_model_is (model, "YaA") ||
babl_model_is (model, "Y'aA"))
{
format = babl_format_with_space ("YaA float", space);
}
#if 0 // just treat as else
else if (babl_model_is (model, "RGB") ||
babl_model_is (model, "R'G'B'") ||
babl_model_is (model, "R~G~B~") ||
babl_model_is (model, "RGBA") ||
babl_model_is (model, "RGB") ||
babl_model_is (model, "R'G'B'A") ||
babl_model_is (model, "R'G'B'") ||
babl_model_is (model, "R~G~B~A") ||
babl_model_is (model, "R~G~B~") ||
babl_model_is (model, "RaGaBaA") ||
babl_model_is (model, "R'aG'aB'aA"))
{
format = babl_format_with_space (use_srgb?"R~aG~aB~aA float":"RaGaBaA float", space);
}
#endif
else
{
format = babl_format_with_space ("RaGaBaA float", space);
}
return format;
}
static const Babl *gegl_babl_format_premultiplied_perceptual_float (const Babl *format)
{
const Babl *space = babl_format_get_space (format);
const Babl *model = NULL;
if (!format)
return babl_format ("R~aG~aB~aA float");
model = babl_format_get_model (format);
if (babl_model_is (model, "Y") ||
babl_model_is (model, "Y'") ||
babl_model_is (model, "Y~") ||
babl_model_is (model, "YA") ||
babl_model_is (model, "Y'A") ||
babl_model_is (model, "Y~A") ||
babl_model_is (model, "YaA") ||
babl_model_is (model, "Y'aA"))
{
format = babl_format_with_space ("Y~aA float", space);
}
#if 0 // just treat as else
else if (babl_model_is (model, "RGB") ||
babl_model_is (model, "R'G'B'") ||
babl_model_is (model, "R~G~B~") ||
babl_model_is (model, "RGBA") ||
babl_model_is (model, "RGB") ||
babl_model_is (model, "R'G'B'A") ||
babl_model_is (model, "R'G'B'") ||
babl_model_is (model, "R~G~B~A") ||
babl_model_is (model, "R~G~B~") ||
babl_model_is (model, "RaGaBaA") ||
babl_model_is (model, "R'aG'aB'aA"))
{
format = babl_format_with_space (use_srgb?"R~aG~aB~aA float":"RaGaBaA float", space);
}
#endif
else
{
format = babl_format_with_space ("R~aG~aB~aA float", space);
}
return format;
}
static const Babl *gegl_babl_format_float (const Babl *format)
{
const Babl *space;
const char *encoding;
if (!format)
return NULL;
space = babl_format_get_space (format);
encoding = babl_format_get_encoding (format);
char *encdup = g_strdup (encoding);
char *newenc;
char *s = strrchr (encdup, ' ');
if (s) *s = 0;
newenc = g_strdup_printf ("%s float", encdup);
format = babl_format_with_space (newenc, space);
g_free (encdup);
g_free (newenc);
return format;
}
static const Babl *gegl_babl_format_float_premultiplied_linear_if_alpha (const Babl *format)
{
if (!format)
return NULL;
if (babl_format_has_alpha (format))
return gegl_babl_format_premultiplied_linear_float (format);
return gegl_babl_format_float (format);
}
static const Babl *gegl_babl_format_float_premultiplied_perceptual_if_alpha (const Babl *format)
{
if (!format)
return NULL;
if (babl_format_has_alpha (format))
return gegl_babl_format_premultiplied_perceptual_float (format);
return gegl_babl_format_float (format);
}
const Babl *gegl_babl_variant (const Babl *format, GeglBablVariant variant)
{
if (!format)
return NULL;
switch (variant)
{
case GEGL_BABL_VARIANT_FLOAT:
return gegl_babl_format_float (format);
case GEGL_BABL_VARIANT_LINEAR:
return gegl_babl_format_linear_float (format);
case GEGL_BABL_VARIANT_NONLINEAR:
return gegl_babl_format_nonlinear_float (format);
case GEGL_BABL_VARIANT_PERCEPTUAL:
return gegl_babl_format_perceptual_float (format);
case GEGL_BABL_VARIANT_LINEAR_PREMULTIPLIED:
return gegl_babl_format_premultiplied_linear_float (format);
case GEGL_BABL_VARIANT_PERCEPTUAL_PREMULTIPLIED:
return gegl_babl_format_premultiplied_perceptual_float (format);
case GEGL_BABL_VARIANT_LINEAR_PREMULTIPLIED_IF_ALPHA:
return gegl_babl_format_float_premultiplied_linear_if_alpha (format);
case GEGL_BABL_VARIANT_PERCEPTUAL_PREMULTIPLIED_IF_ALPHA:
return gegl_babl_format_float_premultiplied_perceptual_if_alpha (format);
}
return format;
}
...@@ -116,6 +116,8 @@ void gegl_buffer_set_color (GeglBuffer *buffer, ...@@ -116,6 +116,8 @@ void gegl_buffer_set_color (GeglBuffer *buffer,
const GeglRectangle *rect, const GeglRectangle *rect,
GeglColor *color); GeglColor *color);
const Babl *gegl_babl_variant (const Babl *format, GeglBablVariant variant);
G_END_DECLS G_END_DECLS
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment