Adding upstream version 2.10.36.upstream/2.10.36

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

1 files changed, 1784 insertions, 0 deletions

diff --git a/plug-ins/common/file-sunras.c b/plug-ins/common/file-sunras.c
new file mode 100644
index 0000000..62928cf
--- /dev/null
+++ b/plug-ins/common/file-sunras.c
@@ -0,0 +1,1784 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ * SUN raster reading and writing code Copyright (C) 1996 Peter Kirchgessner
+ * (email: peter@kirchgessner.net, WWW: http://www.kirchgessner.net)
+ *
+ * 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/>.
+ *
+ */
+
+/* This program was written using pages 625-629 of the book
+ * "Encyclopedia of Graphics File Formats", Murray/van Ryper,
+ * O'Reilly & Associates Inc.
+ * Bug reports or suggestions should be e-mailed to peter@kirchgessner.net
+ */
+
+/* Event history:
+ * V 1.00, PK, 25-Jul-96: First try
+ * V 1.90, PK, 15-Mar-97: Upgrade to work with GIMP V0.99
+ * V 1.91, PK, 05-Apr-97: Return all arguments, even in case of an error
+ * V 1.92, PK, 18-May-97: Ignore EOF-error on reading image data
+ * V 1.93, PK, 05-Oct-97: Parse rc file
+ * V 1.94, PK, 12-Oct-97: No progress bars for non-interactive mode
+ * V 1.95, nn, 20-Dec-97: Initialize some variable
+ * V 1.96, PK, 21-Nov-99: Internationalization
+ * V 1.97, PK, 20-Dec-00: Recognize extensions .rs and .ras too
+ */
+
+#include "config.h"
+
+#include <errno.h>
+#include <string.h>
+
+#include <glib/gstdio.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "libgimp/stdplugins-intl.h"
+
+
+#define LOAD_PROC      "file-sunras-load"
+#define SAVE_PROC      "file-sunras-save"
+#define PLUG_IN_BINARY "file-sunras"
+#define PLUG_IN_ROLE   "gimp-file-sunras"
+
+
+typedef int WRITE_FUN(void*,size_t,size_t,FILE*);
+
+typedef gulong  L_CARD32;
+typedef gushort L_CARD16;
+typedef guchar  L_CARD8;
+
+/* Fileheader of SunRaster files */
+typedef struct
+{
+  L_CARD32 l_ras_magic;    /* Magic Number */
+  L_CARD32 l_ras_width;    /* Width */
+  L_CARD32 l_ras_height;   /* Height */
+  L_CARD32 l_ras_depth;    /* Number of bits per pixel (1,8,24,32) */
+  L_CARD32 l_ras_length;   /* Length of image data (but may also be 0) */
+  L_CARD32 l_ras_type;     /* Encoding */
+  L_CARD32 l_ras_maptype;  /* Type of colormap */
+  L_CARD32 l_ras_maplength;/* Number of bytes for colormap */
+} L_SUNFILEHEADER;
+
+/* Sun-raster magic */
+#define RAS_MAGIC 0x59a66a95
+
+#define RAS_TYPE_STD 1    /* Standard uncompressed format */
+#define RAS_TYPE_RLE 2    /* Runlength compression format */
+
+typedef struct
+{
+  gint val;   /* The value that is to be repeated */
+  gint n;     /* How many times it is repeated */
+} RLEBUF;
+
+
+/* Declare some local functions.
+ */
+static void      query            (void);
+static void      run              (const gchar       *name,
+                                   gint               nparams,
+                                   const GimpParam   *param,
+                                   gint              *nreturn_vals,
+                                   GimpParam        **return_vals);
+
+static gint32    load_image       (const gchar       *filename,
+                                   GError           **error);
+static gboolean  save_image       (const gchar       *filename,
+                                   gint32             image_ID,
+                                   gint32             drawable_ID,
+                                   GError           **error);
+
+static void      set_color_table  (gint32             image_ID,
+                                   L_SUNFILEHEADER   *sunhdr,
+                                   const guchar      *suncolmap);
+static gint32    create_new_image (const gchar       *filename,
+                                   guint              width,
+                                   guint              height,
+                                   GimpImageBaseType  type,
+                                   gint32            *layer_ID,
+                                   GeglBuffer       **buffer);
+
+static gint32    load_sun_d1      (const gchar       *filename,
+                                   FILE              *ifp,
+                                   L_SUNFILEHEADER   *sunhdr,
+                                   guchar            *suncolmap);
+static gint32    load_sun_d8      (const gchar       *filename,
+                                   FILE              *ifp,
+                                   L_SUNFILEHEADER   *sunhdr,
+                                   guchar            *suncolmap);
+static gint32    load_sun_d24     (const gchar       *filename,
+                                   FILE              *ifp,
+                                   L_SUNFILEHEADER   *sunhdr,
+                                   guchar            *suncolmap);
+static gint32    load_sun_d32     (const gchar       *filename,
+                                   FILE              *ifp,
+                                   L_SUNFILEHEADER   *sunhdr,
+                                   guchar            *suncolmap);
+
+static L_CARD32  read_card32      (FILE              *ifp,
+                                   int               *err);
+
+static void      write_card32     (FILE              *ofp,
+                                   L_CARD32           c);
+
+static void      byte2bit         (guchar            *byteline,
+                                   int                width,
+                                   guchar            *bitline,
+                                   gboolean           invert);
+
+static void      rle_startread    (FILE              *ifp);
+static int       rle_fread        (char              *ptr,
+                                   int                sz,
+                                   int                nelem,
+                                   FILE              *ifp);
+static int       rle_fgetc        (FILE              *ifp);
+#define rle_getc(fp) ((rlebuf.n > 0) ? (rlebuf.n)--,rlebuf.val : rle_fgetc (fp))
+
+static void      rle_startwrite   (FILE              *ofp);
+static int       rle_fwrite       (char              *ptr,
+                                   int                sz,
+                                   int                nelem,
+                                   FILE              *ofp);
+static int       rle_fputc        (int                val,
+                                   FILE              *ofp);
+static int       rle_putrun       (int                n,
+                                   int                val,
+                                   FILE              *ofp);
+static void      rle_endwrite     (FILE              *ofp);
+#define rle_putc rle_fputc
+
+static void      read_sun_header  (FILE              *ifp,
+                                   L_SUNFILEHEADER   *sunhdr);
+static void      write_sun_header (FILE              *ofp,
+                                   L_SUNFILEHEADER   *sunhdr);
+static void      read_sun_cols    (FILE              *ifp,
+                                   L_SUNFILEHEADER   *sunhdr,
+                                   guchar            *colormap);
+static void      write_sun_cols   (FILE              *ofp,
+                                   L_SUNFILEHEADER   *sunhdr,
+                                   guchar            *colormap);
+
+static gint      save_index       (FILE             *ofp,
+                                   gint32            image_ID,
+                                   gint32            drawable_ID,
+                                   gboolean          grey,
+                                   gboolean          rle);
+static gint      save_rgb         (FILE             *ofp,
+                                   gint32            image_ID,
+                                   gint32            drawable_ID,
+                                   gboolean          rle);
+
+static gboolean  save_dialog      (void);
+
+/* Portability kludge */
+static int       my_fwrite        (void             *ptr,
+                                   int               size,
+                                   int               nmemb,
+                                   FILE             *stream);
+
+
+static int    read_msb_first = 1;
+static RLEBUF rlebuf;
+
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+  NULL,  /* init_proc  */
+  NULL,  /* quit_proc  */
+  query, /* query_proc */
+  run,   /* run_proc   */
+};
+
+
+/* Export info  */
+typedef struct
+{
+  gboolean  rle;  /*  rle or standard */
+} SUNRASSaveVals;
+
+
+static SUNRASSaveVals psvals =
+{
+  TRUE     /* rle */
+};
+
+
+MAIN ()
+
+
+static void
+query (void)
+{
+  static const GimpParamDef load_args[] =
+  {
+    { GIMP_PDB_INT32,  "run-mode",      "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+    { GIMP_PDB_STRING, "filename",      "The name of the file to load" },
+    { GIMP_PDB_STRING, "raw-filename",  "The name of the file to load" }
+  };
+
+  static const GimpParamDef load_return_vals[] =
+  {
+    { GIMP_PDB_IMAGE,  "image",         "Output image" }
+  };
+
+  static const GimpParamDef save_args[] =
+  {
+    { GIMP_PDB_INT32,    "run-mode",     "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" },
+    { GIMP_PDB_IMAGE,    "image",        "Input image" },
+    { GIMP_PDB_DRAWABLE, "drawable",     "Drawable to export" },
+    { GIMP_PDB_STRING,   "filename",     "The name of the file to export the image in" },
+    { GIMP_PDB_STRING,   "raw-filename", "The name of the file to export the image in" },
+    { GIMP_PDB_INT32,    "rle",          "Specify non-zero for rle output, zero for standard output" }
+  };
+
+  gimp_install_procedure (LOAD_PROC,
+                          "load file of the SunRaster file format",
+                          "load file of the SunRaster file format",
+                          "Peter Kirchgessner",
+                          "Peter Kirchgessner",
+                          "1996",
+                          N_("SUN Rasterfile image"),
+                          NULL,
+                          GIMP_PLUGIN,
+                          G_N_ELEMENTS (load_args),
+                          G_N_ELEMENTS (load_return_vals),
+                          load_args, load_return_vals);
+
+  gimp_register_file_handler_mime (LOAD_PROC, "image/x-sun-raster");
+  gimp_register_magic_load_handler (LOAD_PROC,
+                                    "im1,im8,im24,im32,rs,ras,sun",
+                                    "",
+                                    "0,long,0x59a66a95");
+
+  gimp_install_procedure (SAVE_PROC,
+                          "export file in the SunRaster file format",
+                          "SUNRAS exporting handles all image types except "
+                          "those with alpha channels.",
+                          "Peter Kirchgessner",
+                          "Peter Kirchgessner",
+                          "1996",
+                          N_("SUN Rasterfile image"),
+                          "RGB, GRAY, INDEXED",
+                          GIMP_PLUGIN,
+                          G_N_ELEMENTS (save_args), 0,
+                          save_args, NULL);
+
+  gimp_register_file_handler_mime (SAVE_PROC, "image/x-sun-raster");
+  gimp_register_save_handler (SAVE_PROC,
+                              "im1,im8,im24,im32,rs,ras,sun", "");
+}
+
+
+static void
+run (const gchar      *name,
+     gint              nparams,
+     const GimpParam  *param,
+     gint             *nreturn_vals,
+     GimpParam       **return_vals)
+{
+  static GimpParam   values[2];
+  GimpRunMode        run_mode;
+  GimpPDBStatusType  status = GIMP_PDB_SUCCESS;
+  gint32             image_ID;
+  gint32             drawable_ID;
+  GimpExportReturn   export = GIMP_EXPORT_CANCEL;
+  GError            *error  = NULL;
+
+  run_mode = param[0].data.d_int32;
+
+  INIT_I18N ();
+  gegl_init (NULL, NULL);
+
+  *nreturn_vals = 1;
+  *return_vals  = values;
+
+  values[0].type          = GIMP_PDB_STATUS;
+  values[0].data.d_status = GIMP_PDB_EXECUTION_ERROR;
+
+  if (strcmp (name, LOAD_PROC) == 0)
+    {
+      image_ID = load_image (param[1].data.d_string, &error);
+
+      if (image_ID != -1)
+        {
+          *nreturn_vals = 2;
+          values[1].type         = GIMP_PDB_IMAGE;
+          values[1].data.d_image = image_ID;
+        }
+      else
+        {
+          status = GIMP_PDB_EXECUTION_ERROR;
+        }
+    }
+  else if (strcmp (name, SAVE_PROC) == 0)
+    {
+      image_ID = param[1].data.d_int32;
+      drawable_ID = param[2].data.d_int32;
+
+      /*  eventually export the image */
+      switch (run_mode)
+        {
+        case GIMP_RUN_INTERACTIVE:
+        case GIMP_RUN_WITH_LAST_VALS:
+          gimp_ui_init (PLUG_IN_BINARY, FALSE);
+
+          export = gimp_export_image (&image_ID, &drawable_ID, "SUNRAS",
+                                      GIMP_EXPORT_CAN_HANDLE_RGB  |
+                                      GIMP_EXPORT_CAN_HANDLE_GRAY |
+                                      GIMP_EXPORT_CAN_HANDLE_INDEXED);
+
+          if (export == GIMP_EXPORT_CANCEL)
+            {
+              values[0].data.d_status = GIMP_PDB_CANCEL;
+              return;
+          }
+          break;
+        default:
+          break;
+        }
+
+      switch (run_mode)
+        {
+        case GIMP_RUN_INTERACTIVE:
+          /*  Possibly retrieve data  */
+          gimp_get_data (SAVE_PROC, &psvals);
+
+          /*  First acquire information with a dialog  */
+          if (! save_dialog ())
+            status = GIMP_PDB_CANCEL;
+          break;
+
+        case GIMP_RUN_NONINTERACTIVE:
+          /*  Make sure all the arguments are there!  */
+          if (nparams != 6)
+            {
+              status = GIMP_PDB_CALLING_ERROR;
+            }
+          else
+            {
+              psvals.rle = (param[5].data.d_int32) ? TRUE : FALSE;
+            }
+          break;
+
+        case GIMP_RUN_WITH_LAST_VALS:
+          /*  Possibly retrieve data  */
+          gimp_get_data (SAVE_PROC, &psvals);
+          break;
+
+        default:
+          break;
+        }
+
+      if (status == GIMP_PDB_SUCCESS)
+        {
+          if (save_image (param[3].data.d_string, image_ID, drawable_ID,
+                          &error))
+            {
+              /*  Store psvals data  */
+              gimp_set_data (SAVE_PROC, &psvals, sizeof (SUNRASSaveVals));
+            }
+          else
+            {
+              status = GIMP_PDB_EXECUTION_ERROR;
+            }
+        }
+
+      if (export == GIMP_EXPORT_EXPORT)
+        gimp_image_delete (image_ID);
+    }
+  else
+    {
+      status = GIMP_PDB_CALLING_ERROR;
+    }
+
+  if (status != GIMP_PDB_SUCCESS && error)
+    {
+      *nreturn_vals = 2;
+      values[1].type          = GIMP_PDB_STRING;
+      values[1].data.d_string = error->message;
+    }
+
+  values[0].data.d_status = status;
+}
+
+
+static gint32
+load_image (const gchar  *filename,
+            GError      **error)
+{
+  gint32           image_ID;
+  FILE            *ifp;
+  L_SUNFILEHEADER  sunhdr;
+  guchar          *suncolmap = NULL;
+
+  gimp_progress_init_printf (_("Opening '%s'"),
+                             gimp_filename_to_utf8 (filename));
+
+  ifp = g_fopen (filename, "rb");
+  if (!ifp)
+    {
+      g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
+                   _("Could not open '%s' for reading: %s"),
+                   gimp_filename_to_utf8 (filename), g_strerror (errno));
+      return -1;
+    }
+
+  read_msb_first = 1;   /* SUN raster is always most significant byte first */
+
+  read_sun_header (ifp, &sunhdr);
+  if (sunhdr.l_ras_magic != RAS_MAGIC)
+    {
+      g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+                   _("Could not open '%s' as SUN-raster-file"),
+                   gimp_filename_to_utf8 (filename));
+      fclose (ifp);
+      return -1;
+    }
+
+  if (sunhdr.l_ras_type > 5)
+    {
+      g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+                   "%s",
+                   _("The type of this SUN-rasterfile is not supported"));
+      fclose (ifp);
+      return -1;
+    }
+
+  if (sunhdr.l_ras_maplength > (256 * 3))
+    {
+      g_message ("Map lengths greater than 256 entries are unsupported by GIMP.");
+      gimp_quit ();
+    }
+
+  /* Is there a RGB colormap ? */
+  if ((sunhdr.l_ras_maptype == 1) && (sunhdr.l_ras_maplength > 0))
+    {
+      suncolmap = g_new (guchar, sunhdr.l_ras_maplength);
+
+      read_sun_cols (ifp, &sunhdr, suncolmap);
+#ifdef DEBUG
+      {
+        int j, ncols;
+        printf ("File %s\n",filename);
+        ncols = sunhdr.l_ras_maplength/3;
+        for (j=0; j < ncols; j++)
+          printf ("Entry 0x%08x: 0x%04x,  0x%04x, 0x%04x\n",
+                  j,suncolmap[j],suncolmap[j+ncols],suncolmap[j+2*ncols]);
+      }
+#endif
+      if (sunhdr.l_ras_magic != RAS_MAGIC)
+        {
+          g_message (_("Could not read color entries from '%s'"),
+                     gimp_filename_to_utf8 (filename));
+          fclose (ifp);
+          g_free (suncolmap);
+          return -1;
+        }
+    }
+  else if (sunhdr.l_ras_maplength > 0)
+    {
+      g_message (_("Type of colormap not supported"));
+      fseek (ifp, (sizeof (L_SUNFILEHEADER)/sizeof (L_CARD32))
+             *4 + sunhdr.l_ras_maplength, SEEK_SET);
+    }
+
+  if (sunhdr.l_ras_width <= 0)
+    {
+      g_message (_("'%s':\nNo image width specified"),
+                 gimp_filename_to_utf8 (filename));
+      fclose (ifp);
+      return -1;
+    }
+
+  if (sunhdr.l_ras_width > GIMP_MAX_IMAGE_SIZE)
+    {
+      g_message (_("'%s':\nImage width is larger than GIMP can handle"),
+                 gimp_filename_to_utf8 (filename));
+      fclose (ifp);
+      return -1;
+    }
+
+  if (sunhdr.l_ras_height <= 0)
+    {
+      g_message (_("'%s':\nNo image height specified"),
+                 gimp_filename_to_utf8 (filename));
+      fclose (ifp);
+      return -1;
+    }
+
+  if (sunhdr.l_ras_height > GIMP_MAX_IMAGE_SIZE)
+    {
+      g_message (_("'%s':\nImage height is larger than GIMP can handle"),
+                 gimp_filename_to_utf8 (filename));
+      fclose (ifp);
+      return -1;
+    }
+
+  switch (sunhdr.l_ras_depth)
+    {
+    case 1:    /* bitmap */
+      image_ID = load_sun_d1 (filename, ifp, &sunhdr, suncolmap);
+      break;
+
+    case 8:    /* 256 colors */
+      image_ID = load_sun_d8 (filename, ifp, &sunhdr, suncolmap);
+      break;
+
+    case 24:   /* True color */
+      image_ID = load_sun_d24 (filename, ifp, &sunhdr, suncolmap);
+      break;
+
+    case 32:   /* True color with extra byte */
+      image_ID = load_sun_d32 (filename, ifp, &sunhdr, suncolmap);
+      break;
+
+    default:
+      image_ID = -1;
+      break;
+    }
+  gimp_progress_update (1.0);
+
+  fclose (ifp);
+
+  g_free (suncolmap);
+
+  if (image_ID == -1)
+    {
+      g_message (_("This image depth is not supported"));
+      return -1;
+    }
+
+  return image_ID;
+}
+
+
+static gboolean
+save_image (const gchar  *filename,
+            gint32        image_ID,
+            gint32        drawable_ID,
+            GError      **error)
+{
+  FILE          *ofp;
+  GimpImageType  drawable_type;
+  gboolean       retval;
+
+  drawable_type = gimp_drawable_type (drawable_ID);
+
+  /*  Make sure we're not exporting an image with an alpha channel  */
+  if (gimp_drawable_has_alpha (drawable_ID))
+    {
+      g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED,
+                   _("SUNRAS export cannot handle images with alpha channels"));
+      return FALSE;
+    }
+
+  switch (drawable_type)
+    {
+    case GIMP_INDEXED_IMAGE:
+    case GIMP_GRAY_IMAGE:
+    case GIMP_RGB_IMAGE:
+      break;
+    default:
+      g_message (_("Can't operate on unknown image types"));
+      return FALSE;
+      break;
+    }
+
+  gimp_progress_init_printf (_("Exporting '%s'"),
+                             gimp_filename_to_utf8 (filename));
+
+  /* Open the output file. */
+  ofp = g_fopen (filename, "wb");
+  if (! ofp)
+    {
+      g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno),
+                   _("Could not open '%s' for writing: %s"),
+                   gimp_filename_to_utf8 (filename), g_strerror (errno));
+      return FALSE;
+    }
+
+  if (drawable_type == GIMP_INDEXED_IMAGE)
+    retval = save_index (ofp,image_ID, drawable_ID, FALSE, psvals.rle);
+  else if (drawable_type == GIMP_GRAY_IMAGE)
+    retval = save_index (ofp,image_ID, drawable_ID, TRUE, psvals.rle);
+  else if (drawable_type == GIMP_RGB_IMAGE)
+    retval = save_rgb (ofp,image_ID, drawable_ID, psvals.rle);
+  else
+    retval = FALSE;
+
+  fclose (ofp);
+
+  return retval;
+}
+
+
+static L_CARD32
+read_card32 (FILE *ifp,
+             gint *err)
+{
+  L_CARD32 c;
+
+  if (read_msb_first)
+    {
+      c = (((L_CARD32)(getc (ifp))) << 24);
+      c |= (((L_CARD32)(getc (ifp))) << 16);
+      c |= (((L_CARD32)(getc (ifp))) << 8);
+      c |= ((L_CARD32)(*err = getc (ifp)));
+    }
+  else
+    {
+      c = ((L_CARD32)(getc (ifp)));
+      c |= (((L_CARD32)(getc (ifp))) << 8);
+      c |= (((L_CARD32)(getc (ifp))) << 16);
+      c |= (((L_CARD32)(*err = getc (ifp))) << 24);
+    }
+
+  *err = (*err < 0);
+
+  return c;
+}
+
+
+static void
+write_card32 (FILE     *ofp,
+              L_CARD32  c)
+{
+  putc ((int)((c >> 24) & 0xff), ofp);
+  putc ((int)((c >> 16) & 0xff), ofp);
+  putc ((int)((c >> 8) & 0xff), ofp);
+  putc ((int)((c) & 0xff), ofp);
+}
+
+
+/* Convert n bytes of 0/1 to a line of bits */
+static void
+byte2bit (guchar   *byteline,
+          gint      width,
+          guchar   *bitline,
+          gboolean  invert)
+{
+  guchar bitval;
+  guchar rest[8];
+
+  while (width >= 8)
+    {
+      bitval = 0;
+      if (*(byteline++)) bitval |= 0x80;
+      if (*(byteline++)) bitval |= 0x40;
+      if (*(byteline++)) bitval |= 0x20;
+      if (*(byteline++)) bitval |= 0x10;
+      if (*(byteline++)) bitval |= 0x08;
+      if (*(byteline++)) bitval |= 0x04;
+      if (*(byteline++)) bitval |= 0x02;
+      if (*(byteline++)) bitval |= 0x01;
+      *(bitline++) = invert ? ~bitval : bitval;
+      width -= 8;
+    }
+  if (width > 0)
+    {
+      memset (rest, 0, 8);
+      memcpy (rest, byteline, width);
+      bitval = 0;
+      byteline = rest;
+      if (*(byteline++)) bitval |= 0x80;
+      if (*(byteline++)) bitval |= 0x40;
+      if (*(byteline++)) bitval |= 0x20;
+      if (*(byteline++)) bitval |= 0x10;
+      if (*(byteline++)) bitval |= 0x08;
+      if (*(byteline++)) bitval |= 0x04;
+      if (*(byteline++)) bitval |= 0x02;
+      *bitline = invert ? ~bitval : bitval;
+    }
+}
+
+
+/* Start reading Runlength Encoded Data */
+static void
+rle_startread (FILE *ifp)
+{
+  /* Clear RLE-buffer */
+  rlebuf.val = rlebuf.n = 0;
+}
+
+
+/* Read uncompressed elements from RLE-stream */
+static gint
+rle_fread (gchar *ptr,
+           gint   sz,
+           gint   nelem,
+           FILE  *ifp)
+{
+  int elem_read, cnt, val, err = 0;
+
+  for (elem_read = 0; elem_read < nelem; elem_read++)
+    {
+      for (cnt = 0; cnt < sz; cnt++)
+        {
+          val = rle_getc (ifp);
+
+          if (val < 0)
+            {
+              err = 1;
+              break;
+            }
+
+          *(ptr++) = (char)val;
+        }
+
+      if (err)
+        break;
+    }
+
+  return elem_read;
+}
+
+
+/* Get one byte of uncompressed data from RLE-stream */
+static gint
+rle_fgetc (FILE *ifp)
+{
+  int flag, runcnt, runval;
+
+  if (rlebuf.n > 0)    /* Something in the buffer ? */
+    {
+      (rlebuf.n)--;
+      return rlebuf.val;
+    }
+
+  /* Nothing in the buffer. We have to read something */
+  if ((flag = getc (ifp)) < 0) return -1;
+  if (flag != 0x0080) return flag;    /* Single byte run ? */
+
+  if ((runcnt = getc (ifp)) < 0) return -1;
+  if (runcnt == 0) return 0x0080;     /* Single 0x80 ? */
+
+  /* The run */
+  if ((runval = getc (ifp)) < 0) return -1;
+  rlebuf.n = runcnt;
+  rlebuf.val = runval;
+
+  return runval;
+}
+
+
+/* Start writing Runlength Encoded Data */
+static void
+rle_startwrite (FILE *ofp)
+{
+  /* Clear RLE-buffer */
+  rlebuf.val = rlebuf.n = 0;
+}
+
+
+/* Write uncompressed elements to RLE-stream */
+static gint
+rle_fwrite (gchar *ptr,
+            gint   sz,
+            gint   nelem,
+            FILE  *ofp)
+{
+  int     elem_write, cnt, val, err = 0;
+  guchar *pixels = (unsigned char *)ptr;
+
+  for (elem_write = 0; elem_write < nelem; elem_write++)
+    {
+      for (cnt = 0; cnt < sz; cnt++)
+        {
+          val = rle_fputc (*(pixels++), ofp);
+          if (val < 0)
+            {
+              err = 1;
+              break;
+            }
+        }
+
+      if (err)
+        break;
+    }
+
+  return elem_write;
+}
+
+
+/* Write uncompressed character to RLE-stream */
+static gint
+rle_fputc (gint  val,
+           FILE *ofp)
+{
+  int retval;
+
+  if (rlebuf.n == 0)    /* Nothing in the buffer ? Save the value */
+    {
+      rlebuf.n   = 1;
+      rlebuf.val = val;
+
+      return val;
+    }
+
+  /* Something in the buffer */
+
+  if (rlebuf.val == val)   /* Same value in the buffer ? */
+    {
+      (rlebuf.n)++;
+      if (rlebuf.n == 257) /* Can not be encoded in a single run ? */
+        {
+          retval = rle_putrun (256, rlebuf.val, ofp);
+          if (retval < 0)
+            return retval;
+
+          rlebuf.n -= 256;
+        }
+
+      return val;
+    }
+
+  /* Something different in the buffer ? Write out the run */
+
+  retval = rle_putrun (rlebuf.n, rlebuf.val, ofp);
+  if (retval < 0)
+    return retval;
+
+  /* Save the new value */
+  rlebuf.n   = 1;
+  rlebuf.val = val;
+
+  return val;
+}
+
+
+/* Write out a run with 0 < n < 257 */
+static gint
+rle_putrun (gint  n,
+            gint  val,
+            FILE *ofp)
+{
+  int retval, flag = 0x80;
+
+  /* Useful to write a 3 byte run ? */
+  if ((n > 2) || ((n == 2) && (val == flag)))
+    {
+      putc (flag, ofp);
+      putc (n-1, ofp);
+      retval = putc (val, ofp);
+    }
+  else if (n == 2) /* Write two single runs (could not be value 0x80) */
+    {
+      putc (val, ofp);
+      retval = putc (val, ofp);
+    }
+  else  /* Write a single run */
+    {
+      if (val == flag)
+        retval = putc (flag, ofp), putc (0x00, ofp);
+      else
+        retval = putc (val, ofp);
+    }
+
+  return (retval < 0) ? retval : val;
+}
+
+
+/* End writing Runlength Encoded Data */
+static void
+rle_endwrite (FILE *ofp)
+{
+  if (rlebuf.n > 0)
+    {
+      rle_putrun (rlebuf.n, rlebuf.val, ofp);
+      rlebuf.val = rlebuf.n = 0; /* Clear RLE-buffer */
+    }
+}
+
+
+static void
+read_sun_header (FILE            *ifp,
+                 L_SUNFILEHEADER *sunhdr)
+{
+  int       j, err;
+  L_CARD32 *cp;
+
+  cp = (L_CARD32 *)sunhdr;
+
+  /* Read in all 32-bit values of the header and check for byte order */
+  for (j = 0; j < sizeof (L_SUNFILEHEADER) / sizeof(sunhdr->l_ras_magic); j++)
+    {
+      *(cp++) = read_card32 (ifp, &err);
+      if (err)
+        break;
+    }
+
+  if (err)
+    sunhdr->l_ras_magic = 0;  /* Not a valid SUN-raster file */
+}
+
+
+/* Write out a SUN-fileheader */
+
+static void
+write_sun_header (FILE            *ofp,
+                  L_SUNFILEHEADER *sunhdr)
+{
+  int       j, hdr_entries;
+  L_CARD32 *cp;
+
+  hdr_entries = sizeof (L_SUNFILEHEADER) / sizeof(sunhdr->l_ras_magic);
+
+  cp = (L_CARD32 *)sunhdr;
+
+  /* Write out all 32-bit values of the header and check for byte order */
+  for (j = 0; j < hdr_entries; j++)
+    {
+      write_card32 (ofp, *(cp++));
+    }
+}
+
+
+/* Read the sun colormap */
+
+static void
+read_sun_cols (FILE            *ifp,
+               L_SUNFILEHEADER *sunhdr,
+               guchar          *colormap)
+{
+  int ncols, err = 0;
+
+  /* Read in SUN-raster Colormap */
+  ncols = sunhdr->l_ras_maplength / 3;
+  if (ncols <= 0)
+    err = 1;
+  else
+    err = (fread (colormap, 3, ncols, ifp) != ncols);
+
+  if (err)
+    sunhdr->l_ras_magic = 0;  /* Not a valid SUN-raster file */
+}
+
+
+/* Write a sun colormap */
+
+static void
+write_sun_cols (FILE            *ofp,
+                L_SUNFILEHEADER *sunhdr,
+                guchar          *colormap)
+{
+  int ncols;
+
+  ncols = sunhdr->l_ras_maplength / 3;
+  fwrite (colormap, 3, ncols, ofp);
+}
+
+
+/* Set a GIMP colortable using the sun colormap */
+
+static void
+set_color_table (gint32           image_ID,
+                 L_SUNFILEHEADER *sunhdr,
+                 const guchar    *suncolmap)
+{
+  guchar ColorMap[256 * 3];
+  gint   ncols, j;
+
+  ncols = sunhdr->l_ras_maplength / 3;
+  if (ncols <= 0)
+    return;
+
+  for (j = 0; j < MIN (ncols, 256); j++)
+    {
+      ColorMap[j * 3 + 0] = suncolmap[j];
+      ColorMap[j * 3 + 1] = suncolmap[j + ncols];
+      ColorMap[j * 3 + 2] = suncolmap[j + 2 * ncols];
+    }
+
+#ifdef DEBUG
+  printf ("Set GIMP colortable:\n");
+  for (j = 0; j < ncols; j++)
+    printf ("%3d: 0x%02x 0x%02x 0x%02x\n", j,
+            ColorMap[j*3], ColorMap[j*3+1], ColorMap[j*3+2]);
+#endif
+
+  gimp_image_set_colormap (image_ID, ColorMap, ncols);
+}
+
+
+/* Create an image. Sets layer_ID, drawable and rgn. Returns image_ID */
+static gint32
+create_new_image (const gchar        *filename,
+                  guint               width,
+                  guint               height,
+                  GimpImageBaseType   type,
+                  gint32             *layer_ID,
+                  GeglBuffer        **buffer)
+{
+  gint32        image_ID;
+  GimpImageType gdtype;
+
+  switch (type)
+    {
+    case GIMP_RGB:
+      gdtype = GIMP_RGB_IMAGE;
+      break;
+    case GIMP_GRAY:
+      gdtype = GIMP_GRAY_IMAGE;
+      break;
+    case GIMP_INDEXED:
+      gdtype = GIMP_INDEXED_IMAGE;
+      break;
+    default:
+      g_warning ("Unsupported image type");
+      return -1;
+    }
+
+  image_ID = gimp_image_new (width, height, type);
+  gimp_image_set_filename (image_ID, filename);
+
+  *layer_ID = gimp_layer_new (image_ID, _("Background"), width, height,
+                              gdtype,
+                              100,
+                              gimp_image_get_default_new_layer_mode (image_ID));
+  gimp_image_insert_layer (image_ID, *layer_ID, -1, 0);
+
+  *buffer = gimp_drawable_get_buffer (*layer_ID);
+
+  return image_ID;
+}
+
+
+/* Load SUN-raster-file with depth 1 */
+static gint32
+load_sun_d1 (const gchar     *filename,
+             FILE            *ifp,
+             L_SUNFILEHEADER *sunhdr,
+             guchar          *suncolmap)
+{
+  int               pix8;
+  int               width, height, linepad, scan_lines, tile_height;
+  int               i, j;
+  guchar           *dest, *data;
+  gint32            layer_ID, image_ID;
+  GeglBuffer       *buffer;
+  guchar            bit2byte[256 * 8];
+  L_SUNFILEHEADER   sun_bwhdr;
+  guchar            sun_bwcolmap[6] = { 255,0,255,0,255,0 };
+  int               err = 0;
+  gboolean          rle = (sunhdr->l_ras_type == RAS_TYPE_RLE);
+
+  width = sunhdr->l_ras_width;
+  height = sunhdr->l_ras_height;
+
+  image_ID = create_new_image (filename, width, height, GIMP_INDEXED,
+                               &layer_ID, &buffer);
+
+  tile_height = gimp_tile_height ();
+  data = g_malloc (tile_height * width);
+
+  if (suncolmap != NULL)   /* Set up the specified color map */
+    {
+      set_color_table (image_ID, sunhdr, suncolmap);
+    }
+  else   /* No colormap available. Set up a dummy b/w-colormap */
+    {      /* Copy the original header and simulate b/w-colormap */
+      memcpy ((char *)&sun_bwhdr,(char *)sunhdr,sizeof (L_SUNFILEHEADER));
+      sun_bwhdr.l_ras_maptype = 2;
+      sun_bwhdr.l_ras_maplength = 6;
+      set_color_table (image_ID, &sun_bwhdr, sun_bwcolmap);
+    }
+
+  /* Get an array for mapping 8 bits in a byte to 8 bytes */
+  dest = bit2byte;
+  for (j = 0; j < 256; j++)
+    for (i = 7; i >= 0; i--)
+      *(dest++) = ((j & (1 << i)) != 0);
+
+  linepad = (((sunhdr->l_ras_width+7)/8) % 2); /* Check for 16bit align */
+
+  if (rle)
+    rle_startread (ifp);
+
+  dest = data;
+  scan_lines = 0;
+
+  for (i = 0; i < height; i++)
+    {
+      j = width;
+      while (j >= 8)
+        {
+          pix8 = rle ? rle_getc (ifp) : getc (ifp);
+          if (pix8 < 0) { err = 1; pix8 = 0; }
+
+          memcpy (dest, bit2byte + pix8*8, 8);
+          dest += 8;
+          j -= 8;
+        }
+
+      if (j > 0)
+        {
+          pix8 = rle ? rle_getc (ifp) : getc (ifp);
+          if (pix8 < 0) { err = 1; pix8 = 0; }
+
+          memcpy (dest, bit2byte + pix8*8, j);
+          dest += j;
+        }
+
+      if (linepad)
+        err |= ((rle ? rle_getc (ifp) : getc (ifp)) < 0);
+
+      scan_lines++;
+
+      if ((i % 20) == 0)
+        gimp_progress_update ((double)(i+1) / (double)height);
+
+      if ((scan_lines == tile_height) || ((i+1) == height))
+        {
+          gegl_buffer_set (buffer, GEGL_RECTANGLE (0, i - scan_lines + 1,
+                                                   width, scan_lines), 0,
+                           NULL, data, GEGL_AUTO_ROWSTRIDE);
+          scan_lines = 0;
+          dest = data;
+        }
+    }
+
+  g_free (data);
+
+  if (err)
+    g_message (_("EOF encountered on reading"));
+
+  g_object_unref (buffer);
+
+  return image_ID;
+}
+
+
+/* Load SUN-raster-file with depth 8 */
+
+static gint32
+load_sun_d8 (const gchar     *filename,
+             FILE            *ifp,
+             L_SUNFILEHEADER *sunhdr,
+             guchar          *suncolmap)
+{
+  int         width, height, linepad, i, j;
+  gboolean    grayscale;
+  gint        ncols;
+  int         scan_lines, tile_height;
+  guchar     *dest, *data;
+  gint32      layer_ID, image_ID;
+  GeglBuffer *buffer;
+  int         err = 0;
+  gboolean    rle = (sunhdr->l_ras_type == RAS_TYPE_RLE);
+
+  width  = sunhdr->l_ras_width;
+  height = sunhdr->l_ras_height;
+
+  /* This could also be a grayscale image. Check it */
+  ncols = sunhdr->l_ras_maplength / 3;
+
+  grayscale = TRUE;  /* Also grayscale if no colormap present */
+
+  if ((ncols > 0) && (suncolmap != NULL))
+    {
+      for (j = 0; j < ncols; j++)
+        {
+          if ((suncolmap[j]             != j) ||
+              (suncolmap[j + ncols]     != j) ||
+              (suncolmap[j + 2 * ncols] != j))
+            {
+              grayscale = FALSE;
+              break;
+            }
+        }
+    }
+
+  image_ID = create_new_image (filename, width, height,
+                               grayscale ? GIMP_GRAY : GIMP_INDEXED,
+                               &layer_ID, &buffer);
+
+  tile_height = gimp_tile_height ();
+  data = g_malloc (tile_height * width);
+
+  if (!grayscale)
+    set_color_table (image_ID, sunhdr, suncolmap);
+
+  linepad = (sunhdr->l_ras_width % 2);
+
+  if (rle)
+    rle_startread (ifp);  /* Initialize RLE-buffer */
+
+  dest = data;
+  scan_lines = 0;
+
+  for (i = 0; i < height; i++)
+    {
+      memset ((char *)dest, 0, width);
+      err |= ((rle ? rle_fread ((char *)dest, 1, width, ifp)
+               : fread ((char *)dest, 1, width, ifp)) != width);
+
+      if (linepad)
+        err |= ((rle ? rle_getc (ifp) : getc (ifp)) < 0);
+
+      dest += width;
+      scan_lines++;
+
+      if ((i % 20) == 0)
+        gimp_progress_update ((double)(i+1) / (double)height);
+
+      if ((scan_lines == tile_height) || ((i+1) == height))
+        {
+          gegl_buffer_set (buffer, GEGL_RECTANGLE (0, i - scan_lines + 1,
+                                                   width, scan_lines), 0,
+                           NULL, data, GEGL_AUTO_ROWSTRIDE);
+          scan_lines = 0;
+          dest = data;
+        }
+    }
+
+  g_free (data);
+
+  if (err)
+    g_message (_("EOF encountered on reading"));
+
+  g_object_unref (buffer);
+
+  return image_ID;
+}
+
+
+/* Load SUN-raster-file with depth 24 */
+static gint32
+load_sun_d24 (const gchar      *filename,
+              FILE             *ifp,
+              L_SUNFILEHEADER  *sunhdr,
+              guchar           *suncolmap)
+{
+  guchar     *dest, blue;
+  guchar     *data;
+  int         width, height, linepad, tile_height, scan_lines;
+  int         i, j;
+  gint32      layer_ID, image_ID;
+  GeglBuffer *buffer;
+  int         err = 0;
+  gboolean    rle = (sunhdr->l_ras_type == RAS_TYPE_RLE);
+
+  width  = sunhdr->l_ras_width;
+  height = sunhdr->l_ras_height;
+
+  image_ID = create_new_image (filename, width, height, GIMP_RGB,
+                               &layer_ID, &buffer);
+
+  tile_height = gimp_tile_height ();
+  data = g_malloc (tile_height * width * 3);
+
+  linepad = ((sunhdr->l_ras_width*3) % 2);
+
+  if (rle)
+    rle_startread (ifp);  /* Initialize RLE-buffer */
+
+  dest = data;
+  scan_lines = 0;
+
+  for (i = 0; i < height; i++)
+    {
+      memset ((char *)dest, 0, 3*width);
+      err |= ((rle ? rle_fread ((char *)dest, 3, width, ifp)
+               : fread ((char *)dest, 3, width, ifp)) != width);
+
+      if (linepad)
+        err |= ((rle ? rle_getc (ifp) : getc (ifp)) < 0);
+
+      if (sunhdr->l_ras_type == 3) /* RGB-format ? That is what GIMP wants */
+        {
+          dest += width * 3;
+        }
+      else                         /* We have BGR format. Correct it */
+        {
+          for (j = 0; j < width; j++)
+            {
+              blue = *dest;
+              *dest = *(dest+2);
+              *(dest+2) = blue;
+              dest += 3;
+            }
+        }
+
+      scan_lines++;
+
+      if ((i % 20) == 0)
+        gimp_progress_update ((double)(i + 1) / (double)height);
+
+      if ((scan_lines == tile_height) || ((i + 1) == height))
+        {
+          gegl_buffer_set (buffer, GEGL_RECTANGLE (0, i - scan_lines + 1,
+                                                   width, scan_lines), 0,
+                           NULL, data, GEGL_AUTO_ROWSTRIDE);
+          scan_lines = 0;
+          dest = data;
+        }
+    }
+
+  g_free (data);
+
+  if (err)
+    g_message (_("EOF encountered on reading"));
+
+  g_object_unref (buffer);
+
+  return image_ID;
+}
+
+
+/* Load SUN-raster-file with depth 32 */
+
+static gint32
+load_sun_d32 (const gchar     *filename,
+              FILE            *ifp,
+              L_SUNFILEHEADER *sunhdr,
+              guchar          *suncolmap)
+{
+  guchar     *dest, blue;
+  guchar     *data;
+  int         width, height, tile_height, scan_lines;
+  int         i, j;
+  gint32      layer_ID, image_ID;
+  GeglBuffer *buffer;
+  int         err = 0;
+  int         cerr;
+  gboolean    rle = (sunhdr->l_ras_type == RAS_TYPE_RLE);
+
+  width  = sunhdr->l_ras_width;
+  height = sunhdr->l_ras_height;
+
+  /* initialize */
+
+  cerr = 0;
+
+  image_ID = create_new_image (filename, width, height, GIMP_RGB,
+                               &layer_ID, &buffer);
+
+  tile_height = gimp_tile_height ();
+  data = g_malloc (tile_height * width * 3);
+
+  if (rle)
+    rle_startread (ifp);  /* Initialize RLE-buffer */
+
+  dest = data;
+  scan_lines = 0;
+
+  for (i = 0; i < height; i++)
+    {
+      if (rle)
+        {
+          for (j = 0; j < width; j++)
+            {
+              rle_getc (ifp);   /* Skip unused byte */
+              *(dest++) = rle_getc (ifp);
+              *(dest++) = rle_getc (ifp);
+              *(dest++) = (cerr = (rle_getc (ifp)));
+            }
+        }
+      else
+        {
+          for (j = 0; j < width; j++)
+            {
+              getc (ifp);   /* Skip unused byte */
+              *(dest++) = getc (ifp);
+              *(dest++) = getc (ifp);
+              *(dest++) = (cerr = (getc (ifp)));
+            }
+        }
+      err |= (cerr < 0);
+
+      if (sunhdr->l_ras_type != 3) /* BGR format ? Correct it */
+        {
+          for (j = 0; j < width; j++)
+            {
+              dest -= 3;
+              blue = *dest;
+              *dest = *(dest+2);
+              *(dest+2) = blue;
+            }
+          dest += width*3;
+        }
+
+      scan_lines++;
+
+      if ((i % 20) == 0)
+        gimp_progress_update ((double)(i + 1) / (double)height);
+
+      if ((scan_lines == tile_height) || ((i + 1) == height))
+        {
+          gegl_buffer_set (buffer, GEGL_RECTANGLE (0, i - scan_lines + 1,
+                                                   width, scan_lines), 0,
+                           NULL, data, GEGL_AUTO_ROWSTRIDE);
+          scan_lines = 0;
+          dest = data;
+        }
+    }
+
+  g_free (data);
+
+  if (err)
+    g_message (_("EOF encountered on reading"));
+
+  g_object_unref (buffer);
+
+  return image_ID;
+}
+
+
+static gint
+save_index (FILE     *ofp,
+            gint32    image_ID,
+            gint32    drawable_ID,
+            gboolean  grey,
+            gboolean  rle)
+{
+  int             height, width, linepad, i, j;
+  int             ncols, bw, is_bw, is_wb, bpl;
+  int             tile_height;
+  long            tmp = 0;
+  guchar         *cmap, *bwline = NULL;
+  guchar         *data, *src;
+  L_SUNFILEHEADER sunhdr;
+  guchar          sun_colormap[256*3];
+  static guchar   sun_bwmap[6] = { 0,   255, 0,   255, 0,   255 };
+  static guchar   sun_wbmap[6] = { 255, 0,   255, 0,   255, 0   };
+  unsigned char  *suncolmap = sun_colormap;
+  GeglBuffer     *buffer;
+  const Babl     *format;
+  WRITE_FUN      *write_fun;
+
+  buffer = gimp_drawable_get_buffer (drawable_ID);
+
+  width  = gegl_buffer_get_width (buffer);
+  height = gegl_buffer_get_height (buffer);
+
+  tile_height = gimp_tile_height ();
+
+  if (grey)
+    format = babl_format ("Y' u8");
+  else
+    format = gegl_buffer_get_format (buffer);
+
+  /* allocate a buffer for retrieving information from the buffer  */
+  src = data = g_malloc (tile_height * width *
+                         babl_format_get_bytes_per_pixel (format));
+
+  /* Fill SUN-color map */
+  if (grey)
+    {
+      ncols = 256;
+
+      for (j = 0; j < ncols; j++)
+        {
+          suncolmap[j]             = j;
+          suncolmap[j + ncols]     = j;
+          suncolmap[j + ncols * 2] = j;
+        }
+    }
+  else
+    {
+      cmap = gimp_image_get_colormap (image_ID, &ncols);
+
+      for (j = 0; j < ncols; j++)
+        {
+          suncolmap[j]             = *(cmap++);
+          suncolmap[j + ncols]     = *(cmap++);
+          suncolmap[j + ncols * 2] = *(cmap++);
+        }
+    }
+
+  bw = (ncols == 2);   /* Maybe this is a two-color image */
+  if (bw)
+    {
+      bwline = g_malloc ((width + 7) / 8);
+      if (bwline == NULL)
+        bw = 0;
+    }
+
+  is_bw = is_wb = 0;
+  if (bw)    /* The Sun-OS imagetool generates index 0 for white and */
+    {          /* index 1 for black. Do the same without colortable. */
+      is_bw = (memcmp (suncolmap, sun_bwmap, 6) == 0);
+      is_wb = (memcmp (suncolmap, sun_wbmap, 6) == 0);
+    }
+
+  /* Number of data bytes per line */
+  bpl = bw ?  (width+7)/8 : width;
+  linepad = bpl % 2;
+
+  /* Fill in the SUN header */
+  sunhdr.l_ras_magic  = RAS_MAGIC;
+  sunhdr.l_ras_width  = width;
+  sunhdr.l_ras_height = height;
+  sunhdr.l_ras_depth  = bw ? 1 : 8;
+  sunhdr.l_ras_length = (bpl + linepad) * height;
+  sunhdr.l_ras_type   = rle ? RAS_TYPE_RLE : RAS_TYPE_STD;
+
+  if (is_bw || is_wb)   /* No colortable for real b/w images */
+    {
+      sunhdr.l_ras_maptype = 0;   /* No colormap */
+      sunhdr.l_ras_maplength = 0; /* Length of colormap */
+    }
+  else
+    {
+      sunhdr.l_ras_maptype = 1;   /* RGB colormap */
+      sunhdr.l_ras_maplength = ncols*3; /* Length of colormap */
+    }
+
+  write_sun_header (ofp, &sunhdr);
+
+  if (sunhdr.l_ras_maplength > 0)
+    write_sun_cols (ofp, &sunhdr, suncolmap);
+
+#define GET_INDEX_TILE(begin) \
+  {int scan_lines; \
+    scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i); \
+    gegl_buffer_get (buffer, GEGL_RECTANGLE (0, i, width, scan_lines), 1.0, \
+                     format, begin, \
+                     GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); \
+    src = begin; }
+
+  if (rle)
+    {
+      write_fun = (WRITE_FUN *) &rle_fwrite;
+      rle_startwrite (ofp);
+    }
+  else
+    {
+      write_fun = (WRITE_FUN *) &my_fwrite;
+    }
+
+  if (bw)  /* Two color image */
+    {
+      for (i = 0; i < height; i++)
+        {
+          if ((i % tile_height) == 0)
+            GET_INDEX_TILE (data); /* Get more data */
+
+          byte2bit (src, width, bwline, is_bw);
+          (*write_fun) (bwline, bpl, 1, ofp);
+          if (linepad)
+            (*write_fun) ((char *)&tmp, linepad, 1, ofp);
+          src += width;
+
+          if ((i % 20) == 0)
+            gimp_progress_update ((double) i / (double) height);
+        }
+    }
+  else   /* Color or grey-image */
+    {
+      for (i = 0; i < height; i++)
+        {
+          if ((i % tile_height) == 0)
+            GET_INDEX_TILE (data); /* Get more data */
+
+          (*write_fun) ((char *)src, width, 1, ofp);
+          if (linepad)
+            (*write_fun) ((char *)&tmp, linepad, 1, ofp);
+          src += width;
+
+          if ((i % 20) == 0)
+            gimp_progress_update ((double) i / (double) height);
+        }
+    }
+
+#undef GET_INDEX_TILE
+
+  if (rle)
+    rle_endwrite (ofp);
+
+  g_free (data);
+
+  if (bwline)
+    g_free (bwline);
+
+  g_object_unref (buffer);
+
+  if (ferror (ofp))
+    {
+      g_message (_("Write error occurred"));
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+
+static gint
+save_rgb (FILE     *ofp,
+          gint32    image_ID,
+          gint32    drawable_ID,
+          gboolean  rle)
+{
+  int              height, width, tile_height, linepad;
+  int              i, j, bpp;
+  guchar          *data, *src;
+  L_SUNFILEHEADER  sunhdr;
+  GeglBuffer      *buffer;
+  const Babl      *format;
+
+  buffer = gimp_drawable_get_buffer (drawable_ID);
+
+  width  = gegl_buffer_get_width  (buffer);
+  height = gegl_buffer_get_height (buffer);
+
+  tile_height = gimp_tile_height ();
+
+  format = babl_format ("R'G'B' u8");
+
+  /* allocate a buffer for retrieving information from the pixel region  */
+  src = data = g_malloc (tile_height * width *
+                         babl_format_get_bytes_per_pixel (format));
+
+/* #define SUNRAS_32 */
+#ifdef SUNRAS_32
+  bpp = 4;
+#else
+  bpp = 3;
+#endif
+  linepad = (width * bpp) % 2;
+
+  /* Fill in the SUN header */
+  sunhdr.l_ras_magic     = RAS_MAGIC;
+  sunhdr.l_ras_width     = width;
+  sunhdr.l_ras_height    = height;
+  sunhdr.l_ras_depth     = 8 * bpp;
+  sunhdr.l_ras_length    = (width * bpp + linepad) * height;
+  sunhdr.l_ras_type      = rle ? RAS_TYPE_RLE : RAS_TYPE_STD;
+  sunhdr.l_ras_maptype   = 0;   /* No colormap */
+  sunhdr.l_ras_maplength = 0; /* Length of colormap */
+
+  write_sun_header (ofp, &sunhdr);
+
+#define GET_RGB_TILE(begin) \
+  {int scan_lines; \
+    scan_lines = (i+tile_height-1 < height) ? tile_height : (height-i); \
+    gegl_buffer_get (buffer, GEGL_RECTANGLE (0, i, width, scan_lines), 1.0, \
+                     format, begin, \
+                     GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); \
+    src = begin; }
+
+  if (! rle)
+    {
+      for (i = 0; i < height; i++)
+        {
+          if ((i % tile_height) == 0)
+            GET_RGB_TILE (data); /* Get more data */
+
+          for (j = 0; j < width; j++)
+            {
+              if (bpp == 4) putc (0, ofp);   /* Dummy */
+              putc (*(src + 2), ofp);        /* Blue */
+              putc (*(src + 1), ofp);        /* Green */
+              putc (*src,       ofp);        /* Red */
+              src += 3;
+            }
+
+          for (j = 0; j < linepad; j++)
+            putc (0, ofp);
+
+          if ((i % 20) == 0)
+            gimp_progress_update ((double) i / (double) height);
+        }
+    }
+  else  /* Write runlength encoded */
+    {
+      rle_startwrite (ofp);
+
+      for (i = 0; i < height; i++)
+        {
+          if ((i % tile_height) == 0)
+            GET_RGB_TILE (data); /* Get more data */
+
+          for (j = 0; j < width; j++)
+            {
+              if (bpp == 4) rle_putc (0, ofp);   /* Dummy */
+              rle_putc (*(src + 2), ofp);        /* Blue */
+              rle_putc (*(src + 1), ofp);        /* Green */
+              rle_putc (*src,       ofp);        /* Red */
+              src += 3;
+            }
+
+          for (j = 0; j < linepad; j++)
+            rle_putc (0, ofp);
+
+          if ((i % 20) == 0)
+            gimp_progress_update ((double) i / (double) height);
+        }
+
+      rle_endwrite (ofp);
+    }
+
+#undef GET_RGB_TILE
+
+  g_free (data);
+
+  g_object_unref (buffer);
+
+  if (ferror (ofp))
+    {
+      g_message (_("Write error occurred"));
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+
+/*  Save interface functions  */
+
+static gboolean
+save_dialog (void)
+{
+  GtkWidget *dialog;
+  GtkWidget *frame;
+  gboolean   run;
+
+  dialog = gimp_export_dialog_new (_("SUNRAS"), PLUG_IN_BINARY, SAVE_PROC);
+
+  /*  file save type  */
+  frame = gimp_int_radio_group_new (TRUE, _("Data Formatting"),
+                                    G_CALLBACK (gimp_radio_button_update),
+                                    &psvals.rle, psvals.rle,
+
+                                    _("_RunLength Encoded"), TRUE,  NULL,
+                                    _("_Standard"),          FALSE, NULL,
+
+                                    NULL);
+
+  gtk_container_set_border_width (GTK_CONTAINER (frame), 12);
+  gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
+                      frame, TRUE, TRUE, 0);
+  gtk_widget_show (frame);
+
+  gtk_widget_show (dialog);
+
+  run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);
+
+  gtk_widget_destroy (dialog);
+
+  return run;
+}
+
+static int
+my_fwrite (void *ptr,
+           int   size,
+           int   nmemb,
+           FILE *stream)
+{
+  return fwrite (ptr, size, nmemb, stream);
+}