[gimp/goat-invasion: 83/412] app: convert drawables between RGB and GRAY using gegl_buffer_copy()

[Michael Natterer <mitch src gnome org>]

commit e8f13f0fc6207eee77a66a85e7a885219b29ee64
Author: Michael Natterer <mitch gimp org>
Date:   Fri Mar 16 18:47:04 2012 +0100

    app: convert drawables between RGB and GRAY using gegl_buffer_copy()

 app/core/gimpdrawable-convert.c |  272 ++++++++++++++++++---------------------
 1 files changed, 123 insertions(+), 149 deletions(-)
---
diff --git a/app/core/gimpdrawable-convert.c b/app/core/gimpdrawable-convert.c
index bebc985..e6f6d69 100644
--- a/app/core/gimpdrawable-convert.c
+++ b/app/core/gimpdrawable-convert.c
@@ -28,6 +28,8 @@
 #include "base/pixel-region.h"
 #include "base/tile-manager.h"
 
+#include "gegl/gimp-gegl-utils.h"
+
 #include "gimpdrawable.h"
 #include "gimpdrawable-convert.h"
 #include "gimpimage.h"
@@ -89,15 +91,8 @@ void
 gimp_drawable_convert_tiles_rgb (GimpDrawable *drawable,
                                  TileManager  *new_tiles)
 {
-  PixelRegion   srcPR, destPR;
-  gint          row, col;
-  gint          offset;
   GimpImageType type;
   gboolean      has_alpha;
-  const guchar *src, *s;
-  guchar       *dest, *d;
-  const guchar *cmap;
-  gpointer      pr;
 
   g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
   g_return_if_fail (new_tiles != NULL);
@@ -107,81 +102,73 @@ gimp_drawable_convert_tiles_rgb (GimpDrawable *drawable,
 
   g_return_if_fail (tile_manager_bpp (new_tiles) == (has_alpha ? 4 : 3));
 
-  cmap = gimp_drawable_get_colormap (drawable);
-
-  pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable),
-                     0, 0,
-                     gimp_item_get_width  (GIMP_ITEM (drawable)),
-                     gimp_item_get_height (GIMP_ITEM (drawable)),
-                     FALSE);
-  pixel_region_init (&destPR, new_tiles,
-                     0, 0,
-                     gimp_item_get_width  (GIMP_ITEM (drawable)),
-                     gimp_item_get_height (GIMP_ITEM (drawable)),
-                     TRUE);
-
   switch (GIMP_IMAGE_TYPE_BASE_TYPE (type))
     {
     case GIMP_GRAY:
-      for (pr = pixel_regions_register (2, &srcPR, &destPR);
-           pr != NULL;
-           pr = pixel_regions_process (pr))
-        {
-          src  = srcPR.data;
-          dest = destPR.data;
-
-          for (row = 0; row < srcPR.h; row++)
-            {
-              s = src;
-              d = dest;
-
-              for (col = 0; col < srcPR.w; col++)
-                {
-                  d[RED] = *s;
-                  d[GREEN] = *s;
-                  d[BLUE] = *s;
-
-                  d += 3;
-                  s++;
-                  if (has_alpha)
-                    *d++ = *s++;
-                }
-
-              src += srcPR.rowstride;
-              dest += destPR.rowstride;
-            }
-        }
+      {
+        GeglBuffer *dest_buffer;
+
+        dest_buffer = gimp_tile_manager_create_buffer (new_tiles, TRUE);
+
+        gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL,
+                          dest_buffer, NULL);
+
+        g_object_unref (dest_buffer);
+      }
       break;
 
     case GIMP_INDEXED:
-      for (pr = pixel_regions_register (2, &srcPR, &destPR);
-           pr != NULL;
-           pr = pixel_regions_process (pr))
-        {
-          src  = srcPR.data;
-          dest = destPR.data;
-
-          for (row = 0; row < srcPR.h; row++)
-            {
-              s = src;
-              d = dest;
-
-              for (col = 0; col < srcPR.w; col++)
-                {
-                  offset = *s++ * 3;
-                  d[RED] = cmap[offset + 0];
-                  d[GREEN] = cmap[offset + 1];
-                  d[BLUE] = cmap[offset + 2];
-
-                  d += 3;
-                  if (has_alpha)
-                    *d++ = *s++;
-                }
-
-              src += srcPR.rowstride;
-              dest += destPR.rowstride;
-            }
-        }
+      {
+        PixelRegion   srcPR, destPR;
+        gint          row, col;
+        gint          offset;
+        const guchar *src, *s;
+        guchar       *dest, *d;
+        const guchar *cmap;
+        gpointer      pr;
+
+        cmap = gimp_drawable_get_colormap (drawable);
+
+        pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable),
+                           0, 0,
+                           gimp_item_get_width  (GIMP_ITEM (drawable)),
+                           gimp_item_get_height (GIMP_ITEM (drawable)),
+                           FALSE);
+        pixel_region_init (&destPR, new_tiles,
+                           0, 0,
+                           gimp_item_get_width  (GIMP_ITEM (drawable)),
+                           gimp_item_get_height (GIMP_ITEM (drawable)),
+                           TRUE);
+
+        for (pr = pixel_regions_register (2, &srcPR, &destPR);
+             pr != NULL;
+             pr = pixel_regions_process (pr))
+          {
+            src  = srcPR.data;
+            dest = destPR.data;
+
+            for (row = 0; row < srcPR.h; row++)
+              {
+                s = src;
+                d = dest;
+
+                for (col = 0; col < srcPR.w; col++)
+                  {
+                    offset = *s++ * 3;
+                    d[RED] = cmap[offset + 0];
+                    d[GREEN] = cmap[offset + 1];
+                    d[BLUE] = cmap[offset + 2];
+
+                    d += 3;
+                    if (has_alpha)
+                      *d++ = *s++;
+                  }
+
+                src += srcPR.rowstride;
+                dest += destPR.rowstride;
+              }
+          }
+      }
       break;
 
     default:
