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);
}
}
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;
}
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;
}
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
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
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);
}
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 *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 *gamma_rgbaF = 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 *gamma_rgbAF = 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 *lrgba8 = babl_format_new (
babl_model ("RGBA"),
babl_type ("u8"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
const Babl *rgba8 = babl_format_new (
babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
babl_component ("A"),
NULL);
const Babl *bgrA8 = babl_format_new (
"name", "B'aG'aR'aA u8",
babl_model ("R'aG'aB'aA"),
babl_type ("u8"),
babl_component ("B'a"),
babl_component ("G'a"),
babl_component ("R'a"),
babl_component ("A"),
NULL);
const Babl *rgb8 = babl_format_new (
babl_model ("R'G'B'"),
babl_type ("u8"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
NULL);
table_init ();
#define o(src, dst) \
babl_conversion_new (src, dst, "linear", conv_ ## src ## _ ## dst, NULL)
o (rgbaF, rgbAF);
o (rgbAF, rgbaF);
o (gamma_rgbaF, gamma_rgbAF);
o (gamma_rgbAF, gamma_rgbaF);
o (rgbAF, lrgba8);
o (rgb8, rgbaF);
o (rgb8, rgbAF);
o (rgba8, rgbaF);
o (rgbaF, rgb8);
o (rgbAF, rgb8);
o (bgrA8, rgba8);
return 0;
}
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_SSE4_1) && defined(USE_F16C) && defined(ARCH_X86_64)
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 *rgbaHalf_linear = babl_format_new (
babl_model ("RGBA"),
babl_type ("half"),
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 *rgbaHalf_gamma = babl_format_new (
babl_model ("R'G'B'A"),
babl_type ("half"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
babl_component ("A"),
NULL);
const Babl *rgbF_linear = babl_format_new (
babl_model ("RGB"),
babl_type ("float"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
NULL);
const Babl *rgbHalf_linear = babl_format_new (
babl_model ("RGB"),
babl_type ("half"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
NULL);
const Babl *rgbF_gamma = babl_format_new (
babl_model ("R'G'B'"),
babl_type ("float"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
NULL);
const Babl *rgbHalf_gamma = babl_format_new (
babl_model ("R'G'B'"),
babl_type ("half"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
NULL);
const Babl *yaF_linear = babl_format_new (
babl_model ("YA"),
babl_type ("float"),
babl_component ("Y"),
babl_component ("A"),
NULL);
const Babl *yaHalf_linear = babl_format_new (
babl_model ("YA"),
babl_type ("half"),
babl_component ("Y"),
babl_component ("A"),
NULL);
const Babl *yaF_gamma = babl_format_new (
babl_model ("Y'A"),
babl_type ("float"),
babl_component ("Y'"),
babl_component ("A"),
NULL);
const Babl *yaHalf_gamma = babl_format_new (
babl_model ("Y'A"),
babl_type ("half"),
babl_component ("Y'"),
babl_component ("A"),
NULL);
const Babl *yF_linear = babl_format_new (
babl_model ("Y"),
babl_type ("float"),
babl_component ("Y"),
NULL);
const Babl *yHalf_linear = babl_format_new (
babl_model ("Y"),
babl_type ("half"),
babl_component ("Y"),
NULL);
const Babl *yF_gamma = babl_format_new (
babl_model ("Y'"),
babl_type ("float"),
babl_component ("Y'"),
NULL);
const Babl *yHalf_gamma = babl_format_new (
babl_model ("Y'"),
babl_type ("half"),
babl_component ("Y'"),
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_SSE4_1) &&
(babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_F16C))
{
CONV(rgbaHalf, rgbaF);
CONV(rgbHalf, rgbF);
CONV(yaHalf, yaF);
CONV(yHalf, yF);
CONV(rgbaF, rgbaHalf);
CONV(rgbF, rgbHalf);
CONV(yaF, yaHalf);
CONV(yF, yHalf);
}
#endif /* defined(USE_SSE4_1) && defined(USE_F16C) && defined(ARCH_X86_64) */
return 0;
}
void
gimp_babl_init (void)
{
babl_format_new ("name", "R' u8",
babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("R'"),
NULL);
babl_format_new ("name", "G' u8",
babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("G'"),
NULL);
babl_format_new ("name", "B' u8",
babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("B'"),
NULL);
babl_format_new ("name", "A u8",
babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("A"),
NULL);
babl_format_new ("name", "R' u16",
babl_model ("R'G'B'A"),
babl_type ("u16"),
babl_component ("R'"),
NULL);
babl_format_new ("name", "G' u16",
babl_model ("R'G'B'A"),
babl_type ("u16"),
babl_component ("G'"),
NULL);
babl_format_new ("name", "B' u16",
babl_model ("R'G'B'A"),
babl_type ("u16"),
babl_component ("B'"),
NULL);
babl_format_new ("name", "A u16",
babl_model ("R'G'B'A"),
babl_type ("u16"),
babl_component ("A"),
NULL);
babl_format_new ("name", "R u32",
babl_model ("RGBA"),
babl_type ("u32"),
babl_component ("R"),
NULL);
babl_format_new ("name", "G u32",
babl_model ("RGBA"),
babl_type ("u32"),
babl_component ("G"),
NULL);
babl_format_new ("name", "B u32",
babl_model ("RGBA"),
babl_type ("u32"),
babl_component ("B"),
NULL);
babl_format_new ("name", "A u32",
babl_model ("RGBA"),
babl_type ("u32"),
babl_component ("A"),
NULL);
babl_format_new ("name", "R half",
babl_model ("RGBA"),
babl_type ("half"),
babl_component ("R"),
NULL);
babl_format_new ("name", "G half",
babl_model ("RGBA"),
babl_type ("half"),
babl_component ("G"),
NULL);
babl_format_new ("name", "B half",
babl_model ("RGBA"),
babl_type ("half"),
babl_component ("B"),
NULL);
babl_format_new ("name", "A half",
babl_model ("RGBA"),
babl_type ("half"),
babl_component ("A"),
NULL);
babl_format_new ("name", "R float",
babl_model ("RGBA"),
babl_type ("float"),
babl_component ("R"),
NULL);
babl_format_new ("name", "G float",
babl_model ("RGBA"),
babl_type ("float"),
babl_component ("G"),
NULL);
babl_format_new ("name", "B float",
babl_model ("RGBA"),
babl_type ("float"),
babl_component ("B"),
NULL);
babl_format_new ("name", "A float",
babl_model ("RGBA"),
babl_type ("float"),
babl_component ("A"),
NULL);
babl_format_new ("name", "A double",
babl_model ("RGBA"),
babl_type ("double"),
babl_component ("A"),
NULL);
}
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;
}
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 *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 *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 *rgbF_linear = babl_format_new (
babl_model ("RGB"),
babl_type ("float"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
NULL);
const Babl *rgbF_gamma = babl_format_new (
babl_model ("R'G'B'"),
babl_type ("float"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
NULL);
const Babl *yaF_linear = babl_format_new (
babl_model ("YA"),
babl_type ("float"),
babl_component ("Y"),
babl_component ("A"),
NULL);
const Babl *yaF_gamma = babl_format_new (
babl_model ("Y'A"),
babl_type ("float"),
babl_component ("Y'"),
babl_component ("A"),
NULL);
const Babl *yF_linear = babl_format_new (
babl_model ("Y"),
babl_type ("float"),
babl_component ("Y"),
NULL);
const Babl *yF_gamma = babl_format_new (
babl_model ("Y'"),
babl_type ("float"),
babl_component ("Y'"),
NULL);
if ((babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE) &&
(babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE2))
{
babl_conversion_new(rgbaF_linear,
rgbAF_linear,
"linear",
conv_rgbaF_linear_rgbAF_linear,
NULL);
babl_conversion_new(rgbaF_gamma,
rgbAF_gamma,
"linear",
conv_rgbaF_linear_rgbAF_linear,
NULL);
babl_conversion_new(rgbaF_linear,
rgbAF_gamma,
"linear",
conv_rgbaF_linear_rgbAF_gamma,
NULL);
/* Which of these is faster varies by CPU, and the difference
* is big enough that it's worthwhile to include both and
* let them fight it out in the babl benchmarks.
*/
babl_conversion_new(rgbAF_linear,
rgbaF_linear,
"linear",
conv_rgbAF_linear_rgbaF_linear_shuffle,
NULL);
babl_conversion_new(rgbAF_gamma,
rgbaF_gamma,
"linear",
conv_rgbAF_linear_rgbaF_linear_shuffle,
NULL);
babl_conversion_new(rgbAF_linear,
rgbaF_linear,
"linear",
conv_rgbAF_linear_rgbaF_linear_spin,
NULL);
o (yF_linear, yF_gamma);
o (yF_gamma, yF_linear);
o (yaF_linear, yaF_gamma);
o (yaF_gamma, yaF_linear);
o (rgbF_linear, rgbF_gamma);
o (rgbF_gamma, rgbF_linear);
o (rgbaF_linear, rgbaF_gamma);
o (rgbaF_gamma, rgbaF_linear);
}
#endif /* defined(USE_SSE2) */
return 0;
}
int
init (void)
{
const Babl *rgbaF = 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 *rgba16 = 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);
const Babl *rgba8 = babl_format_new (
babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
babl_component ("A"),
NULL);
const Babl *rgbAF = 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 = babl_format_new (
babl_model ("R'aG'aB'aA"),
babl_type ("u16"),
babl_component ("R'a"),
babl_component ("G'a"),
babl_component ("B'a"),
babl_component ("A"),
NULL);
const Babl *rgbA8 = babl_format_new (
babl_model ("R'aG'aB'aA"),
babl_type ("u8"),
babl_component ("R'a"),
babl_component ("G'a"),
babl_component ("B'a"),
babl_component ("A"),
NULL);
const Babl *rgbF = babl_format_new (
babl_model ("R'G'B'"),
babl_type ("float"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
NULL);
const Babl *rgb16 = babl_format_new (
babl_model ("R'G'B'"),
babl_type ("u16"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
NULL);
const Babl *rgb8 = babl_format_new (
babl_model ("R'G'B'"),
babl_type ("u8"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
NULL);
const Babl *gaF = babl_format_new (
babl_model ("Y'A"),
babl_type ("float"),
babl_component ("Y'"),
babl_component ("A"),
NULL);
const Babl *gAF = babl_format_new (
babl_model ("Y'aA"),
babl_type ("float"),
babl_component ("Y'a"),
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 ("Y'A"),
babl_type ("u16"),
babl_component ("Y'"),
babl_component ("A"),
NULL);
const Babl *gA16 = babl_format_new (
babl_model ("Y'aA"),
babl_type ("u16"),
babl_component ("Y'a"),
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 ("Y'A"),
babl_type ("u8"),
babl_component ("Y'"),
babl_component ("A"),
NULL);
const Babl *gA8 = babl_format_new (
babl_model ("Y'aA"),
babl_type ("u8"),
babl_component ("Y'a"),
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, 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 (gaF, ga8);
o (gAF, gA8);
o (gF, g8);
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 (rgbaF, rgb8);
o (rgb8, rgbaF);
if (!table_inited)
table_init ();
return 0;
}
static void
prepare (GeglOperation *operation)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
Priv *p= (Priv*)o->chant_data;
if (p == NULL)
init (o);
p = (Priv*)o->chant_data;
gegl_operation_set_format (operation, "output",
babl_format_new (
babl_model ("R'G'B'"),
babl_type ("u8"),
babl_component ("B'"),
babl_component ("G'"),
babl_component ("R'"),
NULL));
p->w = o->width;
p->h = o->height;
if (!p->vd)
{
p->vd = g_malloc0 (sizeof (v4ldevice));
if (v4lopen (o->path, p->vd))
return;
p->active = 1;
if (v4lmmap (p->vd))
return;
v4lsetdefaultnorm (p->vd, VIDEO_MODE_PAL);
v4lgetcapability (p->vd);
if (!(p->vd->capability.type & VID_TYPE_CAPTURE)) {
g_warning (
"video_init: This device seems not to support video capturing.\n");
return;
}
}
if (p->w != p->w_stored || p->h != p->h_stored)
{
if (p->w > p->vd->capability.maxwidth
|| p->h > p->vd->capability.maxheight)
{
p->w = p->vd->capability.maxwidth;
p->h = p->vd->capability.maxheight;
o->width = p->w;
o->height = p->h;
g_warning ( "capturing size is set to %dx%d.\n", p->w, p->h);
}
else if (p->w < p->vd->capability.minwidth
|| p->h < p->vd->capability.minheight)
{
p->w = p->vd->capability.minwidth;
p->h = p->vd->capability.minheight;
o->width = p->w;
o->height = p->h;
g_warning ( "capturing size is set to %dx%d.\n", p->w, p->h);
}
p->w_stored = p->w;
p->h_stored = p->h;
/* FIXME: try other palettes as well, do some profiling on the spca
* based cameras to see what is the ideal format wrt performance
*/
if (!v4lsetpalette (p->vd, VIDEO_PALETTE_RGB24))
{
p->decode=0;
}
else if (!v4lsetpalette (p->vd, VIDEO_PALETTE_YUV420P))
{
p->decode=1;
}
else
{
g_warning ( "oops,. no usable v4l format found\n");
return;
}
v4lgrabinit (p->vd, p->w, p->h);
v4lgrabf (p->vd);
}
}
static gboolean
process (GeglOperation *operation,
GeglBuffer *input,
const GeglRectangle *result)
{
GeglChantO *o = GEGL_CHANT_PROPERTIES (operation);
GeglBuffer *source;
SDL_Surface **sdl_outwin = NULL; /*op_sym (op, "sdl_outwin");*/
init_sdl ();
if (!handle)
handle = g_timeout_add (500, idle, NULL);
if (!o->screen ||
o->width != result->width ||
o->height != result->height)
{
if (sdl_outwin)
{
if (o->screen)
{
SDL_FreeSurface (o->screen);
o->screen = NULL;
}
o->screen = SDL_CreateRGBSurface (SDL_SWSURFACE,
result->width, result->height, 32, 0xff0000,
0x00ff00, 0x0000ff, 0x000000);
*sdl_outwin = o->screen;
if (!o->screen)
{
fprintf (stderr, "CreateRGBSurface failed: %s\n",
SDL_GetError ());
return -1;
}
}
else
{
o->screen = SDL_SetVideoMode (result->width, result->height, 32, SDL_SWSURFACE);
if (!o->screen)
{
fprintf (stderr, "Unable to set SDL mode: %s\n",
SDL_GetError ());
return -1;
}
}
o->width = result->width ;
o->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?
*
*/
source = gegl_buffer_create_sub_buffer (input, result);
gegl_buffer_get (source,
1.0,
NULL,
babl_format_new (babl_model ("RGBA"),
babl_type ("u8"),
babl_component ("B"),
babl_component ("G"),
babl_component ("R"),
babl_component ("A"),
NULL),
((SDL_Surface*)o->screen)->pixels, GEGL_AUTO_ROWSTRIDE);
g_object_unref (source);
if (!sdl_outwin)
{
SDL_UpdateRect (o->screen, 0, 0, 0, 0);
SDL_WM_SetCaption (o->window_title, o->icon_title);
}
o->width = result->width ;
o->height = result->height;
return TRUE;
}
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);
}
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;
}
int
init (void)
{
#if defined(__GNUC__) && (__GNUC__ >= 4) && defined(USE_SSE) && defined(USE_MMX)
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 *rgba8_linear = babl_format_new (
babl_model ("RGBA"),
babl_type ("u8"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
babl_component ("A"),
NULL);
const Babl *rgb8_linear = babl_format_new (
babl_model ("RGB"),
babl_type ("u8"),
babl_component ("R"),
babl_component ("G"),
babl_component ("B"),
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 *rgba8_gamma = babl_format_new (
babl_model ("R'G'B'A"),
babl_type ("u8"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
babl_component ("A"),
NULL);
const Babl *rgb8_gamma = babl_format_new (
babl_model ("R'G'B'"),
babl_type ("u8"),
babl_component ("R'"),
babl_component ("G'"),
babl_component ("B'"),
NULL);
if ((babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_MMX) &&
(babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_SSE) &&
!(babl_cpu_accel_get_support () & BABL_CPU_ACCEL_X86_64))
{
o (rgbaF_linear, rgb8_linear);
o (rgbaF_linear, rgba8_linear);
o (rgbaF_gamma, rgb8_gamma);
o (rgbaF_gamma, rgba8_gamma);
}
#endif
return 0;
}
