dnrops
/
gimp
mirror of https://github.com/GNOME/gimp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

libgimpcolor: add new object GimpColorTransform 

which encapsulates a cmsHTRANSFORM and does all the pixel format
conversion magic. It has API to create transforms and proofing
transforms, and to convert pixels arrays and GeglBuffers.

Before, each place which has a transform had to keep around the
transform and its input and output Babl formats, and had to implement
lots of stuff itself. Now all that lives in GimpColorTransform,
removing lots of logic from many places, and pretty much removing lcms
from the public API entirely.

This removes including <lcms2.h>, LCMS_LIBS and LCMS_CFLAGS from
almost all directories and potentially allows to replace lcms by
something else.
This commit is contained in:
Michael Natterer 2016-05-25 21:35:54 +02:00
parent 97d16bd1d6
commit cc92887908
24 changed files with 759 additions and 518 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
app/core/gimpdrawable-preview.c
View File

@ -192,9 +192,7 @@ gimp_drawable_get_sub_pixbuf (GimpDrawable *drawable,
gdouble scale; gdouble scale;
gint scaled_x; gint scaled_x;
gint scaled_y; gint scaled_y;
GimpColorTransform transform; GimpColorTransform *transform;
const Babl *src_format;
const Babl *dest_format;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL); g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
g_return_val_if_fail (src_x >= 0, NULL); g_return_val_if_fail (src_x >= 0, NULL);
@ -225,9 +223,7 @@ gimp_drawable_get_sub_pixbuf (GimpDrawable *drawable,
scaled_x = RINT ((gdouble) src_x * scale); scaled_x = RINT ((gdouble) src_x * scale);
scaled_y = RINT ((gdouble) src_y * scale); scaled_y = RINT ((gdouble) src_y * scale);
transform = gimp_image_get_color_transform_to_srgb_u8 (image, transform = gimp_image_get_color_transform_to_srgb_u8 (image);
&src_format,
&dest_format);
if (transform) if (transform)
{ {
@ -235,7 +231,8 @@ gimp_drawable_get_sub_pixbuf (GimpDrawable *drawable,
GeglBuffer *src_buf; GeglBuffer *src_buf;
GeglBuffer *dest_buf; GeglBuffer *dest_buf;
temp_buf = gimp_temp_buf_new (dest_width, dest_height, src_format); temp_buf = gimp_temp_buf_new (dest_width, dest_height,
gimp_drawable_get_format (drawable));
gegl_buffer_get (buffer, gegl_buffer_get (buffer,
GEGL_RECTANGLE (scaled_x, scaled_y, GEGL_RECTANGLE (scaled_x, scaled_y,
@ -250,15 +247,12 @@ gimp_drawable_get_sub_pixbuf (GimpDrawable *drawable,
gimp_temp_buf_unref (temp_buf); gimp_temp_buf_unref (temp_buf);
gimp_gegl_convert_color_transform (src_buf, gimp_color_transform_process_buffer (transform,
src_buf,
GEGL_RECTANGLE (0, 0, GEGL_RECTANGLE (0, 0,
dest_width, dest_height), dest_width, dest_height),
src_format,
dest_buf, dest_buf,
GEGL_RECTANGLE (0, 0, 0, 0), GEGL_RECTANGLE (0, 0, 0, 0));
dest_format,
transform,
NULL);
g_object_unref (src_buf); g_object_unref (src_buf);
g_object_unref (dest_buf); g_object_unref (dest_buf);

206
app/core/gimpimage-color-profile.c
View File

@ -497,110 +497,62 @@ gimp_image_import_color_profile (GimpImage *image,
} }
} }
GimpColorTransform GimpColorTransform *
gimp_image_get_color_transform_to_srgb_u8 (GimpImage *image, gimp_image_get_color_transform_to_srgb_u8 (GimpImage *image)
const Babl **pixel_format,
const Babl **srgb_u8_format)
{ {
GimpImagePrivate *private; GimpImagePrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (pixel_format != NULL, NULL);
g_return_val_if_fail (srgb_u8_format != NULL, NULL);
private = GIMP_IMAGE_GET_PRIVATE (image); private = GIMP_IMAGE_GET_PRIVATE (image);
if (private->is_color_managed) if (private->is_color_managed)
{
*pixel_format = private->transform_layer_format;
*srgb_u8_format = private->transform_srgb_u8_format;
return private->transform_to_srgb_u8; return private->transform_to_srgb_u8;
}
*pixel_format = NULL;
*srgb_u8_format = NULL;
return NULL; return NULL;
} }
GimpColorTransform GimpColorTransform *
gimp_image_get_color_transform_from_srgb_u8 (GimpImage *image, gimp_image_get_color_transform_from_srgb_u8 (GimpImage *image)
const Babl **pixel_format,
const Babl **srgb_u8_format)
{ {
GimpImagePrivate *private; GimpImagePrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (pixel_format != NULL, NULL);
g_return_val_if_fail (srgb_u8_format != NULL, NULL);
private = GIMP_IMAGE_GET_PRIVATE (image); private = GIMP_IMAGE_GET_PRIVATE (image);
if (private->is_color_managed) if (private->is_color_managed)
{
*pixel_format = private->transform_layer_format;
*srgb_u8_format = private->transform_srgb_u8_format;
return private->transform_from_srgb_u8; return private->transform_from_srgb_u8;
}
*pixel_format = NULL;
*srgb_u8_format = NULL;
return NULL; return NULL;
} }
GimpColorTransform GimpColorTransform *
gimp_image_get_color_transform_to_srgb_double (GimpImage *image, gimp_image_get_color_transform_to_srgb_double (GimpImage *image)
const Babl **pixel_format,
const Babl **srgb_double_format)
{ {
GimpImagePrivate *private; GimpImagePrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (pixel_format != NULL, NULL);
g_return_val_if_fail (srgb_double_format != NULL, NULL);
private = GIMP_IMAGE_GET_PRIVATE (image); private = GIMP_IMAGE_GET_PRIVATE (image);
if (private->is_color_managed) if (private->is_color_managed)
{
*pixel_format = private->transform_layer_format;
*srgb_double_format = private->transform_srgb_double_format;
return private->transform_to_srgb_double; return private->transform_to_srgb_double;
}
*pixel_format = NULL;
*srgb_double_format = NULL;
return NULL; return NULL;
} }
GimpColorTransform GimpColorTransform *
gimp_image_get_color_transform_from_srgb_double (GimpImage *image, gimp_image_get_color_transform_from_srgb_double (GimpImage *image)
const Babl **pixel_format,
const Babl **srgb_double_format)
{ {
GimpImagePrivate *private; GimpImagePrivate *private;
g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL); g_return_val_if_fail (GIMP_IS_IMAGE (image), NULL);
g_return_val_if_fail (pixel_format != NULL, NULL);
g_return_val_if_fail (srgb_double_format != NULL, NULL);
private = GIMP_IMAGE_GET_PRIVATE (image); private = GIMP_IMAGE_GET_PRIVATE (image);
if (private->is_color_managed) if (private->is_color_managed)
{
*pixel_format = private->transform_layer_format;
*srgb_double_format = private->transform_srgb_double_format;
return private->transform_from_srgb_double; return private->transform_from_srgb_double;
}
*pixel_format = NULL;
*srgb_double_format = NULL;
return NULL; return NULL;
} }
@ -616,30 +568,12 @@ gimp_image_color_profile_pixel_to_srgb (GimpImage *image,
if (private->is_color_managed && if (private->is_color_managed &&
private->transform_to_srgb_double) private->transform_to_srgb_double)
{ {
guchar srgb_pixel[32]; gimp_color_transform_process_pixels (private->transform_to_srgb_double,
pixel_format,
/* for the alpha channel */ pixel,
gimp_rgba_set_pixel (color, pixel_format, pixel); babl_format ("R'G'B'A double"),
color,
if (pixel_format == private->transform_layer_format) 1);
{
cmsDoTransform (private->transform_to_srgb_double,
pixel, srgb_pixel, 1);
}
else
{
guchar src_pixel[32];
babl_process (babl_fish (pixel_format,
private->transform_layer_format),
pixel, src_pixel, 1);
cmsDoTransform (private->transform_to_srgb_double,
src_pixel, srgb_pixel, 1);
}
gimp_rgb_set_pixel (color, private->transform_srgb_double_format,
srgb_pixel);
} }
else else
{ {
@ -657,35 +591,16 @@ gimp_image_color_profile_srgb_to_pixel (GimpImage *image,
if (private->is_color_managed && if (private->is_color_managed &&
private->transform_from_srgb_double) private->transform_from_srgb_double)
{
guchar srgb_pixel[32];
gimp_rgb_get_pixel (color, private->transform_srgb_double_format,
srgb_pixel);
if (pixel_format == private->transform_layer_format)
{ {
/* for the alpha channel */ /* for the alpha channel */
gimp_rgba_get_pixel (color, pixel_format, pixel); gimp_rgba_get_pixel (color, pixel_format, pixel);
cmsDoTransform (private->transform_from_srgb_double, gimp_color_transform_process_pixels (private->transform_from_srgb_double,
srgb_pixel, pixel, 1); babl_format ("R'G'B'A double"),
} color,
else pixel_format,
{ pixel,
guchar dest_pixel[32]; 1);
/* for the alpha channel */
gimp_rgba_get_pixel (color, private->transform_layer_format,
dest_pixel);
cmsDoTransform (private->transform_from_srgb_double,
srgb_pixel, dest_pixel, 1);
babl_process (babl_fish (private->transform_layer_format,
pixel_format),
dest_pixel, pixel, 1);
}
} }
else else
{ {
@ -709,31 +624,27 @@ _gimp_image_free_color_profile (GimpImage *image)
if (private->transform_to_srgb_u8) if (private->transform_to_srgb_u8)
{ {
cmsDeleteTransform (private->transform_to_srgb_u8); g_object_unref (private->transform_to_srgb_u8);
private->transform_to_srgb_u8 = NULL; private->transform_to_srgb_u8 = NULL;
} }
if (private->transform_from_srgb_u8) if (private->transform_from_srgb_u8)
{ {
cmsDeleteTransform (private->transform_from_srgb_u8); g_object_unref (private->transform_from_srgb_u8);
private->transform_from_srgb_u8 = NULL; private->transform_from_srgb_u8 = NULL;
} }
if (private->transform_to_srgb_double) if (private->transform_to_srgb_double)
{ {
cmsDeleteTransform (private->transform_to_srgb_double); g_object_unref (private->transform_to_srgb_double);
private->transform_to_srgb_double = NULL; private->transform_to_srgb_double = NULL;
} }
if (private->transform_from_srgb_double) if (private->transform_from_srgb_double)
{ {
cmsDeleteTransform (private->transform_from_srgb_double); g_object_unref (private->transform_from_srgb_double);
private->transform_from_srgb_double = NULL; private->transform_from_srgb_double = NULL;
} }
private->transform_layer_format = NULL;
private->transform_srgb_u8_format = NULL;
private->transform_srgb_double_format = NULL;
} }
void void
@ -754,59 +665,42 @@ _gimp_image_update_color_profile (GimpImage *image,
if (private->color_profile) if (private->color_profile)
{ {
GimpColorProfile *srgb_profile; GimpColorProfile *srgb_profile;
cmsHPROFILE image_lcms;
cmsHPROFILE srgb_lcms;
cmsUInt32Number image_lcms_format;
cmsUInt32Number srgb_u8_lcms_format;
cmsUInt32Number srgb_double_lcms_format;
cmsUInt32Number flags; cmsUInt32Number flags;
srgb_profile = gimp_color_profile_new_rgb_srgb (); srgb_profile = gimp_color_profile_new_rgb_srgb ();
image_lcms = gimp_color_profile_get_lcms_profile (private->color_profile);
srgb_lcms = gimp_color_profile_get_lcms_profile (srgb_profile);
private->transform_layer_format = gimp_image_get_layer_format (image,
TRUE);
private->transform_srgb_u8_format = babl_format ("R'G'B'A u8");
private->transform_srgb_double_format = babl_format ("R'G'B'A double");
private->transform_layer_format =
gimp_color_profile_get_format (private->transform_layer_format,
&image_lcms_format);
private->transform_srgb_u8_format =
gimp_color_profile_get_format (private->transform_srgb_u8_format,
&srgb_u8_lcms_format);
private->transform_srgb_double_format =
gimp_color_profile_get_format (private->transform_srgb_double_format,
&srgb_double_lcms_format);
flags = cmsFLAGS_NOOPTIMIZE; flags = cmsFLAGS_NOOPTIMIZE;
flags |= cmsFLAGS_BLACKPOINTCOMPENSATION; flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
private->transform_to_srgb_u8 = private->transform_to_srgb_u8 =
cmsCreateTransform (image_lcms, image_lcms_format, gimp_color_transform_new (private->color_profile,
srgb_lcms, srgb_u8_lcms_format, gimp_image_get_layer_format (image, TRUE),
srgb_profile,
babl_format ("R'G'B'A u8"),
GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL, GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
flags); flags);
private->transform_from_srgb_u8 = private->transform_from_srgb_u8 =
cmsCreateTransform (srgb_lcms, srgb_u8_lcms_format, gimp_color_transform_new (srgb_profile,
image_lcms, image_lcms_format, babl_format ("R'G'B'A u8"),
private->color_profile,
gimp_image_get_layer_format (image, TRUE),
GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL, GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
flags); flags);
private->transform_to_srgb_double = private->transform_to_srgb_double =
cmsCreateTransform (image_lcms, image_lcms_format, gimp_color_transform_new (private->color_profile,
srgb_lcms, srgb_double_lcms_format, gimp_image_get_layer_format (image, TRUE),
srgb_profile,
babl_format ("R'G'B'A double"),
GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL, GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
flags); flags);
private->transform_from_srgb_double = private->transform_from_srgb_double =
cmsCreateTransform (srgb_lcms, srgb_double_lcms_format, gimp_color_transform_new (srgb_profile,
image_lcms, image_lcms_format, babl_format ("R'G'B'A double"),
private->color_profile,
gimp_image_get_layer_format (image, TRUE),
GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL, GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL,
flags); flags);
@ -891,28 +785,28 @@ gimp_image_convert_profile_colormap (GimpImage *image,
gboolean bpc, gboolean bpc,
GimpProgress *progress) GimpProgress *progress)
{ {
cmsHPROFILE src_lcms; GimpColorTransform *transform;
cmsHPROFILE dest_lcms;
guchar *cmap; guchar *cmap;
gint n_colors; gint n_colors;
GimpColorTransform transform;
src_lcms = gimp_color_profile_get_lcms_profile (src_profile);
dest_lcms = gimp_color_profile_get_lcms_profile (dest_profile);
n_colors = gimp_image_get_colormap_size (image); n_colors = gimp_image_get_colormap_size (image);
cmap = g_memdup (gimp_image_get_colormap (image), n_colors * 3); cmap = g_memdup (gimp_image_get_colormap (image), n_colors * 3);
transform = cmsCreateTransform (src_lcms, TYPE_RGB_8, transform = gimp_color_transform_new (src_profile,
dest_lcms, TYPE_RGB_8, babl_format ("R'G'B' u8"),
dest_profile,
babl_format ("R'G'B' u8"),
intent, intent,
cmsFLAGS_NOOPTIMIZE | cmsFLAGS_NOOPTIMIZE |
(bpc ? cmsFLAGS_BLACKPOINTCOMPENSATION : 0)); (bpc ? cmsFLAGS_BLACKPOINTCOMPENSATION : 0));
if (transform) if (transform)
{ {
cmsDoTransform (transform, cmap, cmap, n_colors); gimp_color_transform_process_pixels (transform,
cmsDeleteTransform (transform); babl_format ("R'G'B' u8"), cmap,
babl_format ("R'G'B' u8"), cmap,
n_colors);
g_object_unref (transform);
gimp_image_set_colormap (image, cmap, n_colors, TRUE); gimp_image_set_colormap (image, cmap, n_colors, TRUE);
} }

24
app/core/gimpimage-color-profile.h
View File

@ -80,23 +80,15 @@ void gimp_image_import_color_profile (GimpImage *ima
GimpProgress *progress, GimpProgress *progress,
gboolean interactive); gboolean interactive);
GimpColorTransform gimp_image_get_color_transform_to_srgb_u8 GimpColorTransform * gimp_image_get_color_transform_to_srgb_u8
(GimpImage *image, (GimpImage *image);
const Babl **pixel_format, GimpColorTransform * gimp_image_get_color_transform_from_srgb_u8
const Babl **srgb_u8_format); (GimpImage *image);
GimpColorTransform gimp_image_get_color_transform_from_srgb_u8
(GimpImage *image,
const Babl **pixel_format,
const Babl **srgb_u8_format);
GimpColorTransform gimp_image_get_color_transform_to_srgb_double GimpColorTransform * gimp_image_get_color_transform_to_srgb_double
(GimpImage *image, (GimpImage *image);
const Babl **pixel_format, GimpColorTransform * gimp_image_get_color_transform_from_srgb_double
const Babl **srgb_double_format); (GimpImage *image);
GimpColorTransform gimp_image_get_color_transform_from_srgb_double
(GimpImage *image,
const Babl **pixel_format,
const Babl **srgb_double_format);
void gimp_image_color_profile_pixel_to_srgb void gimp_image_color_profile_pixel_to_srgb
(GimpImage *image, (GimpImage *image,

20
app/core/gimpimage-preview.c
View File

@ -145,9 +145,7 @@ gimp_image_get_new_pixbuf (GimpViewable *viewable,
GdkPixbuf *pixbuf; GdkPixbuf *pixbuf;
gdouble scale_x; gdouble scale_x;
gdouble scale_y; gdouble scale_y;
GimpColorTransform transform; GimpColorTransform *transform;
const Babl *src_format;
const Babl *dest_format;
scale_x = (gdouble) width / (gdouble) gimp_image_get_width (image); scale_x = (gdouble) width / (gdouble) gimp_image_get_width (image);
scale_y = (gdouble) height / (gdouble) gimp_image_get_height (image); scale_y = (gdouble) height / (gdouble) gimp_image_get_height (image);
@ -155,9 +153,7 @@ gimp_image_get_new_pixbuf (GimpViewable *viewable,
pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8,
width, height); width, height);
transform = gimp_image_get_color_transform_to_srgb_u8 (image, transform = gimp_image_get_color_transform_to_srgb_u8 (image);
&src_format,
&dest_format);
if (transform) if (transform)
{ {
@ -165,7 +161,8 @@ gimp_image_get_new_pixbuf (GimpViewable *viewable,
GeglBuffer *src_buf; GeglBuffer *src_buf;
GeglBuffer *dest_buf; GeglBuffer *dest_buf;
temp_buf = gimp_temp_buf_new (width, height, src_format); temp_buf = gimp_temp_buf_new (width, height,
gimp_pickable_get_format (GIMP_PICKABLE (image)));
gegl_buffer_get (gimp_pickable_get_buffer (GIMP_PICKABLE (image)), gegl_buffer_get (gimp_pickable_get_buffer (GIMP_PICKABLE (image)),
GEGL_RECTANGLE (0, 0, width, height), GEGL_RECTANGLE (0, 0, width, height),
@ -179,15 +176,12 @@ gimp_image_get_new_pixbuf (GimpViewable *viewable,
gimp_temp_buf_unref (temp_buf); gimp_temp_buf_unref (temp_buf);
gimp_gegl_convert_color_transform (src_buf, gimp_color_transform_process_buffer (transform,
src_buf,
GEGL_RECTANGLE (0, 0, GEGL_RECTANGLE (0, 0,
width, height), width, height),
src_format,
dest_buf, dest_buf,
GEGL_RECTANGLE (0, 0, 0, 0), GEGL_RECTANGLE (0, 0, 0, 0));
dest_format,
transform,
NULL);
g_object_unref (src_buf); g_object_unref (src_buf);
g_object_unref (dest_buf); g_object_unref (dest_buf);

13
app/core/gimpimage-private.h
View File

@ -60,15 +60,10 @@ struct _GimpImagePrivate
GimpColorProfile *color_profile; /* image's color profile */ GimpColorProfile *color_profile; /* image's color profile */
/* Cached color transforms: from layer to sRGB u8 and double, and back */ /* Cached color transforms: from layer to sRGB u8 and double, and back */
GimpColorTransform transform_to_srgb_u8; GimpColorTransform *transform_to_srgb_u8;
GimpColorTransform transform_from_srgb_u8; GimpColorTransform *transform_from_srgb_u8;
GimpColorTransform transform_to_srgb_double; GimpColorTransform *transform_to_srgb_double;
GimpColorTransform transform_from_srgb_double; GimpColorTransform *transform_from_srgb_double;
/* Babl formats for above transforms: layer, sRGB u8, sRGB double */
const Babl *transform_layer_format;
const Babl *transform_srgb_u8_format;
const Babl *transform_srgb_double_format;
GimpMetadata *metadata; /* image's metadata */ GimpMetadata *metadata; /* image's metadata */

43
app/display/gimpdisplayshell-profile.c
View File

@ -129,17 +129,14 @@ gimp_display_shell_profile_update (GimpDisplayShell *shell)
gimp_widget_get_color_transform (gtk_widget_get_toplevel (GTK_WIDGET (shell)), gimp_widget_get_color_transform (gtk_widget_get_toplevel (GTK_WIDGET (shell)),
gimp_display_shell_get_color_config (shell), gimp_display_shell_get_color_config (shell),
src_profile, src_profile,
&src_format, src_format,
&dest_format); dest_format);
if (shell->profile_transform) if (shell->profile_transform)
{ {
gint w = GIMP_DISPLAY_RENDER_BUF_WIDTH * GIMP_DISPLAY_RENDER_MAX_SCALE; gint w = GIMP_DISPLAY_RENDER_BUF_WIDTH * GIMP_DISPLAY_RENDER_MAX_SCALE;
gint h = GIMP_DISPLAY_RENDER_BUF_HEIGHT * GIMP_DISPLAY_RENDER_MAX_SCALE; gint h = GIMP_DISPLAY_RENDER_BUF_HEIGHT * GIMP_DISPLAY_RENDER_MAX_SCALE;
shell->profile_src_format = src_format;
shell->profile_dest_format = dest_format;
shell->profile_data = shell->profile_data =
gegl_malloc (w * h * babl_format_get_bytes_per_pixel (src_format)); gegl_malloc (w * h * babl_format_get_bytes_per_pixel (src_format));
@ -192,34 +189,10 @@ gimp_display_shell_profile_convert_buffer (GimpDisplayShell *shell,
GeglBuffer *dest_buffer, GeglBuffer *dest_buffer,
GeglRectangle *dest_area) GeglRectangle *dest_area)
{ {
GeglBufferIterator *iter; if (shell->profile_transform)
const Babl *fish; gimp_color_transform_process_buffer (shell->profile_transform,
src_buffer, src_area,
if (! shell->profile_transform) dest_buffer, dest_area);
return;
iter = gegl_buffer_iterator_new (src_buffer, src_area, 0,
shell->profile_src_format,
GEGL_ACCESS_READ, GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (iter, dest_buffer, dest_area, 0,
shell->profile_dest_format,
GEGL_ACCESS_WRITE, GEGL_ABYSS_NONE);
fish = babl_fish (shell->profile_src_format,
shell->profile_dest_format);
while (gegl_buffer_iterator_next (iter))
{
gpointer src_data = iter->data[0];
gpointer dest_data = iter->data[1];
babl_process (fish, src_data, dest_data, iter->length);
cmsDoTransform (shell->profile_transform,
src_data, dest_data,
iter->length);
}
} }
@ -230,10 +203,8 @@ gimp_display_shell_profile_free (GimpDisplayShell *shell)
{ {
if (shell->profile_transform) if (shell->profile_transform)
{ {
cmsDeleteTransform (shell->profile_transform); g_object_unref (shell->profile_transform);
shell->profile_transform = NULL; shell->profile_transform = NULL;
shell->profile_src_format = NULL;
shell->profile_dest_format = NULL;
} }
if (shell->profile_buffer) if (shell->profile_buffer)

6
app/display/gimpdisplayshell-render.c
View File

@ -33,9 +33,7 @@
#include "core/gimpdrawable.h" #include "core/gimpdrawable.h"
#include "core/gimpimage.h" #include "core/gimpimage.h"
#include "core/gimppickable.h" #include "core/gimppickable.h"
#ifdef USE_NODE_BLIT
#include "core/gimpprojectable.h" #include "core/gimpprojectable.h"
#endif
#include "gimpdisplay.h" #include "gimpdisplay.h"
#include "gimpdisplayshell.h" #include "gimpdisplayshell.h"
@ -204,7 +202,7 @@ gimp_display_shell_render (GimpDisplayShell *shell,
GEGL_RECTANGLE (scaled_x, scaled_y, GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height), scaled_width, scaled_height),
buffer_scale, buffer_scale,
shell->profile_src_format, gimp_projectable_get_format (GIMP_PROJECTABLE (image)),
shell->profile_data, shell->profile_stride, shell->profile_data, shell->profile_stride,
GEGL_ABYSS_CLAMP); GEGL_ABYSS_CLAMP);
#else #else
@ -212,7 +210,7 @@ gimp_display_shell_render (GimpDisplayShell *shell,
buffer_scale, buffer_scale,
GEGL_RECTANGLE (scaled_x, scaled_y, GEGL_RECTANGLE (scaled_x, scaled_y,
scaled_width, scaled_height), scaled_width, scaled_height),
shell->profile_src_format, gimp_projectable_get_format (GIMP_PROJECTABLE (image)),
shell->profile_data, shell->profile_stride, shell->profile_data, shell->profile_stride,
GEGL_BLIT_CACHE); GEGL_BLIT_CACHE);
#endif #endif

5
app/display/gimpdisplayshell.h
View File

@ -153,10 +153,7 @@ struct _GimpDisplayShell
GimpColorConfig *color_config; /* color management settings */ GimpColorConfig *color_config; /* color management settings */
gboolean color_config_set; /* settings changed from defaults */ gboolean color_config_set; /* settings changed from defaults */
GimpColorTransform profile_transform; GimpColorTransform *profile_transform;
const Babl *profile_src_format;
const Babl *profile_dest_format;
GeglBuffer *profile_buffer; /* buffer for profile transform */ GeglBuffer *profile_buffer; /* buffer for profile transform */
guchar *profile_data; /* profile_buffer's pixels */ guchar *profile_data; /* profile_buffer's pixels */
gint profile_stride; /* profile_buffer's stride */ gint profile_stride; /* profile_buffer's stride */

93
app/gegl/gimp-gegl-loops.c
View File

@ -710,14 +710,10 @@ gimp_gegl_convert_color_profile (GeglBuffer *src_buffer,
gboolean bpc, gboolean bpc,
GimpProgress *progress) GimpProgress *progress)
{ {
GimpColorTransform *transform;
const Babl *src_format; const Babl *src_format;
const Babl *dest_format; const Babl *dest_format;
cmsHPROFILE src_lcms;
cmsHPROFILE dest_lcms;
cmsUInt32Number lcms_src_format;
cmsUInt32Number lcms_dest_format;
cmsUInt32Number flags; cmsUInt32Number flags;
cmsHTRANSFORM transform;
src_format = gegl_buffer_get_format (src_buffer); src_format = gegl_buffer_get_format (src_buffer);
dest_format = gegl_buffer_get_format (dest_buffer); dest_format = gegl_buffer_get_format (dest_buffer);
@ -729,28 +725,27 @@ gimp_gegl_convert_color_profile (GeglBuffer *src_buffer,
return; return;
} }
src_lcms = gimp_color_profile_get_lcms_profile (src_profile);
dest_lcms = gimp_color_profile_get_lcms_profile (dest_profile);
src_format = gimp_color_profile_get_format (src_format, &lcms_src_format);
dest_format = gimp_color_profile_get_format (dest_format, &lcms_dest_format);
flags = cmsFLAGS_NOOPTIMIZE; flags = cmsFLAGS_NOOPTIMIZE;
if (bpc) if (bpc)
flags |= cmsFLAGS_BLACKPOINTCOMPENSATION; flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
transform = cmsCreateTransform (src_lcms, lcms_src_format, transform = gimp_color_transform_new (src_profile, src_format,
dest_lcms, lcms_dest_format, dest_profile, dest_format,
intent, flags); intent, flags);
if (transform) if (transform)
{ {
gimp_gegl_convert_color_transform (src_buffer, src_rect, src_format, if (progress)
dest_buffer, dest_rect, dest_format, g_signal_connect_swapped (transform, "progress",
transform, progress); G_CALLBACK (gimp_progress_set_value),
progress);
cmsDeleteTransform (transform); gimp_color_transform_process_buffer (transform,
src_buffer, src_rect,
dest_buffer, dest_rect);
g_object_unref (transform);
} }
else else
{ {
@ -762,67 +757,3 @@ gimp_gegl_convert_color_profile (GeglBuffer *src_buffer,
gimp_progress_set_value (progress, 1.0); gimp_progress_set_value (progress, 1.0);
} }
} }
void
gimp_gegl_convert_color_transform (GeglBuffer *src_buffer,
const GeglRectangle *src_rect,
const Babl *src_format,
GeglBuffer *dest_buffer,
const GeglRectangle *dest_rect,
const Babl *dest_format,
GimpColorTransform transform,
GimpProgress *progress)
{
GeglBufferIterator *iter;
gboolean has_alpha;
gint total_pixels;
gint done_pixels = 0;
if (src_rect)
{
total_pixels = src_rect->width * src_rect->height;
}
else
{
total_pixels = (gegl_buffer_get_width (src_buffer) *
gegl_buffer_get_height (src_buffer));
}
has_alpha = babl_format_has_alpha (dest_format);
/* make sure the alpha channel is copied too, lcms doesn't copy it */
if (has_alpha)
gegl_buffer_copy (src_buffer, src_rect, GEGL_ABYSS_NONE,
dest_buffer, dest_rect);
iter = gegl_buffer_iterator_new (src_buffer, src_rect, 0,
src_format,
GEGL_ACCESS_READ,
GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (iter, dest_buffer, dest_rect, 0,
dest_format,
/* use READWRITE for alpha surfaces
* because we must use the alpha channel
* that is already copied, see above
*/
has_alpha ?
GEGL_ACCESS_READWRITE: GEGL_ACCESS_WRITE,
GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iter))
{
cmsDoTransform (transform,
iter->data[0], iter->data[1], iter->length);
done_pixels += iter->roi[0].width * iter->roi[0].height;
if (progress)
gimp_progress_set_value (progress,
(gdouble) done_pixels /
(gdouble) total_pixels);
}
if (progress)
gimp_progress_set_value (progress, 1.0);
}

10
app/gegl/gimp-gegl-loops.h
View File

@ -98,15 +98,5 @@ void gimp_gegl_convert_color_profile (GeglBuffer *src_buffer,
gboolean bpc, gboolean bpc,
GimpProgress *progress); GimpProgress *progress);
void gimp_gegl_convert_color_transform
(GeglBuffer *src_buffer,
const GeglRectangle *src_rect,
const Babl *src_format,
GeglBuffer *dest_buffer,
const GeglRectangle *dest_rect,
const Babl *dest_format,
GimpColorTransform transform,
GimpProgress *progress);
#endif /* __GIMP_GEGL_LOOPS_H__ */ #endif /* __GIMP_GEGL_LOOPS_H__ */

31
app/operations/gimpoperationprofiletransform.c
View File

@ -153,7 +153,7 @@ gimp_operation_profile_transform_finalize (GObject *object)
if (self->transform) if (self->transform)
{ {
cmsDeleteTransform (self->transform); g_object_unref (self->transform);
self->transform = NULL; self->transform = NULL;
} }
@ -241,7 +241,7 @@ gimp_operation_profile_transform_prepare (GeglOperation *operation)
if (self->transform) if (self->transform)
{ {
cmsDeleteTransform (self->transform); g_object_unref (self->transform);
self->transform = NULL; self->transform = NULL;
} }
@ -250,27 +250,13 @@ gimp_operation_profile_transform_prepare (GeglOperation *operation)
if (self->src_profile && self->dest_profile) if (self->src_profile && self->dest_profile)
{ {
cmsHPROFILE src_lcms; cmsUInt32Number flags = cmsFLAGS_NOOPTIMIZE;
cmsHPROFILE dest_lcms;
cmsUInt32Number lcms_src_format;
cmsUInt32Number lcms_dest_format;
cmsUInt32Number flags;
src_lcms = gimp_color_profile_get_lcms_profile (self->src_profile);
dest_lcms = gimp_color_profile_get_lcms_profile (self->dest_profile);
self->src_format = gimp_color_profile_get_format (format,
&lcms_src_format);
self->dest_format = gimp_color_profile_get_format (format,
&lcms_dest_format);
flags = cmsFLAGS_NOOPTIMIZE;
if (self->bpc) if (self->bpc)
flags |= cmsFLAGS_BLACKPOINTCOMPENSATION; flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
self->transform = cmsCreateTransform (src_lcms, lcms_src_format, self->transform = gimp_color_transform_new (self->src_profile, format,
dest_lcms, lcms_dest_format, self->dest_profile, format,
self->intent, flags); self->intent, flags);
} }
@ -298,7 +284,12 @@ gimp_operation_profile_transform_process (GeglOperation *operation,
self->dest_format), self->dest_format),
src, dest, samples); src, dest, samples);
cmsDoTransform (self->transform, src, dest, samples); gimp_color_transform_process_pixels (self->transform,
self->src_format,
src,
self->dest_format,
dest,
samples);
} }
else else
{ {

2
app/operations/gimpoperationprofiletransform.h
View File

@ -50,7 +50,7 @@ struct _GimpOperationProfileTransform
GimpColorRenderingIntent intent; GimpColorRenderingIntent intent;
gboolean bpc; gboolean bpc;
GimpColorTransform transform; GimpColorTransform *transform;
}; };
struct _GimpOperationProfileTransformClass struct _GimpOperationProfileTransformClass

34
app/widgets/gimpviewrenderer.c
View File

@ -69,9 +69,7 @@ struct _GimpViewRendererPrivate
gchar *bg_icon_name; gchar *bg_icon_name;
GimpColorConfig *color_config; GimpColorConfig *color_config;
GimpColorTransform profile_transform; GimpColorTransform *profile_transform;
const Babl *profile_src_format;
const Babl *profile_dest_format;
gboolean needs_render; gboolean needs_render;
guint idle_id; guint idle_id;
@ -1119,16 +1117,13 @@ gimp_view_render_temp_buf_to_surface (GimpViewRenderer *renderer,
if (renderer->priv->profile_transform) if (renderer->priv->profile_transform)
{ {
gimp_gegl_convert_color_transform (src_buffer, gimp_color_transform_process_buffer (renderer->priv->profile_transform,
src_buffer,
GEGL_RECTANGLE (x - temp_buf_x, GEGL_RECTANGLE (x - temp_buf_x,
y - temp_buf_y, y - temp_buf_y,
width, height), width, height),
renderer->priv->profile_src_format,
dest_buffer, dest_buffer,
GEGL_RECTANGLE (0, 0, 0, 0), GEGL_RECTANGLE (0, 0, 0, 0));
renderer->priv->profile_dest_format,
renderer->priv->profile_transform,
NULL);
} }
else else
{ {
@ -1169,16 +1164,13 @@ gimp_view_render_temp_buf_to_surface (GimpViewRenderer *renderer,
if (renderer->priv->profile_transform) if (renderer->priv->profile_transform)
{ {
gimp_gegl_convert_color_transform (src_buffer, gimp_color_transform_process_buffer (renderer->priv->profile_transform,
src_buffer,
GEGL_RECTANGLE (x - temp_buf_x, GEGL_RECTANGLE (x - temp_buf_x,
y - temp_buf_y, y - temp_buf_y,
width, height), width, height),
renderer->priv->profile_src_format,
dest_buffer, dest_buffer,
GEGL_RECTANGLE (x, y, 0, 0), GEGL_RECTANGLE (x, y, 0, 0));
renderer->priv->profile_dest_format,
renderer->priv->profile_transform,
NULL);
} }
else else
{ {
@ -1313,15 +1305,11 @@ gimp_view_renderer_transform_create (GimpViewRenderer *renderer,
if (! config) if (! config)
config = renderer->context->gimp->config->color_management; config = renderer->context->gimp->config->color_management;
renderer->priv->profile_src_format = gegl_buffer_get_format (src_buffer);
renderer->priv->profile_dest_format = gegl_buffer_get_format (dest_buffer);
renderer->priv->profile_transform = renderer->priv->profile_transform =
gimp_widget_get_color_transform (widget, config, gimp_widget_get_color_transform (widget, config,
profile, profile,
&renderer->priv->profile_src_format, gegl_buffer_get_format (src_buffer),
&renderer->priv->profile_dest_format); gegl_buffer_get_format (dest_buffer));
} }
} }
} }
@ -1331,9 +1319,7 @@ gimp_view_renderer_transform_free (GimpViewRenderer *renderer)
{ {
if (renderer->priv->profile_transform) if (renderer->priv->profile_transform)
{ {
cmsDeleteTransform (renderer->priv->profile_transform); g_object_unref (renderer->priv->profile_transform);
renderer->priv->profile_transform = NULL; renderer->priv->profile_transform = NULL;
renderer->priv->profile_src_format = NULL;
renderer->priv->profile_dest_format = NULL;
} }
} }

3
libgimpcolor/Makefile.am
View File

@ -78,6 +78,8 @@ libgimpcolor_@GIMP_API_VERSION@_la_SOURCES = \
gimpcolorprofile.h \ gimpcolorprofile.h \
gimpcolorspace.c \ gimpcolorspace.c \
gimpcolorspace.h \ gimpcolorspace.h \
gimpcolortransform.c \
gimpcolortransform.h \
gimphsl.c \ gimphsl.c \
gimphsl.h \ gimphsl.h \
gimphsv.c \ gimphsv.c \
@ -98,6 +100,7 @@ libgimpcolorinclude_HEADERS = \
gimpcolormanaged.h \ gimpcolormanaged.h \
gimpcolorprofile.h \ gimpcolorprofile.h \
gimpcolorspace.h \ gimpcolorspace.h \
gimpcolortransform.h \
gimphsl.h \ gimphsl.h \
gimphsv.h \ gimphsv.h \
gimppixbuf.h \ gimppixbuf.h \

5
libgimpcolor/gimpcolor.def
View File

@ -52,6 +52,11 @@ EXPORTS
gimp_color_profile_new_rgb_srgb_linear gimp_color_profile_new_rgb_srgb_linear
gimp_color_profile_new_srgb_trc_from_color_profile gimp_color_profile_new_srgb_trc_from_color_profile
gimp_color_profile_save_to_file gimp_color_profile_save_to_file
gimp_color_transform_get_type
gimp_color_transform_new
gimp_color_transform_new_proofing
gimp_color_transform_process_buffer
gimp_color_transform_process_pixels
gimp_hsl_get_type gimp_hsl_get_type
gimp_hsl_set gimp_hsl_set
gimp_hsl_set_alpha gimp_hsl_set_alpha

1
libgimpcolor/gimpcolor.h
View File

@ -29,6 +29,7 @@
#include <libgimpcolor/gimpcolormanaged.h> #include <libgimpcolor/gimpcolormanaged.h>
#include <libgimpcolor/gimpcolorprofile.h> #include <libgimpcolor/gimpcolorprofile.h>
#include <libgimpcolor/gimpcolorspace.h> #include <libgimpcolor/gimpcolorspace.h>
#include <libgimpcolor/gimpcolortransform.h>
#include <libgimpcolor/gimpcmyk.h> #include <libgimpcolor/gimpcmyk.h>
#include <libgimpcolor/gimphsl.h> #include <libgimpcolor/gimphsl.h>
#include <libgimpcolor/gimphsv.h> #include <libgimpcolor/gimphsv.h>

417
libgimpcolor/gimpcolortransform.c Normal file
View File

@ -0,0 +1,417 @@
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
*
* gimpcolortransform.c
* Copyright (C) 2014 Michael Natterer <mitch@gimp.org>
* Elle Stone <ellestone@ninedegreesbelow.com>
* Øyvind Kolås <pippin@gimp.org>
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*/
#include "config.h"
#include <string.h>
#include <lcms2.h>
#include <gio/gio.h>
#include <gegl.h>
#include "libgimpbase/gimpbase.h"
#include "libgimpconfig/gimpconfig.h"
#include "gimpcolortypes.h"
#include "gimpcolorprofile.h"
#include "gimpcolortransform.h"
#include "libgimp/libgimp-intl.h"
/**
* SECTION: gimpcolortransform
* @title: GimpColorTransform
* @short_description: Definitions and Functions relating to LCMS.
*
* Definitions and Functions relating to LCMS.
**/
/**
* GimpColorTransform:
*
* Simply a typedef to #gpointer, but actually is a cmsHTRANSFORM. It's
* used in public GIMP APIs in order to avoid having to include LCMS
* headers.
**/
enum
{
PROGRESS,
LAST_SIGNAL
};
struct _GimpColorTransformPrivate
{
GimpColorProfile *src_profile;
const Babl *src_format;
GimpColorProfile *dest_profile;
const Babl *dest_format;
cmsHTRANSFORM transform;
};
static void gimp_color_transform_finalize (GObject *object);
G_DEFINE_TYPE (GimpColorTransform, gimp_color_transform,
G_TYPE_OBJECT);
#define parent_class gimp_color_transform_parent_class
static guint gimp_color_transform_signals[LAST_SIGNAL] = { 0 };
static void
gimp_color_transform_class_init (GimpColorTransformClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gimp_color_transform_finalize;
gimp_color_transform_signals[PROGRESS] =
g_signal_new ("progress",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (GimpColorTransformClass,
progress),
NULL, NULL,
g_cclosure_marshal_VOID__DOUBLE,
G_TYPE_NONE, 1,
G_TYPE_DOUBLE);
g_type_class_add_private (klass, sizeof (GimpColorTransformPrivate));
}
static void
gimp_color_transform_init (GimpColorTransform *transform)
{
transform->priv = G_TYPE_INSTANCE_GET_PRIVATE (transform,
GIMP_TYPE_COLOR_TRANSFORM,
GimpColorTransformPrivate);
}
static void
gimp_color_transform_finalize (GObject *object)
{
GimpColorTransform *transform = GIMP_COLOR_TRANSFORM (object);
if (transform->priv->src_profile)
{
g_object_unref (transform->priv->src_profile);
transform->priv->src_profile = NULL;
}
if (transform->priv->dest_profile)
{
g_object_unref (transform->priv->dest_profile);
transform->priv->dest_profile = NULL;
}
if (transform->priv->transform)
{
cmsDeleteTransform (transform->priv->transform);
transform->priv->transform = NULL;
}
G_OBJECT_CLASS (parent_class)->finalize (object);
}
/**
* gimp_color_transform_new:
* @src_profile:
* @src_format:
* @desr_profile:
* @dest_format:
* @rendering_intent:
* @flags:
*
* This function creates an color transform.
*
* Return value: the #GimpColorTransform, or %NULL.
*
* Since: 2.10
**/
GimpColorTransform *
gimp_color_transform_new (GimpColorProfile *src_profile,
const Babl *src_format,
GimpColorProfile *dest_profile,
const Babl *dest_format,
GimpColorRenderingIntent rendering_intent,
guint32 flags)
{
GimpColorTransform *transform;
GimpColorTransformPrivate *priv;
cmsHPROFILE src_lcms;
cmsHPROFILE dest_lcms;
cmsUInt32Number lcms_src_format;
cmsUInt32Number lcms_dest_format;
g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (src_profile), NULL);
g_return_val_if_fail (src_format != NULL, NULL);
g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (dest_profile), NULL);
g_return_val_if_fail (dest_format != NULL, NULL);
transform = g_object_new (GIMP_TYPE_COLOR_TRANSFORM, NULL);
priv = transform->priv;
src_lcms = gimp_color_profile_get_lcms_profile (src_profile);
dest_lcms = gimp_color_profile_get_lcms_profile (dest_profile);
priv->src_format = gimp_color_profile_get_format (src_format,
&lcms_src_format);
priv->dest_format = gimp_color_profile_get_format (dest_format,
&lcms_dest_format);
priv->transform = cmsCreateTransform (src_lcms, lcms_src_format,
dest_lcms, lcms_dest_format,
rendering_intent,
flags);
return transform;
}
/**
* gimp_color_transform_new_proofing:
* @src_profile:
* @src_format:
* @desr_profile:
* @dest_format:
* @proof_profile:
* @proof_intent:
* @display_intent:
* @flags:
*
* This function creates a simulation / proofing color transform.
*
* Return value: the #GimpColorTransform, or %NULL.
*
* Since: 2.10
**/
GimpColorTransform *
gimp_color_transform_new_proofing (GimpColorProfile *src_profile,
const Babl *src_format,
GimpColorProfile *dest_profile,
const Babl *dest_format,
GimpColorProfile *proof_profile,
GimpColorRenderingIntent proof_intent,
GimpColorRenderingIntent display_intent,
guint32 flags)
{
GimpColorTransform *transform;
GimpColorTransformPrivate *priv;
cmsHPROFILE src_lcms;
cmsHPROFILE dest_lcms;
cmsHPROFILE proof_lcms;
cmsUInt32Number lcms_src_format;
cmsUInt32Number lcms_dest_format;
g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (src_profile), NULL);
g_return_val_if_fail (src_format != NULL, NULL);
g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (dest_profile), NULL);
g_return_val_if_fail (dest_format != NULL, NULL);
g_return_val_if_fail (GIMP_IS_COLOR_PROFILE (proof_profile), NULL);
transform = g_object_new (GIMP_TYPE_COLOR_TRANSFORM, NULL);
priv = transform->priv;
src_lcms = gimp_color_profile_get_lcms_profile (src_profile);
dest_lcms = gimp_color_profile_get_lcms_profile (dest_profile);
proof_lcms = gimp_color_profile_get_lcms_profile (proof_profile);
priv->src_format = gimp_color_profile_get_format (src_format,
&lcms_src_format);
priv->dest_format = gimp_color_profile_get_format (dest_format,
&lcms_dest_format);
priv->transform = cmsCreateProofingTransform (src_lcms, lcms_src_format,
dest_lcms, lcms_dest_format,
proof_lcms,
proof_intent,
display_intent,
flags | cmsFLAGS_SOFTPROOFING);
return transform;
}
/**
* gimp_color_transform_process_pixels:
* @transform:
* @src_format:
* @src_pixels:
* @dest_format:
* @dest_pixels:
* @length:
*
* This function transforms a contiguous line of pixels.
*
* Since: 2.10
**/
void
gimp_color_transform_process_pixels (GimpColorTransform *transform,
const Babl *src_format,
gconstpointer src_pixels,
const Babl *dest_format,
gpointer dest_pixels,
gsize length)
{
GimpColorTransformPrivate *priv;
gpointer *src;
gpointer *dest;
g_return_if_fail (GIMP_IS_COLOR_TRANSFORM (transform));
g_return_if_fail (src_format != NULL);
g_return_if_fail (src_pixels != NULL);
g_return_if_fail (dest_format != NULL);
g_return_if_fail (dest_pixels != NULL);
priv = transform->priv;
if (src_format != priv->src_format)
{
src = g_malloc (length * babl_format_get_bytes_per_pixel (priv->src_format));
babl_process (babl_fish (src_format,
priv->src_format),
src_pixels, src, length);
}
else
{
src = (gpointer) src_pixels;
}
if (dest_format != priv->dest_format)
{
dest = g_malloc (length * babl_format_get_bytes_per_pixel (priv->dest_format));
}
else
{
dest = dest_pixels;
}
/* copy the alpha channel */
if (babl_format_has_alpha (dest_format))
babl_process (babl_fish (src_format,
priv->dest_format),
src, dest, length);
cmsDoTransform (priv->transform, src, dest, length);
if (src_format != priv->src_format)
{
g_free (src);
}
if (dest_format != priv->dest_format)
{
babl_process (babl_fish (priv->dest_format,
dest_format),
dest, dest_pixels, length);
g_free (dest);
}
}
/**
* gimp_color_transform_process_buffer:
* @transform:
* @src_format:
* @src_rect:
* @dest_format:
* @dest_rect:
*
* This function transforms a contiguous line of pixels.
*
* Since: 2.10
**/
void
gimp_color_transform_process_buffer (GimpColorTransform *transform,
GeglBuffer *src_buffer,
const GeglRectangle *src_rect,
GeglBuffer *dest_buffer,
const GeglRectangle *dest_rect)
{
GimpColorTransformPrivate *priv;
GeglBufferIterator *iter;
const Babl *fish = NULL;
gint total_pixels;
gint done_pixels = 0;
g_return_if_fail (GIMP_IS_COLOR_TRANSFORM (transform));
g_return_if_fail (GEGL_IS_BUFFER (src_buffer));
g_return_if_fail (GEGL_IS_BUFFER (dest_buffer));
priv = transform->priv;
if (src_rect)
{
total_pixels = src_rect->width * src_rect->height;
}
else
{
total_pixels = (gegl_buffer_get_width (src_buffer) *
gegl_buffer_get_height (src_buffer));
}
if (babl_format_has_alpha (priv->dest_format))
fish = babl_fish (priv->src_format,
priv->dest_format);
iter = gegl_buffer_iterator_new (src_buffer, src_rect, 0,
priv->src_format,
GEGL_ACCESS_READ,
GEGL_ABYSS_NONE);
gegl_buffer_iterator_add (iter, dest_buffer, dest_rect, 0,
priv->dest_format,
GEGL_ACCESS_WRITE,
GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iter))
{
/* make sure the alpha channel is copied too, lcms doesn't copy it */
if (fish)
babl_process (fish, iter->data[0], iter->data[1], iter->length);
cmsDoTransform (priv->transform,
iter->data[0], iter->data[1], iter->length);
done_pixels += iter->roi[0].width * iter->roi[0].height;
g_signal_emit (transform, gimp_color_transform_signals[PROGRESS], 0,
(gdouble) done_pixels /
(gdouble) total_pixels);
}
g_signal_emit (transform, gimp_color_transform_signals[PROGRESS], 0,
1.0);
}

105
libgimpcolor/gimpcolortransform.h Normal file
View File

@ -0,0 +1,105 @@
/* LIBGIMP - The GIMP Library
* Copyright (C) 1995-1997 Spencer Kimball and Peter Mattis
*
* gimpcolortransform.h
* Copyright (C) 2014 Michael Natterer <mitch@gimp.org>
* Elle Stone <ellestone@ninedegreesbelow.com>
*
* This library is free software: you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 3 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see
* <http://www.gnu.org/licenses/>.
*/
#if !defined (__GIMP_COLOR_H_INSIDE__) && !defined (GIMP_COLOR_COMPILATION)
#error "Only <libgimpcolor/gimpcolor.h> can be included directly."
#endif
#ifndef __GIMP_COLOR_TRANSFORM_H__
#define __GIMP_COLOR_TRANSFORM_H__
G_BEGIN_DECLS
/* For information look into the C source or the html documentation */
#define GIMP_TYPE_COLOR_TRANSFORM (gimp_color_transform_get_type ())
#define GIMP_COLOR_TRANSFORM(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GIMP_TYPE_COLOR_TRANSFORM, GimpColorTransform))
#define GIMP_COLOR_TRANSFORM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GIMP_TYPE_COLOR_TRANSFORM, GimpColorTransformClass))
#define GIMP_IS_COLOR_TRANSFORM(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GIMP_TYPE_COLOR_TRANSFORM))
#define GIMP_IS_COLOR_TRANSFORM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GIMP_TYPE_COLOR_TRANSFORM))
#define GIMP_COLOR_TRANSFORM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GIMP_TYPE_COLOR_TRANSFORM, GimpColorTransformClass))
typedef struct _GimpColorTransformClass GimpColorTransformClass;
typedef struct _GimpColorTransformPrivate GimpColorTransformPrivate;
struct _GimpColorTransform
{
GObject parent_instance;
GimpColorTransformPrivate *priv;
};
struct _GimpColorTransformClass
{
GObjectClass parent_class;
/* signals */
void (* progress) (GimpColorTransform *transform,
gdouble fraction);
/* Padding for future expansion */
void (* _gimp_reserved1) (void);
void (* _gimp_reserved2) (void);
void (* _gimp_reserved3) (void);
void (* _gimp_reserved4) (void);
};
GType gimp_color_transform_get_type (void) G_GNUC_CONST;
GimpColorTransform *
gimp_color_transform_new (GimpColorProfile *src_profile,
const Babl *src_format,
GimpColorProfile *dest_profile,
const Babl *dest_format,
GimpColorRenderingIntent rendering_intent,
guint32 flags);
GimpColorTransform *
gimp_color_transform_new_proofing (GimpColorProfile *src_profile,
const Babl *src_format,
GimpColorProfile *dest_profile,
const Babl *dest_format,
GimpColorProfile *proof_profile,
GimpColorRenderingIntent proof_intent,
GimpColorRenderingIntent display_intent,
guint32 flags);
void gimp_color_transform_process_pixels (GimpColorTransform *transform,
const Babl *src_format,
gconstpointer src,
const Babl *dest_format,
gpointer dest,
gsize length);
void gimp_color_transform_process_buffer (GimpColorTransform *transform,
GeglBuffer *src_buffer,
const GeglRectangle *src_rect,
GeglBuffer *dest_buffer,
const GeglRectangle *dest_rect);
G_END_DECLS
#endif /* __GIMP_COLOR_TRANSFORM_H__ */

4
libgimpcolor/gimpcolortypes.h
View File

@ -21,6 +21,7 @@
#include <libgimpbase/gimpbasetypes.h> #include <libgimpbase/gimpbasetypes.h>
#include <libgimpconfig/gimpconfigtypes.h>
G_BEGIN_DECLS G_BEGIN_DECLS
@ -30,8 +31,7 @@ G_BEGIN_DECLS
typedef struct _GimpColorManaged GimpColorManaged; /* dummy typedef */ typedef struct _GimpColorManaged GimpColorManaged; /* dummy typedef */
typedef struct _GimpColorProfile GimpColorProfile; typedef struct _GimpColorProfile GimpColorProfile;
typedef struct _GimpColorTransform GimpColorTransform;
typedef gpointer GimpColorTransform;
/* usually we don't keep the structure definitions in the types file /* usually we don't keep the structure definitions in the types file

16
libgimpwidgets/gimpcolorarea.c
View File

@ -72,7 +72,7 @@ typedef struct _GimpColorAreaPrivate GimpColorAreaPrivate;
struct _GimpColorAreaPrivate struct _GimpColorAreaPrivate
{ {
GimpColorConfig *config; GimpColorConfig *config;
GimpColorTransform transform; GimpColorTransform *transform;
}; };
#define GET_PRIVATE(obj) \ #define GET_PRIVATE(obj) \
@ -402,6 +402,7 @@ gimp_color_area_expose (GtkWidget *widget,
if (priv->transform) if (priv->transform)
{ {
const Babl *format = babl_format ("cairo-RGB24");
guchar *buf = g_new (guchar, area->rowstride * area->height); guchar *buf = g_new (guchar, area->rowstride * area->height);
guchar *src = area->buf; guchar *src = area->buf;
guchar *dest = buf; guchar *dest = buf;
@ -409,7 +410,10 @@ gimp_color_area_expose (GtkWidget *widget,
for (i = 0; i < area->height; i++) for (i = 0; i < area->height; i++)
{ {
cmsDoTransform (priv->transform, src, dest, area->width); gimp_color_transform_process_pixels (priv->transform,
format, src,
format, dest,
area->width);
src += area->rowstride; src += area->rowstride;
dest += area->rowstride; dest += area->rowstride;
@ -621,7 +625,7 @@ gimp_color_area_set_color_config (GimpColorArea *area,
if (priv->transform) if (priv->transform)
{ {
cmsDeleteTransform (priv->transform); g_object_unref (priv->transform);
priv->transform = NULL; priv->transform = NULL;
} }
} }
@ -919,7 +923,7 @@ gimp_color_area_config_notify (GimpColorConfig *config,
if (priv->transform) if (priv->transform)
{ {
cmsDeleteTransform (priv->transform); g_object_unref (priv->transform);
priv->transform = NULL; priv->transform = NULL;
} }
@ -943,7 +947,7 @@ gimp_color_area_create_transform (GimpColorArea *area)
priv->transform = gimp_widget_get_color_transform (GTK_WIDGET (area), priv->transform = gimp_widget_get_color_transform (GTK_WIDGET (area),
priv->config, priv->config,
profile, profile,
&format, format,
&format); format);
} }
} }

16
libgimpwidgets/gimppreviewarea.c
View File

@ -67,7 +67,7 @@ typedef struct _GimpPreviewAreaPrivate GimpPreviewAreaPrivate;
struct _GimpPreviewAreaPrivate struct _GimpPreviewAreaPrivate
{ {
GimpColorConfig *config; GimpColorConfig *config;
GimpColorTransform transform; GimpColorTransform *transform;
}; };
#define GET_PRIVATE(obj) \ #define GET_PRIVATE(obj) \
@ -291,6 +291,7 @@ gimp_preview_area_expose (GtkWidget *widget,
if (priv->transform) if (priv->transform)
{ {
const Babl *format = babl_format ("R'G'B' u8");
gint rowstride = ((area->width * 3) + 3) & ~3; gint rowstride = ((area->width * 3) + 3) & ~3;
guchar *buf = g_new (guchar, rowstride * area->height); guchar *buf = g_new (guchar, rowstride * area->height);
guchar *src = area->buf; guchar *src = area->buf;
@ -299,7 +300,10 @@ gimp_preview_area_expose (GtkWidget *widget,
for (i = 0; i < area->height; i++) for (i = 0; i < area->height; i++)
{ {
cmsDoTransform (priv->transform, src, dest, area->width); gimp_color_transform_process_pixels (priv->transform,
format, src,
format, dest,
area->width);
src += area->rowstride; src += area->rowstride;
dest += rowstride; dest += rowstride;
@ -392,7 +396,7 @@ gimp_preview_area_config_notify (GimpColorConfig *config,
if (priv->transform) if (priv->transform)
{ {
cmsDeleteTransform (priv->transform); g_object_unref (priv->transform);
priv->transform = NULL; priv->transform = NULL;
} }
@ -416,8 +420,8 @@ gimp_preview_area_create_transform (GimpPreviewArea *area)
priv->transform = gimp_widget_get_color_transform (GTK_WIDGET (area), priv->transform = gimp_widget_get_color_transform (GTK_WIDGET (area),
priv->config, priv->config,
profile, profile,
&format, format,
&format); format);
} }
} }
@ -1805,7 +1809,7 @@ gimp_preview_area_set_color_config (GimpPreviewArea *area,
if (priv->transform) if (priv->transform)
{ {
cmsDeleteTransform (priv->transform); g_object_unref (priv->transform);
priv->transform = NULL; priv->transform = NULL;
} }
} }

33
libgimpwidgets/gimpwidgetsutils.c
View File

@ -479,20 +479,16 @@ get_display_profile (GtkWidget *widget,
return profile; return profile;
} }
GimpColorTransform GimpColorTransform *
gimp_widget_get_color_transform (GtkWidget *widget, gimp_widget_get_color_transform (GtkWidget *widget,
GimpColorConfig *config, GimpColorConfig *config,
GimpColorProfile *src_profile, GimpColorProfile *src_profile,
const Babl **src_format, const Babl *src_format,
const Babl **dest_format) const Babl *dest_format)
{ {
GimpColorTransform transform = NULL; GimpColorTransform *transform = NULL;
GimpColorProfile *dest_profile = NULL; GimpColorProfile *dest_profile = NULL;
GimpColorProfile *proof_profile = NULL; GimpColorProfile *proof_profile = NULL;
cmsHPROFILE src_lcms;
cmsHPROFILE dest_lcms;
cmsUInt32Number lcms_src_format;
cmsUInt32Number lcms_dest_format;
cmsUInt16Number alarmCodes[cmsMAXCHANNELS] = { 0, }; cmsUInt16Number alarmCodes[cmsMAXCHANNELS] = { 0, };
g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), NULL); g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), NULL);
@ -515,19 +511,10 @@ gimp_widget_get_color_transform (GtkWidget *widget,
break; break;
} }
src_lcms = gimp_color_profile_get_lcms_profile (src_profile);
dest_lcms = gimp_color_profile_get_lcms_profile (dest_profile);
*src_format = gimp_color_profile_get_format (*src_format, &lcms_src_format);
*dest_format = gimp_color_profile_get_format (*dest_format, &lcms_dest_format);
if (proof_profile) if (proof_profile)
{ {
cmsHPROFILE proof_lcms;
cmsUInt32Number softproof_flags = cmsFLAGS_SOFTPROOFING; cmsUInt32Number softproof_flags = cmsFLAGS_SOFTPROOFING;
proof_lcms = gimp_color_profile_get_lcms_profile (proof_profile);
if (config->simulation_use_black_point_compensation) if (config->simulation_use_black_point_compensation)
{ {
softproof_flags |= cmsFLAGS_BLACKPOINTCOMPENSATION; softproof_flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
@ -548,9 +535,9 @@ gimp_widget_get_color_transform (GtkWidget *widget,
cmsSetAlarmCodes (alarmCodes); cmsSetAlarmCodes (alarmCodes);
} }
transform = cmsCreateProofingTransform (src_lcms, lcms_src_format, transform = gimp_color_transform_new_proofing (src_profile, src_format,
dest_lcms, lcms_dest_format, dest_profile, dest_format,
proof_lcms, proof_profile,
config->simulation_intent, config->simulation_intent,
config->display_intent, config->display_intent,
softproof_flags); softproof_flags);
@ -559,15 +546,15 @@ gimp_widget_get_color_transform (GtkWidget *widget,
} }
else if (! gimp_color_profile_is_equal (src_profile, dest_profile)) else if (! gimp_color_profile_is_equal (src_profile, dest_profile))
{ {
cmsUInt32Number display_flags = 0; guint32 display_flags = 0;
if (config->display_use_black_point_compensation) if (config->display_use_black_point_compensation)
{ {
display_flags |= cmsFLAGS_BLACKPOINTCOMPENSATION; display_flags |= cmsFLAGS_BLACKPOINTCOMPENSATION;
} }
transform = cmsCreateTransform (src_lcms, lcms_src_format, transform = gimp_color_transform_new (src_profile, src_format,
dest_lcms, lcms_dest_format, dest_profile, dest_format,
config->display_intent, config->display_intent,
display_flags); display_flags);
} }

6
libgimpwidgets/gimpwidgetsutils.h
View File

@ -48,11 +48,11 @@ gint gimp_get_monitor_at_pointer (GdkScreen **screen)
GimpColorProfile * gimp_widget_get_color_profile (GtkWidget *widget); GimpColorProfile * gimp_widget_get_color_profile (GtkWidget *widget);
GimpColorTransform gimp_widget_get_color_transform (GtkWidget *widget, GimpColorTransform * gimp_widget_get_color_transform (GtkWidget *widget,
GimpColorConfig *config, GimpColorConfig *config,
GimpColorProfile *src_profile, GimpColorProfile *src_profile,
const Babl **src_format, const Babl *src_format,
const Babl **dest_format); const Babl *dest_format);
G_END_DECLS G_END_DECLS

40
modules/display-filter-lcms.c
View File

@ -62,9 +62,7 @@ struct _CdisplayLcms
{ {
GimpColorDisplay parent_instance; GimpColorDisplay parent_instance;
GimpColorTransform transform; GimpColorTransform *transform;
const Babl *src_format;
const Babl *dest_format;
}; };
struct _CdisplayLcmsClass struct _CdisplayLcmsClass
@ -148,7 +146,6 @@ cdisplay_lcms_class_finalize (CdisplayLcmsClass *klass)
static void static void
cdisplay_lcms_init (CdisplayLcms *lcms) cdisplay_lcms_init (CdisplayLcms *lcms)
{ {
lcms->transform = NULL;
} }
static void static void
@ -158,7 +155,7 @@ cdisplay_lcms_finalize (GObject *object)
if (lcms->transform) if (lcms->transform)
{ {
cmsDeleteTransform (lcms->transform); g_object_unref (lcms->transform);
lcms->transform = NULL; lcms->transform = NULL;
} }
@ -235,21 +232,11 @@ cdisplay_lcms_convert_buffer (GimpColorDisplay *display,
GeglRectangle *area) GeglRectangle *area)
{ {
CdisplayLcms *lcms = CDISPLAY_LCMS (display); CdisplayLcms *lcms = CDISPLAY_LCMS (display);
GeglBufferIterator *iter;
if (! lcms->transform) if (lcms->transform)
return; gimp_color_transform_process_buffer (lcms->transform,
buffer, area,
iter = gegl_buffer_iterator_new (buffer, area, 0, buffer, area);
lcms->src_format,
GEGL_ACCESS_READWRITE, GEGL_ABYSS_NONE);
while (gegl_buffer_iterator_next (iter))
{
gfloat *data = iter->data[0];
cmsDoTransform (lcms->transform, data, data, iter->length);
}
} }
static void static void
@ -263,7 +250,7 @@ cdisplay_lcms_changed (GimpColorDisplay *display)
if (lcms->transform) if (lcms->transform)
{ {
cmsDeleteTransform (lcms->transform); g_object_unref (lcms->transform);
lcms->transform = NULL; lcms->transform = NULL;
} }
@ -278,16 +265,11 @@ cdisplay_lcms_changed (GimpColorDisplay *display)
src_profile = gimp_color_managed_get_color_profile (managed); src_profile = gimp_color_managed_get_color_profile (managed);
if (src_profile) lcms->transform =
{ gimp_widget_get_color_transform (widget,
lcms->src_format = babl_format ("R'G'B'A float");
lcms->dest_format = babl_format ("R'G'B'A float");
lcms->transform = gimp_widget_get_color_transform (widget,
config, src_profile, config, src_profile,
&lcms->src_format, babl_format ("R'G'B'A float"),
&lcms->dest_format); babl_format ("R'G'B'A float"));
}
} }
static GimpColorProfile * static GimpColorProfile *