static void
prepare (GeglOperation *operation)
{
const Babl *src_format = gegl_operation_get_source_format (operation, "input");
const char *format = "RGB float";
if (src_format)
{
const Babl *model = babl_format_get_model (src_format);
if (model == babl_model ("RGB"))
format = "RGB float";
else if (model == babl_model ("RGBA"))
format = "RGBA float";
else if (model == babl_model ("R'G'B'"))
format = "R'G'B' float";
else if (model == babl_model ("R'G'B'A"))
format = "R'G'B'A float";
else if (babl_format_has_alpha (src_format))
format = "RGBA float";
}
gegl_operation_set_format (operation, "input", babl_format (format));
gegl_operation_set_format (operation, "output", babl_format (format));
}
static void
load_buffer (GeglProperties *op_raw_load)
{
if (!op_raw_load->user_data)
{
FILE *pfp;
gchar *command;
gint width, height, val_max;
gchar newline;
command = g_strdup_printf ("dcraw -4 -c '%s'\n", op_raw_load->path);
pfp = popen (command, PIPE_MODE);
g_free (command);
if (fscanf (pfp, "P6 %d %d %d %c",
&width, &height, &val_max, &newline) != 4)
{
pclose (pfp);
g_warning ("not able to aquire raw data");
return;
}
{
GeglRectangle extent = { 0, 0, 0, 0 };
extent.width = width;
extent.height = height;
op_raw_load->user_data = (gpointer) gegl_buffer_new (&extent,
babl_format_new (
babl_model ("RGB"),
babl_type ("u16"),
babl_component ("G"),
babl_component ("B"),
babl_component ("R"),
NULL));
}
{
guint16 *buf = g_new (guint16, width * height * 3);
fread (buf, 1, width * height * 3 * 2, pfp);
gegl_buffer_set (GEGL_BUFFER (op_raw_load->user_data),
NULL,
0,
babl_format_new (
babl_model ("RGB"),
babl_type ("u16"),
babl_component ("G"),
babl_component ("B"),
babl_component ("R"),
NULL),
buf,
GEGL_AUTO_ROWSTRIDE
);
g_free (buf);
}
fclose (pfp);
}
}
static void
conversions (void)
{
babl_conversion_new (
babl_model ("RGBA"),
babl_model ("Y'CbCr709"),
"linear", rgba_to_ycbcr709,
NULL
);
babl_conversion_new (
babl_model ("RGBA"),
babl_model ("Y'CbCrA709"),
"linear", rgba_to_ycbcra709,
NULL
);
babl_conversion_new (
babl_model ("Y'CbCrA709"),
babl_model ("RGBA"),
"linear", ycbcra709_to_rgba,
NULL
);
babl_conversion_new (
babl_model ("Y'CbCr709"),
babl_model ("RGBA"),
"linear", ycbcr709_to_rgba,
NULL
);
}
static void
prepare (GeglOperation *operation)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
const Babl *src_format = gegl_operation_get_source_format (operation, "input");
const Babl *input_format = babl_format ("RGB double");
gint n_components = 3;
const Babl *output_format;
if (src_format)
{
const Babl *model = babl_format_get_model (src_format);
if (model == babl_model ("RGB") || model == babl_model ("R'G'B'") ||
model == babl_model ("RGBA") || model == babl_model ("R'G'B'A"))
{
input_format = babl_format ("RGB double");
n_components = 3;
}
else if (model == babl_model ("Y") || model == babl_model ("Y'") ||
model == babl_model ("YA") || model == babl_model ("Y'A"))
{
input_format = babl_format ("Y double");
n_components = 1;
}
}
if (o->squared)
n_components *= 2;
output_format = babl_format_n (babl_type ("double"), n_components);
gegl_operation_set_format (operation, "input", input_format);
gegl_operation_set_format (operation, "output", output_format);
}
static void
gegl_gblur_1d_prepare (GeglOperation *operation)
{
const Babl *src_format = gegl_operation_get_source_format (operation, "input");
const char *format = "RaGaBaA float";
/*
* FIXME: when the abyss policy is _NONE, the behavior at the edge
* depends on input format (with or without an alpha component)
*/
if (src_format)
{
const Babl *model = babl_format_get_model (src_format);
if (model == babl_model ("RGB") || model == babl_model ("R'G'B'"))
format = "RGB float";
else if (model == babl_model ("Y") || model == babl_model ("Y'"))
format = "Y float";
else if (model == babl_model ("YA") || model == babl_model ("Y'A") ||
model == babl_model ("YaA") || model == babl_model ("Y'aA"))
format = "YaA float";
}
gegl_operation_set_format (operation, "output", babl_format (format));
}
GimpImageBaseType
gimp_babl_format_get_base_type (const Babl *format)
{
const Babl *model;
g_return_val_if_fail (format != NULL, -1);
model = babl_format_get_model (format);
if (model == babl_model ("Y") ||
model == babl_model ("Y'") ||
model == babl_model ("YA") ||
model == babl_model ("Y'A"))
{
return GIMP_GRAY;
}
else if (model == babl_model ("RGB") ||
model == babl_model ("R'G'B'") ||
model == babl_model ("RGBA") ||
model == babl_model ("R'G'B'A"))
{
return GIMP_RGB;
}
else if (babl_format_is_palette (format))
{
return GIMP_INDEXED;
}
g_return_val_if_reached (-1);
}
gboolean
gimp_babl_format_get_linear (const Babl *format)
{
const Babl *model;
g_return_val_if_fail (format != NULL, FALSE);
model = babl_format_get_model (format);
if (model == babl_model ("Y") ||
model == babl_model ("YA") ||
model == babl_model ("RGB") ||
model == babl_model ("RGBA"))
{
return TRUE;
}
else if (model == babl_model ("Y'") ||
model == babl_model ("Y'A") ||
model == babl_model ("R'G'B'") ||
model == babl_model ("R'G'B'A"))
{
return FALSE;
}
else if (babl_format_is_palette (format))
{
return FALSE;
}
g_return_val_if_reached (FALSE);
}
static void
conversions (void)
{
babl_conversion_new (
babl_model ("RGBA"),
babl_model ("HSVA"),
"linear", rgba_to_hsva,
NULL
);
babl_conversion_new (
babl_model ("RGBA"),
babl_model ("HSV"),
"linear", rgba_to_hsv,
NULL
);
babl_conversion_new (
babl_model ("HSVA"),
babl_model ("RGBA"),
"linear", hsva_to_rgba,
NULL
);
babl_conversion_new (
babl_model ("HSV"),
babl_model ("RGBA"),
"linear", hsv_to_rgba,
NULL
);
}
static int
test_buffer_cast (void)
{
gint result = SUCCESS;
GeglBuffer *buffer = gegl_buffer_new (GEGL_RECTANGLE (0,0,1,1),
babl_format ("R'G'B'A u8"));
GeglBuffer *cbuffer = gegl_buffer_new (GEGL_RECTANGLE (0,0,1,1),
babl_format ("Y u8"));
guchar srcpix[4] = {1,2,3,4};
guchar dstpix[4] = {0};
gegl_buffer_set (buffer, NULL, 0, NULL, srcpix, GEGL_AUTO_ROWSTRIDE);
gegl_buffer_set_format (cbuffer,
babl_format_new ("name", "B' u8",
babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("B'"),
NULL));
gegl_buffer_copy (buffer, NULL, cbuffer, NULL);
gegl_buffer_set_format (cbuffer, NULL);
gegl_buffer_get (cbuffer, NULL, 1.0, NULL,
dstpix, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
if (dstpix[0] != 3)
result = FAILURE;
g_object_unref (buffer);
g_object_unref (cbuffer);
return result;
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
const GeglRectangle *result,
gint level)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
SDLState *state = NULL;
if(!o->chant_data)
o->chant_data = g_new0 (SDLState, 1);
state = o->chant_data;
init_sdl ();
if (!handle)
handle = g_timeout_add (500, idle, NULL);
if (!state->screen ||
state->width != result->width ||
state->height != result->height)
{
state->screen = SDL_SetVideoMode (result->width, result->height, 32, SDL_SWSURFACE);
if (!state->screen)
{
fprintf (stderr, "Unable to set SDL mode: %s\n",
SDL_GetError ());
return -1;
}
state->width = result->width ;
state->height = result->height;
}
/*
* There seems to be a valid faster path to the SDL desired display format
* in B'G'R'A, perhaps babl should have been able to figure this out ito?
*
*/
gegl_buffer_get (input,
NULL,
1.0,
babl_format_new (babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("B'"),
babl_component ("G'"),
babl_component ("R'"),
babl_component ("A"),
NULL),
state->screen->pixels, GEGL_AUTO_ROWSTRIDE,
GEGL_ABYSS_NONE);
SDL_UpdateRect (state->screen, 0, 0, 0, 0);
SDL_WM_SetCaption (o->window_title, o->icon_title);
state->width = result->width ;
state->height = result->height;
return TRUE;
}
MyPaintGeglTiledSurface *
mypaint_gegl_tiled_surface_new(void)
{
MyPaintGeglTiledSurface *self = (MyPaintGeglTiledSurface *)malloc(sizeof(MyPaintGeglTiledSurface));
mypaint_tiled_surface_init(&self->parent, tile_request_start, tile_request_end);
// MyPaintSurface vfuncs
self->parent.parent.destroy = free_gegl_tiledsurf;
self->parent.parent.save_png = save_png;
self->parent.threadsafe_tile_requests = TRUE;
self->buffer = NULL;
gegl_rectangle_set(&self->extent_rect, 0, 0, 0, 0);
self->format = babl_format_new(babl_model ("R'aG'aB'aA"), babl_type ("u15"),
babl_component("R'a"), babl_component("G'a"), babl_component("B'a"), babl_component("A"),
NULL);
g_assert(self->format);
mypaint_gegl_tiled_surface_set_buffer(self, NULL);
return self;
}
int
init (void)
{
int testint = 23;
char *testchar = (char*) &testint;
int littleendian = (testchar[0] == 23);
if (littleendian)
{
const Babl *f24 = babl_format_new (
"name", "cairo-RGB24",
babl_model ("R'G'B'"),
babl_type ("u8"),
babl_component ("B'"),
babl_component ("G'"),
babl_component ("R'"),
babl_component ("PAD"),
NULL
);
babl_conversion_new (babl_format ("RGB float"),
f24,
"linear",
conv_rgbfloat_linear_cairo24_le,
NULL);
babl_conversion_new (babl_format ("RGBA float"),
f24,
"linear",
conv_rgbafloat_linear_cairo24_le,
NULL);
}
babl_conversion_new (babl_format ("RGBA float"),
babl_format ("R'G'B' u8"),
"linear",
conv_rgbafloat_linear_rgbu8_gamma,
NULL);
babl_conversion_new (babl_format ("RGB float"),
babl_format ("R'G'B' u8"),
"linear",
conv_rgbfloat_linear_rgbu8_gamma,
NULL);
babl_conversion_new (babl_format ("Y float"),
babl_format ("Y' u8"),
"linear",
conv_yfloat_linear_yu8_gamma,
NULL);
babl_conversion_new (babl_format ("YA float"),
babl_format ("Y'A u8"),
"linear",
conv_yafloat_linear_yau8_gamma,
NULL);
return 0;
}
static void prepare (GeglOperation *operation)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
const Babl *format;
const Babl *input_format;
const Babl *input_model;
const Babl *lch_model;
input_format = gegl_operation_get_source_format (operation, "input");
if (input_format == NULL)
return;
input_model = babl_format_get_model (input_format);
if (babl_format_has_alpha (input_format))
{
lch_model = babl_model ("CIE LCH(ab) alpha");
if (input_model == lch_model)
{
format = babl_format ("CIE LCH(ab) alpha float");
o->user_data = process_lch_alpha;
}
else
{
format = babl_format ("CIE Lab alpha float");
o->user_data = process_lab_alpha;
}
}
else
{
lch_model = babl_model ("CIE LCH(ab)");
if (input_model == lch_model)
{
format = babl_format ("CIE LCH(ab) float");
o->user_data = process_lch;
}
else
{
format = babl_format ("CIE Lab float");
o->user_data = process_lab;
}
}
gegl_operation_set_format (operation, "input", format);
gegl_operation_set_format (operation, "output", format);
}
static void
load_buffer (GeglProperties *op_raw_load)
{
if (!op_raw_load->user_data)
{
FILE *pfp;
gchar *command;
gint width, height, val_max;
char newline;
command = g_strdup_printf ("dcraw -j -d -4 -c '%s'\n", op_raw_load->path);
pfp = popen (command, PIPE_MODE);
g_free (command);
if (fscanf (pfp, "P6 %d %d %d %c",
&width, &height, &val_max, &newline) != 4)
{
pclose (pfp);
g_warning ("not able to aquire raw data");
return;
}
{
GeglRectangle extent = { 0, 0, width, height };
op_raw_load->user_data = (void*)gegl_buffer_new (&extent, babl_format ("Y u16"));
}
{
guchar *buf = g_new (guchar, width * height * 3 * 2);
fread (buf, 1, width * height * 3 * 2, pfp);
if(strstr (op_raw_load->path, "rawbayerS")){
gint i;
for (i=0;i<width*height*3;i++)
{
guchar tmp = buf[i*2];
buf[i*2] = buf[i*2+1];
buf[i*2+1] = tmp;
}
}
gegl_buffer_set (GEGL_BUFFER (op_raw_load->user_data),
NULL,
0,
babl_format_new (
babl_model ("RGB"),
babl_type ("u16"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
NULL),
buf,
GEGL_AUTO_ROWSTRIDE);
g_free (buf);
}
fclose (pfp);
}
}
static void
init_path_instrumentation (FishPathInstrumentation *fpi,
Babl *fmt_source,
Babl *fmt_destination)
{
long ticks_start = 0;
long ticks_end = 0;
if (!fpi->fmt_rgba_double)
{
fpi->fmt_rgba_double = babl_format_new (
babl_model ("RGBA"),
babl_type ("double"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
}
if (!fpi->test)
fpi->test = test_create (); // <- test_create utiliza var static dentro de la función
fpi->fish_rgba_to_source = babl_fish_reference (fpi->fmt_rgba_double,
fmt_source);
fpi->fish_reference = babl_fish_reference (fmt_source,
fmt_destination);
fpi->fish_destination_to_rgba = babl_fish_reference (fmt_destination,
fpi->fmt_rgba_double);
fpi->source = babl_calloc (NUM_TEST_PIXELS,
fmt_source->format.bytes_per_pixel);
fpi->destination = babl_calloc (NUM_TEST_PIXELS,
fmt_destination->format.bytes_per_pixel);
fpi->ref_destination = babl_calloc (NUM_TEST_PIXELS,
fmt_destination->format.bytes_per_pixel);
fpi->destination_rgba_double = babl_calloc (NUM_TEST_PIXELS,
fpi->fmt_rgba_double->format.bytes_per_pixel);
fpi->ref_destination_rgba_double = babl_calloc (NUM_TEST_PIXELS,
fpi->fmt_rgba_double->format.bytes_per_pixel);
/* create sourcebuffer from testbuffer in the correct format */
babl_process (fpi->fish_rgba_to_source,
fpi->test, fpi->source, NUM_TEST_PIXELS);
/* calculate the reference buffer of how it should be */
ticks_start = babl_ticks ();
babl_process (fpi->fish_reference,
fpi->source, fpi->ref_destination, NUM_TEST_PIXELS);
ticks_end = babl_ticks ();
fpi->reference_cost = babl_process_cost (ticks_start, ticks_end);
/* transform the reference destination buffer to RGBA */
babl_process (fpi->fish_destination_to_rgba,
fpi->ref_destination, fpi->ref_destination_rgba_double, NUM_TEST_PIXELS);
}
static int
test (void)
{
const Babl *fish;
int i;
int OK = 1;
fish = babl_fish (
babl_format_new (
babl_model ("Y"),
babl_type ("float"),
babl_component ("Y"),
NULL
),
babl_format_new (
babl_model ("RGB"),
babl_type ("float"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
NULL
)
);
babl_process (fish,
grayscale_buf, rgb_buf,
PIXELS);
for (i = 0; i < PIXELS * 3; i++)
{
if (rgb_buf[i] != rgb_buf_ref[i])
{
babl_log ("index %i is problematic : %f instead of %f",
i, rgb_buf[i], rgb_buf_ref[i]);
OK = 0;
}
}
if (!OK)
return -1;
return 0;
}
static int
test (void)
{
const Babl *fish;
int i;
int OK = 1;
fish = babl_fish (
babl_format_new (
babl_model ("RGB"),
babl_type ("u8"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
NULL
),
babl_format_new (
babl_model ("RGB"),
babl_type ("u8"),
babl_component ("B"),
babl_component ("G"),
babl_component ("R"),
NULL
)
);
babl_process (fish, source_buf, destination_buf, PIXELS);
for (i = 0; i < PIXELS * 3; i++)
{
if (abs (destination_buf[i] - reference_buf[i]) > TOLERANCE)
{
babl_log ("%2i (%2i%%3=%i, %2i/3=%i) is %i should be %i",
i, i, i % 3, i, i / 3, destination_buf[i], reference_buf[i]);
OK = 0;
}
}
if (!OK)
return -1;
return 0;
}
static void
formats (void)
{
babl_format_new (
babl_model ("Y'CbCrA709"),
babl_type ("float"),
babl_component ("Y'"),
babl_type ("float"),
babl_component ("Cb"),
babl_component ("Cr"),
babl_component ("alpha"),
NULL);
babl_format_new (
babl_model ("Y'CbCr709"),
babl_type ("float"),
babl_component ("Y'"),
babl_type ("float"),
babl_component ("Cb"),
babl_component ("Cr"),
NULL);
}
static void
prepare (GeglOperation *self)
{
const Babl *fmt = gegl_operation_get_source_format (self, "input");
GeglChantO *o = GEGL_CHANT_PROPERTIES (self);
if (fmt)
{
const Babl *model = babl_format_get_model (fmt);
if (model == babl_model ("RaGaBaA") ||
model == babl_model ("R'aG'aB'aA") ||
model == babl_model ("YaA") ||
model == babl_model ("Y'aA"))
{
o->chant_data = NULL;
gegl_operation_set_format (self, "input",
babl_format ("RaGaBaA float"));
gegl_operation_set_format (self, "output",
babl_format ("RaGaBaA float"));
gegl_operation_set_format (self, "aux",
babl_format ("Y float"));
return;
}
}
/* ugly way of communicating that we want the RGBA version */
/* because of that, we can't use the common opencl api for point ops */
o->chant_data = (void*)0xabc;
gegl_operation_set_format (self, "input", babl_format ("RGBA float"));
gegl_operation_set_format (self, "output", babl_format ("RGBA float"));
gegl_operation_set_format (self, "aux", babl_format ("Y float"));
return;
}
static void
prepare (GeglOperation *self)
{
const Babl *fmt = gegl_operation_get_source_format (self, "input");
GeglProperties *o = GEGL_PROPERTIES (self);
if (fmt)
{
const Babl *model = babl_format_get_model (fmt);
if (model == babl_model ("R'aG'aB'aA") ||
model == babl_model ("Y'aA"))
{
o->user_data = NULL;
fmt = babl_format ("R'aG'aB'aA float");
}
else if (model == babl_model ("RaGaBaA") ||
model == babl_model ("YaA"))
{
o->user_data = NULL;
fmt = babl_format ("RaGaBaA float");
}
else if (model == babl_model ("R'G'B'A") ||
model == babl_model ("R'G'B'") ||
model == babl_model ("Y'") ||
model == babl_model ("Y'A"))
{
o->user_data = (void*)0xabc;
fmt = babl_format ("R'G'B'A float");
}
else
{
o->user_data = (void*)0xabc;
fmt = babl_format ("RGBA float");
}
}
else
{
o->user_data = (void*)0xabc;
fmt = babl_format ("RGBA float");
}
gegl_operation_set_format (self, "input", fmt);
gegl_operation_set_format (self, "output", fmt);
gegl_operation_set_format (self, "aux", babl_format ("Y float"));
return;
}
static void
formats (void)
{
babl_format_new (
"name", "HSVA float",
babl_model ("HSVA"),
babl_type ("float"),
babl_component ("hue"),
babl_component ("saturation"),
babl_component ("value"),
babl_component ("alpha"),
NULL
);
babl_format_new (
"name", "HSV float",
babl_model ("HSV"),
babl_type ("float"),
babl_component ("hue"),
babl_component ("saturation"),
babl_component ("value"),
NULL
);
}
static void
copy_one_component (GeglBuffer *src,
GeglBuffer *dst,
const gchar *model,
const COMPONENT component,
gboolean clamp)
{
const Babl *component_format, *dst_format;
GeglBuffer *temp;
const GeglRectangle *extent;
/* We are working in linear double precison*/
component_format = babl_format_new (babl_model (model),
babl_type ("double"),
babl_component (component.babl_name),
NULL);
/* We need to enforce linearity here
* If the output is "Y'", the ouput of temp is already ok
* If the output is "Y" , it will enforce gamma-decoding.
* A bit tricky and suboptimal...
*/
if (component.perceptual_channel)
dst_format = babl_format ("Y' double");
else
dst_format = babl_format ("Y double");
extent = gegl_buffer_get_extent (src);
temp = gegl_buffer_new (extent, dst_format);
/* we want to copy the component as is */
gegl_buffer_set_format (temp, component_format);
gegl_buffer_copy (src, NULL, temp, NULL);
if (component.range_min != 0.0 || component.range_max != 1.0 || clamp)
cpn_affine_transform_clamp (temp, component.range_min, component.range_max);
/* This is our new "Y(') double" component buffer */
gegl_buffer_set_format (temp, NULL);
/* Now we let babl convert it back to the format that dst needs */
gegl_buffer_copy (temp, NULL, dst, NULL);
g_object_unref (temp);
}
GimpImageType
gimp_babl_format_get_image_type (const Babl *format)
{
const Babl *model;
g_return_val_if_fail (format != NULL, -1);
model = babl_format_get_model (format);
if (model == babl_model ("Y") ||
model == babl_model ("Y'"))
{
return GIMP_GRAY_IMAGE;
}
else if (model == babl_model ("YA") ||
model == babl_model ("Y'A"))
{
return GIMP_GRAYA_IMAGE;
}
else if (model == babl_model ("RGB") ||
model == babl_model ("R'G'B'"))
{
return GIMP_RGB_IMAGE;
}
else if (model == babl_model ("RGBA") ||
model == babl_model ("R'G'B'A"))
{
return GIMP_RGBA_IMAGE;
}
else if (babl_format_is_palette (format))
{
if (babl_format_has_alpha (format))
return GIMP_INDEXEDA_IMAGE;
else
return GIMP_INDEXED_IMAGE;
}
g_return_val_if_reached (-1);
}
static void
gimp_operation_mask_components_prepare (GeglOperation *operation)
{
const Babl *format = gegl_operation_get_source_format (operation, "input");
if (format)
{
const Babl *model = babl_format_get_model (format);
if (model == babl_model ("R'G'B'A"))
format = babl_format ("R'G'B'A float");
else
format = babl_format ("RGBA float");
}
else
{
format = babl_format ("RGBA float");
}
gegl_operation_set_format (operation, "input", format);
gegl_operation_set_format (operation, "aux", format);
gegl_operation_set_format (operation, "output", format);
}
const Babl *
babl_new_palette_with_space (const char *name,
const Babl *space,
const Babl **format_u8,
const Babl **format_u8_with_alpha)
{
const Babl *model;
const Babl *model_no_alpha;
Babl *f_pal_u8;
Babl *f_pal_a_u8;
const Babl *component;
const Babl *alpha;
BablPalette **palptr;
char cname[64];
if (!space)
space = babl_space ("sRGB");
if (!name)
{
static int cnt = 0;
snprintf (cname, sizeof (cname), "_babl-int-%i", cnt++);
name = cname;
}
else
{
snprintf (cname, sizeof (cname), "%s-%p", name, space);
name = cname;
if ((model = babl_db_exist_by_name (babl_model_db (), name)))
{
cname[0] = ')';
if (format_u8)
*format_u8 = babl_db_exist_by_name (babl_format_db (), name);
cname[0] = '\\';
if (format_u8_with_alpha)
*format_u8_with_alpha = babl_db_exist_by_name (babl_format_db (), name);
return model;
}
}
/* re-registering is a no-op */
component = babl_component_new (
"I",
"luma",
"chroma",
NULL);
alpha = babl_component ("A");
model = babl_model_new ("name", name, component, alpha, NULL);
palptr = malloc (sizeof (void*));
*palptr = default_palette ();;
cname[0] = 'v';
model_no_alpha = babl_model_new ("name", name, component, NULL);
cname[0] = '\\';
f_pal_a_u8 = (void*) babl_format_new ("name", name, model, space,
babl_type ("u8"),
component, alpha, NULL);
cname[0] = ')';
f_pal_u8 = (void*) babl_format_new ("name", name, model_no_alpha, space,
babl_type ("u8"),
component, NULL);
f_pal_a_u8->format.palette = 1;
f_pal_u8->format.palette = 1;
babl_conversion_new (
model,
babl_model ("RGBA"),
"linear", pala_to_rgba,
"data", palptr,
NULL
);
babl_conversion_new (
babl_model ("RGBA"),
model,
"linear", rgba_to_pala,
"data", palptr,
NULL
);
babl_conversion_new (
model_no_alpha,
babl_model ("RGBA"),
"linear", pal_to_rgba,
"data", palptr,
NULL
);
babl_conversion_new (
babl_model ("RGBA"),
model_no_alpha,
"linear", rgba_to_pal,
"data", palptr,
NULL
);
babl_conversion_new (
f_pal_u8,
f_pal_a_u8,
"linear", conv_pal8_pala8,
NULL
);
babl_conversion_new (
f_pal_a_u8,
f_pal_u8,
"linear", conv_pala8_pal8,
NULL
);
babl_conversion_new (
f_pal_u8,
babl_format ("R'G'B'A u8"),
"linear", pal_u8_to_rgba_u8,
"data", palptr,
NULL);
babl_conversion_new (
f_pal_a_u8,
babl_format ("R'G'B'A u8"),
"linear", pala_u8_to_rgba_u8,
"data", palptr,
NULL);
babl_conversion_new (
babl_format ("R'G'B'A u8"),
f_pal_a_u8,
"linear", rgba_u8_to_pal_a,
"data", palptr,
NULL);
babl_conversion_new (
babl_format ("R'G'B'A u8"),
f_pal_u8,
"linear", rgba_u8_to_pal,
"data", palptr,
NULL);
babl_conversion_new (
babl_format ("RGBA float"),
f_pal_a_u8,
"linear", rgba_float_to_pal_a,
"data", palptr,
NULL);
babl_conversion_new (
babl_format ("RGBA float"),
f_pal_u8,
"linear", rgba_float_to_pal,
"data", palptr,
NULL);
babl_set_user_data (model, palptr);
babl_set_user_data (model_no_alpha, palptr);
if (format_u8)
*format_u8 = f_pal_u8;
if (format_u8_with_alpha)
*format_u8_with_alpha = f_pal_a_u8;
babl_sanity ();
return model;
}
static void
formats (void)
{
babl_format_new (
"name", "CIE Lab float",
babl_model ("CIE Lab"),
babl_type ("float"),
babl_component ("CIE L"),
babl_component ("CIE a"),
babl_component ("CIE b"),
NULL);
/*babl_format_new (
"name", "CIE XYZ float",
babl_model ("CIE XYZ"),
babl_type ("float"),
babl_component ("CIE X"),
babl_component ("CIE Y"),
babl_component ("CIE Z"),
NULL);*/
babl_format_new (
"name", "CIE Lab alpha float",
babl_model ("CIE Lab alpha"),
babl_type ("float"),
babl_component ("CIE L"),
babl_component ("CIE a"),
babl_component ("CIE b"),
babl_component ("A"),
NULL);
babl_format_new (
"name", "CIE L alpha float",
babl_model ("CIE Lab alpha"),
babl_type ("float"),
babl_component ("CIE L"),
babl_component ("A"),
NULL);
babl_format_new (
"name", "CIE Lab u8",
babl_model ("CIE Lab"),
babl_type ("CIE u8 L"),
babl_component ("CIE L"),
babl_type ("CIE u8 ab"),
babl_component ("CIE a"),
babl_type ("CIE u8 ab"),
babl_component ("CIE b"),
NULL);
babl_format_new (
"name", "CIE Lab u16",
babl_model ("CIE Lab"),
babl_type ("CIE u16 L"),
babl_component ("CIE L"),
babl_type ("CIE u16 ab"),
babl_component ("CIE a"),
babl_type ("CIE u16 ab"),
babl_component ("CIE b"),
NULL);
babl_format_new (
"name", "CIE LCH(ab) float",
babl_model ("CIE LCH(ab)"),
babl_type ("float"),
babl_component ("CIE L"),
babl_component ("CIE C(ab)"),
babl_component ("CIE H(ab)"),
NULL);
babl_format_new (
"name", "CIE LCH(ab) alpha float",
babl_model ("CIE LCH(ab) alpha"),
babl_type ("float"),
babl_component ("CIE L"),
babl_component ("CIE C(ab)"),
babl_component ("CIE H(ab)"),
babl_component ("A"),
NULL);
}
static void
conversions (void)
{
babl_conversion_new (
babl_model ("RGBA"),
babl_model ("CIE Lab"),
"linear", rgba_to_lab,
NULL
);
babl_conversion_new (
babl_model ("CIE Lab"),
babl_model ("RGBA"),
"linear", lab_to_rgba,
NULL
);
babl_conversion_new (
babl_model ("RGBA"),
babl_model ("CIE Lab alpha"),
"linear", rgba_to_laba,
NULL
);
babl_conversion_new (
babl_model ("CIE Lab alpha"),
babl_model ("RGBA"),
"linear", laba_to_rgba,
NULL
);
babl_conversion_new (
babl_format ("RGBA float"),
babl_format ("CIE Lab alpha float"),
"linear", rgbaf_to_Labaf,
NULL
);
babl_conversion_new (
babl_format ("CIE Lab alpha float"),
babl_format ("RGBA float"),
"linear", Labaf_to_rgbaf,
NULL
);
babl_conversion_new (
babl_format ("YA float"),
babl_format ("CIE L alpha float"),
"linear", Yaf_to_Laf,
NULL
);
babl_conversion_new (
babl_model ("RGBA"),
babl_model ("CIE LCH(ab)"),
"linear", rgba_to_lchab,
NULL
);
babl_conversion_new (
babl_model ("CIE LCH(ab)"),
babl_model ("RGBA"),
"linear", lchab_to_rgba,
NULL
);
babl_conversion_new (
babl_model ("RGBA"),
babl_model ("CIE LCH(ab) alpha"),
"linear", rgba_to_lchaba,
NULL
);
babl_conversion_new (
babl_model ("CIE LCH(ab) alpha"),
babl_model ("RGBA"),
"linear", lchaba_to_rgba,
NULL
);
/*babl_conversion_new (
babl_model ("RGBA"),
babl_model ("CIE XYZ"),
"linear", RGB_to_XYZ,
NULL
);
babl_conversion_new (
babl_model ("CIE XYZ"),
babl_model ("RGBA"),
"linear", XYZ_to_RGB,
NULL
);*/
rgbcie_init ();
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
const GeglRectangle *result,
gint level)
{
GeglProperties *o = GEGL_PROPERTIES (operation);
const Babl *input_format;
const Babl *data_format;
gint bps;
gint row_stride;
gint n_components;
guchar *data;
CoglPixelFormat cogl_pixel_format;
g_object_get (input, "format", &input_format, NULL);
/* cogl doesnt support anything more than 8bit bps */
bps = 8;
n_components = babl_format_get_n_components (input_format);
switch (n_components)
{
case 1:
data_format = babl_format ("Y'");
cogl_pixel_format = COGL_PIXEL_FORMAT_G_8;
break;
default:
if (babl_format_has_alpha (input_format)) {
data_format = babl_format_new (babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("B'"),
babl_component ("G'"),
babl_component ("R'"),
babl_component ("A"),
NULL);
cogl_pixel_format = COGL_PIXEL_FORMAT_BGRA_8888;
n_components = 4;
}
else {
data_format = babl_format_new (babl_model ("R'G'B'"),
babl_type ("u8"),
babl_component ("B'"),
babl_component ("G'"),
babl_component ("R'"),
NULL);
cogl_pixel_format = COGL_PIXEL_FORMAT_BGR_888;
n_components = 3;
}
break;
}
row_stride = result->width * n_components * bps/8;
data = g_malloc (result->height * row_stride);
gegl_buffer_get (input,
result, /* rect */
1.0, /* scale */
data_format,
data,
GEGL_AUTO_ROWSTRIDE,
GEGL_ABYSS_NONE);
if (data)
{
if (o->texture == NULL)
{
CoglTextureFlags flags = COGL_TEXTURE_NONE;
if (result->width >= 512 && result->height >= 512) {
flags |= COGL_TEXTURE_NO_ATLAS;
}
o->texture = cogl_texture_new_from_data (result->width,
result->height,
flags,
cogl_pixel_format,
COGL_PIXEL_FORMAT_ANY,
row_stride,
data);
}
else
{
gboolean success;
success = cogl_texture_set_region (COGL_TEXTURE (o->texture),
0, 0,
result->x, result->y,
result->width, result->height,
result->width, result->height,
cogl_pixel_format,
row_stride,
data);
if (!success)
{
cogl_object_unref (o->texture);
o->texture = NULL;
}
}
}
else
{
g_warning (G_STRLOC ": inexistant data, unable to create CoglTexture.");
}
return TRUE;
}
int
init (void)
{
#if defined(USE_SSE2)
const Babl *rgbaF_linear = babl_format_new (
babl_model ("RGBA"),
babl_type ("float"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
const Babl *rgbAF_linear = babl_format_new (
babl_model ("RaGaBaA"),
babl_type ("float"),
babl_component ("Ra"),
babl_component ("Ga"),
babl_component ("Ba"),
babl_component ("A"),
NULL);
const Babl *rgba16_linear = babl_format_new (
babl_model ("RGBA"),
babl_type ("u16"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
const Babl *rgbaF_gamma = babl_format_new (
babl_model ("R'G'B'A"),
babl_type ("float"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
babl_component ("A"),
NULL);
const Babl *rgbAF_gamma = babl_format_new (
babl_model ("R'aG'aB'aA"),
babl_type ("float"),
babl_component ("R'a"),
babl_component ("G'a"),
babl_component ("B'a"),
babl_component ("A"),
NULL);
const Babl *rgba16_gamma = babl_format_new (
babl_model ("R'G'B'A"),
babl_type ("u16"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
babl_component ("A"),
NULL);
#define CONV(src, dst) \
{ \
babl_conversion_new (src ## _linear, dst ## _linear, "linear", conv_ ## src ## _ ## dst, NULL); \
babl_conversion_new (src ## _gamma, dst ## _gamma, "linear", conv_ ## src ## _ ## dst, NULL); \
}
if ((babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE) &&
(babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE2))
{
CONV (rgba16, rgbaF);
CONV (rgba16, rgbAF);
}
#endif /* defined(USE_SSE2) */
return 0;
}
int
init (void)
{
const Babl *rgbaF = babl_format_new (
babl_model ("RGBA"),
babl_type ("float"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
const Babl *rgba16 = babl_format_new (
babl_model ("RGBA"),
babl_type ("u16"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
const Babl *rgbaD = babl_format_new (
babl_model ("RGBA"),
babl_type ("double"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
const Babl *rgba8 = babl_format_new (
babl_model ("RGBA"),
babl_type ("u8"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
const Babl *rgbAF = babl_format_new (
babl_model ("RaGaBaA"),
babl_type ("float"),
babl_component ("Ra"),
babl_component ("Ga"),
babl_component ("Ba"),
babl_component ("A"),
NULL);
const Babl *rgbAD = babl_format_new (
babl_model ("RaGaBaA"),
babl_type ("double"),
babl_component ("Ra"),
babl_component ("Ga"),
babl_component ("Ba"),
babl_component ("A"),
NULL);
const Babl *rgbA16 = babl_format_new (
babl_model ("RaGaBaA"),
babl_type ("u16"),
babl_component ("Ra"),
babl_component ("Ga"),
babl_component ("Ba"),
babl_component ("A"),
NULL);
const Babl *rgbA8 = babl_format_new (
babl_model ("RaGaBaA"),
babl_type ("u8"),
babl_component ("Ra"),
babl_component ("Ga"),
babl_component ("Ba"),
babl_component ("A"),
NULL);
const Babl *rgbF = babl_format_new (
babl_model ("RGB"),
babl_type ("float"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
NULL);
const Babl *rgb16 = babl_format_new (
babl_model ("RGB"),
babl_type ("u16"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
NULL);
const Babl *rgb8 = babl_format_new (
babl_model ("RGB"),
babl_type ("u8"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
NULL);
const Babl *gaF = babl_format_new (
babl_model ("YA"),
babl_type ("float"),
babl_component ("Y"),
babl_component ("A"),
NULL);
const Babl *gAF = babl_format_new (
babl_model ("YaA"),
babl_type ("float"),
babl_component ("Ya"),
babl_component ("A"),
NULL);
const Babl *gF = babl_format_new (
babl_model ("Y"),
babl_type ("float"),
babl_component ("Y"),
NULL);
const Babl *ga16 = babl_format_new (
babl_model ("YA"),
babl_type ("u16"),
babl_component ("Y"),
babl_component ("A"),
NULL);
const Babl *gA16 = babl_format_new (
babl_model ("YaA"),
babl_type ("u16"),
babl_component ("Ya"),
babl_component ("A"),
NULL);
const Babl *g16 = babl_format_new (
babl_model ("Y"),
babl_type ("u16"),
babl_component ("Y"),
NULL);
const Babl *ga8 = babl_format_new (
babl_model ("YA"),
babl_type ("u8"),
babl_component ("Y"),
babl_component ("A"),
NULL);
const Babl *gA8 = babl_format_new (
babl_model ("YaA"),
babl_type ("u8"),
babl_component ("Ya"),
babl_component ("A"),
NULL);
const Babl *g8 = babl_format_new (
babl_model ("Y"),
babl_type ("u8"),
babl_component ("Y"),
NULL);
#define o(src, dst) \
babl_conversion_new (src, dst, "linear", conv_ ## src ## _ ## dst, NULL)
o (rgbaF, rgbaD);
o (rgbaD, rgbaF);
o (rgbAF, rgbAD);
o (rgbAD, rgbAF);
o (rgbaF, rgba8);
o (rgba8, rgbaF);
o (rgbaF, rgba16);
o (rgba16, rgbaF);
o (rgbAF, rgbA8);
o (rgbA8, rgbAF);
o (rgbAF, rgbA16);
o (rgbA16, rgbAF);
o (rgbF, rgb8);
o (rgb8, rgbF);
o (rgbF, rgb16);
o (rgb16, rgbF);
o (rgba8, rgba16);
o (rgba16, rgba8);
o (rgbA8, rgbA16);
o (rgbA16, rgbA8);
o (rgb8, rgb16);
o (rgb16, rgb8);
o (gaF, ga8);
o (gAF, gA8);
o (gF, g8);
o (gF, rgbAF);
o (gF, rgbaF);
o (ga8, gaF);
o (gA8, gAF);
o (g8, gF);
o (gaF, ga16);
o (gAF, gA16);
o (gF, g16);
o (ga16, gaF);
o (gA16, gAF);
o (g16, gF);
o (ga16, ga8);
o (g16, g8);
o (ga8, ga16);
o (gA8, gA16);
o (g8, g16);
o (gaF, gAF);
o (gAF, gaF);
o (rgbaF, rgbF);
o (gaF, gF);
o (rgbF, rgbaF);
o (rgbF, rgbAF);
o (gF, gaF);
o (gF, gAF);
o (gF, rgbF);
o (gaF, rgbaF);
o (gAF, rgbAF);
o (rgbaF, rgb8);
o (rgbA8, rgba8);
o (rgba8, rgbA8);
o (rgbaF, rgb16);
o (rgb8, rgba8);
o (rgb8, rgbA8);
o (rgba8, rgb8);
o (rgbaF, rgbA8);
return 0;
}