summaryrefslogtreecommitdiffstats
path: root/plug-ins/common/file-pnm.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--plug-ins/common/file-pnm.c1820
1 files changed, 1820 insertions, 0 deletions
diff --git a/plug-ins/common/file-pnm.c b/plug-ins/common/file-pnm.c
new file mode 100644
index 0000000..2132eec
--- /dev/null
+++ b/plug-ins/common/file-pnm.c
@@ -0,0 +1,1820 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * PNM reading and writing code Copyright (C) 1996 Erik Nygren
+ *
+ * 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/>.
+ */
+
+/*
+ * The pnm reading and writing code was written from scratch by Erik Nygren
+ * (nygren@mit.edu) based on the specifications in the man pages and
+ * does not contain any code from the netpbm or pbmplus distributions.
+ *
+ * 2006: pbm saving written by Martin K Collins (martin@mkcollins.org)
+ * 2015: pfm reading written by Tobias Ellinghaus (me@houz.org)
+ */
+
+#include "config.h"
+
+#include <setjmp.h>
+#include <stdlib.h>
+#include <math.h>
+#include <errno.h>
+
+#include <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "libgimp/stdplugins-intl.h"
+
+
+#define LOAD_PROC "file-pnm-load"
+#define PNM_SAVE_PROC "file-pnm-save"
+#define PBM_SAVE_PROC "file-pbm-save"
+#define PGM_SAVE_PROC "file-pgm-save"
+#define PPM_SAVE_PROC "file-ppm-save"
+#define PFM_SAVE_PROC "file-pfm-save"
+#define PLUG_IN_BINARY "file-pnm"
+#define PLUG_IN_ROLE "gimp-file-pnm"
+
+
+/* Declare local data types
+ */
+
+typedef struct _PNMScanner PNMScanner;
+typedef struct _PNMInfo PNMInfo;
+typedef struct _PNMRowInfo PNMRowInfo;
+
+typedef void (* PNMLoaderFunc) (PNMScanner *scanner,
+ PNMInfo *info,
+ GeglBuffer *buffer);
+typedef gboolean (* PNMSaverowFunc) (PNMRowInfo *info,
+ guchar *data,
+ GError **error);
+
+struct _PNMScanner
+{
+ GInputStream *input; /* The input stream of the file being read */
+ gchar cur; /* The current character in the input stream */
+ gint eof; /* Have we reached end of file? */
+ gchar *inbuf; /* Input buffer - initially 0 */
+ gint inbufsize; /* Size of input buffer */
+ gint inbufvalidsize; /* Size of input buffer with valid data */
+ gint inbufpos; /* Position in input buffer */
+};
+
+struct _PNMInfo
+{
+ gint xres, yres; /* The size of the image */
+ gboolean float_format; /* Whether it is a floating point format */
+ gint maxval; /* For integer format image files, the max value
+ * which we need to normalize to */
+ gfloat scale_factor; /* PFM files have a scale factor */
+ gint np; /* Number of image planes (0 for pbm) */
+ gboolean asciibody; /* 1 if ascii body, 0 if raw body */
+ jmp_buf jmpbuf; /* Where to jump to on an error loading */
+
+ PNMLoaderFunc loader; /* Routine to use to load the pnm body */
+};
+
+/* Contains the information needed to write out PNM rows */
+struct _PNMRowInfo
+{
+ GOutputStream *output; /* Output stream */
+ gchar *rowbuf; /* Buffer for writing out rows */
+ gint xres; /* X resolution */
+ gint np; /* Number of planes */
+ gint bpc; /* Bytes per color */
+ guchar *red; /* Colormap red */
+ guchar *grn; /* Colormap green */
+ guchar *blu; /* Colormap blue */
+ gboolean zero_is_black; /* index zero is black (PBM only) */
+};
+
+/* Export info */
+typedef struct
+{
+ gint raw; /* raw or ascii */
+} PNMSaveVals;
+
+#define BUFLEN 512 /* The input buffer size for data returned
+ * from the scanner. Note that lines
+ * aren't allowed to be over 256 characters
+ * by the spec anyways so this shouldn't
+ * be an issue. */
+
+/* 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 (GFile *file,
+ GError **error);
+static gint save_image (GFile *file,
+ gint32 image_ID,
+ gint32 drawable_ID,
+ gboolean pbm,
+ gboolean float_format,
+ GError **error);
+
+static gboolean save_dialog (void);
+
+static void pnm_load_ascii (PNMScanner *scan,
+ PNMInfo *info,
+ GeglBuffer *buffer);
+static void pnm_load_raw (PNMScanner *scan,
+ PNMInfo *info,
+ GeglBuffer *buffer);
+static void pnm_load_rawpbm (PNMScanner *scan,
+ PNMInfo *info,
+ GeglBuffer *buffer);
+static void pnm_load_rawpfm (PNMScanner *scan,
+ PNMInfo *info,
+ GeglBuffer *buffer);
+
+static gboolean pnmsaverow_ascii (PNMRowInfo *ri,
+ guchar *data,
+ GError **error);
+static gboolean pnmsaverow_raw (PNMRowInfo *ri,
+ guchar *data,
+ GError **error);
+static gboolean pnmsaverow_raw_pbm (PNMRowInfo *ri,
+ guchar *data,
+ GError **error);
+static gboolean pnmsaverow_ascii_pbm (PNMRowInfo *ri,
+ guchar *data,
+ GError **error);
+static gboolean pnmsaverow_ascii_indexed (PNMRowInfo *ri,
+ guchar *data,
+ GError **error);
+static gboolean pnmsaverow_raw_indexed (PNMRowInfo *ri,
+ guchar *data,
+ GError **error);
+
+static void pnmscanner_destroy (PNMScanner *s);
+static void pnmscanner_createbuffer (PNMScanner *s,
+ gint bufsize);
+static void pnmscanner_getchar (PNMScanner *s);
+static void pnmscanner_eatwhitespace (PNMScanner *s);
+static void pnmscanner_gettoken (PNMScanner *s,
+ gchar *buf,
+ gint bufsize);
+static void pnmscanner_getsmalltoken (PNMScanner *s,
+ gchar *buf);
+
+static PNMScanner * pnmscanner_create (GInputStream *input);
+
+
+#define pnmscanner_eof(s) ((s)->eof)
+#define pnmscanner_input(s) ((s)->input)
+
+/* Checks for a fatal error */
+#define CHECK_FOR_ERROR(predicate, jmpbuf, ...) \
+ if ((predicate)) \
+ { g_message (__VA_ARGS__); longjmp ((jmpbuf), 1); }
+
+static const struct
+{
+ gchar name;
+ gint np;
+ gint asciibody;
+ gint maxval;
+ PNMLoaderFunc loader;
+} pnm_types[] =
+{
+ { '1', 0, 1, 1, pnm_load_ascii }, /* ASCII PBM */
+ { '2', 1, 1, 255, pnm_load_ascii }, /* ASCII PGM */
+ { '3', 3, 1, 255, pnm_load_ascii }, /* ASCII PPM */
+ { '4', 0, 0, 1, pnm_load_rawpbm }, /* RAW PBM */
+ { '5', 1, 0, 255, pnm_load_raw }, /* RAW PGM */
+ { '6', 3, 0, 255, pnm_load_raw }, /* RAW PPM */
+ { 'F', 3, 0, 0, pnm_load_rawpfm }, /* RAW PFM (color) */
+ { 'f', 1, 0, 0, pnm_load_rawpfm }, /* RAW PFM (grayscale) */
+ { 0 , 0, 0, 0, NULL}
+};
+
+const GimpPlugInInfo PLUG_IN_INFO =
+{
+ NULL, /* init_proc */
+ NULL, /* quit_proc */
+ query, /* query_proc */
+ run, /* run_proc */
+};
+
+static PNMSaveVals psvals =
+{
+ TRUE /* raw? or ascii */
+};
+
+
+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, "raw", "TRUE for raw output, FALSE for ascii output" }
+ };
+
+ static const GimpParamDef pfm_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_install_procedure (LOAD_PROC,
+ "Loads files in the PNM file format",
+ "This plug-in loads files in the various Netpbm portable file formats.",
+ "Erik Nygren",
+ "Erik Nygren",
+ "1996",
+ N_("PNM 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-portable-anymap");
+ gimp_register_file_handler_uri (LOAD_PROC);
+ gimp_register_magic_load_handler (LOAD_PROC,
+ "pnm,ppm,pgm,pbm,pfm",
+ "",
+ "0,string,P1,0,string,P2,0,string,P3,"
+ "0,string,P4,0,string,P5,0,string,P6,"
+ "0,string,PF,0,string,Pf");
+
+ gimp_install_procedure (PNM_SAVE_PROC,
+ "Exports files in the PNM file format",
+ "PNM exporting handles all image types without transparency.",
+ "Erik Nygren",
+ "Erik Nygren",
+ "1996",
+ N_("PNM image"),
+ "RGB, GRAY, INDEXED",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (save_args), 0,
+ save_args, NULL);
+
+ gimp_install_procedure (PBM_SAVE_PROC,
+ "Exports files in the PBM file format",
+ "PBM exporting produces mono images without transparency.",
+ "Martin K Collins",
+ "Erik Nygren",
+ "2006",
+ N_("PBM image"),
+ "RGB, GRAY, INDEXED",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (save_args), 0,
+ save_args, NULL);
+
+ gimp_install_procedure (PGM_SAVE_PROC,
+ "Exports files in the PGM file format",
+ "PGM exporting produces grayscale images without transparency.",
+ "Erik Nygren",
+ "Erik Nygren",
+ "1996",
+ N_("PGM image"),
+ "RGB, GRAY, INDEXED",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (save_args), 0,
+ save_args, NULL);
+
+ gimp_install_procedure (PPM_SAVE_PROC,
+ "Exports files in the PPM file format",
+ "PPM exporting handles RGB images without transparency.",
+ "Erik Nygren",
+ "Erik Nygren",
+ "1996",
+ N_("PPM image"),
+ "RGB, GRAY, INDEXED",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (save_args), 0,
+ save_args, NULL);
+
+ gimp_install_procedure (PFM_SAVE_PROC,
+ "Exports files in the PFM file format",
+ "PFM exporting handles all images without transparency.",
+ "Mukund Sivaraman",
+ "Mukund Sivaraman",
+ "2015",
+ N_("PFM image"),
+ "RGB, GRAY, INDEXED",
+ GIMP_PLUGIN,
+ G_N_ELEMENTS (pfm_save_args), 0,
+ pfm_save_args, NULL);
+
+ gimp_register_file_handler_mime (PNM_SAVE_PROC, "image/x-portable-anymap");
+ gimp_register_file_handler_mime (PBM_SAVE_PROC, "image/x-portable-bitmap");
+ gimp_register_file_handler_mime (PGM_SAVE_PROC, "image/x-portable-graymap");
+ gimp_register_file_handler_mime (PPM_SAVE_PROC, "image/x-portable-pixmap");
+ gimp_register_file_handler_mime (PPM_SAVE_PROC, "image/x-portable-floatmap");
+
+ gimp_register_file_handler_uri (PNM_SAVE_PROC);
+ gimp_register_file_handler_uri (PBM_SAVE_PROC);
+ gimp_register_file_handler_uri (PGM_SAVE_PROC);
+ gimp_register_file_handler_uri (PPM_SAVE_PROC);
+ gimp_register_file_handler_uri (PFM_SAVE_PROC);
+
+ gimp_register_save_handler (PNM_SAVE_PROC, "pnm", "");
+ gimp_register_save_handler (PBM_SAVE_PROC, "pbm", "");
+ gimp_register_save_handler (PGM_SAVE_PROC, "pgm", "");
+ gimp_register_save_handler (PPM_SAVE_PROC, "ppm", "");
+ gimp_register_save_handler (PFM_SAVE_PROC, "pfm", "");
+}
+
+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;
+ gboolean pbm = FALSE; /* flag for PBM output */
+ gboolean float_format = FALSE; /* flag for PFM output */
+
+ INIT_I18N ();
+ gegl_init (NULL, NULL);
+
+ run_mode = param[0].data.d_int32;
+
+ *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 (g_file_new_for_uri (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, PNM_SAVE_PROC) == 0 ||
+ strcmp (name, PBM_SAVE_PROC) == 0 ||
+ strcmp (name, PGM_SAVE_PROC) == 0 ||
+ strcmp (name, PPM_SAVE_PROC) == 0 ||
+ strcmp (name, PFM_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);
+
+ if (strcmp (name, PNM_SAVE_PROC) == 0)
+ {
+ export = gimp_export_image (&image_ID, &drawable_ID, "PNM",
+ GIMP_EXPORT_CAN_HANDLE_RGB |
+ GIMP_EXPORT_CAN_HANDLE_GRAY |
+ GIMP_EXPORT_CAN_HANDLE_INDEXED);
+ }
+ else if (strcmp (name, PBM_SAVE_PROC) == 0)
+ {
+ export = gimp_export_image (&image_ID, &drawable_ID, "PBM",
+ GIMP_EXPORT_CAN_HANDLE_BITMAP);
+ pbm = TRUE; /* gimp has no mono image type so hack it */
+ }
+ else if (strcmp (name, PGM_SAVE_PROC) == 0)
+ {
+ export = gimp_export_image (&image_ID, &drawable_ID, "PGM",
+ GIMP_EXPORT_CAN_HANDLE_GRAY);
+ }
+ else if (strcmp (name, PPM_SAVE_PROC) == 0)
+ {
+ export = gimp_export_image (&image_ID, &drawable_ID, "PPM",
+ GIMP_EXPORT_CAN_HANDLE_RGB |
+ GIMP_EXPORT_CAN_HANDLE_INDEXED);
+ }
+ else
+ {
+ export = gimp_export_image (&image_ID, &drawable_ID, "PFM",
+ GIMP_EXPORT_CAN_HANDLE_RGB |
+ GIMP_EXPORT_CAN_HANDLE_GRAY);
+ float_format = TRUE;
+ }
+
+ if (export == GIMP_EXPORT_CANCEL)
+ {
+ values[0].data.d_status = GIMP_PDB_CANCEL;
+ return;
+ }
+ break;
+
+ default:
+ break;
+ }
+
+ if (strcmp (name, PFM_SAVE_PROC) != 0)
+ {
+ switch (run_mode)
+ {
+ case GIMP_RUN_INTERACTIVE:
+ /* Possibly retrieve data */
+ gimp_get_data (name, &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.raw = (param[5].data.d_int32) ? TRUE : FALSE;
+ pbm = (strcmp (name, PBM_SAVE_PROC) == 0);
+ }
+ break;
+
+ case GIMP_RUN_WITH_LAST_VALS:
+ /* Possibly retrieve data */
+ gimp_get_data (name, &psvals);
+ break;
+
+ default:
+ break;
+ }
+ }
+ else
+ {
+ switch (run_mode)
+ {
+ case GIMP_RUN_NONINTERACTIVE:
+ /* Make sure all the arguments are there! */
+ if (nparams != 5)
+ {
+ status = GIMP_PDB_CALLING_ERROR;
+ }
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ if (status == GIMP_PDB_SUCCESS)
+ {
+ if (save_image (g_file_new_for_uri (param[3].data.d_string),
+ image_ID, drawable_ID, pbm, float_format,
+ &error))
+ {
+ if (strcmp (name, PFM_SAVE_PROC) != 0)
+ {
+ /* Store psvals data */
+ gimp_set_data (name, &psvals, sizeof (PNMSaveVals));
+ }
+ }
+ 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;
+
+ gegl_exit ();
+}
+
+static gint32
+load_image (GFile *file,
+ GError **error)
+{
+ GInputStream *input;
+ GeglBuffer *buffer;
+ gint32 volatile image_ID = -1;
+ gint32 layer_ID;
+ char buf[BUFLEN + 4]; /* buffer for random things like scanning */
+ PNMInfo *pnminfo;
+ PNMScanner *volatile scan;
+ int ctr;
+ GimpPrecision precision;
+
+ gimp_progress_init_printf (_("Opening '%s'"),
+ g_file_get_parse_name (file));
+
+ input = G_INPUT_STREAM (g_file_read (file, NULL, error));
+ if (! input)
+ return -1;
+
+ /* allocate the necessary structures */
+ pnminfo = g_new (PNMInfo, 1);
+
+ scan = NULL;
+ /* set error handling */
+ if (setjmp (pnminfo->jmpbuf))
+ {
+ /* If we get here, we had a problem reading the file */
+ if (scan)
+ pnmscanner_destroy (scan);
+
+ g_object_unref (input);
+ g_free (pnminfo);
+
+ if (image_ID != -1)
+ gimp_image_delete (image_ID);
+
+ return -1;
+ }
+
+ if (! (scan = pnmscanner_create (input)))
+ longjmp (pnminfo->jmpbuf, 1);
+
+ /* Get magic number */
+ pnmscanner_gettoken (scan, buf, BUFLEN);
+ CHECK_FOR_ERROR (pnmscanner_eof (scan), pnminfo->jmpbuf,
+ _("Premature end of file."));
+ CHECK_FOR_ERROR ((buf[0] != 'P' || buf[2]), pnminfo->jmpbuf,
+ _("Invalid file."));
+
+ /* Look up magic number to see what type of PNM this is */
+ for (ctr = 0; pnm_types[ctr].name; ctr++)
+ if (buf[1] == pnm_types[ctr].name)
+ {
+ pnminfo->np = pnm_types[ctr].np;
+ pnminfo->asciibody = pnm_types[ctr].asciibody;
+ pnminfo->float_format = g_ascii_tolower (pnm_types[ctr].name) == 'f';
+ pnminfo->maxval = pnm_types[ctr].maxval;
+ pnminfo->loader = pnm_types[ctr].loader;
+ }
+
+ if (!pnminfo->loader)
+ {
+ g_message (_("File not in a supported format."));
+ longjmp (pnminfo->jmpbuf, 1);
+ }
+
+ pnmscanner_gettoken (scan, buf, BUFLEN);
+ CHECK_FOR_ERROR (pnmscanner_eof (scan), pnminfo->jmpbuf,
+ _("Premature end of file."));
+ pnminfo->xres = g_ascii_isdigit(*buf) ? atoi (buf) : 0;
+ CHECK_FOR_ERROR (pnminfo->xres <= 0, pnminfo->jmpbuf,
+ _("Invalid X resolution."));
+ CHECK_FOR_ERROR (pnminfo->xres > GIMP_MAX_IMAGE_SIZE, pnminfo->jmpbuf,
+ _("Image width is larger than GIMP can handle."));
+
+ pnmscanner_gettoken (scan, buf, BUFLEN);
+ CHECK_FOR_ERROR (pnmscanner_eof (scan), pnminfo->jmpbuf,
+ _("Premature end of file."));
+ pnminfo->yres = g_ascii_isdigit (*buf) ? atoi (buf) : 0;
+ CHECK_FOR_ERROR (pnminfo->yres <= 0, pnminfo->jmpbuf,
+ _("Invalid Y resolution."));
+ CHECK_FOR_ERROR (pnminfo->yres > GIMP_MAX_IMAGE_SIZE, pnminfo->jmpbuf,
+ _("Image height is larger than GIMP can handle."));
+
+ if (pnminfo->float_format)
+ {
+ gchar *endptr = NULL;
+
+ pnmscanner_gettoken (scan, buf, BUFLEN);
+ CHECK_FOR_ERROR (pnmscanner_eof (scan), pnminfo->jmpbuf,
+ _("Premature end of file."));
+
+ pnminfo->scale_factor = g_ascii_strtod (buf, &endptr);
+ CHECK_FOR_ERROR (endptr == NULL || *endptr != 0 || errno == ERANGE,
+ pnminfo->jmpbuf, _("Bogus scale factor."));
+ CHECK_FOR_ERROR (!isnormal (pnminfo->scale_factor),
+ pnminfo->jmpbuf, _("Unsupported scale factor."));
+ precision = GIMP_PRECISION_FLOAT_LINEAR;
+ }
+ else if (pnminfo->np != 0) /* pbm's don't have a maxval field */
+ {
+ pnmscanner_gettoken (scan, buf, BUFLEN);
+ CHECK_FOR_ERROR (pnmscanner_eof (scan), pnminfo->jmpbuf,
+ _("Premature end of file."));
+
+ pnminfo->maxval = g_ascii_isdigit (*buf) ? atoi (buf) : 0;
+ CHECK_FOR_ERROR (((pnminfo->maxval<=0) || (pnminfo->maxval>65535)),
+ pnminfo->jmpbuf, _("Unsupported maximum value."));
+ if (pnminfo->maxval < 256)
+ {
+ precision = GIMP_PRECISION_U8_GAMMA;
+ }
+ else
+ {
+ precision = GIMP_PRECISION_U16_GAMMA;
+ }
+ }
+ else
+ {
+ precision = GIMP_PRECISION_U8_GAMMA;
+ }
+
+ /* Create a new image of the proper size and associate the filename
+ with it. */
+ image_ID = gimp_image_new_with_precision
+ (pnminfo->xres, pnminfo->yres,
+ (pnminfo->np >= 3) ? GIMP_RGB : GIMP_GRAY,
+ precision);
+
+ gimp_image_set_filename (image_ID, g_file_get_uri (file));
+
+ layer_ID = gimp_layer_new (image_ID, _("Background"),
+ pnminfo->xres, pnminfo->yres,
+ (pnminfo->np >= 3 ?
+ GIMP_RGB_IMAGE : GIMP_GRAY_IMAGE),
+ 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);
+
+ pnminfo->loader (scan, pnminfo, buffer);
+
+ /* Destroy the scanner */
+ pnmscanner_destroy (scan);
+
+ g_object_unref (buffer);
+ g_free (pnminfo);
+ g_object_unref (input);
+
+ return image_ID;
+}
+
+static void
+pnm_load_ascii (PNMScanner *scan,
+ PNMInfo *info,
+ GeglBuffer *buffer)
+{
+ gint bpc;
+ guchar *data, *d;
+ gushort *s;
+ gint x, y, i, b;
+ gint start, end, scanlines;
+ gint np;
+ gchar buf[BUFLEN];
+ gboolean aborted = FALSE;
+
+ np = (info->np) ? (info->np) : 1;
+
+ if (info->maxval > 255)
+ bpc = 2;
+ else
+ bpc = 1;
+
+ /* No overflow as long as gimp_tile_height() < 1365 = 2^(31 - 18) / 6 */
+ data = g_new (guchar, gimp_tile_height () * info->xres * np * bpc);
+
+ /* Buffer reads to increase performance */
+ pnmscanner_createbuffer (scan, 4096);
+
+ for (y = 0; y < info->yres; y += scanlines)
+ {
+ start = y;
+ end = y + gimp_tile_height ();
+ end = MIN (end, info->yres);
+
+ scanlines = end - start;
+
+ d = data;
+ s = (gushort *)d;
+
+ for (i = 0; i < scanlines; i++)
+ for (x = 0; x < info->xres; x++)
+ {
+ for (b = 0; b < np; b++)
+ {
+ if (aborted)
+ {
+ d[b] = 0;
+ continue;
+ }
+
+ /* Truncated files will just have all 0's
+ at the end of the images */
+ if (pnmscanner_eof (scan))
+ {
+ g_message (_("Premature end of file."));
+ aborted = TRUE;
+
+ d[b] = 0;
+ continue;
+ }
+
+ if (info->np)
+ pnmscanner_gettoken (scan, buf, BUFLEN);
+ else
+ pnmscanner_getsmalltoken (scan, buf);
+
+ if (info->maxval == 1)
+ {
+ if (info->np)
+ d[b] = (*buf == '0') ? 0x00 : 0xff;
+ else
+ d[b] = (*buf == '0') ? 0xff : 0x00; /* invert for PBM */
+ }
+ else if (bpc > 1)
+ {
+ s[b] = (65535.0 * (((gdouble) (g_ascii_isdigit (*buf) ?
+ atoi (buf) : 0))
+ / (gdouble) (info->maxval)));
+ }
+ else
+ {
+ d[b] = (255.0 * (((gdouble) (g_ascii_isdigit (*buf) ?
+ atoi (buf) : 0))
+ / (gdouble) (info->maxval)));
+ }
+ }
+
+ if (bpc > 1)
+ {
+ s += np;
+ }
+ else
+ {
+ d += np;
+ }
+ }
+
+ gegl_buffer_set (buffer, GEGL_RECTANGLE (0, y, info->xres, scanlines), 0,
+ NULL, data, GEGL_AUTO_ROWSTRIDE);
+
+ gimp_progress_update ((double) y / (double) info->yres);
+ }
+
+ g_free (data);
+
+ gimp_progress_update (1.0);
+}
+
+static void
+pnm_load_raw (PNMScanner *scan,
+ PNMInfo *info,
+ GeglBuffer *buffer)
+{
+ GInputStream *input;
+ gint bpc;
+ guchar *data, *d;
+ gushort *s;
+ gint x, y, i;
+ gint start, end, scanlines;
+
+ if (info->maxval > 255)
+ bpc = 2;
+ else
+ bpc = 1;
+
+ /* No overflow as long as gimp_tile_height() < 1365 = 2^(31 - 18) / 6 */
+ data = g_new (guchar, gimp_tile_height () * info->xres * info->np * bpc);
+
+ input = pnmscanner_input (scan);
+
+ for (y = 0; y < info->yres; y += scanlines)
+ {
+ start = y;
+ end = y + gimp_tile_height ();
+ end = MIN (end, info->yres);
+ scanlines = end - start;
+ d = data;
+ s = (gushort *)data;
+
+ for (i = 0; i < scanlines; i++)
+ {
+ gsize bytes_read;
+ GError *error = NULL;
+
+ if (g_input_stream_read_all (input, d, info->xres * info->np * bpc,
+ &bytes_read, NULL, &error))
+ {
+ CHECK_FOR_ERROR (info->xres * info->np * bpc != bytes_read,
+ info->jmpbuf,
+ _("Premature end of file."));
+ }
+ else
+ {
+ CHECK_FOR_ERROR (FALSE, info->jmpbuf, "%s", error->message);
+ }
+
+ if (bpc > 1)
+ {
+ for (x = 0; x < info->xres * info->np; x++)
+ {
+ int v;
+
+ v = *d++ << 8;
+ v += *d++;
+
+ s[x] = MIN (v, info->maxval); /* guard against overflow */
+ s[x] = 65535.0 * (gdouble) v / (gdouble) info->maxval;
+ }
+ s += info->xres * info->np;
+ }
+ else
+ {
+ if (info->maxval != 255) /* Normalize if needed */
+ {
+ for (x = 0; x < info->xres * info->np; x++)
+ {
+ d[x] = MIN (d[x], info->maxval); /* guard against overflow */
+ d[x] = 255.0 * (gdouble) d[x] / (gdouble) info->maxval;
+ }
+ }
+
+ d += info->xres * info->np;
+ }
+ }
+
+ gegl_buffer_set (buffer,
+ GEGL_RECTANGLE (0, y, info->xres, scanlines), 0,
+ NULL, data, GEGL_AUTO_ROWSTRIDE);
+
+ gimp_progress_update ((double) y / (double) info->yres);
+ }
+
+ g_free (data);
+
+ gimp_progress_update (1.0);
+}
+
+static void
+pnm_load_rawpbm (PNMScanner *scan,
+ PNMInfo *info,
+ GeglBuffer *buffer)
+{
+ GInputStream *input;
+ guchar *buf;
+ guchar curbyte;
+ guchar *data, *d;
+ gint x, y, i;
+ gint start, end, scanlines;
+ gint rowlen, bufpos;
+
+ input = pnmscanner_input (scan);
+
+ rowlen = (int)ceil ((double)(info->xres)/8.0);
+ data = g_new (guchar, gimp_tile_height () * info->xres);
+ buf = g_new (guchar, rowlen);
+
+ for (y = 0; y < info->yres; y += scanlines)
+ {
+ start = y;
+ end = y + gimp_tile_height ();
+ end = MIN (end, info->yres);
+ scanlines = end - start;
+ d = data;
+
+ for (i = 0; i < scanlines; i++)
+ {
+ gsize bytes_read;
+ GError *error = NULL;
+
+ if (g_input_stream_read_all (input, buf, rowlen,
+ &bytes_read, NULL, &error))
+ {
+ CHECK_FOR_ERROR (rowlen != bytes_read,
+ info->jmpbuf,
+ _("Premature end of file."));
+ }
+ else
+ {
+ CHECK_FOR_ERROR (FALSE, info->jmpbuf, "%s", error->message);
+ }
+
+ bufpos = 0;
+ curbyte = buf[0];
+
+ for (x = 0; x < info->xres; x++)
+ {
+ if ((x % 8) == 0)
+ curbyte = buf[bufpos++];
+ d[x] = (curbyte & 0x80) ? 0x00 : 0xff;
+ curbyte <<= 1;
+ }
+
+ d += info->xres;
+ }
+
+ gegl_buffer_set (buffer, GEGL_RECTANGLE (0, y, info->xres, scanlines), 0,
+ NULL, data, GEGL_AUTO_ROWSTRIDE);
+
+ gimp_progress_update ((double) y / (double) info->yres);
+ }
+
+ g_free (buf);
+ g_free (data);
+
+ gimp_progress_update (1.0);
+}
+
+static void
+pnm_load_rawpfm (PNMScanner *scan,
+ PNMInfo *info,
+ GeglBuffer *buffer)
+{
+ GInputStream *input;
+ gfloat *data;
+ gint x, y;
+ gboolean swap_byte_order;
+
+ swap_byte_order =
+ (info->scale_factor >= 0.0) ^ (G_BYTE_ORDER == G_BIG_ENDIAN);
+
+ data = g_new (gfloat, info->xres * info->np);
+
+ input = pnmscanner_input (scan);
+
+ for (y = info->yres - 1; y >= 0; y--)
+ {
+ gsize bytes_read;
+ GError *error = NULL;
+
+ if (g_input_stream_read_all (input, data,
+ info->xres * info->np * sizeof (float),
+ &bytes_read, NULL, &error))
+ {
+ CHECK_FOR_ERROR
+ (info->xres * info->np * sizeof (float) != bytes_read,
+ info->jmpbuf, _("Premature end of file."));
+ }
+ else
+ {
+ CHECK_FOR_ERROR (FALSE, info->jmpbuf, "%s", error->message);
+ }
+
+ for (x = 0; x < info->xres * info->np; x++)
+ {
+ if (swap_byte_order)
+ {
+ union { gfloat f; guint32 i; } v;
+
+ v.f = data[x];
+ v.i = GUINT32_SWAP_LE_BE (v.i);
+ data[x] = v.f;
+ }
+
+ /* let's see if this is what people want, the PFM specs are a
+ * little vague about what the scale factor should be used
+ * for */
+ data[x] *= fabsf (info->scale_factor);
+ /* Keep values smaller than zero. That is in line with what the
+ * TIFF loader does. If the user doesn't want the negative numbers
+ * he has to get rid of them afterwards */
+ /* data[x] = fmaxf (0.0f, fminf (FLT_MAX, data[x])); */
+ }
+
+ gegl_buffer_set (buffer,
+ GEGL_RECTANGLE (0, y, info->xres, 1), 0,
+ NULL, data, GEGL_AUTO_ROWSTRIDE);
+
+ if (y % 32 == 0)
+ gimp_progress_update ((double) (info->yres - y) / (double) info->yres);
+ }
+
+ g_free (data);
+
+ gimp_progress_update (1.0);
+}
+
+static gboolean
+output_write (GOutputStream *output,
+ gconstpointer buffer,
+ gsize count,
+ GError **error)
+{
+ return g_output_stream_write_all (output, buffer, count, NULL, NULL, error);
+}
+
+/* Writes out mono raw rows */
+static gboolean
+pnmsaverow_raw_pbm (PNMRowInfo *ri,
+ guchar *data,
+ GError **error)
+{
+ gint b, p = 0;
+ gchar *rbcur = ri->rowbuf;
+ gint32 len = (gint) ceil ((gdouble) (ri->xres) / 8.0);
+
+ for (b = 0; b < len; b++) /* each output byte */
+ {
+ gint i;
+
+ rbcur[b] = 0;
+
+ for (i = 0; i < 8; i++) /* each bit in this byte */
+ {
+ if (p >= ri->xres)
+ break;
+
+ if (data[p] != ri->zero_is_black)
+ rbcur[b] |= (char) (1 << (7 - i));
+
+ p++;
+ }
+ }
+
+ return output_write (ri->output, ri->rowbuf, len, error);
+}
+
+/* Writes out mono ascii rows */
+static gboolean
+pnmsaverow_ascii_pbm (PNMRowInfo *ri,
+ guchar *data,
+ GError **error)
+{
+ static gint line_len = 0; /* ascii pbm lines must be <= 70 chars long */
+ gint32 len = 0;
+ gint i;
+ gchar *rbcur = ri->rowbuf;
+
+ for (i = 0; i < ri->xres; i++)
+ {
+ if (line_len > 69)
+ {
+ rbcur[i] = '\n';
+ line_len = 0;
+ len++;
+ rbcur++;
+ }
+
+ if (data[i] == ri->zero_is_black)
+ rbcur[i] = '0';
+ else
+ rbcur[i] = '1';
+
+ line_len++;
+ len++;
+ }
+
+ *(rbcur+i) = '\n';
+
+ return output_write (ri->output, ri->rowbuf, len, error);
+}
+
+/* Writes out RGB and grayscale raw rows */
+static gboolean
+pnmsaverow_raw (PNMRowInfo *ri,
+ guchar *data,
+ GError **error)
+{
+ gint i;
+ if (ri->bpc == 2)
+ {
+ gushort *d = (gushort *)data;
+ for (i = 0; i < ri->xres * ri->np; i++)
+ {
+ *d = g_htons(*d);
+ d++;
+ }
+ }
+ return output_write (ri->output, data, ri->xres * ri->np * ri->bpc, error);
+}
+
+/* Writes out RGB and grayscale float rows */
+static gboolean
+pnmsaverow_float (PNMRowInfo *ri,
+ const float *data,
+ GError **error)
+{
+ return output_write (ri->output, data,
+ ri->xres * ri->np * sizeof (float),
+ error);
+}
+
+/* Writes out indexed raw rows */
+static gboolean
+pnmsaverow_raw_indexed (PNMRowInfo *ri,
+ guchar *data,
+ GError **error)
+{
+ gint i;
+ gchar *rbcur = ri->rowbuf;
+
+ for (i = 0; i < ri->xres; i++)
+ {
+ *(rbcur++) = ri->red[*data];
+ *(rbcur++) = ri->grn[*data];
+ *(rbcur++) = ri->blu[*(data++)];
+ }
+
+ return output_write (ri->output, ri->rowbuf, ri->xres * 3, error);
+}
+
+/* Writes out RGB and grayscale ascii rows */
+static gboolean
+pnmsaverow_ascii (PNMRowInfo *ri,
+ guchar *data,
+ GError **error)
+{
+ gint i;
+ gchar *rbcur = ri->rowbuf;
+ gushort *sdata = (gushort *)data;
+
+ for (i = 0; i < ri->xres * ri->np; i++)
+ {
+ if (ri->bpc == 2)
+ {
+ sprintf ((gchar *) rbcur,"%d\n", 0xffff & *(sdata++));
+ }
+ else
+ {
+ sprintf ((gchar *) rbcur,"%d\n", 0xff & *(data++));
+ }
+ rbcur += strlen (rbcur);
+ }
+
+ return output_write (ri->output, ri->rowbuf, rbcur - ri->rowbuf,
+ error);
+}
+
+/* Writes out RGB and grayscale ascii rows */
+static gboolean
+pnmsaverow_ascii_indexed (PNMRowInfo *ri,
+ guchar *data,
+ GError **error)
+{
+ gint i;
+ gchar *rbcur = ri->rowbuf;
+
+ for (i = 0; i < ri->xres; i++)
+ {
+ sprintf (rbcur, "%d\n", 0xff & ri->red[*(data)]);
+ rbcur += strlen (rbcur);
+ sprintf (rbcur, "%d\n", 0xff & ri->grn[*(data)]);
+ rbcur += strlen (rbcur);
+ sprintf (rbcur, "%d\n", 0xff & ri->blu[*(data++)]);
+ rbcur += strlen (rbcur);
+ }
+
+ return output_write (ri->output, ri->rowbuf, strlen ((char *) ri->rowbuf),
+ error);
+}
+
+static gboolean
+save_image (GFile *file,
+ gint32 image_ID,
+ gint32 drawable_ID,
+ gboolean pbm,
+ gboolean float_format,
+ GError **error)
+{
+ gboolean status = FALSE;
+ GOutputStream *output = NULL;
+ GeglBuffer *buffer = NULL;
+ const Babl *format;
+ const gchar *header_string = NULL;
+ GimpImageType drawable_type;
+ PNMRowInfo rowinfo;
+ PNMSaverowFunc saverow = NULL;
+ guchar red[256];
+ guchar grn[256];
+ guchar blu[256];
+ gchar buf[BUFLEN];
+ gint np = 0;
+ gint xres, yres;
+ gint ypos, yend;
+ gint rowbufsize = 0;
+ gchar *comment = NULL;
+
+ /* Make sure we're not saving an image with an alpha channel */
+ if (gimp_drawable_has_alpha (drawable_ID))
+ {
+ g_message (_("Cannot export images with alpha channel."));
+ goto out;
+ }
+
+ gimp_progress_init_printf (_("Exporting '%s'"),
+ g_file_get_parse_name (file));
+
+ /* open the file */
+ output = G_OUTPUT_STREAM (g_file_replace (file,
+ NULL, FALSE, G_FILE_CREATE_NONE,
+ NULL, error));
+ if (! output)
+ goto out;
+
+ buffer = gimp_drawable_get_buffer (drawable_ID);
+
+ xres = gegl_buffer_get_width (buffer);
+ yres = gegl_buffer_get_height (buffer);
+
+ drawable_type = gimp_drawable_type (drawable_ID);
+
+ switch (gimp_image_get_precision (image_ID))
+ {
+ case GIMP_PRECISION_U8_LINEAR:
+ case GIMP_PRECISION_U8_GAMMA:
+ rowinfo.bpc = 1;
+ break;
+ default:
+ rowinfo.bpc = 2;
+ break;
+ }
+
+ /* write out magic number */
+ if (!float_format && !psvals.raw)
+ {
+ if (pbm)
+ {
+ header_string = "P1\n";
+ format = gegl_buffer_get_format (buffer);
+ np = 0;
+ rowbufsize = xres + (int) (xres / 70) + 1;
+ saverow = pnmsaverow_ascii_pbm;
+ }
+ else
+ {
+ switch (drawable_type)
+ {
+ case GIMP_GRAY_IMAGE:
+ header_string = "P2\n";
+ if (rowinfo.bpc == 1)
+ {
+ format = babl_format ("Y' u8");
+ rowbufsize = xres * 4;
+ }
+ else
+ {
+ format = babl_format ("Y' u16");
+ rowbufsize = xres * 6;
+ }
+ np = 1;
+ saverow = pnmsaverow_ascii;
+ break;
+
+ case GIMP_RGB_IMAGE:
+ header_string = "P3\n";
+ if (rowinfo.bpc == 1)
+ {
+ format = babl_format ("R'G'B' u8");
+ rowbufsize = xres * 12;
+ }
+ else
+ {
+ format = babl_format ("R'G'B' u16");
+ rowbufsize = xres * 18;
+ }
+ np = 3;
+ saverow = pnmsaverow_ascii;
+ break;
+
+ case GIMP_INDEXED_IMAGE:
+ header_string = "P3\n";
+ format = gegl_buffer_get_format (buffer);
+ np = 1;
+ rowbufsize = xres * 12;
+ saverow = pnmsaverow_ascii_indexed;
+ break;
+
+ default:
+ g_warning ("PNM: Unknown drawable_type\n");
+ goto out;
+ }
+ }
+ }
+ else if (!float_format)
+ {
+ if (pbm)
+ {
+ header_string = "P4\n";
+ format = gegl_buffer_get_format (buffer);
+ np = 0;
+ rowbufsize = (gint) ceil ((gdouble) xres / 8.0);
+ saverow = pnmsaverow_raw_pbm;
+ }
+ else
+ {
+ switch (drawable_type)
+ {
+ case GIMP_GRAY_IMAGE:
+ header_string = "P5\n";
+ if (rowinfo.bpc == 1)
+ {
+ format = babl_format ("Y' u8");
+ rowbufsize = xres;
+ }
+ else
+ {
+ format = babl_format ("Y' u16");
+ rowbufsize = xres * 2;
+ }
+ np = 1;
+ saverow = pnmsaverow_raw;
+ break;
+
+ case GIMP_RGB_IMAGE:
+ header_string = "P6\n";
+ if (rowinfo.bpc == 1)
+ {
+ format = babl_format ("R'G'B' u8");
+ rowbufsize = xres * 3;
+ }
+ else
+ {
+ format = babl_format ("R'G'B' u16");
+ rowbufsize = xres * 6;
+ }
+ np = 3;
+ saverow = pnmsaverow_raw;
+ break;
+
+ case GIMP_INDEXED_IMAGE:
+ header_string = "P6\n";
+ format = gegl_buffer_get_format (buffer);
+ np = 1;
+ rowbufsize = xres * 3;
+ saverow = pnmsaverow_raw_indexed;
+ break;
+
+ default:
+ g_warning ("PNM: Unknown drawable_type\n");
+ goto out;
+ }
+ }
+ }
+ else
+ {
+ switch (drawable_type)
+ {
+ case GIMP_GRAY_IMAGE:
+ header_string = "Pf\n";
+ format = babl_format ("Y float");
+ np = 1;
+ break;
+
+ case GIMP_RGB_IMAGE:
+ header_string = "PF\n";
+ format = babl_format ("RGB float");
+ np = 3;
+ break;
+
+ default:
+ g_warning ("PFM: Unknown drawable_type\n");
+ goto out;
+ }
+ }
+
+ if (! output_write (output, header_string, strlen (header_string), error))
+ goto out;
+
+ rowinfo.zero_is_black = FALSE;
+
+ if (drawable_type == GIMP_INDEXED_IMAGE)
+ {
+ guchar *cmap;
+ gint num_colors;
+
+ cmap = gimp_image_get_colormap (image_ID, &num_colors);
+
+ if (pbm)
+ {
+ /* Test which of the two colors is white and which is black */
+ switch (num_colors)
+ {
+ case 1:
+ rowinfo.zero_is_black = (GIMP_RGB_LUMINANCE (cmap[0],
+ cmap[1],
+ cmap[2]) < 128);
+ break;
+
+ case 2:
+ rowinfo.zero_is_black = (GIMP_RGB_LUMINANCE (cmap[0],
+ cmap[1],
+ cmap[2]) <
+ GIMP_RGB_LUMINANCE (cmap[3],
+ cmap[4],
+ cmap[5]));
+ break;
+
+ default:
+ g_warning ("Images exported as PBM should be black/white");
+ break;
+ }
+ }
+ else
+ {
+ const guchar *c = cmap;
+ gint i;
+
+ for (i = 0; i < num_colors; i++)
+ {
+ red[i] = *c++;
+ grn[i] = *c++;
+ blu[i] = *c++;
+ }
+
+ rowinfo.red = red;
+ rowinfo.grn = grn;
+ rowinfo.blu = blu;
+ }
+
+ g_free (cmap);
+ }
+
+ if (!float_format)
+ {
+ /* write out comment string */
+ comment = g_strdup_printf("# Created by GIMP version %s PNM plug-in\n",
+ GIMP_VERSION);
+
+ if (! output_write (output, comment, strlen (comment), error))
+ goto out;
+ }
+
+ /* write out resolution and maxval */
+ if (pbm)
+ g_snprintf (buf, sizeof (buf), "%d %d\n", xres, yres);
+ else if (!float_format)
+ g_snprintf (buf, sizeof (buf), "%d %d\n%d\n", xres, yres,
+ rowinfo.bpc == 1 ? 255 : 65535);
+ else
+ g_snprintf (buf, sizeof (buf), "%d %d\n%s\n", xres, yres,
+ G_BYTE_ORDER == G_BIG_ENDIAN ? "1.0" : "-1.0");
+
+ if (! output_write (output, buf, strlen (buf), error))
+ goto out;
+
+ if (!float_format)
+ {
+ guchar *data;
+ guchar *d;
+ gchar *rowbuf = NULL;
+
+ /* allocate a buffer for retrieving information from the pixel region */
+ data = g_new (guchar,
+ gimp_tile_height () * xres *
+ babl_format_get_bytes_per_pixel (format));
+
+ rowbuf = g_new (gchar, rowbufsize + 1);
+
+ rowinfo.output = output;
+ rowinfo.rowbuf = rowbuf;
+ rowinfo.xres = xres;
+ rowinfo.np = np;
+
+ d = NULL; /* only to please the compiler */
+
+ /* Write the body out */
+ for (ypos = 0; ypos < yres; ypos++)
+ {
+ if ((ypos % gimp_tile_height ()) == 0)
+ {
+ yend = ypos + gimp_tile_height ();
+ yend = MIN (yend, yres);
+
+ gegl_buffer_get (buffer,
+ GEGL_RECTANGLE (0, ypos, xres, yend - ypos), 1.0,
+ format, data,
+ GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+
+ d = data;
+ }
+
+ if (! saverow (&rowinfo, d, error))
+ {
+ g_free (rowbuf);
+ g_free (data);
+ goto out;
+ }
+
+ d += xres * (np ? np : 1) * rowinfo.bpc;
+
+ if (ypos % 32 == 0)
+ gimp_progress_update ((double) ypos / (double) yres);
+ }
+
+ g_free (rowbuf);
+ g_free (data);
+ }
+ else
+ {
+ /* allocate a buffer for retrieving information from the pixel
+ region */
+ gfloat *data = g_new (gfloat, xres * np);
+
+ rowinfo.output = output;
+ rowinfo.rowbuf = NULL;
+ rowinfo.xres = xres;
+ rowinfo.np = np;
+
+ /* Write the body out in reverse row order */
+ for (ypos = yres - 1; ypos >= 0; ypos--)
+ {
+ gegl_buffer_get (buffer,
+ GEGL_RECTANGLE (0, ypos, xres, 1), 1.0,
+ format, data,
+ GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE);
+
+ if (! pnmsaverow_float (&rowinfo, data, error))
+ {
+ g_free (data);
+ goto out;
+ }
+
+ if (ypos % 32 == 0)
+ gimp_progress_update ((double) (yres - ypos) / (double) yres);
+ }
+
+ g_free (data);
+ }
+
+ gimp_progress_update (1.0);
+ status = TRUE;
+
+ out:
+ if (! status)
+ {
+ GCancellable *cancellable = g_cancellable_new ();
+
+ g_cancellable_cancel (cancellable);
+ g_output_stream_close (output, cancellable, NULL);
+ g_object_unref (cancellable);
+ }
+
+ if (comment)
+ g_free (comment);
+ if (buffer)
+ g_object_unref (buffer);
+ if (output)
+ g_object_unref (output);
+
+ return status;
+}
+
+static gboolean
+save_dialog (void)
+{
+ GtkWidget *dialog;
+ GtkWidget *frame;
+ gboolean run;
+
+ dialog = gimp_export_dialog_new (_("PNM"), PLUG_IN_BINARY, PNM_SAVE_PROC);
+
+ /* file save type */
+ frame = gimp_int_radio_group_new (TRUE, _("Data formatting"),
+ G_CALLBACK (gimp_radio_button_update),
+ &psvals.raw, psvals.raw,
+
+ _("_Raw"), TRUE, NULL,
+ _("_ASCII"), FALSE, NULL,
+
+ NULL);
+ gtk_container_set_border_width (GTK_CONTAINER (frame), 6);
+ gtk_box_pack_start (GTK_BOX (gimp_export_dialog_get_content_area (dialog)),
+ frame, FALSE, 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;
+}
+
+
+/**************** FILE SCANNER UTILITIES **************/
+
+/* pnmscanner_create ---
+ * Creates a new scanner based on a file descriptor. The
+ * look ahead buffer is one character initially.
+ */
+static PNMScanner *
+pnmscanner_create (GInputStream *input)
+{
+ PNMScanner *s;
+ gsize bytes_read;
+
+ s = g_new (PNMScanner, 1);
+
+ s->input = input;
+ s->inbuf = NULL;
+ s->eof = FALSE;
+
+ if (! g_input_stream_read_all (input, &s->cur, 1,
+ &bytes_read, NULL, NULL) ||
+ bytes_read != 1)
+ {
+ s->eof = TRUE;
+ }
+
+ return s;
+}
+
+/* pnmscanner_destroy ---
+ * Destroys a scanner and its resources. Doesn't close the fd.
+ */
+static void
+pnmscanner_destroy (PNMScanner *s)
+{
+ if (s->inbuf)
+ g_free (s->inbuf);
+
+ g_free (s);
+}
+
+/* pnmscanner_createbuffer ---
+ * Creates a buffer so we can do buffered reads.
+ */
+static void
+pnmscanner_createbuffer (PNMScanner *s,
+ gint bufsize)
+{
+ gsize bytes_read;
+
+ s->inbuf = g_new (gchar, bufsize);
+ s->inbufsize = bufsize;
+ s->inbufpos = 0;
+ s->inbufvalidsize = 0;
+
+ g_input_stream_read_all (s->input, s->inbuf, bufsize,
+ &bytes_read, NULL, NULL);
+
+ s->inbufvalidsize = bytes_read;
+}
+
+/* pnmscanner_gettoken ---
+ * Gets the next token, eating any leading whitespace.
+ */
+static void
+pnmscanner_gettoken (PNMScanner *s,
+ gchar *buf,
+ gint bufsize)
+{
+ gint ctr = 0;
+
+ pnmscanner_eatwhitespace (s);
+
+ while (! s->eof &&
+ ! g_ascii_isspace (s->cur) &&
+ (s->cur != '#') &&
+ (ctr < bufsize))
+ {
+ buf[ctr++] = s->cur;
+ pnmscanner_getchar (s);
+ }
+
+ buf[ctr] = '\0';
+}
+
+/* pnmscanner_getsmalltoken ---
+ * Gets the next char, eating any leading whitespace.
+ */
+static void
+pnmscanner_getsmalltoken (PNMScanner *s,
+ gchar *buf)
+{
+ pnmscanner_eatwhitespace (s);
+
+ if (! s->eof && ! g_ascii_isspace (s->cur) && (s->cur != '#'))
+ {
+ *buf = s->cur;
+ pnmscanner_getchar (s);
+ }
+}
+
+/* pnmscanner_getchar ---
+ * Reads a character from the input stream
+ */
+static void
+pnmscanner_getchar (PNMScanner *s)
+{
+ if (s->inbuf)
+ {
+ s->cur = s->inbuf[s->inbufpos++];
+
+ if (s->inbufpos >= s->inbufvalidsize)
+ {
+ if (s->inbufpos > s->inbufvalidsize)
+ {
+ s->eof = 1;
+ }
+ else
+ {
+ gsize bytes_read;
+
+ g_input_stream_read_all (s->input, s->inbuf, s->inbufsize,
+ &bytes_read, NULL, NULL);
+
+ s->inbufvalidsize = bytes_read;
+ }
+
+ s->inbufpos = 0;
+ }
+ }
+ else
+ {
+ gsize bytes_read;
+
+ s->eof = FALSE;
+
+ if (! g_input_stream_read_all (s->input, &s->cur, 1,
+ &bytes_read, NULL, NULL) ||
+ bytes_read != 1)
+ {
+ s->eof = TRUE;
+ }
+ }
+}
+
+/* pnmscanner_eatwhitespace ---
+ * Eats up whitespace from the input and returns when done or eof.
+ * Also deals with comments.
+ */
+static void
+pnmscanner_eatwhitespace (PNMScanner *s)
+{
+ gint state = 0;
+
+ while (!(s->eof) && (state != -1))
+ {
+ switch (state)
+ {
+ case 0: /* in whitespace */
+ if (s->cur == '#')
+ {
+ state = 1; /* goto comment */
+ pnmscanner_getchar (s);
+ }
+ else if (! g_ascii_isspace (s->cur))
+ {
+ state = -1;
+ }
+ else
+ {
+ pnmscanner_getchar (s);
+ }
+ break;
+
+ case 1: /* in comment */
+ if (s->cur == '\n')
+ state = 0; /* goto whitespace */
+ pnmscanner_getchar (s);
+ break;
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-02 11:43:31 +0000