Adding upstream version 2.10.22.upstream/2.10.22upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 647 insertions, 0 deletions

diff --git a/app/paint/gimpbrushcore-loops.cc b/app/paint/gimpbrushcore-loops.cc
new file mode 100644
index 0000000..31b4afb
--- /dev/null
+++ b/app/paint/gimpbrushcore-loops.cc
@@ -0,0 +1,647 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include <gegl.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "libgimpmath/gimpmath.h"
+
+extern "C"
+{
+
+#include "paint-types.h"
+
+#include "core/gimptempbuf.h"
+
+#include "gimpbrushcore.h"
+#include "gimpbrushcore-loops.h"
+
+} /* extern "C" */
+
+#include "gimpbrushcore-kernels.h"
+
+
+#define PIXELS_PER_THREAD \
+  (/* each thread costs as much as */ 64.0 * 64.0 /* pixels */)
+
+#define EPSILON 1e-6
+
+
+static void
+clear_edges (GimpTempBuf *buf,
+             gint         top,
+             gint         bottom,
+             gint         left,
+             gint         right)
+{
+  guchar     *data;
+  const Babl *format = gimp_temp_buf_get_format (buf);
+  gint        bpp    = babl_format_get_bytes_per_pixel (format);
+  gint        width  = gimp_temp_buf_get_width  (buf);
+  gint        height = gimp_temp_buf_get_height (buf);
+
+  if (top + bottom >= height || left + right >= width)
+    {
+      gimp_temp_buf_data_clear (buf);
+
+      return;
+    }
+
+  data = gimp_temp_buf_get_data (buf);
+
+  memset (data, 0, (top * width + left) * bpp);
+
+  if (left + right)
+    {
+      gint stride = width * bpp;
+      gint size   = (left + right) * bpp;
+      gint y;
+
+      data = gimp_temp_buf_get_data (buf) +
+             ((top + 1) * width - right) * bpp;
+
+      for (y = top; y < height - bottom - 1; y++)
+        {
+          memset (data, 0, size);
+
+          data += stride;
+        }
+    }
+
+  data = gimp_temp_buf_get_data (buf) +
+         ((height - bottom) * width - right) * bpp;
+
+  memset (data, 0, (bottom * width + right) * bpp);
+}
+
+template <class T>
+static inline void
+rotate_pointers (T    **p,
+                 gint   n)
+{
+  T    *tmp;
+  gint  i;
+
+  tmp = p[0];
+
+  for (i = 0; i < n - 1; i++)
+    p[i] = p[i + 1];
+
+  p[i] = tmp;
+}
+
+template <class T>
+static void
+gimp_brush_core_subsample_mask_impl (const GimpTempBuf *mask,
+                                     GimpTempBuf       *dest,
+                                     gint               dest_offset_x,
+                                     gint               dest_offset_y,
+                                     gint               index1,
+                                     gint               index2)
+{
+  using value_type  = typename Subsample<T>::value_type;
+  using kernel_type = typename Subsample<T>::kernel_type;
+  using accum_type  = typename Subsample<T>::accum_type;
+
+  Subsample<T>       subsample;
+  const kernel_type *kernel      = subsample.kernel[index2][index1];
+  gint               mask_width  = gimp_temp_buf_get_width  (mask);
+  gint               mask_height = gimp_temp_buf_get_height (mask);
+  gint               dest_width  = gimp_temp_buf_get_width  (dest);
+  gint               dest_height = gimp_temp_buf_get_height (dest);
+
+  gegl_parallel_distribute_range (
+    mask_height, PIXELS_PER_THREAD / mask_width,
+    [=] (gint y, gint height)
+    {
+      const value_type  *m;
+      value_type        *d;
+      const kernel_type *k;
+      gint               y0;
+      gint               i, j;
+      gint               r, s;
+      gint               offs;
+      accum_type        *accum[KERNEL_HEIGHT];
+
+      /* Allocate and initialize the accum buffer */
+      for (i = 0; i < KERNEL_HEIGHT ; i++)
+        accum[i] = gegl_scratch_new0 (accum_type, dest_width + 1);
+
+      y0 = MAX (y - (KERNEL_HEIGHT - 1), 0);
+
+      m = (const value_type *) gimp_temp_buf_get_data (mask) +
+          y0 * mask_width;
+
+      for (i = y0; i < y; i++)
+        {
+          for (j = 0; j < mask_width; j++)
+            {
+              k = kernel + KERNEL_WIDTH * (y - i);
+              for (r = y - i; r < KERNEL_HEIGHT; r++)
+                {
+                  offs = j + dest_offset_x;
+                  s = KERNEL_WIDTH;
+                  while (s--)
+                    accum[r][offs++] += *m * *k++;
+                }
+              m++;
+            }
+
+          rotate_pointers (accum, KERNEL_HEIGHT);
+        }
+
+      for (i = y; i < y + height; i++)
+        {
+          for (j = 0; j < mask_width; j++)
+            {
+              k = kernel;
+              for (r = 0; r < KERNEL_HEIGHT; r++)
+                {
+                  offs = j + dest_offset_x;
+                  s = KERNEL_WIDTH;
+                  while (s--)
+                    accum[r][offs++] += *m * *k++;
+                }
+              m++;
+            }
+
+          /* store the accum buffer into the destination mask */
+          d = (value_type *) gimp_temp_buf_get_data (dest) +
+              (i + dest_offset_y) * dest_width;
+          for (j = 0; j < dest_width; j++)
+            *d++ = subsample.round (accum[0][j]);
+
+          rotate_pointers (accum, KERNEL_HEIGHT);
+
+          memset (accum[KERNEL_HEIGHT - 1], 0,
+                  sizeof (accum_type) * dest_width);
+        }
+
+      if (y + height == mask_height)
+        {
+          /* store the rest of the accum buffer into the dest mask */
+          while (i + dest_offset_y < dest_height)
+            {
+              d = (value_type *) gimp_temp_buf_get_data (dest) +
+                  (i + dest_offset_y) * dest_width;
+              for (j = 0; j < dest_width; j++)
+                *d++ = subsample.round (accum[0][j]);
+
+              rotate_pointers (accum, KERNEL_HEIGHT);
+              i++;
+            }
+        }
+
+      for (i = KERNEL_HEIGHT - 1; i >= 0; i--)
+        gegl_scratch_free (accum[i]);
+    });
+}
+
+const GimpTempBuf *
+gimp_brush_core_subsample_mask (GimpBrushCore     *core,
+                                const GimpTempBuf *mask,
+                                gdouble            x,
+                                gdouble            y)
+{
+  GimpTempBuf *dest;
+  const Babl  *mask_format;
+  gdouble      left;
+  gint         index1;
+  gint         index2;
+  gint         dest_offset_x = 0;
+  gint         dest_offset_y = 0;
+  gint         mask_width  = gimp_temp_buf_get_width  (mask);
+  gint         mask_height = gimp_temp_buf_get_height (mask);
+
+  left = x - floor (x);
+  index1 = (gint) (left * (gdouble) (KERNEL_SUBSAMPLE + 1));
+
+  left = y - floor (y);
+  index2 = (gint) (left * (gdouble) (KERNEL_SUBSAMPLE + 1));
+
+  if ((mask_width % 2) == 0)
+    {
+      index1 += KERNEL_SUBSAMPLE >> 1;
+
+      if (index1 > KERNEL_SUBSAMPLE)
+        {
+          index1 -= KERNEL_SUBSAMPLE + 1;
+          dest_offset_x = 1;
+        }
+    }
+
+  if ((mask_height % 2) == 0)
+    {
+      index2 += KERNEL_SUBSAMPLE >> 1;
+
+      if (index2 > KERNEL_SUBSAMPLE)
+        {
+          index2 -= KERNEL_SUBSAMPLE + 1;
+          dest_offset_y = 1;
+        }
+    }
+
+  if (mask == core->last_subsample_brush_mask &&
+      ! core->subsample_cache_invalid)
+    {
+      if (core->subsample_brushes[index2][index1])
+        return core->subsample_brushes[index2][index1];
+    }
+  else
+    {
+      gint i, j;
+
+      for (i = 0; i < KERNEL_SUBSAMPLE + 1; i++)
+        for (j = 0; j < KERNEL_SUBSAMPLE + 1; j++)
+          g_clear_pointer (&core->subsample_brushes[i][j], gimp_temp_buf_unref);
+
+      core->last_subsample_brush_mask = mask;
+      core->subsample_cache_invalid   = FALSE;
+    }
+
+  mask_format = gimp_temp_buf_get_format (mask);
+
+  dest = gimp_temp_buf_new (mask_width  + 2,
+                            mask_height + 2,
+                            mask_format);
+  clear_edges (dest, dest_offset_y, 0, 0, 0);
+
+  core->subsample_brushes[index2][index1] = dest;
+
+  if (mask_format == babl_format ("Y u8"))
+    {
+      gimp_brush_core_subsample_mask_impl<guchar> (mask, dest,
+                                                   dest_offset_x, dest_offset_y,
+                                                   index1, index2);
+    }
+  else if (mask_format == babl_format ("Y float"))
+    {
+      gimp_brush_core_subsample_mask_impl<gfloat> (mask, dest,
+                                                   dest_offset_x, dest_offset_y,
+                                                   index1, index2);
+    }
+  else
+    {
+      g_warn_if_reached ();
+    }
+
+  return dest;
+}
+
+/* The simple pressure profile
+ *
+ * It is: I'(I) = MIN (2 * pressure * I, 1)
+ */
+class SimplePressure
+{
+  gfloat scale;
+
+public:
+  SimplePressure (gdouble pressure)
+  {
+    scale = 2.0 * pressure;
+  }
+
+  guchar
+  operator () (guchar x) const
+  {
+    gint v = RINT (scale * x);
+
+    return MIN (v, 255);
+  }
+
+  gfloat
+  operator () (gfloat x) const
+  {
+    gfloat v = scale * x;
+
+    return MIN (v, 1.0f);
+  }
+
+  template <class T>
+  T
+  operator () (T x) const = delete;
+};
+
+/* The fancy pressure profile
+ *
+ * It is: I'(I) = tanh (20 * (pressure - 0.5) * I)           : pressure > 0.5
+ *        I'(I) = 1 - tanh (20 * (0.5 - pressure) * (1 - I)) : pressure < 0.5
+ *
+ * It looks like:
+ *
+ *    low pressure      medium pressure     high pressure
+ *
+ *         |                   /                  --
+ *         |                  /                  /
+ *        /                  /                  |
+ *      --                  /                   |
+ */
+class FancyPressure
+{
+  gfloat map[257];
+
+public:
+  FancyPressure (gdouble pressure)
+  {
+    gdouble ds, s, c;
+    gint    i;
+
+    ds = (pressure - 0.5) * (20.0 / 256.0);
+    s  = 0;
+    c  = 1.0;
+
+    if (ds > 0)
+      {
+        for (i = 0; i < 256; i++)
+          {
+            map[i] = s / c;
+            s += c * ds;
+            c += s * ds;
+          }
+
+        for (i = 0; i < 256; i++)
+          map[i] = map[i] / map[255];
+      }
+    else
+      {
+        ds = -ds;
+
+        for (i = 255; i >= 0; i--)
+          {
+            map[i] = s / c;
+            s += c * ds;
+            c += s * ds;
+          }
+
+        for (i = 255; i >= 0; i--)
+          map[i] = 1.0f - map[i] / map[0];
+      }
+
+    map[256] = map[255];
+  }
+
+  guchar
+  operator () (guchar x) const
+  {
+    return RINT (255.0f * map[x]);
+  }
+
+  gfloat
+  operator () (gfloat x) const
+  {
+    gint   i;
+    gfloat f;
+
+    x *= 255.0f;
+
+    i = floorf (x);
+    f = x - i;
+
+    return map[i] + (map[i + 1] - map[i]) * f;
+  }
+
+  template <class T>
+  T
+  operator () (T x) const = delete;
+};
+
+template <class T>
+class CachedPressure
+{
+  T map[T (~0) + 1];
+
+public:
+  template <class Pressure>
+  CachedPressure (Pressure pressure)
+  {
+    gint i;
+
+    for (i = 0; i < (gint) G_N_ELEMENTS (map); i++)
+      map[i] = pressure (T (i));
+  }
+
+  T
+  operator () (T x) const
+  {
+    return map[x];
+  }
+
+  template <class U>
+  U
+  operator () (U x) const = delete;
+};
+
+template <class T,
+          class Pressure>
+void
+gimp_brush_core_pressurize_mask_impl (const GimpTempBuf *mask,
+                                      GimpTempBuf       *dest,
+                                      Pressure           pressure)
+{
+  gegl_parallel_distribute_range (
+    gimp_temp_buf_get_width (mask) * gimp_temp_buf_get_height (mask),
+    PIXELS_PER_THREAD,
+    [=] (gint offset, gint size)
+    {
+      const T *m;
+      T       *d;
+      gint     i;
+
+      m = (const T *) gimp_temp_buf_get_data (mask) + offset;
+      d = (      T *) gimp_temp_buf_get_data (dest) + offset;
+
+      for (i = 0; i < size; i++)
+        *d++ = pressure (*m++);
+    });
+}
+
+/* #define FANCY_PRESSURE */
+
+const GimpTempBuf *
+gimp_brush_core_pressurize_mask (GimpBrushCore     *core,
+                                 const GimpTempBuf *brush_mask,
+                                 gdouble            x,
+                                 gdouble            y,
+                                 gdouble            pressure)
+{
+  const GimpTempBuf *subsample_mask;
+  const Babl        *subsample_mask_format;
+
+  /* Get the raw subsampled mask */
+  subsample_mask = gimp_brush_core_subsample_mask (core,
+                                                   brush_mask,
+                                                   x, y);
+
+  /* Special case pressure = 0.5 */
+  if (fabs (pressure - 0.5) <= EPSILON)
+    return subsample_mask;
+
+  g_clear_pointer (&core->pressure_brush, gimp_temp_buf_unref);
+
+  subsample_mask_format = gimp_temp_buf_get_format (subsample_mask);
+
+  core->pressure_brush =
+    gimp_temp_buf_new (gimp_temp_buf_get_width  (brush_mask) + 2,
+                       gimp_temp_buf_get_height (brush_mask) + 2,
+                       subsample_mask_format);
+
+#ifdef FANCY_PRESSURE
+  using Pressure = FancyPressure;
+#else
+  using Pressure = SimplePressure;
+#endif
+
+  if (subsample_mask_format == babl_format ("Y u8"))
+    {
+      gimp_brush_core_pressurize_mask_impl<guchar> (subsample_mask,
+                                                    core->pressure_brush,
+                                                    CachedPressure<guchar> (
+                                                      Pressure (pressure)));
+    }
+  else if (subsample_mask_format == babl_format ("Y float"))
+    {
+      gimp_brush_core_pressurize_mask_impl<gfloat> (subsample_mask,
+                                                    core->pressure_brush,
+                                                    Pressure (pressure));
+    }
+  else
+    {
+      g_warn_if_reached ();
+    }
+
+  return core->pressure_brush;
+}
+
+template <class T>
+static void
+gimp_brush_core_solidify_mask_impl (const GimpTempBuf *mask,
+                                    GimpTempBuf       *dest,
+                                    gint               dest_offset_x,
+                                    gint               dest_offset_y)
+{
+  gint mask_width  = gimp_temp_buf_get_width  (mask);
+  gint mask_height = gimp_temp_buf_get_height (mask);
+  gint dest_width  = gimp_temp_buf_get_width  (dest);
+
+  gegl_parallel_distribute_area (
+    GEGL_RECTANGLE (0, 0, mask_width, mask_height),
+    PIXELS_PER_THREAD,
+    [=] (const GeglRectangle *area)
+    {
+      const T *m;
+      gfloat  *d;
+      gint     i, j;
+
+      m = (const T *) gimp_temp_buf_get_data (mask) +
+          area->y * mask_width + area->x;
+      d = ((gfloat *) gimp_temp_buf_get_data (dest) +
+           ((dest_offset_y + 1 + area->y) * dest_width +
+            (dest_offset_x + 1 + area->x)));
+
+      for (i = 0; i < area->height; i++)
+        {
+          for (j = 0; j < area->width; j++)
+            *d++ = (*m++) ? 1.0 : 0.0;
+
+          m += mask_width - area->width;
+          d += dest_width - area->width;
+        }
+    });
+}
+
+const GimpTempBuf *
+gimp_brush_core_solidify_mask (GimpBrushCore     *core,
+                               const GimpTempBuf *brush_mask,
+                               gdouble            x,
+                               gdouble            y)
+{
+  GimpTempBuf  *dest;
+  const Babl   *brush_mask_format;
+  gint          dest_offset_x     = 0;
+  gint          dest_offset_y     = 0;
+  gint          brush_mask_width  = gimp_temp_buf_get_width  (brush_mask);
+  gint          brush_mask_height = gimp_temp_buf_get_height (brush_mask);
+
+  if ((brush_mask_width % 2) == 0)
+    {
+      if (x < 0.0)
+        x = fmod (x, brush_mask_width) + brush_mask_width;
+
+      if ((x - floor (x)) >= 0.5)
+        dest_offset_x++;
+    }
+
+  if ((brush_mask_height % 2) == 0)
+    {
+      if (y < 0.0)
+        y = fmod (y, brush_mask_height) + brush_mask_height;
+
+      if ((y - floor (y)) >= 0.5)
+        dest_offset_y++;
+    }
+
+  if (! core->solid_cache_invalid &&
+      brush_mask == core->last_solid_brush_mask)
+    {
+      if (core->solid_brushes[dest_offset_y][dest_offset_x])
+        return core->solid_brushes[dest_offset_y][dest_offset_x];
+    }
+  else
+    {
+      gint i, j;
+
+      for (i = 0; i < BRUSH_CORE_SOLID_SUBSAMPLE; i++)
+        for (j = 0; j < BRUSH_CORE_SOLID_SUBSAMPLE; j++)
+          g_clear_pointer (&core->solid_brushes[i][j], gimp_temp_buf_unref);
+
+      core->last_solid_brush_mask = brush_mask;
+      core->solid_cache_invalid   = FALSE;
+    }
+
+  brush_mask_format = gimp_temp_buf_get_format (brush_mask);
+
+  dest = gimp_temp_buf_new (brush_mask_width  + 2,
+                            brush_mask_height + 2,
+                            babl_format ("Y float"));
+  clear_edges (dest,
+               1 + dest_offset_y, 1 - dest_offset_y,
+               1 + dest_offset_x, 1 - dest_offset_x);
+
+  core->solid_brushes[dest_offset_y][dest_offset_x] = dest;
+
+  if (brush_mask_format == babl_format ("Y u8"))
+    {
+      gimp_brush_core_solidify_mask_impl<guchar> (brush_mask, dest,
+                                                  dest_offset_x, dest_offset_y);
+    }
+  else if (brush_mask_format == babl_format ("Y float"))
+    {
+      gimp_brush_core_solidify_mask_impl<gfloat> (brush_mask, dest,
+                                                  dest_offset_x, dest_offset_y);
+    }
+  else
+    {
+      g_warn_if_reached ();
+    }
+
+  return dest;
+}