@@ -193,15 +180,8 @@ void
 gimp_drawable_convert_tiles_grayscale (GimpDrawable *drawable,
                                        TileManager  *new_tiles)
 {
-  PixelRegion   srcPR, destPR;
-  gint          row, col;
-  gint          offset, val;
   GimpImageType type;
   gboolean      has_alpha;
-  const guchar *src, *s;
-  guchar       *dest, *d;
-  const guchar *cmap;
-  gpointer      pr;
 
   g_return_if_fail (GIMP_IS_DRAWABLE (drawable));
   g_return_if_fail (new_tiles != NULL);
@@ -211,78 +191,72 @@ gimp_drawable_convert_tiles_grayscale (GimpDrawable *drawable,
 
   g_return_if_fail (tile_manager_bpp (new_tiles) == (has_alpha ? 2 : 1));
 
-  cmap = gimp_drawable_get_colormap (drawable);
-
-  pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable),
-                     0, 0,
-                     gimp_item_get_width  (GIMP_ITEM (drawable)),
-                     gimp_item_get_height (GIMP_ITEM (drawable)),
-                     FALSE);
-  pixel_region_init (&destPR, new_tiles,
-                     0, 0,
-                     gimp_item_get_width  (GIMP_ITEM (drawable)),
-                     gimp_item_get_height (GIMP_ITEM (drawable)),
-                     TRUE);
-
   switch (GIMP_IMAGE_TYPE_BASE_TYPE (type))
     {
     case GIMP_RGB:
-      for (pr = pixel_regions_register (2, &srcPR, &destPR);
-           pr != NULL;
-           pr = pixel_regions_process (pr))
-        {
-          src = srcPR.data;
-          dest = destPR.data;
-
-          for (row = 0; row < srcPR.h; row++)
-            {
-              s = src;
-              d = dest;
-              for (col = 0; col < srcPR.w; col++)
-                {
-                  val = GIMP_RGB_LUMINANCE (s[RED],
-                                            s[GREEN],
-                                            s[BLUE]) + 0.5;
-                  *d++ = (guchar) val;
-                  s += 3;
-                  if (has_alpha)
-                    *d++ = *s++;
-                }
-
-              src += srcPR.rowstride;
-              dest += destPR.rowstride;
-            }
-        }
+      {
+        GeglBuffer *dest_buffer;
+
+        dest_buffer = gimp_tile_manager_create_buffer (new_tiles, TRUE);
+
+        gegl_buffer_copy (gimp_drawable_get_read_buffer (drawable), NULL,
+                          dest_buffer, NULL);
+
+        g_object_unref (dest_buffer);
+      }
       break;
 
     case GIMP_INDEXED:
-      for (pr = pixel_regions_register (2, &srcPR, &destPR);
-           pr != NULL;
-           pr = pixel_regions_process (pr))
-        {
-          src = srcPR.data;
-          dest = destPR.data;
-
-          for (row = 0; row < srcPR.h; row++)
-            {
-              s = src;
-              d = dest;
-
-              for (col = 0; col < srcPR.w; col++)
-                {
-                  offset = *s++ * 3;
-                  val = GIMP_RGB_LUMINANCE (cmap[offset+0],
-                                            cmap[offset+1],
-                                            cmap[offset+2]) + 0.5;
-                  *d++ = (guchar) val;
-                  if (has_alpha)
-                    *d++ = *s++;
-                }
-
-              src += srcPR.rowstride;
-              dest += destPR.rowstride;
-            }
-        }
+      {
+        PixelRegion   srcPR, destPR;
+        gint          row, col;
+        gint          offset, val;
+        const guchar *src, *s;
+        guchar       *dest, *d;
+        const guchar *cmap;
+        gpointer      pr;
+
+        cmap = gimp_drawable_get_colormap (drawable);
+
+        pixel_region_init (&srcPR, gimp_drawable_get_tiles (drawable),
+                           0, 0,
+                           gimp_item_get_width  (GIMP_ITEM (drawable)),
+                           gimp_item_get_height (GIMP_ITEM (drawable)),
+                           FALSE);
+        pixel_region_init (&destPR, new_tiles,
+                           0, 0,
+                           gimp_item_get_width  (GIMP_ITEM (drawable)),
+                           gimp_item_get_height (GIMP_ITEM (drawable)),
+                           TRUE);
+
+        for (pr = pixel_regions_register (2, &srcPR, &destPR);
+             pr != NULL;
+             pr = pixel_regions_process (pr))
+          {
+            src = srcPR.data;
+            dest = destPR.data;
+
+            for (row = 0; row < srcPR.h; row++)
+              {
+                s = src;
+                d = dest;
+
+                for (col = 0; col < srcPR.w; col++)
+                  {
+                    offset = *s++ * 3;
+                    val = GIMP_RGB_LUMINANCE (cmap[offset+0],
+                                              cmap[offset+1],
+                                              cmap[offset+2]) + 0.5;
+                    *d++ = (guchar) val;
+                    if (has_alpha)
+                      *d++ = *s++;
+                  }
+
+                src += srcPR.rowstride;
+                dest += destPR.rowstride;
+              }
+          }
+      }
       break;
 
     default: