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

app: require a Babl for all buffers created on top of tiles 

Fixes quite some introduced glitches with indexed mode because
the buffers use the right pixel format now.
This commit is contained in:
Michael Natterer 2012-03-17 21:21:36 +01:00
parent 19fc49a972
commit d146cc40ea
14 changed files with 86 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
app/core/gimp-edit.c
View File

@ -520,7 +520,7 @@ gimp_edit_extract (GimpImage *image,
GeglBuffer *temp; GeglBuffer *temp;
GimpBuffer *buffer; GimpBuffer *buffer;
temp = gimp_tile_manager_create_buffer (tiles, TRUE); temp = gimp_tile_manager_create_buffer (tiles, NULL, TRUE);
tile_manager_unref (tiles); tile_manager_unref (tiles);
buffer = gimp_buffer_new (temp, _("Global Buffer"), buffer = gimp_buffer_new (temp, _("Global Buffer"),
@ -549,6 +549,7 @@ gimp_edit_fill_internal (GimpImage *image,
gint x, y, width, height; gint x, y, width, height;
GimpImageType drawable_type; GimpImageType drawable_type;
gint tiles_bytes; gint tiles_bytes;
const Babl *format;
guchar col[MAX_CHANNELS]; guchar col[MAX_CHANNELS];
TempBuf *pat_buf = NULL; TempBuf *pat_buf = NULL;
gboolean new_buf; gboolean new_buf;
@ -558,6 +559,7 @@ gimp_edit_fill_internal (GimpImage *image,
drawable_type = gimp_drawable_type (drawable); drawable_type = gimp_drawable_type (drawable);
tiles_bytes = gimp_drawable_bytes (drawable); tiles_bytes = gimp_drawable_bytes (drawable);
format = gimp_drawable_get_babl_format (drawable);
switch (fill_type) switch (fill_type)
{ {
@ -588,7 +590,10 @@ gimp_edit_fill_internal (GimpImage *image,
if (! gimp_drawable_has_alpha (drawable) && if (! gimp_drawable_has_alpha (drawable) &&
(pat_buf->bytes == 2 || pat_buf->bytes == 4)) (pat_buf->bytes == 2 || pat_buf->bytes == 4))
tiles_bytes++; {
tiles_bytes++;
format = gimp_drawable_get_babl_format_with_alpha (drawable);
}
} }
break; break;
@ -598,7 +603,7 @@ gimp_edit_fill_internal (GimpImage *image,
buf_tiles = tile_manager_new (width, height, tiles_bytes); buf_tiles = tile_manager_new (width, height, tiles_bytes);
dest_buffer = gimp_tile_manager_create_buffer (buf_tiles, TRUE); dest_buffer = gimp_tile_manager_create_buffer (buf_tiles, format, TRUE);
if (pat_buf) if (pat_buf)
{ {
@ -609,7 +614,7 @@ gimp_edit_fill_internal (GimpImage *image,
rect.height = pat_buf->height; rect.height = pat_buf->height;
src_buffer = gegl_buffer_linear_new_from_data (temp_buf_get_data (pat_buf), src_buffer = gegl_buffer_linear_new_from_data (temp_buf_get_data (pat_buf),
gimp_bpp_to_babl_format (tiles_bytes, TRUE), format,
&rect, &rect,
rect.width * pat_buf->bytes, rect.width * pat_buf->bytes,
NULL, NULL); NULL, NULL);

9
app/core/gimpchannel.c
View File

@ -1660,9 +1660,9 @@ gimp_channel_new_from_alpha (GimpImage *image,
gimp_channel_clear (channel, NULL, FALSE); gimp_channel_clear (channel, NULL, FALSE);
dest_tiles = gimp_drawable_get_tiles (GIMP_DRAWABLE (channel)); dest_tiles = gimp_drawable_get_tiles (GIMP_DRAWABLE (channel));
dest_buffer = gimp_tile_manager_create_buffer_with_format (dest_tiles, dest_buffer = gimp_tile_manager_create_buffer (dest_tiles,
babl_format ("A u8"), babl_format ("A u8"),
TRUE); TRUE);
gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL, gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL,
dest_buffer, NULL); dest_buffer, NULL);
@ -1706,8 +1706,7 @@ gimp_channel_new_from_component (GimpImage *image,
channel = gimp_channel_new (image, width, height, name, color); channel = gimp_channel_new (image, width, height, name, color);
dest_tiles = gimp_drawable_get_tiles (GIMP_DRAWABLE (channel)); dest_tiles = gimp_drawable_get_tiles (GIMP_DRAWABLE (channel));
dest_buffer = gimp_tile_manager_create_buffer_with_format (dest_tiles, dest_buffer = gimp_tile_manager_create_buffer (dest_tiles, format, TRUE);
format, TRUE);
gegl_buffer_copy (src_buffer, NULL, dest_buffer, NULL); gegl_buffer_copy (src_buffer, NULL, dest_buffer, NULL);

4
app/core/gimpdrawable-convert.c
View File

@ -101,7 +101,7 @@ gimp_drawable_convert_tiles_rgb (GimpDrawable *drawable,
g_return_if_fail (tile_manager_bpp (new_tiles) == (has_alpha ? 4 : 3)); g_return_if_fail (tile_manager_bpp (new_tiles) == (has_alpha ? 4 : 3));
dest_buffer = gimp_tile_manager_create_buffer (new_tiles, TRUE); dest_buffer = gimp_tile_manager_create_buffer (new_tiles, NULL, TRUE);
gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL, gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL,
dest_buffer, NULL); dest_buffer, NULL);
@ -124,7 +124,7 @@ gimp_drawable_convert_tiles_grayscale (GimpDrawable *drawable,
g_return_if_fail (tile_manager_bpp (new_tiles) == (has_alpha ? 2 : 1)); g_return_if_fail (tile_manager_bpp (new_tiles) == (has_alpha ? 2 : 1));
dest_buffer = gimp_tile_manager_create_buffer (new_tiles, TRUE); dest_buffer = gimp_tile_manager_create_buffer (new_tiles, NULL, TRUE);
gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL, gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL,
dest_buffer, NULL); dest_buffer, NULL);

4
app/core/gimpdrawable-offset.c
View File

@ -89,7 +89,9 @@ gimp_drawable_offset (GimpDrawable *drawable,
new_tiles = tile_manager_new (width, height, gimp_drawable_bytes (drawable)); new_tiles = tile_manager_new (width, height, gimp_drawable_bytes (drawable));
src_buffer = gimp_drawable_get_read_buffer (drawable); src_buffer = gimp_drawable_get_read_buffer (drawable);
dest_buffer = gimp_tile_manager_create_buffer (new_tiles, TRUE); dest_buffer = gimp_tile_manager_create_buffer (new_tiles,
gimp_drawable_get_babl_format (drawable),
TRUE);
if (! wrap_around) if (! wrap_around)
{ {

5
app/core/gimpdrawable-operation.c
View File

@ -63,6 +63,7 @@ gimp_drawable_apply_operation (GimpDrawable *drawable,
dest_buffer = dest_buffer =
gimp_tile_manager_create_buffer (gimp_drawable_get_shadow_tiles (drawable), gimp_tile_manager_create_buffer (gimp_drawable_get_shadow_tiles (drawable),
gimp_drawable_get_babl_format (drawable),
TRUE); TRUE);
gimp_apply_operation (gimp_drawable_get_read_buffer (drawable), gimp_apply_operation (gimp_drawable_get_read_buffer (drawable),
@ -149,7 +150,9 @@ gimp_drawable_apply_operation_to_tiles (GimpDrawable *drawable,
g_return_if_fail (GEGL_IS_NODE (operation)); g_return_if_fail (GEGL_IS_NODE (operation));
g_return_if_fail (dest_tiles != NULL); g_return_if_fail (dest_tiles != NULL);
dest_buffer = gimp_tile_manager_create_buffer (dest_tiles, TRUE); dest_buffer = gimp_tile_manager_create_buffer (dest_tiles,
gimp_drawable_get_babl_format (drawable),
TRUE);
gimp_drawable_apply_operation_to_buffer (drawable, gimp_drawable_apply_operation_to_buffer (drawable,
progress, progress,

2
app/core/gimpdrawable-stroke.c
View File

@ -346,7 +346,7 @@ gimp_drawable_stroke_scan_convert (GimpDrawable *drawable,
*/ */
mask = tile_manager_new (w, h, 1); mask = tile_manager_new (w, h, 1);
tmp_buffer = gimp_tile_manager_create_buffer (mask, TRUE); tmp_buffer = gimp_tile_manager_create_buffer (mask, NULL, TRUE);
gegl_buffer_clear (tmp_buffer, NULL); gegl_buffer_clear (tmp_buffer, NULL);
g_object_unref (tmp_buffer); g_object_unref (tmp_buffer);

39
app/core/gimpdrawable.c
View File

@ -576,7 +576,9 @@ gimp_drawable_resize (GimpItem *item,
new_tiles = tile_manager_new (new_width, new_height, new_tiles = tile_manager_new (new_width, new_height,
gimp_drawable_bytes (drawable)); gimp_drawable_bytes (drawable));
dest_buffer = gimp_tile_manager_create_buffer (new_tiles, TRUE); dest_buffer = gimp_tile_manager_create_buffer (new_tiles,
gimp_drawable_get_babl_format (drawable),
TRUE);
if (copy_width != new_width || if (copy_width != new_width ||
copy_height != new_height) copy_height != new_height)
@ -924,7 +926,9 @@ gimp_drawable_real_push_undo (GimpDrawable *drawable,
tiles = tile_manager_new (width, height, gimp_drawable_bytes (drawable)); tiles = tile_manager_new (width, height, gimp_drawable_bytes (drawable));
dest_buffer = gimp_tile_manager_create_buffer (tiles, TRUE); dest_buffer = gimp_tile_manager_create_buffer (tiles,
gimp_drawable_get_babl_format (drawable),
TRUE);
src_rect.x = x; src_rect.x = x;
src_rect.y = y; src_rect.y = y;
@ -1503,7 +1507,7 @@ gimp_drawable_create_buffer (GimpDrawable *drawable,
TileManager *tiles = gimp_drawable_get_tiles (drawable); TileManager *tiles = gimp_drawable_get_tiles (drawable);
const Babl *format = gimp_drawable_get_babl_format (drawable); const Babl *format = gimp_drawable_get_babl_format (drawable);
return gimp_tile_manager_create_buffer_with_format (tiles, format, write); return gimp_tile_manager_create_buffer (tiles, format, write);
} }
GeglBuffer * GeglBuffer *
@ -1877,6 +1881,35 @@ gimp_drawable_get_babl_format (const GimpDrawable *drawable)
return NULL; return NULL;
} }
const Babl *
gimp_drawable_get_babl_format_with_alpha (const GimpDrawable *drawable)
{
GimpImageType type;
g_return_val_if_fail (GIMP_IS_DRAWABLE (drawable), NULL);
type = gimp_drawable_type (drawable);
switch (type)
{
case GIMP_RGB_IMAGE:
case GIMP_RGBA_IMAGE: return babl_format ("RGBA u8");
case GIMP_GRAY_IMAGE:
case GIMP_GRAYA_IMAGE: return babl_format ("YA u8");
case GIMP_INDEXED_IMAGE:
case GIMP_INDEXEDA_IMAGE:
{
GimpImage *image = gimp_item_get_image (GIMP_ITEM (drawable));
return gimp_image_colormap_get_rgba_format (image);
}
}
g_warn_if_reached ();
return NULL;
}
gboolean gboolean
gimp_drawable_has_alpha (const GimpDrawable *drawable) gimp_drawable_has_alpha (const GimpDrawable *drawable)
{ {

2
app/core/gimpdrawable.h
View File

@ -226,6 +226,8 @@ void gimp_drawable_fill_by_type (GimpDrawable *drawable,
GimpFillType fill_type); GimpFillType fill_type);
const Babl * gimp_drawable_get_babl_format (const GimpDrawable *drawable); const Babl * gimp_drawable_get_babl_format (const GimpDrawable *drawable);
const Babl * gimp_drawable_get_babl_format_with_alpha
(const GimpDrawable *drawable);
gboolean gimp_drawable_has_alpha (const GimpDrawable *drawable); gboolean gimp_drawable_has_alpha (const GimpDrawable *drawable);
GimpImageType gimp_drawable_type (const GimpDrawable *drawable); GimpImageType gimp_drawable_type (const GimpDrawable *drawable);
GimpImageType gimp_drawable_type_with_alpha (const GimpDrawable *drawable); GimpImageType gimp_drawable_type_with_alpha (const GimpDrawable *drawable);

14
app/core/gimpimagemap.c
View File

@ -298,6 +298,7 @@ gimp_image_map_get_buffer (GimpPickable *pickable)
if (! image_map->undo_buffer) if (! image_map->undo_buffer)
image_map->undo_buffer = image_map->undo_buffer =
gimp_tile_manager_create_buffer (image_map->undo_tiles, gimp_tile_manager_create_buffer (image_map->undo_tiles,
gimp_drawable_get_babl_format (image_map->drawable),
FALSE); FALSE);
return image_map->undo_buffer; return image_map->undo_buffer;
@ -415,13 +416,14 @@ gimp_image_map_apply (GimpImageMap *image_map,
if (image_map->operation) if (image_map->operation)
{ {
const Babl *format = gimp_drawable_get_babl_format (image_map->drawable);
GeglBuffer *input_buffer; GeglBuffer *input_buffer;
GeglBuffer *output_buffer; GeglBuffer *output_buffer;
input_buffer = input_buffer =
gimp_tile_manager_create_buffer (image_map->undo_tiles, FALSE); gimp_tile_manager_create_buffer (image_map->undo_tiles, format, FALSE);
output_buffer = output_buffer =
gimp_tile_manager_create_buffer (gimp_drawable_get_shadow_tiles (image_map->drawable), TRUE); gimp_tile_manager_create_buffer (gimp_drawable_get_shadow_tiles (image_map->drawable), format, TRUE);
if (! image_map->gegl) if (! image_map->gegl)
{ {
@ -710,7 +712,9 @@ gimp_image_map_update_undo_tiles (GimpImageMap *image_map,
/* Copy from the image to the new tiles */ /* Copy from the image to the new tiles */
src = gimp_drawable_get_read_buffer (image_map->drawable); src = gimp_drawable_get_read_buffer (image_map->drawable);
dest = gimp_tile_manager_create_buffer (image_map->undo_tiles, TRUE); dest = gimp_tile_manager_create_buffer (image_map->undo_tiles,
gimp_drawable_get_babl_format (image_map->drawable),
TRUE);
gegl_buffer_copy (src, rect, dest, &dest_rect); gegl_buffer_copy (src, rect, dest, &dest_rect);
@ -870,7 +874,9 @@ gimp_image_map_data_written (GObject *operation,
GeglRectangle src_rect; GeglRectangle src_rect;
GeglRectangle dest_rect; GeglRectangle dest_rect;
src = gimp_tile_manager_create_buffer (image_map->undo_tiles, FALSE); src = gimp_tile_manager_create_buffer (image_map->undo_tiles,
gimp_drawable_get_babl_format (image_map->drawable),
FALSE);
dest = gimp_drawable_get_write_buffer (image_map->drawable); dest = gimp_drawable_get_write_buffer (image_map->drawable);
src_rect.x = extent->x - image_map->undo_offset_x; src_rect.x = extent->x - image_map->undo_offset_x;

13
app/core/gimplayer.c
View File

@ -1647,9 +1647,9 @@ gimp_layer_create_mask (const GimpLayer *layer,
GeglBuffer *dest_buffer; GeglBuffer *dest_buffer;
dest_tiles = gimp_drawable_get_tiles (GIMP_DRAWABLE (mask)); dest_tiles = gimp_drawable_get_tiles (GIMP_DRAWABLE (mask));
dest_buffer = gimp_tile_manager_create_buffer_with_format (dest_tiles, dest_buffer = gimp_tile_manager_create_buffer (dest_tiles,
babl_format ("A u8"), babl_format ("A u8"),
TRUE); TRUE);
gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL, gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL,
dest_buffer, NULL); dest_buffer, NULL);
@ -1756,7 +1756,8 @@ gimp_layer_create_mask (const GimpLayer *layer,
gimp_drawable_convert_tiles_grayscale (drawable, copy_tiles); gimp_drawable_convert_tiles_grayscale (drawable, copy_tiles);
src_buffer = gimp_tile_manager_create_buffer (copy_tiles, FALSE); src_buffer = gimp_tile_manager_create_buffer (copy_tiles, NULL,
FALSE);
} }
else else
{ {
@ -2032,7 +2033,9 @@ gimp_layer_add_alpha (GimpLayer *layer)
gimp_item_get_height (item), gimp_item_get_height (item),
GIMP_IMAGE_TYPE_BYTES (new_type)); GIMP_IMAGE_TYPE_BYTES (new_type));
dest_buffer = gimp_tile_manager_create_buffer (new_tiles, TRUE); dest_buffer = gimp_tile_manager_create_buffer (new_tiles,
gimp_drawable_get_babl_format_with_alpha (GIMP_DRAWABLE (layer)),
TRUE);
gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL, gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL,
dest_buffer, NULL); dest_buffer, NULL);

2
app/core/gimpprojection-construct.c
View File

@ -264,7 +264,7 @@ gimp_projection_initialize (GimpProjection *proj,
{ {
TileManager *tiles = gimp_pickable_get_tiles (GIMP_PICKABLE (proj)); TileManager *tiles = gimp_pickable_get_tiles (GIMP_PICKABLE (proj));
buffer = gimp_tile_manager_create_buffer (tiles, TRUE); buffer = gimp_tile_manager_create_buffer (tiles, NULL, TRUE);
} }
gegl_buffer_clear (buffer, &rect); gegl_buffer_clear (buffer, &rect);

6
app/core/gimpprojection.c
View File

@ -355,7 +355,7 @@ gimp_projection_get_buffer (GimpPickable *pickable)
{ {
TileManager *tiles = gimp_projection_get_tiles (pickable); TileManager *tiles = gimp_projection_get_tiles (pickable);
proj->buffer = gimp_tile_manager_create_buffer (tiles, FALSE); proj->buffer = gimp_tile_manager_create_buffer (tiles, NULL, FALSE);
} }
return proj->buffer; return proj->buffer;
@ -442,7 +442,7 @@ gimp_projection_get_sink_node (GimpProjection *proj)
gegl_node_add_child (proj->graph, graph); gegl_node_add_child (proj->graph, graph);
tiles = gimp_projection_get_tiles (GIMP_PICKABLE (proj)); tiles = gimp_projection_get_tiles (GIMP_PICKABLE (proj));
buffer = gimp_tile_manager_create_buffer (tiles, TRUE); buffer = gimp_tile_manager_create_buffer (tiles, NULL, TRUE);
proj->sink_node = proj->sink_node =
gegl_node_new_child (proj->graph, gegl_node_new_child (proj->graph,
@ -485,7 +485,7 @@ gimp_projection_get_tiles_at_level (GimpProjection *proj,
GeglBuffer *buffer; GeglBuffer *buffer;
tiles = tile_pyramid_get_tiles (proj->pyramid, 0, NULL); tiles = tile_pyramid_get_tiles (proj->pyramid, 0, NULL);
buffer = gimp_tile_manager_create_buffer (tiles, TRUE); buffer = gimp_tile_manager_create_buffer (tiles, NULL, TRUE);
gegl_node_set (proj->sink_node, gegl_node_set (proj->sink_node,
"buffer", buffer, "buffer", buffer,

34
app/gegl/gimp-gegl-utils.c
View File

@ -78,31 +78,6 @@ gimp_bpp_to_babl_format (guint bpp,
return NULL; return NULL;
} }
static gint
gimp_babl_format_to_legacy_bpp (const Babl *format)
{
return babl_format_get_n_components (format);
}
TileManager *
gimp_buffer_to_tiles (GeglBuffer *buffer)
{
TileManager *new_tiles;
GeglBuffer *temp;
gint width = gegl_buffer_get_width (buffer);
gint height = gegl_buffer_get_height (buffer);
const Babl *format = gegl_buffer_get_format (buffer);
new_tiles = tile_manager_new (width, height,
gimp_babl_format_to_legacy_bpp (format));
temp = gimp_tile_manager_create_buffer (new_tiles, TRUE);
gegl_buffer_copy (buffer, NULL, temp, NULL);
g_object_unref (temp);
return new_tiles;
}
const gchar * const gchar *
gimp_layer_mode_to_gegl_operation (GimpLayerModeEffects mode) gimp_layer_mode_to_gegl_operation (GimpLayerModeEffects mode)
{ {
@ -159,15 +134,8 @@ gimp_interpolation_to_gegl_filter (GimpInterpolationType interpolation)
GeglBuffer * GeglBuffer *
gimp_tile_manager_create_buffer (TileManager *tm, gimp_tile_manager_create_buffer (TileManager *tm,
const Babl *format,
gboolean write) gboolean write)
{
return gimp_tile_manager_create_buffer_with_format (tm, NULL, write);
}
GeglBuffer *
gimp_tile_manager_create_buffer_with_format (TileManager *tm,
const Babl *format,
gboolean write)
{ {
GeglTileBackend *backend; GeglTileBackend *backend;
GeglBuffer *buffer; GeglBuffer *buffer;

8
app/gegl/gimp-gegl-utils.h
View File

@ -25,16 +25,12 @@
const Babl * gimp_bpp_to_babl_format (guint bpp, const Babl * gimp_bpp_to_babl_format (guint bpp,
gboolean linear) G_GNUC_CONST; gboolean linear) G_GNUC_CONST;
TileManager * gimp_buffer_to_tiles (GeglBuffer *buffer);
const gchar * gimp_layer_mode_to_gegl_operation (GimpLayerModeEffects mode) G_GNUC_CONST; const gchar * gimp_layer_mode_to_gegl_operation (GimpLayerModeEffects mode) G_GNUC_CONST;
const gchar * gimp_interpolation_to_gegl_filter (GimpInterpolationType interpolation) G_GNUC_CONST; const gchar * gimp_interpolation_to_gegl_filter (GimpInterpolationType interpolation) G_GNUC_CONST;
GeglBuffer * gimp_tile_manager_create_buffer (TileManager *tm, GeglBuffer * gimp_tile_manager_create_buffer (TileManager *tm,
const Babl *format,
gboolean write); gboolean write);
GeglBuffer * gimp_tile_manager_create_buffer_with_format (TileManager *tm,
const Babl *format,
gboolean write);
void gimp_gegl_buffer_refetch_tiles (GeglBuffer *buffer); void gimp_gegl_buffer_refetch_tiles (GeglBuffer *buffer);