Adding upstream version 2.10.34.upstream/2.10.34upstream

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

1 files changed, 1415 insertions, 0 deletions

diff --git a/app/gegl/gimp-babl.c b/app/gegl/gimp-babl.c
new file mode 100644
index 0000000..b2dc20a
--- /dev/null
+++ b/app/gegl/gimp-babl.c
@@ -0,0 +1,1415 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimp-babl.c
+ * Copyright (C) 2012 Michael Natterer <mitch@gimp.org>
+ *
+ * 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 <cairo.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gegl.h>
+
+#include "libgimpcolor/gimpcolor.h"
+
+#include "gimp-gegl-types.h"
+
+#include "gimp-babl.h"
+
+#include "gimp-intl.h"
+
+
+void
+gimp_babl_init (void)
+{
+  babl_format_new ("name", "R u8",
+                   babl_model ("RGBA"),
+                   babl_type ("u8"),
+                   babl_component ("R"),
+                   NULL);
+  babl_format_new ("name", "R' u8",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("u8"),
+                   babl_component ("R'"),
+                   NULL);
+  babl_format_new ("name", "G u8",
+                   babl_model ("RGBA"),
+                   babl_type ("u8"),
+                   babl_component ("G"),
+                   NULL);
+  babl_format_new ("name", "G' u8",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("u8"),
+                   babl_component ("G'"),
+                   NULL);
+  babl_format_new ("name", "B u8",
+                   babl_model ("RGBA"),
+                   babl_type ("u8"),
+                   babl_component ("B"),
+                   NULL);
+  babl_format_new ("name", "B' u8",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("u8"),
+                   babl_component ("B'"),
+                   NULL);
+  babl_format_new ("name", "A u8",
+                   babl_model ("RGBA"),
+                   babl_type ("u8"),
+                   babl_component ("A"),
+                   NULL);
+
+  babl_format_new ("name", "R u16",
+                   babl_model ("RGBA"),
+                   babl_type ("u16"),
+                   babl_component ("R"),
+                   NULL);
+  babl_format_new ("name", "R' u16",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("u16"),
+                   babl_component ("R'"),
+                   NULL);
+  babl_format_new ("name", "G u16",
+                   babl_model ("RGBA"),
+                   babl_type ("u16"),
+                   babl_component ("G"),
+                   NULL);
+  babl_format_new ("name", "G' u16",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("u16"),
+                   babl_component ("G'"),
+                   NULL);
+  babl_format_new ("name", "B u16",
+                   babl_model ("RGBA"),
+                   babl_type ("u16"),
+                   babl_component ("B"),
+                   NULL);
+  babl_format_new ("name", "B' u16",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("u16"),
+                   babl_component ("B'"),
+                   NULL);
+  babl_format_new ("name", "A u16",
+                   babl_model ("RGBA"),
+                   babl_type ("u16"),
+                   babl_component ("A"),
+                   NULL);
+
+  babl_format_new ("name", "R u32",
+                   babl_model ("RGBA"),
+                   babl_type ("u32"),
+                   babl_component ("R"),
+                   NULL);
+  babl_format_new ("name", "R' u32",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("u32"),
+                   babl_component ("R'"),
+                   NULL);
+  babl_format_new ("name", "G u32",
+                   babl_model ("RGBA"),
+                   babl_type ("u32"),
+                   babl_component ("G"),
+                   NULL);
+  babl_format_new ("name", "G' u32",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("u32"),
+                   babl_component ("G'"),
+                   NULL);
+  babl_format_new ("name", "B u32",
+                   babl_model ("RGBA"),
+                   babl_type ("u32"),
+                   babl_component ("B"),
+                   NULL);
+  babl_format_new ("name", "B' u32",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("u32"),
+                   babl_component ("B'"),
+                   NULL);
+  babl_format_new ("name", "A u32",
+                   babl_model ("RGBA"),
+                   babl_type ("u32"),
+                   babl_component ("A"),
+                   NULL);
+
+  babl_format_new ("name", "R half",
+                   babl_model ("RGBA"),
+                   babl_type ("half"),
+                   babl_component ("R"),
+                   NULL);
+  babl_format_new ("name", "R' half",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("half"),
+                   babl_component ("R'"),
+                   NULL);
+  babl_format_new ("name", "G half",
+                   babl_model ("RGBA"),
+                   babl_type ("half"),
+                   babl_component ("G"),
+                   NULL);
+  babl_format_new ("name", "G' half",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("half"),
+                   babl_component ("G'"),
+                   NULL);
+  babl_format_new ("name", "B half",
+                   babl_model ("RGBA"),
+                   babl_type ("half"),
+                   babl_component ("B"),
+                   NULL);
+  babl_format_new ("name", "B' half",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("half"),
+                   babl_component ("B'"),
+                   NULL);
+  babl_format_new ("name", "A half",
+                   babl_model ("RGBA"),
+                   babl_type ("half"),
+                   babl_component ("A"),
+                   NULL);
+
+  babl_format_new ("name", "R float",
+                   babl_model ("RGBA"),
+                   babl_type ("float"),
+                   babl_component ("R"),
+                   NULL);
+  babl_format_new ("name", "R' float",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("float"),
+                   babl_component ("R'"),
+                   NULL);
+  babl_format_new ("name", "G float",
+                   babl_model ("RGBA"),
+                   babl_type ("float"),
+                   babl_component ("G"),
+                   NULL);
+  babl_format_new ("name", "G' float",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("float"),
+                   babl_component ("G'"),
+                   NULL);
+  babl_format_new ("name", "B float",
+                   babl_model ("RGBA"),
+                   babl_type ("float"),
+                   babl_component ("B"),
+                   NULL);
+  babl_format_new ("name", "B' float",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("float"),
+                   babl_component ("B'"),
+                   NULL);
+  babl_format_new ("name", "A float",
+                   babl_model ("RGBA"),
+                   babl_type ("float"),
+                   babl_component ("A"),
+                   NULL);
+
+  babl_format_new ("name", "R double",
+                   babl_model ("RGBA"),
+                   babl_type ("double"),
+                   babl_component ("R"),
+                   NULL);
+  babl_format_new ("name", "R' double",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("double"),
+                   babl_component ("R'"),
+                   NULL);
+  babl_format_new ("name", "G double",
+                   babl_model ("RGBA"),
+                   babl_type ("double"),
+                   babl_component ("G"),
+                   NULL);
+  babl_format_new ("name", "G' double",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("double"),
+                   babl_component ("G'"),
+                   NULL);
+  babl_format_new ("name", "B double",
+                   babl_model ("RGBA"),
+                   babl_type ("double"),
+                   babl_component ("B"),
+                   NULL);
+  babl_format_new ("name", "B' double",
+                   babl_model ("R'G'B'A"),
+                   babl_type ("double"),
+                   babl_component ("B'"),
+                   NULL);
+  babl_format_new ("name", "A double",
+                   babl_model ("RGBA"),
+                   babl_type ("double"),
+                   babl_component ("A"),
+                   NULL);
+}
+
+void
+gimp_babl_init_fishes (GimpInitStatusFunc status_callback)
+{
+  /* create a bunch of fishes - to decrease the initial lazy
+   * initialization cost for some interactions
+   */
+  static const struct
+  {
+    const gchar *from_format;
+    const gchar *to_format;
+  }
+  fishes[] =
+  {
+    { "Y' u8",          "RaGaBaA float" },
+    { "Y u8",           "RaGaBaA float" },
+    { "R'G'B'A u8",     "RaGaBaA float" },
+    { "R'G'B'A float",  "R'G'B'A u8"    },
+    { "R'G'B'A float",  "R'G'B' u8"     },
+    { "R'G'B'A u8",     "RGBA float"    },
+    { "RGBA float",     "R'G'B'A u8"    },
+    { "RGBA float",     "R'G'B'A u8"    },
+    { "RGBA float",     "R'G'B'A float" },
+    { "Y' u8",          "R'G'B' u8"     },
+    { "Y u8",           "Y float"       },
+    { "R'G'B' u8",      "cairo-RGB24"   },
+    { "R'G'B' u8",      "R'G'B'A float" },
+    { "R'G'B' u8",      "R'G'B'A u8"    },
+    { "R'G'B'A u8",     "R'G'B'A float" },
+    { "R'G'B'A u8",     "cairo-ARGB32"  },
+    { "R'G'B'A double", "RGBA float"    },
+    { "R'G'B'A float",  "RGBA double"   },
+    { "R'G'B' u8",      "RGB float"     },
+    { "RGB float",      "R'G'B'A float" },
+    { "R'G'B' u8",      "RGBA float"    },
+    { "RaGaBaA float",  "R'G'B'A float" },
+    { "RaGaBaA float",  "RGBA float"    },
+    { "RGBA float",     "RaGaBaA float" },
+    { "R'G'B' u8",      "RaGaBaA float" },
+    { "cairo-ARGB32",   "R'G'B'A u8"    }
+  };
+
+  gint i;
+
+  for (i = 0; i < G_N_ELEMENTS (fishes); i++)
+    {
+      status_callback (NULL, NULL,
+                       (gdouble) (i + 1) /
+                       (gdouble) G_N_ELEMENTS (fishes) * 0.8);
+
+      babl_fish (babl_format (fishes[i].from_format),
+                 babl_format (fishes[i].to_format));
+    }
+}
+
+static const struct
+{
+  const gchar *name;
+  const gchar *description;
+}
+babl_descriptions[] =
+{
+  { "RGB u8",         N_("RGB") },
+  { "R'G'B' u8",      N_("RGB") },
+  { "RGB u16",        N_("RGB") },
+  { "R'G'B' u16",     N_("RGB") },
+  { "RGB u32",        N_("RGB") },
+  { "R'G'B' u32",     N_("RGB") },
+  { "RGB half",       N_("RGB") },
+  { "R'G'B' half",    N_("RGB") },
+  { "RGB float",      N_("RGB") },
+  { "R'G'B' float",   N_("RGB") },
+  { "RGB double",     N_("RGB") },
+  { "R'G'B' double",  N_("RGB") },
+
+  { "RGBA u8",        N_("RGB-alpha") },
+  { "R'G'B'A u8",     N_("RGB-alpha") },
+  { "RGBA u16",       N_("RGB-alpha") },
+  { "R'G'B'A u16",    N_("RGB-alpha") },
+  { "RGBA u32",       N_("RGB-alpha") },
+  { "R'G'B'A u32",    N_("RGB-alpha") },
+  { "RGBA half",      N_("RGB-alpha") },
+  { "R'G'B'A half",   N_("RGB-alpha") },
+  { "RGBA float",     N_("RGB-alpha") },
+  { "R'G'B'A float",  N_("RGB-alpha") },
+  { "RGBA double",    N_("RGB-alpha") },
+  { "R'G'B'A double", N_("RGB-alpha") },
+
+  { "Y u8",           N_("Grayscale") },
+  { "Y' u8",          N_("Grayscale") },
+  { "Y u16",          N_("Grayscale") },
+  { "Y' u16",         N_("Grayscale") },
+  { "Y u32",          N_("Grayscale") },
+  { "Y' u32",         N_("Grayscale") },
+  { "Y half",         N_("Grayscale") },
+  { "Y' half",        N_("Grayscale") },
+  { "Y float",        N_("Grayscale") },
+  { "Y' float",       N_("Grayscale") },
+  { "Y double",       N_("Grayscale") },
+  { "Y' double",      N_("Grayscale") },
+
+  { "YA u8",          N_("Grayscale-alpha") },
+  { "Y'A u8",         N_("Grayscale-alpha") },
+  { "YA u16",         N_("Grayscale-alpha") },
+  { "Y'A u16",        N_("Grayscale-alpha") },
+  { "YA u32",         N_("Grayscale-alpha") },
+  { "Y'A u32",        N_("Grayscale-alpha") },
+  { "YA half",        N_("Grayscale-alpha") },
+  { "Y'A half",       N_("Grayscale-alpha") },
+  { "YA float",       N_("Grayscale-alpha") },
+  { "Y'A float",      N_("Grayscale-alpha") },
+  { "YA double",      N_("Grayscale-alpha") },
+  { "Y'A double",     N_("Grayscale-alpha") },
+
+  { "R u8",           N_("Red component") },
+  { "R' u8",          N_("Red component") },
+  { "R u16",          N_("Red component") },
+  { "R' u16",         N_("Red component") },
+  { "R u32",          N_("Red component") },
+  { "R' u32",         N_("Red component") },
+  { "R half",         N_("Red component") },
+  { "R' half",        N_("Red component") },
+  { "R float",        N_("Red component") },
+  { "R' float",       N_("Red component") },
+  { "R double",       N_("Red component") },
+  { "R' double",      N_("Red component") },
+
+  { "G u8",           N_("Green component") },
+  { "G' u8",          N_("Green component") },
+  { "G u16",          N_("Green component") },
+  { "G' u16",         N_("Green component") },
+  { "G u32",          N_("Green component") },
+  { "G' u32",         N_("Green component") },
+  { "G half",         N_("Green component") },
+  { "G' half",        N_("Green component") },
+  { "G float",        N_("Green component") },
+  { "G' float",       N_("Green component") },
+  { "G double",       N_("Green component") },
+  { "G' double",      N_("Green component") },
+
+  { "B u8",           N_("Blue component") },
+  { "B' u8",          N_("Blue component") },
+  { "B u16",          N_("Blue component") },
+  { "B' u16",         N_("Blue component") },
+  { "B u32",          N_("Blue component") },
+  { "B' u32",         N_("Blue component") },
+  { "B half",         N_("Blue component") },
+  { "B' half",        N_("Blue component") },
+  { "B float",        N_("Blue component") },
+  { "B' float",       N_("Blue component") },
+  { "B double",       N_("Blue component") },
+  { "B' double",      N_("Blue component") },
+
+  { "A u8",          N_("Alpha component") },
+  { "A u16",         N_("Alpha component") },
+  { "A u32",         N_("Alpha component") },
+  { "A half",        N_("Alpha component") },
+  { "A float",       N_("Alpha component") },
+  { "A double",      N_("Alpha component") }
+};
+
+static GHashTable *babl_description_hash = NULL;
+
+const gchar *
+gimp_babl_format_get_description (const Babl *babl)
+{
+  const gchar *description;
+
+  g_return_val_if_fail (babl != NULL, NULL);
+
+  if (G_UNLIKELY (! babl_description_hash))
+    {
+      gint i;
+
+      babl_description_hash = g_hash_table_new (g_str_hash,
+                                                g_str_equal);
+
+      for (i = 0; i < G_N_ELEMENTS (babl_descriptions); i++)
+        g_hash_table_insert (babl_description_hash,
+                             (gpointer) babl_descriptions[i].name,
+                             gettext (babl_descriptions[i].description));
+    }
+
+  if (babl_format_is_palette (babl))
+    {
+      if (babl_format_has_alpha (babl))
+        return _("Indexed-alpha");
+      else
+        return _("Indexed");
+    }
+
+  description = g_hash_table_lookup (babl_description_hash,
+                                     babl_get_name (babl));
+
+  if (description)
+    return description;
+
+  return g_strconcat ("ERROR: unknown Babl format ",
+                      babl_get_name (babl), NULL);
+}
+
+GimpColorProfile *
+gimp_babl_format_get_color_profile (const Babl *format)
+{
+  static GimpColorProfile *srgb_profile        = NULL;
+  static GimpColorProfile *linear_rgb_profile  = NULL;
+  static GimpColorProfile *gray_profile        = NULL;
+  static GimpColorProfile *linear_gray_profile = NULL;
+
+  g_return_val_if_fail (format != NULL, NULL);
+
+  if (gimp_babl_format_get_base_type (format) == GIMP_GRAY)
+    {
+      if (gimp_babl_format_get_linear (format))
+        {
+          if (! linear_gray_profile)
+            {
+              linear_gray_profile = gimp_color_profile_new_d65_gray_linear ();
+              g_object_add_weak_pointer (G_OBJECT (linear_gray_profile),
+                                         (gpointer) &linear_gray_profile);
+            }
+
+          return linear_gray_profile;
+        }
+      else
+        {
+          if (! gray_profile)
+            {
+              gray_profile = gimp_color_profile_new_d65_gray_srgb_trc ();
+              g_object_add_weak_pointer (G_OBJECT (gray_profile),
+                                         (gpointer) &gray_profile);
+            }
+
+          return gray_profile;
+        }
+    }
+  else
+    {
+      if (gimp_babl_format_get_linear (format))
+        {
+          if (! linear_rgb_profile)
+            {
+              linear_rgb_profile = gimp_color_profile_new_rgb_srgb_linear ();
+              g_object_add_weak_pointer (G_OBJECT (linear_rgb_profile),
+                                         (gpointer) &linear_rgb_profile);
+            }
+
+          return linear_rgb_profile;
+        }
+      else
+        {
+          if (! srgb_profile)
+            {
+              srgb_profile = gimp_color_profile_new_rgb_srgb ();
+              g_object_add_weak_pointer (G_OBJECT (srgb_profile),
+                                         (gpointer) &srgb_profile);
+            }
+
+          return srgb_profile;
+        }
+    }
+}
+
+GimpImageBaseType
+gimp_babl_format_get_base_type (const Babl *format)
+{
+  const Babl *model;
+
+  g_return_val_if_fail (format != NULL, -1);
+
+  model = babl_format_get_model (format);
+
+  if (model == babl_model ("Y")  ||
+      model == babl_model ("Y'") ||
+      model == babl_model ("YA") ||
+      model == babl_model ("Y'A"))
+    {
+      return GIMP_GRAY;
+    }
+  else if (model == babl_model ("RGB")     ||
+           model == babl_model ("R'G'B'")  ||
+           model == babl_model ("RGBA")    ||
+           model == babl_model ("R'G'B'A") ||
+           model == babl_model ("RaGaBaA") ||
+           model == babl_model ("R'aG'aB'aA"))
+    {
+      return GIMP_RGB;
+    }
+  else if (babl_format_is_palette (format))
+    {
+      return GIMP_INDEXED;
+    }
+
+  g_return_val_if_reached (-1);
+}
+
+GimpComponentType
+gimp_babl_format_get_component_type (const Babl *format)
+{
+  const Babl *type;
+
+  g_return_val_if_fail (format != NULL, -1);
+
+  type = babl_format_get_type (format, 0);
+
+  if (type == babl_type ("u8"))
+    return GIMP_COMPONENT_TYPE_U8;
+  else if (type == babl_type ("u16"))
+    return GIMP_COMPONENT_TYPE_U16;
+  else if (type == babl_type ("u32"))
+    return GIMP_COMPONENT_TYPE_U32;
+  else if (type == babl_type ("half"))
+    return GIMP_COMPONENT_TYPE_HALF;
+  else if (type == babl_type ("float"))
+    return GIMP_COMPONENT_TYPE_FLOAT;
+  else if (type == babl_type ("double"))
+    return GIMP_COMPONENT_TYPE_DOUBLE;
+
+  g_return_val_if_reached (-1);
+}
+
+GimpPrecision
+gimp_babl_format_get_precision (const Babl *format)
+{
+  const Babl *type;
+
+  g_return_val_if_fail (format != NULL, -1);
+
+  type = babl_format_get_type (format, 0);
+
+  if (gimp_babl_format_get_linear (format))
+    {
+      if (type == babl_type ("u8"))
+        return GIMP_PRECISION_U8_LINEAR;
+      else if (type == babl_type ("u16"))
+        return GIMP_PRECISION_U16_LINEAR;
+      else if (type == babl_type ("u32"))
+        return GIMP_PRECISION_U32_LINEAR;
+      else if (type == babl_type ("half"))
+        return GIMP_PRECISION_HALF_LINEAR;
+      else if (type == babl_type ("float"))
+        return GIMP_PRECISION_FLOAT_LINEAR;
+      else if (type == babl_type ("double"))
+        return GIMP_PRECISION_DOUBLE_LINEAR;
+    }
+  else
+    {
+      if (type == babl_type ("u8"))
+        return GIMP_PRECISION_U8_GAMMA;
+      else if (type == babl_type ("u16"))
+        return GIMP_PRECISION_U16_GAMMA;
+      else if (type == babl_type ("u32"))
+        return GIMP_PRECISION_U32_GAMMA;
+      else if (type == babl_type ("half"))
+        return GIMP_PRECISION_HALF_GAMMA;
+      else if (type == babl_type ("float"))
+        return GIMP_PRECISION_FLOAT_GAMMA;
+      else if (type == babl_type ("double"))
+        return GIMP_PRECISION_DOUBLE_GAMMA;
+    }
+
+  g_return_val_if_reached (-1);
+}
+
+gboolean
+gimp_babl_format_get_linear (const Babl *format)
+{
+  const Babl *model;
+
+  g_return_val_if_fail (format != NULL, FALSE);
+
+  model = babl_format_get_model (format);
+
+  if (model == babl_model ("Y")    ||
+      model == babl_model ("YA")   ||
+      model == babl_model ("RGB")  ||
+      model == babl_model ("RGBA") ||
+      model == babl_model ("RaGaBaA"))
+    {
+      return TRUE;
+    }
+  else if (model == babl_model ("Y'")      ||
+           model == babl_model ("Y'A")     ||
+           model == babl_model ("R'G'B'")  ||
+           model == babl_model ("R'G'B'A") ||
+           model == babl_model ("R'aG'aB'aA"))
+    {
+      return FALSE;
+    }
+  else if (babl_format_is_palette (format))
+    {
+      return FALSE;
+    }
+
+  g_return_val_if_reached (FALSE);
+}
+
+GimpComponentType
+gimp_babl_component_type (GimpPrecision precision)
+{
+  switch (precision)
+    {
+    case GIMP_PRECISION_U8_LINEAR:
+    case GIMP_PRECISION_U8_GAMMA:
+      return GIMP_COMPONENT_TYPE_U8;
+
+    case GIMP_PRECISION_U16_LINEAR:
+    case GIMP_PRECISION_U16_GAMMA:
+      return GIMP_COMPONENT_TYPE_U16;
+
+    case GIMP_PRECISION_U32_LINEAR:
+    case GIMP_PRECISION_U32_GAMMA:
+      return GIMP_COMPONENT_TYPE_U32;
+
+    case GIMP_PRECISION_HALF_LINEAR:
+    case GIMP_PRECISION_HALF_GAMMA:
+      return GIMP_COMPONENT_TYPE_HALF;
+
+    case GIMP_PRECISION_FLOAT_LINEAR:
+    case GIMP_PRECISION_FLOAT_GAMMA:
+      return GIMP_COMPONENT_TYPE_FLOAT;
+
+    case GIMP_PRECISION_DOUBLE_LINEAR:
+    case GIMP_PRECISION_DOUBLE_GAMMA:
+      return GIMP_COMPONENT_TYPE_DOUBLE;
+    }
+
+  g_return_val_if_reached (-1);
+}
+
+gboolean
+gimp_babl_linear (GimpPrecision precision)
+{
+  switch (precision)
+    {
+    case GIMP_PRECISION_U8_LINEAR:
+    case GIMP_PRECISION_U16_LINEAR:
+    case GIMP_PRECISION_U32_LINEAR:
+    case GIMP_PRECISION_HALF_LINEAR:
+    case GIMP_PRECISION_FLOAT_LINEAR:
+    case GIMP_PRECISION_DOUBLE_LINEAR:
+      return TRUE;
+
+    case GIMP_PRECISION_U8_GAMMA:
+    case GIMP_PRECISION_U16_GAMMA:
+    case GIMP_PRECISION_U32_GAMMA:
+    case GIMP_PRECISION_HALF_GAMMA:
+    case GIMP_PRECISION_FLOAT_GAMMA:
+    case GIMP_PRECISION_DOUBLE_GAMMA:
+      return FALSE;
+    }
+
+  g_return_val_if_reached (FALSE);
+}
+
+GimpPrecision
+gimp_babl_precision (GimpComponentType component,
+                     gboolean          linear)
+{
+  switch (component)
+    {
+    case GIMP_COMPONENT_TYPE_U8:
+      if (linear)
+        return GIMP_PRECISION_U8_LINEAR;
+      else
+        return GIMP_PRECISION_U8_GAMMA;
+
+    case GIMP_COMPONENT_TYPE_U16:
+      if (linear)
+        return GIMP_PRECISION_U16_LINEAR;
+      else
+        return GIMP_PRECISION_U16_GAMMA;
+
+    case GIMP_COMPONENT_TYPE_U32:
+      if (linear)
+        return GIMP_PRECISION_U32_LINEAR;
+      else
+        return GIMP_PRECISION_U32_GAMMA;
+
+    case GIMP_COMPONENT_TYPE_HALF:
+      if (linear)
+        return GIMP_PRECISION_HALF_LINEAR;
+      else
+        return GIMP_PRECISION_HALF_GAMMA;
+
+    case GIMP_COMPONENT_TYPE_FLOAT:
+      if (linear)
+        return GIMP_PRECISION_FLOAT_LINEAR;
+      else
+        return GIMP_PRECISION_FLOAT_GAMMA;
+
+    case GIMP_COMPONENT_TYPE_DOUBLE:
+      if (linear)
+        return GIMP_PRECISION_DOUBLE_LINEAR;
+      else
+        return GIMP_PRECISION_DOUBLE_GAMMA;
+
+    default:
+      break;
+    }
+
+  g_return_val_if_reached (-1);
+}
+
+gboolean
+gimp_babl_is_valid (GimpImageBaseType base_type,
+                    GimpPrecision     precision)
+{
+  switch (base_type)
+    {
+    case GIMP_RGB:
+    case GIMP_GRAY:
+      return TRUE;
+
+    case GIMP_INDEXED:
+      switch (precision)
+        {
+        case GIMP_PRECISION_U8_GAMMA:
+          return TRUE;
+
+        default:
+          return FALSE;
+        }
+    }
+
+  g_return_val_if_reached (FALSE);
+}
+
+GimpComponentType
+gimp_babl_is_bounded (GimpPrecision precision)
+{
+  switch (gimp_babl_component_type (precision))
+    {
+    case GIMP_COMPONENT_TYPE_U8:
+    case GIMP_COMPONENT_TYPE_U16:
+    case GIMP_COMPONENT_TYPE_U32:
+      return TRUE;
+
+    case GIMP_COMPONENT_TYPE_HALF:
+    case GIMP_COMPONENT_TYPE_FLOAT:
+    case GIMP_COMPONENT_TYPE_DOUBLE:
+      return FALSE;
+    }
+
+  g_return_val_if_reached (FALSE);
+}
+
+const Babl *
+gimp_babl_format (GimpImageBaseType  base_type,
+                  GimpPrecision      precision,
+                  gboolean           with_alpha)
+{
+  switch (base_type)
+    {
+    case GIMP_RGB:
+      switch (precision)
+        {
+        case GIMP_PRECISION_U8_LINEAR:
+          if (with_alpha)
+            return babl_format ("RGBA u8");
+          else
+            return babl_format ("RGB u8");
+
+        case GIMP_PRECISION_U8_GAMMA:
+          if (with_alpha)
+            return babl_format ("R'G'B'A u8");
+          else
+            return babl_format ("R'G'B' u8");
+
+        case GIMP_PRECISION_U16_LINEAR:
+          if (with_alpha)
+            return babl_format ("RGBA u16");
+          else
+            return babl_format ("RGB u16");
+
+        case GIMP_PRECISION_U16_GAMMA:
+          if (with_alpha)
+            return babl_format ("R'G'B'A u16");
+          else
+            return babl_format ("R'G'B' u16");
+
+        case GIMP_PRECISION_U32_LINEAR:
+          if (with_alpha)
+            return babl_format ("RGBA u32");
+          else
+            return babl_format ("RGB u32");
+
+        case GIMP_PRECISION_U32_GAMMA:
+          if (with_alpha)
+            return babl_format ("R'G'B'A u32");
+          else
+            return babl_format ("R'G'B' u32");
+
+        case GIMP_PRECISION_HALF_LINEAR:
+          if (with_alpha)
+            return babl_format ("RGBA half");
+          else
+            return babl_format ("RGB half");
+
+        case GIMP_PRECISION_HALF_GAMMA:
+          if (with_alpha)
+            return babl_format ("R'G'B'A half");
+          else
+            return babl_format ("R'G'B' half");
+
+        case GIMP_PRECISION_FLOAT_LINEAR:
+          if (with_alpha)
+            return babl_format ("RGBA float");
+          else
+            return babl_format ("RGB float");
+
+        case GIMP_PRECISION_FLOAT_GAMMA:
+          if (with_alpha)
+            return babl_format ("R'G'B'A float");
+          else
+            return babl_format ("R'G'B' float");
+
+        case GIMP_PRECISION_DOUBLE_LINEAR:
+          if (with_alpha)
+            return babl_format ("RGBA double");
+          else
+            return babl_format ("RGB double");
+
+        case GIMP_PRECISION_DOUBLE_GAMMA:
+          if (with_alpha)
+            return babl_format ("R'G'B'A double");
+          else
+            return babl_format ("R'G'B' double");
+
+        default:
+          break;
+        }
+      break;
+
+    case GIMP_GRAY:
+      switch (precision)
+        {
+        case GIMP_PRECISION_U8_LINEAR:
+          if (with_alpha)
+            return babl_format ("YA u8");
+          else
+            return babl_format ("Y u8");
+
+        case GIMP_PRECISION_U8_GAMMA:
+          if (with_alpha)
+            return babl_format ("Y'A u8");
+          else
+            return babl_format ("Y' u8");
+
+        case GIMP_PRECISION_U16_LINEAR:
+          if (with_alpha)
+            return babl_format ("YA u16");
+          else
+            return babl_format ("Y u16");
+
+        case GIMP_PRECISION_U16_GAMMA:
+          if (with_alpha)
+            return babl_format ("Y'A u16");
+          else
+            return babl_format ("Y' u16");
+
+        case GIMP_PRECISION_U32_LINEAR:
+          if (with_alpha)
+            return babl_format ("YA u32");
+          else
+            return babl_format ("Y u32");
+
+        case GIMP_PRECISION_U32_GAMMA:
+          if (with_alpha)
+            return babl_format ("Y'A u32");
+          else
+            return babl_format ("Y' u32");
+
+        case GIMP_PRECISION_HALF_LINEAR:
+          if (with_alpha)
+            return babl_format ("YA half");
+          else
+            return babl_format ("Y half");
+
+        case GIMP_PRECISION_HALF_GAMMA:
+          if (with_alpha)
+            return babl_format ("Y'A half");
+          else
+            return babl_format ("Y' half");
+
+        case GIMP_PRECISION_FLOAT_LINEAR:
+          if (with_alpha)
+            return babl_format ("YA float");
+          else
+            return babl_format ("Y float");
+
+        case GIMP_PRECISION_FLOAT_GAMMA:
+          if (with_alpha)
+            return babl_format ("Y'A float");
+          else
+            return babl_format ("Y' float");
+
+        case GIMP_PRECISION_DOUBLE_LINEAR:
+          if (with_alpha)
+            return babl_format ("YA double");
+          else
+            return babl_format ("Y double");
+
+        case GIMP_PRECISION_DOUBLE_GAMMA:
+          if (with_alpha)
+            return babl_format ("Y'A double");
+          else
+            return babl_format ("Y' double");
+
+        default:
+          break;
+        }
+      break;
+
+    case GIMP_INDEXED:
+      /* need to use the image's api for this */
+      break;
+    }
+
+  g_return_val_if_reached (NULL);
+}
+
+const Babl *
+gimp_babl_mask_format (GimpPrecision precision)
+{
+  switch (gimp_babl_component_type (precision))
+    {
+    case GIMP_COMPONENT_TYPE_U8:     return babl_format ("Y u8");
+    case GIMP_COMPONENT_TYPE_U16:    return babl_format ("Y u16");
+    case GIMP_COMPONENT_TYPE_U32:    return babl_format ("Y u32");
+    case GIMP_COMPONENT_TYPE_HALF:   return babl_format ("Y half");
+    case GIMP_COMPONENT_TYPE_FLOAT:  return babl_format ("Y float");
+    case GIMP_COMPONENT_TYPE_DOUBLE: return babl_format ("Y double");
+    }
+
+  g_return_val_if_reached (NULL);
+}
+
+const Babl *
+gimp_babl_component_format (GimpImageBaseType base_type,
+                            GimpPrecision     precision,
+                            gint              index)
+{
+  switch (base_type)
+    {
+    case GIMP_RGB:
+      switch (precision)
+        {
+        case GIMP_PRECISION_U8_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("R u8");
+            case 1: return babl_format ("G u8");
+            case 2: return babl_format ("B u8");
+            case 3: return babl_format ("A u8");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_U8_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("R' u8");
+            case 1: return babl_format ("G' u8");
+            case 2: return babl_format ("B' u8");
+            case 3: return babl_format ("A u8");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_U16_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("R u16");
+            case 1: return babl_format ("G u16");
+            case 2: return babl_format ("B u16");
+            case 3: return babl_format ("A u16");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_U16_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("R' u16");
+            case 1: return babl_format ("G' u16");
+            case 2: return babl_format ("B' u16");
+            case 3: return babl_format ("A u16");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_U32_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("R u32");
+            case 1: return babl_format ("G u32");
+            case 2: return babl_format ("B u32");
+            case 3: return babl_format ("A u32");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_U32_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("R' u32");
+            case 1: return babl_format ("G' u32");
+            case 2: return babl_format ("B' u32");
+            case 3: return babl_format ("A u32");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_HALF_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("R half");
+            case 1: return babl_format ("G half");
+            case 2: return babl_format ("B half");
+            case 3: return babl_format ("A half");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_HALF_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("R' half");
+            case 1: return babl_format ("G' half");
+            case 2: return babl_format ("B' half");
+            case 3: return babl_format ("A half");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_FLOAT_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("R float");
+            case 1: return babl_format ("G float");
+            case 2: return babl_format ("B float");
+            case 3: return babl_format ("A float");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_FLOAT_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("R' float");
+            case 1: return babl_format ("G' float");
+            case 2: return babl_format ("B' float");
+            case 3: return babl_format ("A float");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_DOUBLE_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("R double");
+            case 1: return babl_format ("G double");
+            case 2: return babl_format ("B double");
+            case 3: return babl_format ("A double");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_DOUBLE_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("R' double");
+            case 1: return babl_format ("G' double");
+            case 2: return babl_format ("B' double");
+            case 3: return babl_format ("A double");
+            default:
+              break;
+            }
+          break;
+
+        default:
+          break;
+        }
+      break;
+
+    case GIMP_GRAY:
+      switch (precision)
+        {
+        case GIMP_PRECISION_U8_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("Y u8");
+            case 1: return babl_format ("A u8");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_U8_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("Y' u8");
+            case 1: return babl_format ("A u8");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_U16_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("Y u16");
+            case 1: return babl_format ("A u16");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_U16_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("Y' u16");
+            case 1: return babl_format ("A u16");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_U32_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("Y u32");
+            case 1: return babl_format ("A u32");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_U32_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("Y' u32");
+            case 1: return babl_format ("A u32");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_HALF_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("Y half");
+            case 1: return babl_format ("A half");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_HALF_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("Y' half");
+            case 1: return babl_format ("A half");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_FLOAT_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("Y float");
+            case 1: return babl_format ("A float");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_FLOAT_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("Y' float");
+            case 1: return babl_format ("A float");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_DOUBLE_LINEAR:
+          switch (index)
+            {
+            case 0: return babl_format ("Y double");
+            case 1: return babl_format ("A double");
+            default:
+              break;
+            }
+          break;
+
+        case GIMP_PRECISION_DOUBLE_GAMMA:
+          switch (index)
+            {
+            case 0: return babl_format ("Y' double");
+            case 1: return babl_format ("A double");
+            default:
+              break;
+            }
+          break;
+
+        default:
+          break;
+        }
+      break;
+
+    case GIMP_INDEXED:
+      /* need to use the image's api for this */
+      break;
+    }
+
+  g_return_val_if_reached (NULL);
+}
+
+const Babl *
+gimp_babl_format_change_component_type (const Babl        *format,
+                                        GimpComponentType  component)
+{
+  g_return_val_if_fail (format != NULL, NULL);
+
+  return gimp_babl_format (gimp_babl_format_get_base_type (format),
+                           gimp_babl_precision (
+                             component,
+                             gimp_babl_format_get_linear (format)),
+                           babl_format_has_alpha (format));
+}
+
+const Babl *
+gimp_babl_format_change_linear (const Babl *format,
+                                gboolean    linear)
+{
+  g_return_val_if_fail (format != NULL, NULL);
+
+  return gimp_babl_format (gimp_babl_format_get_base_type (format),
+                           gimp_babl_precision (
+                             gimp_babl_format_get_component_type (format),
+                             linear),
+                           babl_format_has_alpha (format));
+}
+
+gchar **
+gimp_babl_print_pixel (const Babl *format,
+                       gpointer    pixel)
+{
+  GimpPrecision   precision;
+  gint            n_components;
+  guchar          tmp_pixel[32];
+  gchar         **strings;
+
+  g_return_val_if_fail (format != NULL, NULL);
+  g_return_val_if_fail (pixel != NULL, NULL);
+
+  precision = gimp_babl_format_get_precision (format);
+
+  if (babl_format_is_palette (format))
+    {
+      const Babl *f = gimp_babl_format (GIMP_RGB, precision,
+                                        babl_format_has_alpha (format));
+
+      babl_process (babl_fish (format, f), pixel, tmp_pixel, 1);
+
+      format = f;
+      pixel  = tmp_pixel;
+    }
+
+  n_components = babl_format_get_n_components (format);
+
+  strings = g_new0 (gchar *, n_components + 1);
+
+  switch (gimp_babl_format_get_component_type (format))
+    {
+    case GIMP_COMPONENT_TYPE_U8:
+      {
+        guchar *color = pixel;
+        gint    i;
+
+        for (i = 0; i < n_components; i++)
+          strings[i] = g_strdup_printf ("%d", color[i]);
+      }
+      break;
+
+    case GIMP_COMPONENT_TYPE_U16:
+      {
+        guint16 *color = pixel;
+        gint     i;
+
+        for (i = 0; i < n_components; i++)
+          strings[i] = g_strdup_printf ("%u", color[i]);
+      }
+      break;
+
+    case GIMP_COMPONENT_TYPE_U32:
+      {
+        guint32 *color = pixel;
+        gint     i;
+
+        for (i = 0; i < n_components; i++)
+          strings[i] = g_strdup_printf ("%u", color[i]);
+      }
+      break;
+
+    case GIMP_COMPONENT_TYPE_HALF:
+      {
+        GimpPrecision p;
+        const Babl   *f;
+
+        p = gimp_babl_precision (GIMP_COMPONENT_TYPE_FLOAT,
+                                 gimp_babl_format_get_linear (format));
+
+        f = gimp_babl_format (gimp_babl_format_get_base_type (format),
+                              p,
+                              babl_format_has_alpha (format));
+
+        babl_process (babl_fish (format, f), pixel, tmp_pixel, 1);
+
+        pixel = tmp_pixel;
+      }
+      /* fall through */
+
+    case GIMP_COMPONENT_TYPE_FLOAT:
+      {
+        gfloat *color = pixel;
+        gint    i;
+
+        for (i = 0; i < n_components; i++)
+          strings[i] = g_strdup_printf ("%0.6f", color[i]);
+      }
+      break;
+
+    case GIMP_COMPONENT_TYPE_DOUBLE:
+      {
+        gdouble *color = pixel;
+        gint     i;
+
+        for (i = 0; i < n_components; i++)
+          strings[i] = g_strdup_printf ("%0.6f", color[i]);
+      }
+      break;
+    }
+
+  return strings;
+}