| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Gimp/plug-ins/common/ (Gimp Bildeditor Version 3.2.0©) Datei vom 14.2.2026 mit Größe 85 kB |
|
Quelle file-xwd.c Sprache: C |
|||||||||||||||||||||||||
|
/* GIMP - The GNU Image Manipulation Program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * XWD 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/>. * */ /* * XWD-input/output was written by Peter Kirchgessner (peter@kirchgessner.net) * Examples from mainly used UNIX-systems have been used for testing. * If a file does not work, please return a small (!!) compressed example. * Currently the following formats are supported: * pixmap_format | pixmap_depth | bits_per_pixel * --------------------------------------------- * 0 | 1 | 1 * 1 | 1,...,24 | 1 * 2 | 1 | 1 * 2 | 1,...,8 | 8 * 2 | 1,...,16 | 16 * 2 | 1,...,24 | 24 * 2 | 1,...,32 | 32 */ /* Event history: * PK = Peter Kirchgessner, ME = Mattias Engdegård * V 1.00, PK, xx-Aug-96: First try * V 1.01, PK, 03-Sep-96: Check for bitmap_bit_order * V 1.90, PK, 17-Mar-97: Upgrade to work with GIMP V0.99 * Use visual class 3 to write indexed image * Set gimp b/w-colormap if no xwdcolormap present * V 1.91, PK, 05-Apr-97: Return all arguments, even in case of an error * V 1.92, PK, 12-Oct-97: No progress bars for non-interactive mode * V 1.93, PK, 11-Apr-98: Fix problem with overwriting memory * V 1.94, ME, 27-Feb-00: Remove superfluous little-endian support (format is specified as big-endian). Trim magic header * V 1.95, PK, 02-Jul-01: Fix problem with 8 bit image */ #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-xwd-load" #define EXPORT_PROC "file-xwd-export" #define PLUG_IN_BINARY "file-xwd" #define PLUG_IN_ROLE "gimp-file-xwd" typedef guint32 L_CARD32; typedef gushort L_CARD16; typedef guchar L_CARD8; typedef struct { L_CARD32 l_header_size; /* Header size */ L_CARD32 l_file_version; /* File version (7) */ L_CARD32 l_pixmap_format; /* Image type */ L_CARD32 l_pixmap_depth; /* Number of planes */ L_CARD32 l_pixmap_width; /* Image width */ L_CARD32 l_pixmap_height; /* Image height */ L_CARD32 l_xoffset; /* x-offset (0 ?) */ L_CARD32 l_byte_order; /* Byte ordering */ L_CARD32 l_bitmap_unit; L_CARD32 l_bitmap_bit_order; /* Bit order */ L_CARD32 l_bitmap_pad; L_CARD32 l_bits_per_pixel; /* Number of bits per pixel */ L_CARD32 l_bytes_per_line; /* Number of bytes per scanline */ L_CARD32 l_visual_class; /* Visual class */ L_CARD32 l_red_mask; /* Red mask */ L_CARD32 l_green_mask; /* Green mask */ L_CARD32 l_blue_mask; /* Blue mask */ L_CARD32 l_bits_per_rgb; /* Number of bits per RGB-part */ L_CARD32 l_colormap_entries; /* Number of colors in color table (?) */ L_CARD32 l_ncolors; /* Number of xwdcolor structures */ L_CARD32 l_window_width; /* Window width */ L_CARD32 l_window_height; /* Window height */ L_CARD32 l_window_x; /* Window position x */ L_CARD32 l_window_y; /* Window position y */ L_CARD32 l_window_bdrwidth;/* Window border width */ } L_XWDFILEHEADER; typedef struct { L_CARD32 l_pixel; /* Color index */ L_CARD16 l_red, l_green, l_blue; /* RGB-values */ L_CARD8 l_flags, l_pad; } L_XWDCOLOR; /* Some structures for mapping up to 32bit-pixel */ /* values which are kept in the XWD-Colormap */ #define MAPPERBITS 12 #define MAPPERMASK ((1 << MAPPERBITS)-1) typedef struct { L_CARD32 pixel_val; guchar red; guchar green; guchar blue; } PMAP; typedef struct { gint npixel; /* Number of pixel values in map */ guchar pixel_in_map[1 << MAPPERBITS]; PMAP pmap[256]; } PIXEL_MAP; #define XWDHDR_PAD 0 /* Total number of padding bytes for XWD header */ #define XWDCOL_PAD 0 /* Total number of padding bytes for each XWD color */ typedef struct _Xwd Xwd; typedef struct _XwdClass XwdClass; struct _Xwd { GimpPlugIn parent_instance; }; struct _XwdClass { GimpPlugInClass parent_class; }; #define XWD_TYPE (xwd_get_type ()) #define XWD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), XWD_TYPE, Xwd)) GType xwd_get_type (void) G_GNUC_CONST; static GList * xwd_query_procedures (GimpPlugIn *plug_in); static GimpProcedure * xwd_create_procedure (GimpPlugIn *plug_in, const gchar *name); static GimpValueArray * xwd_load (GimpProcedure *procedure, GimpRunMode run_mode, GFile *file, GimpMetadata *metadata, GimpMetadataLoadFlags *flags, GimpProcedureConfig *config, gpointer run_data); static GimpValueArray * xwd_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data); static GimpImage * load_image (GFile *file, GError **error); static gboolean export_image (GFile *file, GimpImage *image, GimpDrawable *drawable, GError **error); static GimpImage * create_new_image (GFile *file, guint width, guint height, GimpImageBaseType type, GimpImageType gdtype, GimpLayer **layer, GeglBuffer **buffer); static int set_pixelmap (gint ncols, L_XWDCOLOR *xwdcol, PIXEL_MAP *pixelmap); static gboolean get_pixelmap (L_CARD32 pixelval, PIXEL_MAP *pixelmap, guchar *red, guchar *green, guchar *glue); static void set_bw_color_table (GimpImage *image); static void set_color_table (GimpImage *image, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap); static GimpImage * load_xwd_f2_d1_b1 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error); static GimpImage * load_xwd_f2_d8_b8 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error); static GimpImage * load_xwd_f2_d16_b16 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error); static GimpImage * load_xwd_f2_d24_b32 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error); static GimpImage * load_xwd_f2_d32_b32 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error); static GimpImage * load_xwd_f1_d24_b1 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error); static L_CARD32 read_card32 (FILE *ifp, gint *err); static L_CARD16 read_card16 (FILE *ifp, gint *err); static L_CARD8 read_card8 (FILE *ifp, gint *err); static gboolean write_card32 (GOutputStream *output, L_CARD32 c, GError **error); static gboolean write_card16 (GOutputStream *output, L_CARD32 c, GError **error); static gboolean write_card8 (GOutputStream *output, L_CARD32 c, GError **error); static void read_xwd_header (FILE *ifp, L_XWDFILEHEADER *xwdhdr); static gboolean write_xwd_header (GOutputStream *output, L_XWDFILEHEADER *xwdhdr, GError **error); static void read_xwd_cols (FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error); static gboolean write_xwd_cols (GOutputStream *output, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *colormap, GError **error); static gint save_index (GOutputStream *output, GimpImage *image, GimpDrawable *drawable, gboolean gray, GError **error); static gint save_rgb (GOutputStream *output, GimpImage *image, GimpDrawable *drawable, GError **error); G_DEFINE_TYPE (Xwd, xwd, GIMP_TYPE_PLUG_IN) GIMP_MAIN (XWD_TYPE) DEFINE_STD_SET_I18N static void xwd_class_init (XwdClass *klass) { GimpPlugInClass *plug_in_class = GIMP_PLUG_IN_CLASS (klass); plug_in_class->query_procedures = xwd_query_procedures; plug_in_class->create_procedure = xwd_create_procedure; plug_in_class->set_i18n = STD_SET_I18N; } static void xwd_init (Xwd *xwd) { } static GList * xwd_query_procedures (GimpPlugIn *plug_in) { GList *list = NULL; list = g_list_append (list, g_strdup (LOAD_PROC)); list = g_list_append (list, g_strdup (EXPORT_PROC)); return list; } static GimpProcedure * xwd_create_procedure (GimpPlugIn *plug_in, const gchar *name) { GimpProcedure *procedure = NULL; if (! strcmp (name, LOAD_PROC)) { procedure = gimp_load_procedure_new (plug_in, name, GIMP_PDB_PROC_TYPE_PLUGIN, xwd_load, NULL, NULL); gimp_procedure_set_menu_label (procedure, _("X window dump")); gimp_procedure_set_documentation (procedure, "Loads files in the XWD (X Window Dump) " "format", "Loads files in the XWD (X Window Dump) " "format. XWD image files are produced " "by the program xwd. Xwd is an X Window " "System window dumping utility.", name); gimp_procedure_set_attribution (procedure, "Peter Kirchgessner", "Peter Kirchgessner", "1996"); gimp_file_procedure_set_mime_types (GIMP_FILE_PROCEDURE (procedure), "image/x-xwindowdump"); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "xwd"); gimp_file_procedure_set_magics (GIMP_FILE_PROCEDURE (procedure), "4,long,0x00000007"); } else if (! strcmp (name, EXPORT_PROC)) { procedure = gimp_export_procedure_new (plug_in, name, GIMP_PDB_PROC_TYPE_PLUGIN, FALSE, xwd_export, NULL, NULL); gimp_procedure_set_image_types (procedure, "RGB, GRAY, INDEXED"); gimp_procedure_set_menu_label (procedure, _("X window dump")); gimp_procedure_set_documentation (procedure, "Exports files in the XWD (X Window " "Dump) format", "XWD exporting handles all image " "types except those with alpha channels.", name); gimp_procedure_set_attribution (procedure, "Peter Kirchgessner", "Peter Kirchgessner", "1996"); gimp_file_procedure_set_handles_remote (GIMP_FILE_PROCEDURE (procedure), TRUE); gimp_file_procedure_set_mime_types (GIMP_FILE_PROCEDURE (procedure), "image/x-xwindowdump"); gimp_file_procedure_set_extensions (GIMP_FILE_PROCEDURE (procedure), "xwd"); gimp_export_procedure_set_capabilities (GIMP_EXPORT_PROCEDURE (procedure), GIMP_EXPORT_CAN_HANDLE_RGB | GIMP_EXPORT_CAN_HANDLE_GRAY | GIMP_EXPORT_CAN_HANDLE_INDEXED, NULL, NULL, NULL); } return procedure; } static GimpValueArray * xwd_load (GimpProcedure *procedure, GimpRunMode run_mode, GFile *file, GimpMetadata *metadata, GimpMetadataLoadFlags *flags, GimpProcedureConfig *config, gpointer run_data) { GimpValueArray *return_vals; GimpImage *image; GError *error = NULL; gegl_init (NULL, NULL); image = load_image (file, &error); if (! image) return gimp_procedure_new_return_values (procedure, GIMP_PDB_EXECUTION_ERROR, error); return_vals = gimp_procedure_new_return_values (procedure, GIMP_PDB_SUCCESS, NULL); GIMP_VALUES_SET_IMAGE (return_vals, 1, image); return return_vals; } static GimpValueArray * xwd_export (GimpProcedure *procedure, GimpRunMode run_mode, GimpImage *image, GFile *file, GimpExportOptions *options, GimpMetadata *metadata, GimpProcedureConfig *config, gpointer run_data) { GimpPDBStatusType status = GIMP_PDB_SUCCESS; GimpExportReturn export = GIMP_EXPORT_IGNORE; GList *drawables; GError *error = NULL; gegl_init (NULL, NULL); export = gimp_export_options_get_image (options, &image); drawables = gimp_image_list_layers (image); if (! export_image (file, image, drawables->data, &error)) status = GIMP_PDB_EXECUTION_ERROR; if (export == GIMP_EXPORT_EXPORT) gimp_image_delete (image); g_list_free (drawables); return gimp_procedure_new_return_values (procedure, status, error); } static GimpImage * load_image (GFile *file, GError **error) { FILE *ifp; gint depth, bpp; GimpImage *image = NULL; L_XWDFILEHEADER xwdhdr; L_XWDCOLOR *xwdcolmap = NULL; gimp_progress_init_printf (_("Opening '%s'"), gimp_file_get_utf8_name (file)); ifp = g_fopen (g_file_peek_path (file), "rb"); if (! ifp) { g_set_error (error, G_FILE_ERROR, g_file_error_from_errno (errno), _("Could not open '%s' for reading: %s"), gimp_file_get_utf8_name (file), g_strerror (errno)); goto out; } read_xwd_header (ifp, &xwdhdr); #ifdef XWD_DEBUG /* Write info about header */ g_printerr ("XWD header:\n\t" "Header size: %u, filer version: %u, image type: %u\n\t" "Depth: %u, Width: %u, Height: %u\n\t" "X-offset: %u, byte order: %u, bitmap unit: %u, bit order: %u\n\t" "bitmap pad: %u, bits per pixel: %u, bytes per line: %u\n\t" "visual class: %u, Masks: red %x, green %x, blue %x, bits per rgb: %u\n\t" "Number of colors: %u, color map entries: %u\n\t" "Window width: %u, height: %u, x: %u, y: %u, border width: %u" "\n", xwdhdr.l_header_size, xwdhdr.l_file_version, xwdhdr.l_pixmap_format, xwdhdr.l_pixmap_depth, xwdhdr.l_pixmap_width, xwdhdr.l_pixmap_height, xwdhdr.l_xoffset, xwdhdr.l_byte_order, xwdhdr.l_bitmap_unit, xwdhdr.l_bitmap_bit_order, xwdhdr.l_bitmap_pad, xwdhdr.l_bits_per_pixel, xwdhdr.l_bytes_per_line, xwdhdr.l_visual_class, xwdhdr.l_red_mask, xwdhdr.l_green_mask, xwdhdr.l_blue_mask, xwdhdr.l_bits_per_rgb, xwdhdr.l_ncolors, xwdhdr.l_colormap_entries, xwdhdr.l_window_width, xwdhdr.l_window_height, xwdhdr.l_window_x, xwdhdr.l_window_y, xwdhdr.l_window_bdrwidth); #endif if (xwdhdr.l_file_version != 7) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("Could not read XWD header from '%s'"), gimp_file_get_utf8_name (file)); goto out; } #ifdef XWD_COL_WAIT_DEBUG { int k = 1; while (k) k = k; } #endif /* Position to start of XWDColor structures */ if (fseek (ifp, (long)xwdhdr.l_header_size, SEEK_SET) != 0) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("'%s':\nSeek error"), gimp_file_get_utf8_name (file)); goto out; } /* Guard against insanely huge color maps -- gimp_palette_set_colormap() only * accepts colormaps with 0..256 colors anyway. */ if (xwdhdr.l_colormap_entries > 256) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("'%s':\nIllegal number of colormap entries: %u"), gimp_file_get_utf8_name (file), xwdhdr.l_colormap_entries); goto out; } if (xwdhdr.l_colormap_entries > 0) { if (xwdhdr.l_colormap_entries < xwdhdr.l_ncolors) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("'%s':\nNumber of colormap entries < number of colors"), gimp_file_get_utf8_name (file)); goto out; } xwdcolmap = g_new (L_XWDCOLOR, xwdhdr.l_colormap_entries); read_xwd_cols (ifp, &xwdhdr, xwdcolmap, error); if (error && *error) goto out; #ifdef XWD_COL_DEBUG { int j; g_printf ("File %s\n", g_file_peek_path (file)); for (j = 0; j < xwdhdr.l_colormap_entries; j++) g_printf ("Entry 0x%08lx: 0x%04lx, 0x%04lx, 0x%04lx, %d\n", (long)xwdcolmap[j].l_pixel,(long)xwdcolmap[j].l_red, (long)xwdcolmap[j].l_green,(long)xwdcolmap[j].l_blue, (int)xwdcolmap[j].l_flags); } #endif if (xwdhdr.l_file_version != 7) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("Can't read color entries")); goto out; } } if (xwdhdr.l_pixmap_width <= 0) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("'%s':\nNo image width specified"), gimp_file_get_utf8_name (file)); goto out; } if (xwdhdr.l_pixmap_width > GIMP_MAX_IMAGE_SIZE || xwdhdr.l_bytes_per_line > GIMP_MAX_IMAGE_SIZE * 3) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("'%s':\nImage width is larger than GIMP can handle"), gimp_file_get_utf8_name (file)); goto out; } if (xwdhdr.l_pixmap_height <= 0) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("'%s':\nNo image height specified"), gimp_file_get_utf8_name (file)); goto out; } if (xwdhdr.l_pixmap_height > GIMP_MAX_IMAGE_SIZE) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("'%s':\nImage height is larger than GIMP can handle"), gimp_file_get_utf8_name (file)); goto out; } depth = xwdhdr.l_pixmap_depth; bpp = xwdhdr.l_bits_per_pixel; switch (xwdhdr.l_pixmap_format) { case 0: /* Single plane bitmap */ if ((depth == 1) && (bpp == 1)) { /* Can be performed by format 2 loader */ image = load_xwd_f2_d1_b1 (file, ifp, &xwdhdr, xwdcolmap, error); } break; case 1: /* Single plane pixmap */ if ((depth <= 24) && (bpp == 1)) { image = load_xwd_f1_d24_b1 (file, ifp, &xwdhdr, xwdcolmap, error); } break; case 2: /* Multiplane pixmaps */ if ((depth == 1) && (bpp == 1)) { image = load_xwd_f2_d1_b1 (file, ifp, &xwdhdr, xwdcolmap, error); } else if ((depth <= 8) && (bpp == 8)) { image = load_xwd_f2_d8_b8 (file, ifp, &xwdhdr, xwdcolmap, error); } else if ((depth <= 16) && (bpp == 16)) { if (xwdcolmap) image = load_xwd_f2_d16_b16 (file, ifp, &xwdhdr, xwdcolmap, error); } else if ((depth <= 24) && ((bpp == 24) || (bpp == 32))) { image = load_xwd_f2_d24_b32 (file, ifp, &xwdhdr, xwdcolmap, error); } else if ((depth <= 32) && (bpp == 32)) { image = load_xwd_f2_d32_b32 (file, ifp, &xwdhdr, xwdcolmap, error); } break; } gimp_progress_update (1.0); if (! image && ! (error && *error)) g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("XWD-file %s has format %d, depth %d and bits per pixel %d. " "Currently this is not supported."), gimp_file_get_utf8_name (file), (gint) xwdhdr.l_pixmap_format, depth, bpp); out: if (ifp) fclose (ifp); if (xwdcolmap) g_free (xwdcolmap); return image; } static gboolean export_image (GFile *file, GimpImage *image, GimpDrawable *drawable, GError **error) { GOutputStream *output; GimpImageType drawable_type; gboolean success; drawable_type = gimp_drawable_type (drawable); /* Make sure we're not exporting an image with an alpha channel */ if (gimp_drawable_has_alpha (drawable)) { g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("Cannot export 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 (_("Cannot operate on unknown image types.")); return FALSE; break; } gimp_progress_init_printf (_("Exporting '%s'"), gimp_file_get_utf8_name (file)); output = G_OUTPUT_STREAM (g_file_replace (file, NULL, FALSE, 0, NULL, error)); if (! output) { g_prefix_error (error, _("Could not open '%s' for writing: "), gimp_file_get_utf8_name (file)); return FALSE; } switch (drawable_type) { case GIMP_INDEXED_IMAGE: success = save_index (output, image, drawable, FALSE, error); break; case GIMP_GRAY_IMAGE: success = save_index (output, image, drawable, TRUE, error); break; case GIMP_RGB_IMAGE: success = save_rgb (output, image, drawable, error); break; default: success = FALSE; break; } if (success && ! g_output_stream_close (output, NULL, error)) { g_prefix_error (error, _("Error exporting '%s': "), gimp_file_get_utf8_name (file)); success = FALSE; } else if (! success) { GCancellable *cancellable; cancellable = g_cancellable_new (); g_cancellable_cancel (cancellable); g_output_stream_close (output, cancellable, NULL); g_object_unref (cancellable); } g_object_unref (output); gimp_progress_update (1.0); return success; } static L_CARD32 read_card32 (FILE *ifp, int *err) { L_CARD32 c; c = (((L_CARD32) (getc (ifp))) << 24); c |= (((L_CARD32) (getc (ifp))) << 16); c |= (((L_CARD32) (getc (ifp))) << 8); c |= ((L_CARD32) (*err = getc (ifp))); *err = (*err < 0); return c; } static L_CARD16 read_card16 (FILE *ifp, int *err) { L_CARD16 c; c = (((L_CARD16) (getc (ifp))) << 8); c |= ((L_CARD16) (*err = getc (ifp))); *err = (*err < 0); return c; } static L_CARD8 read_card8 (FILE *ifp, int *err) { L_CARD8 c; c = ((L_CARD8) (*err = getc (ifp))); *err = (*err < 0); return c; } static gboolean write_card32 (GOutputStream *output, L_CARD32 c, GError **error) { guchar buffer[4]; buffer[0] = (c >> 24) & 0xff; buffer[1] = (c >> 16) & 0xff; buffer[2] = (c >> 8) & 0xff; buffer[3] = (c) & 0xff; return g_output_stream_write_all (output, buffer, 4, NULL, NULL, error); } static gboolean write_card16 (GOutputStream *output, L_CARD32 c, GError **error) { guchar buffer[2]; buffer[0] = (c >> 8) & 0xff; buffer[1] = (c) & 0xff; return g_output_stream_write_all (output, buffer, 2, NULL, NULL, error); } static gboolean write_card8 (GOutputStream *output, L_CARD32 c, GError **error) { guchar buffer[1]; buffer[0] = c & 0xff; return g_output_stream_write_all (output, buffer, 1, NULL, NULL, error); } static void read_xwd_header (FILE *ifp, L_XWDFILEHEADER *xwdhdr) { gint j, err; L_CARD32 *cp; cp = (L_CARD32 *) xwdhdr; /* Read in all 32-bit values of the header and check for byte order */ for (j = 0; j < sizeof (L_XWDFILEHEADER) / sizeof(xwdhdr->l_file_version); j++) { *(cp++) = read_card32 (ifp, &err); if (err) break; } if (err) xwdhdr->l_file_version = 0; /* Not a valid XWD-file */ } /* Write out an XWD-fileheader. The header size is calculated here */ static gboolean write_xwd_header (GOutputStream *output, L_XWDFILEHEADER *xwdhdr, GError **error) { gint j, hdrpad, hdr_entries; L_CARD32 *cp; hdrpad = XWDHDR_PAD; hdr_entries = sizeof (L_XWDFILEHEADER) / sizeof(xwdhdr->l_file_version); xwdhdr->l_header_size = hdr_entries * 4 + hdrpad; cp = (L_CARD32 *) xwdhdr; /* Write out all 32-bit values of the header and check for byte order */ for (j = 0; j < sizeof (L_XWDFILEHEADER) / sizeof(xwdhdr->l_file_version); j++) { if (! write_card32 (output, *(cp++), error)) return FALSE; } /* Add padding bytes after XWD header */ for (j = 0; j < hdrpad; j++) if (! write_card8 (output, (L_CARD32) 0, error)) return FALSE; return TRUE; } static void read_xwd_cols (FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *colormap, GError **error) { gint j, err = 0; gint flag_is_bad, index_is_bad; gint indexed = (xwdhdr->l_pixmap_depth <= 8); glong colmappos = ftell (ifp); /* Read in XWD-Color structures (the usual case) */ flag_is_bad = index_is_bad = 0; for (j = 0; j < xwdhdr->l_ncolors; j++) { colormap[j].l_pixel = read_card32 (ifp, &err); colormap[j].l_red = read_card16 (ifp, &err); colormap[j].l_green = read_card16 (ifp, &err); colormap[j].l_blue = read_card16 (ifp, &err); colormap[j].l_flags = read_card8 (ifp, &err); colormap[j].l_pad = read_card8 (ifp, &err); if (indexed && (colormap[j].l_pixel > 255)) index_is_bad++; if (err) break; } if (err) /* Not a valid XWD-file ? */ xwdhdr->l_file_version = 0; if (err || ((flag_is_bad == 0) && (index_is_bad == 0))) return; /* Read in XWD-Color structures (with 4 bytes inserted infront of RGB) */ if (fseek (ifp, colmappos, SEEK_SET) != 0) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("Seek error")); return; } flag_is_bad = index_is_bad = 0; for (j = 0; j < xwdhdr->l_ncolors; j++) { colormap[j].l_pixel = read_card32 (ifp, &err); read_card32 (ifp, &err); /* Empty bytes on Alpha OSF */ colormap[j].l_red = read_card16 (ifp, &err); colormap[j].l_green = read_card16 (ifp, &err); colormap[j].l_blue = read_card16 (ifp, &err); colormap[j].l_flags = read_card8 (ifp, &err); colormap[j].l_pad = read_card8 (ifp, &err); if (indexed && (colormap[j].l_pixel > 255)) index_is_bad++; if (err) break; } if (err) /* Not a valid XWD-file ? */ xwdhdr->l_file_version = 0; if (err || ((flag_is_bad == 0) && (index_is_bad == 0))) return; /* Read in XWD-Color structures (with 2 bytes inserted infront of RGB) */ if (fseek (ifp, colmappos, SEEK_SET) !=0) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("Seek error")); return; } flag_is_bad = index_is_bad = 0; for (j = 0; j < xwdhdr->l_ncolors; j++) { colormap[j].l_pixel = read_card32 (ifp, &err); read_card16 (ifp, &err); /* Empty bytes (from where ?) */ colormap[j].l_red = read_card16 (ifp, &err); colormap[j].l_green = read_card16 (ifp, &err); colormap[j].l_blue = read_card16 (ifp, &err); colormap[j].l_flags = read_card8 (ifp, &err); colormap[j].l_pad = read_card8 (ifp, &err); /* if ((colormap[j].l_flags == 0) || (colormap[j].l_flags > 7)) flag_is_bad++; */ if (indexed && (colormap[j].l_pixel > 255)) index_is_bad++; if (err) break; } if (err) /* Not a valid XWD-file ? */ xwdhdr->l_file_version = 0; if (err || ((flag_is_bad == 0) && (index_is_bad == 0))) return; /* Read in XWD-Color structures (every value is 8 bytes from a CRAY) */ if (fseek (ifp, colmappos, SEEK_SET) != 0) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("Seek error")); return; } flag_is_bad = index_is_bad = 0; for (j = 0; j < xwdhdr->l_ncolors; j++) { read_card32 (ifp, &err); colormap[j].l_pixel = read_card32 (ifp, &err); read_card32 (ifp, &err); colormap[j].l_red = read_card32 (ifp, &err); read_card32 (ifp, &err); colormap[j].l_green = read_card32 (ifp, &err); read_card32 (ifp, &err); colormap[j].l_blue = read_card32 (ifp, &err); /* The flag byte is kept in the first byte */ colormap[j].l_flags = read_card8 (ifp, &err); colormap[j].l_pad = read_card8 (ifp, &err); read_card16 (ifp, &err); read_card32 (ifp, &err); if (indexed && (colormap[j].l_pixel > 255)) index_is_bad++; if (err) break; } if (flag_is_bad || index_is_bad) { g_printf ("xwd: Warning. Error in XWD-color-structure ("); if (flag_is_bad) g_printf ("flag"); if (index_is_bad) g_printf ("index"); g_printf (")\n"); } if (err) xwdhdr->l_file_version = 0; /* Not a valid XWD-file */ } static gboolean write_xwd_cols (GOutputStream *output, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *colormap, GError **error) { gint j; for (j = 0; j < xwdhdr->l_colormap_entries; j++) { #ifdef CRAY if (! (write_card32 (output, (L_CARD32)0, error) && write_card32 (output, colormap[j].l_pixel, error) && write_card32 (output, (L_CARD32)0, error) && write_card32 (output, (L_CARD32)colormap[j].l_red, error) && write_card32 (output, (L_CARD32)0, error) && write_card32 (output, (L_CARD32)colormap[j].l_green, error) && write_card32 (output, (L_CARD32)0, error) && write_card32 (output, (L_CARD32)colormap[j].l_blue, error) && write_card8 (output, (L_CARD32)colormap[j].l_flags, error) && write_card8 (output, (L_CARD32)colormap[j].l_pad, error) && write_card16 (output, (L_CARD32)0, error) && write_card32 (output, (L_CARD32)0, error))) { return FALSE; } #else #ifdef __alpha if (! (write_card32 (output, colormap[j].l_pixel, error) && write_card32 (output, (L_CARD32)0, error) && write_card16 (output, (L_CARD32)colormap[j].l_red, error) && write_card16 (output, (L_CARD32)colormap[j].l_green, error) && write_card16 (output, (L_CARD32)colormap[j].l_blue, error) && write_card8 (output, (L_CARD32)colormap[j].l_flags, error) && write_card8 (output, (L_CARD32)colormap[j].l_pad, error))) { return FALSE; } #else if (! (write_card32 (output, colormap[j].l_pixel, error) && write_card16 (output, (L_CARD32)colormap[j].l_red, error) && write_card16 (output, (L_CARD32)colormap[j].l_green, error) && write_card16 (output, (L_CARD32)colormap[j].l_blue, error) && write_card8 (output, (L_CARD32)colormap[j].l_flags, error) && write_card8 (output, (L_CARD32)colormap[j].l_pad, error))) { return FALSE; } #endif #endif } return TRUE; } /* Create a map for mapping up to 32 bit pixelvalues to RGB. * Returns number of colors kept in the map (up to 256) */ static gint set_pixelmap (int ncols, L_XWDCOLOR *xwdcol, PIXEL_MAP *pixelmap) { gint i, j, k, maxcols; L_CARD32 pixel_val; memset ((gchar *) pixelmap, 0, sizeof (PIXEL_MAP)); maxcols = 0; for (j = 0; j < ncols; j++) /* For each entry of the XWD colormap */ { pixel_val = xwdcol[j].l_pixel; for (k = 0; k < maxcols; k++) /* Where to insert in list ? */ { if (pixel_val <= pixelmap->pmap[k].pixel_val) break; } if ((k < maxcols) && (pixel_val == pixelmap->pmap[k].pixel_val)) break; /* It was already in list */ if (k >= 256) break; if (k < maxcols) /* Must move entries to the back ? */ { for (i = maxcols-1; i >= k; i--) memcpy ((char *)&(pixelmap->pmap[i+1]),(char *)&(pixelmap->pmap[i]), sizeof (PMAP)); } pixelmap->pmap[k].pixel_val = pixel_val; pixelmap->pmap[k].red = xwdcol[j].l_red >> 8; pixelmap->pmap[k].green = xwdcol[j].l_green >> 8; pixelmap->pmap[k].blue = xwdcol[j].l_blue >> 8; pixelmap->pixel_in_map[pixel_val & MAPPERMASK] = 1; maxcols++; } pixelmap->npixel = maxcols; #ifdef XWD_COL_DEBUG g_printf ("Colors in pixelmap: %d\n",pixelmap->npixel); for (j=0; j<pixelmap->npixel; j++) g_printf ("Pixelvalue 0x%08lx, 0x%02x 0x%02x 0x%02x\n", pixelmap->pmap[j].pixel_val, pixelmap->pmap[j].red,pixelmap->pmap[j].green, pixelmap->pmap[j].blue); for (j=0; j<=MAPPERMASK; j++) g_printf ("0x%08lx: %d\n",(long)j,pixelmap->pixel_in_map[j]); #endif return pixelmap->npixel; } /* Search a pixel value in the pixel map. Returns FALSE if the * pixelval was not found in map. Returns TRUE if found. */ static gboolean get_pixelmap (L_CARD32 pixelval, PIXEL_MAP *pixelmap, guchar *red, guchar *green, guchar *blue) { register PMAP *low, *high, *middle; if (pixelmap->npixel == 0) return FALSE; if (!(pixelmap->pixel_in_map[pixelval & MAPPERMASK])) return FALSE; low = &(pixelmap->pmap[0]); high = &(pixelmap->pmap[pixelmap->npixel-1]); /* Do a binary search on the array */ while (low < high) { middle = low + ((high - low)/2); if (pixelval <= middle->pixel_val) high = middle; else low = middle+1; } if (pixelval == low->pixel_val) { *red = low->red; *green = low->green; *blue = low->blue; return TRUE; } return FALSE; } static void set_bw_color_table (GimpImage *image) { static guchar BWColorMap[2*3] = { 255, 255, 255, 0, 0, 0 }; GimpPalette *palette = gimp_image_get_palette (image); #ifdef XWD_COL_DEBUG g_printf ("Set GIMP b/w-colortable:\n"); #endif gimp_palette_set_colormap (palette, babl_format ("R'G'B' u8"), BWColorMap, 2 * 3); } /* Initialize an 8-bit colortable from the mask-values of the XWD-header */ static void init_color_table256 (L_XWDFILEHEADER *xwdhdr, guchar *ColorMap) { gint i, j, k, cuind; gint redshift, greenshift, blueshift; gint maxred, maxgreen, maxblue; /* Assume: the bit masks for red/green/blue are grouped together * Example: redmask = 0xe0, greenmask = 0x1c, bluemask = 0x03 * We need to know where to place the RGB-values (shifting) * and the maximum value for each component. */ redshift = greenshift = blueshift = 0; if ((maxred = xwdhdr->l_red_mask) == 0) return; /* Shift the redmask to the rightmost bit position to get * maximum value for red. */ while ((maxred & 1) == 0) { redshift++; maxred >>= 1; } if ((maxgreen = xwdhdr->l_green_mask) == 0) return; while ((maxgreen & 1) == 0) { greenshift++; maxgreen >>= 1; } if ((maxblue = xwdhdr->l_blue_mask) == 0) return; while ((maxblue & 1) == 0) { blueshift++; maxblue >>= 1; } memset ((gchar *) ColorMap, 0, 256 * 3); for (i = 0; i <= maxred; i++) for (j = 0; j <= maxgreen; j++) for (k = 0; k <= maxblue; k++) { cuind = (i << redshift) | (j << greenshift) | (k << blueshift); if (cuind < 256) { ColorMap[cuind*3] = (i * 255)/maxred; ColorMap[cuind*3+1] = (j * 255)/maxgreen; ColorMap[cuind*3+2] = (k * 255)/maxblue; } } } static void set_color_table (GimpImage *image, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap) { gint ncols, i, j; guchar ColorMap[256 * 3]; ncols = xwdhdr->l_colormap_entries; if (xwdhdr->l_ncolors < ncols) ncols = xwdhdr->l_ncolors; if (ncols <= 0) return; if (ncols > 256) ncols = 256; /* Initialize color table for all 256 entries from mask-values */ init_color_table256 (xwdhdr, ColorMap); for (j = 0; j < ncols; j++) { i = xwdcolmap[j].l_pixel; if ((i >= 0) && (i < 256)) { ColorMap[i*3] = (xwdcolmap[j].l_red) >> 8; ColorMap[i*3+1] = (xwdcolmap[j].l_green) >> 8; ColorMap[i*3+2] = (xwdcolmap[j].l_blue) >> 8; } } #ifdef XWD_COL_DEBUG g_printf ("Set GIMP colortable:\n"); for (j = 0; j < 256; j++) g_printf ("%3d: 0x%02x 0x%02x 0x%02x\n", j, ColorMap[j*3], ColorMap[j*3+1], ColorMap[j*3+2]); #endif gimp_palette_set_colormap (gimp_image_get_palette (image), babl_format ("R'G'B' u8"), } /* Create an image. Sets layer, drawable and rgn. Returns image */ static GimpImage * create_new_image (GFile *file, guint width, guint height, GimpImageBaseType type, GimpImageType gdtype, GimpLayer **layer, GeglBuffer **buffer) { GimpImage *image; image = gimp_image_new (width, height, type); *layer = gimp_layer_new (image, "Background", width, height, gdtype, 100, gimp_image_get_default_new_layer_mode (image)); gimp_image_insert_layer (image, *layer, NULL, 0); *buffer = gimp_drawable_get_buffer (GIMP_DRAWABLE (*layer)); return image; } /* Load XWD with pixmap_format 2, pixmap_depth 1, bits_per_pixel 1 */ static GimpImage * load_xwd_f2_d1_b1 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error) { register int pix8; register guchar *dest, *src; guchar c1, c2, c3, c4; gint width, height, scan_lines, tile_height; gint i, j, ncols; gchar *temp; guchar bit2byte[256 * 8]; guchar *data, *scanline; gint err = 0; GimpImage *image; GimpLayer *layer; GeglBuffer *buffer; #ifdef XWD_DEBUG g_printf ("load_xwd_f2_d1_b1 (%s)\n", gimp_file_get_utf8_name (file)); #endif width = xwdhdr->l_pixmap_width; height = xwdhdr->l_pixmap_height; image = create_new_image (file, width, height, GIMP_INDEXED, GIMP_INDEXED_IMAGE, &layer, &buffer); tile_height = gimp_tile_height (); data = g_malloc (tile_height * width); scanline = g_new (guchar, xwdhdr->l_bytes_per_line + 8); ncols = xwdhdr->l_colormap_entries; if (xwdhdr->l_ncolors < ncols) ncols = xwdhdr->l_ncolors; if (ncols < 2) set_bw_color_table (image); else set_color_table (image, xwdhdr, xwdcolmap); temp = (gchar *) bit2byte; /* Get an array for mapping 8 bits in a byte to 8 bytes */ if (!xwdhdr->l_bitmap_bit_order) { for (j = 0; j < 256; j++) for (i = 0; i < 8; i++) *(temp++) = ((j & (1 << i)) != 0); } else { for (j = 0; j < 256; j++) for (i = 7; i >= 0; i--) *(temp++) = ((j & (1 << i)) != 0); } dest = data; scan_lines = 0; for (i = 0; i < height; i++) { if (fread (scanline, xwdhdr->l_bytes_per_line, 1, ifp) != 1) { err = 1; break; } /* Need to check byte order ? */ if (xwdhdr->l_bitmap_bit_order != xwdhdr->l_byte_order) { src = scanline; switch (xwdhdr->l_bitmap_unit) { case 16: j = xwdhdr->l_bytes_per_line; while (j > 0) { c1 = src[0]; c2 = src[1]; *(src++) = c2; *(src++) = c1; j -= 2; } break; case 32: j = xwdhdr->l_bytes_per_line; while (j > 0) { c1 = src[0]; c2 = src[1]; c3 = src[2]; c4 = src[3]; *(src++) = c4; *(src++) = c3; *(src++) = c2; *(src++) = c1; j -= 4; } break; } } src = scanline; j = width; while (j >= 8) { pix8 = *(src++); memcpy (dest, bit2byte + pix8*8, 8); dest += 8; j -= 8; } if (j > 0) { pix8 = *(src++); memcpy (dest, bit2byte + pix8*8, j); dest += j; } 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); g_free (scanline); g_object_unref (buffer); if (err) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("EOF encountered on reading")); return NULL; } return image; } /* Load XWD with pixmap_format 2, pixmap_depth 8, bits_per_pixel 8 */ static GimpImage * load_xwd_f2_d8_b8 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error) { gint width, height, linepad, tile_height, scan_lines; gint i, j, ncols; gint grayscale; guchar *dest, *data; gint err = 0; GimpImage *image; GimpLayer *layer; GeglBuffer *buffer; #ifdef XWD_DEBUG g_printf ("load_xwd_f2_d8_b8 (%s)\n", gimp_file_get_utf8_name (file)); #endif width = xwdhdr->l_pixmap_width; height = xwdhdr->l_pixmap_height; /* This could also be a grayscale image. Check it */ grayscale = 0; if ((xwdhdr->l_ncolors == 256) && (xwdhdr->l_colormap_entries == 256)) { for (j = 0; j < 256; j++) { if ((xwdcolmap[j].l_pixel != j) || ((xwdcolmap[j].l_red >> 8) != j) || ((xwdcolmap[j].l_green >> 8) != j) || ((xwdcolmap[j].l_blue >> 8) != j)) break; } grayscale = (j == 256); } image = create_new_image (file, width, height, grayscale ? GIMP_GRAY : GIMP_INDEXED, grayscale ? GIMP_GRAY_IMAGE : GIMP_INDEXED_IMAGE, &layer, &buffer); tile_height = gimp_tile_height (); data = g_malloc (tile_height * width); if (!grayscale) { ncols = xwdhdr->l_colormap_entries; if (xwdhdr->l_ncolors < ncols) ncols = xwdhdr->l_ncolors; if (ncols < 2) set_bw_color_table (image); else set_color_table (image, xwdhdr, xwdcolmap); } linepad = xwdhdr->l_bytes_per_line - xwdhdr->l_pixmap_width; if (linepad < 0) linepad = 0; dest = data; scan_lines = 0; for (i = 0; i < height; i++) { if (fread (dest, 1, width, ifp) != width) { err = 1; break; } dest += width; for (j = 0; j < linepad; j++) if (getc (ifp) < 0) { err = 1; break; } if (err) break; scan_lines++; if ((i % 20) == 0) gimp_progress_update ((gdouble) (i + 1) / (gdouble) 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); g_object_unref (buffer); if (err) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("EOF encountered on reading")); return NULL; } return image; } /* Load XWD with pixmap_format 2, pixmap_depth up to 16, bits_per_pixel 16 */ static GimpImage * load_xwd_f2_d16_b16 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error) { register guchar *dest, lsbyte_first; gint width, height, linepad, i, j, c0, c1, ncols; gint red, green, blue, redval, greenval, blueval; gint maxred, maxgreen, maxblue; gint tile_height, scan_lines; guint32 redmask, greenmask, bluemask; guint redshift, greenshift, blueshift; guint32 maxval; guchar *ColorMap, *cm, *data; gint err = 0; GimpImage *image; GimpLayer *layer; GeglBuffer *buffer; #ifdef XWD_DEBUG g_printf ("load_xwd_f2_d16_b16 (%s)\n", gimp_file_get_utf8_name (file)); #endif width = xwdhdr->l_pixmap_width; height = xwdhdr->l_pixmap_height; image = create_new_image (file, width, height, GIMP_RGB, GIMP_RGB_IMAGE, &layer, &buffer); tile_height = gimp_tile_height (); data = g_malloc (tile_height * width * 3); /* Get memory for mapping 16 bit XWD-pixel to GIMP-RGB */ maxval = 0x10000 * 3; ColorMap = g_new0 (guchar, maxval); redmask = xwdhdr->l_red_mask; greenmask = xwdhdr->l_green_mask; bluemask = xwdhdr->l_blue_mask; /* How to shift RGB to be right aligned ? */ /* (We rely on the the mask bits are grouped and not mixed) */ redshift = greenshift = blueshift = 0; while (((1 << redshift) & redmask) == 0) redshift++; while (((1 << greenshift) & greenmask) == 0) greenshift++; while (((1 << blueshift) & bluemask) == 0) blueshift++; /* The bits_per_rgb may not be correct. Use redmask instead */ maxred = 0; while (redmask >> (redshift + maxred)) maxred++; maxred = (1 << maxred) - 1; maxgreen = 0; while (greenmask >> (greenshift + maxgreen)) maxgreen++; maxgreen = (1 << maxgreen) - 1; maxblue = 0; while (bluemask >> (blueshift + maxblue)) maxblue++; maxblue = (1 << maxblue) - 1; /* Built up the array to map XWD-pixel value to GIMP-RGB */ for (red = 0; red <= maxred; red++) { redval = (red * 255) / maxred; for (green = 0; green <= maxgreen; green++) { greenval = (green * 255) / maxgreen; for (blue = 0; blue <= maxblue; blue++) { guint32 offset = ((red << redshift) + (green << greenshift) + (blue << blueshift)) * 3; if (offset+2 >= maxval) { g_set_error (error, GIMP_PLUG_IN_ERROR, 0, _("Invalid colormap offset. Possibly corrupt image.")); g_free (data); g_free (ColorMap); g_object_unref (buffer); return NULL; } blueval = (blue * 255) / maxblue; cm = ColorMap + offset; *(cm++) = redval; *(cm++) = greenval; *cm = blueval; } } } /* Now look what was written to the XWD-Colormap */ ncols = xwdhdr->l_colormap_entries; if (xwdhdr->l_ncolors < ncols) ncols = xwdhdr->l_ncolors; for (j = 0; j < ncols; j++) { goffset offset = xwdcolmap[j].l_pixel * 3; if (offset+2 >= maxval) { g_set_error (error, GIMP_PLUG_IN_ERROR, 0, _("Invalid colormap offset. Possibly corrupt image.")); return NULL; } cm = ColorMap + offset; *(cm++) = (xwdcolmap[j].l_red >> 8); *(cm++) = (xwdcolmap[j].l_green >> 8); *cm = (xwdcolmap[j].l_blue >> 8); } /* What do we have to consume after a line has finished ? */ linepad = xwdhdr->l_bytes_per_line - (xwdhdr->l_pixmap_width*xwdhdr->l_bits_per_pixel)/8; if (linepad < 0) linepad = 0; lsbyte_first = (xwdhdr->l_byte_order == 0); dest = data; scan_lines = 0; for (i = 0; i < height; i++) { for (j = 0; j < width; j++) { c0 = getc (ifp); c1 = getc (ifp); if (c1 < 0) { err = 1; break; } if (lsbyte_first) c0 = c0 | (c1 << 8); else c0 = (c0 << 8) | c1; cm = ColorMap + c0 * 3; *(dest++) = *(cm++); *(dest++) = *(cm++); *(dest++) = *cm; } if (err) break; for (j = 0; j < linepad; j++) if (getc (ifp) < 0) { err = 1; break; } if (err) break; 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); g_free (ColorMap); g_object_unref (buffer); if (err) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("EOF encountered on reading")); return NULL; } return image; } /* Load XWD with pixmap_format 2, pixmap_depth up to 24, bits_per_pixel 24/32 */ static GimpImage * load_xwd_f2_d24_b32 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error) { register guchar *dest, lsbyte_first; gint width, height, linepad, i, j, c0, c1, c2, c3; gint tile_height, scan_lines; L_CARD32 pixelval; gint red, green, blue, ncols; guint32 maxred, maxgreen, maxblue; guint32 redmask, greenmask, bluemask; guint redshift, greenshift, blueshift; guchar redmap[256], greenmap[256], bluemap[256]; guchar *data; PIXEL_MAP pixel_map; gint err = 0; GimpImage *image; GimpLayer *layer; GeglBuffer *buffer; #ifdef XWD_DEBUG g_printf ("load_xwd_f2_d24_b32 (%s)\n", gimp_file_get_utf8_name (file)); #endif /* issue #8082: depth and bits per pixel is 24, but 4 bytes are used per pixel */ if (xwdhdr->l_bits_per_pixel == 24) { if (xwdhdr->l_bytes_per_line / xwdhdr->l_pixmap_width == 4 && xwdhdr->l_bytes_per_line % xwdhdr->l_pixmap_width == 0) xwdhdr->l_bits_per_pixel = 32; } width = xwdhdr->l_pixmap_width; height = xwdhdr->l_pixmap_height; redmask = xwdhdr->l_red_mask; greenmask = xwdhdr->l_green_mask; bluemask = xwdhdr->l_blue_mask; if (redmask == 0) redmask = 0xff0000; if (greenmask == 0) greenmask = 0x00ff00; if (bluemask == 0) bluemask = 0x0000ff; /* How to shift RGB to be right aligned ? */ /* (We rely on the the mask bits are grouped and not mixed) */ redshift = greenshift = blueshift = 0; while (((1 << redshift) & redmask) == 0) redshift++; while (((1 << greenshift) & greenmask) == 0) greenshift++; while (((1 << blueshift) & bluemask) == 0) blueshift++; /* The bits_per_rgb may not be correct. Use redmask instead */ maxred = 0; while (redmask >> (redshift + maxred)) maxred++; maxred = (1 << maxred) - 1; maxgreen = 0; while (greenmask >> (greenshift + maxgreen)) maxgreen++; maxgreen = (1 << maxgreen) - 1; maxblue = 0; while (bluemask >> (blueshift + maxblue)) maxblue++; maxblue = (1 << maxblue) - 1; if (maxred == 0 || maxred >= sizeof (redmap) || maxgreen == 0 || maxgreen >= sizeof (greenmap) || maxblue == 0 || maxblue >= sizeof (bluemap)) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("XWD-file %s is corrupt."), gimp_file_get_utf8_name (file)); return NULL; } image = create_new_image (file, width, height, GIMP_RGB, GIMP_RGB_IMAGE, &layer, &buffer); tile_height = gimp_tile_height (); data = g_malloc (tile_height * width * 3); /* Set map-arrays for red, green, blue */ for (red = 0; red <= maxred; red++) redmap[red] = (red * 255) / maxred; for (green = 0; green <= maxgreen; green++) greenmap[green] = (green * 255) / maxgreen; for (blue = 0; blue <= maxblue; blue++) bluemap[blue] = (blue * 255) / maxblue; ncols = xwdhdr->l_colormap_entries; if (xwdhdr->l_ncolors < ncols) ncols = xwdhdr->l_ncolors; set_pixelmap (ncols, xwdcolmap, &pixel_map); /* What do we have to consume after a line has finished ? */ linepad = xwdhdr->l_bytes_per_line - (xwdhdr->l_pixmap_width*xwdhdr->l_bits_per_pixel)/8; if (linepad < 0) linepad = 0; lsbyte_first = (xwdhdr->l_byte_order == 0); dest = data; scan_lines = 0; if (xwdhdr->l_bits_per_pixel == 32) { for (i = 0; i < height; i++) { for (j = 0; j < width; j++) { c0 = getc (ifp); c1 = getc (ifp); c2 = getc (ifp); c3 = getc (ifp); if (c3 < 0) { err = 1; break; } if (lsbyte_first) pixelval = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24); else pixelval = (c0 << 24) | (c1 << 16) | (c2 << 8) | c3; if (get_pixelmap (pixelval, &pixel_map, dest, dest+1, dest+2)) { dest += 3; } else { *(dest++) = redmap[(pixelval & redmask) >> redshift]; *(dest++) = greenmap[(pixelval & greenmask) >> greenshift]; *(dest++) = bluemap[(pixelval & bluemask) >> blueshift]; } } scan_lines++; if (err) break; for (j = 0; j < linepad; j++) if (getc (ifp) < 0) { err = 1; break; } if (err) break; if ((i % 20) == 0) gimp_progress_update ((gdouble) (i + 1) / (gdouble) 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; } } } else /* 24 bits per pixel */ { for (i = 0; i < height; i++) { for (j = 0; j < width; j++) { c0 = getc (ifp); c1 = getc (ifp); c2 = getc (ifp); if (c2 < 0) { err = 1; break; } if (lsbyte_first) pixelval = c0 | (c1 << 8) | (c2 << 16); else pixelval = (c0 << 16) | (c1 << 8) | c2; if (get_pixelmap (pixelval, &pixel_map, dest, dest+1, dest+2)) { dest += 3; } else { *(dest++) = redmap[(pixelval & redmask) >> redshift]; *(dest++) = greenmap[(pixelval & greenmask) >> greenshift]; *(dest++) = bluemap[(pixelval & bluemask) >> blueshift]; } } scan_lines++; if (err) break; for (j = 0; j < linepad; j++) if (getc (ifp) < 0) { err = 1; break; } if (err) break; if ((i % 20) == 0) gimp_progress_update ((gdouble) (i + 1) / (gdouble) 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); g_object_unref (buffer); if (err) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("EOF encountered on reading")); return NULL; } return image; } /* Load XWD with pixmap_format 2, pixmap_depth up to 32, bits_per_pixel 32 */ static GimpImage * load_xwd_f2_d32_b32 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error) { register guchar *dest, lsbyte_first; gint width, height, linepad, i, j, c0, c1, c2, c3; gint tile_height, scan_lines; L_CARD32 pixelval; gint red, green, blue, alpha, ncols; guint32 maxred, maxgreen, maxblue, maxalpha; guint32 redmask, greenmask, bluemask, alphamask; guint redshift, greenshift, blueshift, alphashift; guchar redmap[256], greenmap[256], bluemap[256], alphamap[256]; guchar *data; PIXEL_MAP pixel_map; gint err = 0; GimpImage *image; GimpLayer *layer; GeglBuffer *buffer; #ifdef XWD_DEBUG g_printf ("load_xwd_f2_d32_b32 (%s)\n", gimp_file_get_utf8_name (file)); #endif if (! xwdcolmap) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("'%s':\nInvalid color map"), gimp_file_get_utf8_name (file)); return NULL; } width = xwdhdr->l_pixmap_width; height = xwdhdr->l_pixmap_height; image = create_new_image (file, width, height, GIMP_RGB, GIMP_RGBA_IMAGE, &layer, &buffer); tile_height = gimp_tile_height (); data = g_malloc (tile_height * width * 4); redmask = xwdhdr->l_red_mask; greenmask = xwdhdr->l_green_mask; bluemask = xwdhdr->l_blue_mask; if (redmask == 0) redmask = 0xff0000; if (greenmask == 0) greenmask = 0x00ff00; if (bluemask == 0) bluemask = 0x0000ff; alphamask = 0xffffffff & ~(redmask | greenmask | bluemask); /* How to shift RGB to be right aligned ? */ /* (We rely on the the mask bits are grouped and not mixed) */ redshift = greenshift = blueshift = alphashift = 0; while (((1 << redshift) & redmask) == 0) redshift++; while (((1 << greenshift) & greenmask) == 0) greenshift++; while (((1 << blueshift) & bluemask) == 0) blueshift++; while (((1 << alphashift) & alphamask) == 0) alphashift++; /* The bits_per_rgb may not be correct. Use redmask instead */ maxred = 0; while (redmask >> (redshift + maxred)) maxred++; maxred = (1 << maxred) - 1; maxgreen = 0; while (greenmask >> (greenshift + maxgreen)) maxgreen++; maxgreen = (1 << maxgreen) - 1; maxblue = 0; while (bluemask >> (blueshift + maxblue)) maxblue++; maxblue = (1 << maxblue) - 1; maxalpha = 0; while (alphamask >> (alphashift + maxalpha)) maxalpha++; maxalpha = (1 << maxalpha) - 1; if (maxred == 0 || maxred >= sizeof (redmap) || maxgreen == 0 || maxgreen >= sizeof (greenmap) || maxblue == 0 || maxblue >= sizeof (bluemap) || maxalpha == 0 || maxalpha >= sizeof (alphamap)) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("XWD-file %s is corrupt."), gimp_file_get_utf8_name (file)); return NULL; } /* Set map-arrays for red, green, blue */ for (red = 0; red <= maxred; red++) redmap[red] = (red * 255) / maxred; for (green = 0; green <= maxgreen; green++) greenmap[green] = (green * 255) / maxgreen; for (blue = 0; blue <= maxblue; blue++) bluemap[blue] = (blue * 255) / maxblue; for (alpha = 0; alpha <= maxalpha; alpha++) alphamap[alpha] = (alpha * 255) / maxalpha; ncols = xwdhdr->l_colormap_entries; if (xwdhdr->l_ncolors < ncols) ncols = xwdhdr->l_ncolors; set_pixelmap (ncols, xwdcolmap, &pixel_map); /* What do we have to consume after a line has finished ? */ linepad = xwdhdr->l_bytes_per_line - (xwdhdr->l_pixmap_width*xwdhdr->l_bits_per_pixel)/8; if (linepad < 0) linepad = 0; lsbyte_first = (xwdhdr->l_byte_order == 0); dest = data; scan_lines = 0; for (i = 0; i < height; i++) { for (j = 0; j < width; j++) { c0 = getc (ifp); c1 = getc (ifp); c2 = getc (ifp); c3 = getc (ifp); if (c3 < 0) { err = 1; break; } if (lsbyte_first) pixelval = c0 | (c1 << 8) | (c2 << 16) | (c3 << 24); else pixelval = (c0 << 24) | (c1 << 16) | (c2 << 8) | c3; if (get_pixelmap (pixelval, &pixel_map, dest, dest+1, dest+2)) { /* FIXME: is it always transparent or encoded in an unknown way? */ *(dest+3) = 0x00; dest += 4; } else { *(dest++) = redmap[(pixelval & redmask) >> redshift]; *(dest++) = greenmap[(pixelval & greenmask) >> greenshift]; *(dest++) = bluemap[(pixelval & bluemask) >> blueshift]; *(dest++) = alphamap[(pixelval & alphamask) >> alphashift]; } } scan_lines++; if (err) break; for (j = 0; j < linepad; j++) if (getc (ifp) < 0) { err = 1; break; } if (err) break; if ((i % 20) == 0) gimp_progress_update ((gdouble) (i + 1) / (gdouble) 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); g_object_unref (buffer); if (err) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("EOF encountered on reading")); return NULL; } return image; } /* Load XWD with pixmap_format 1, pixmap_depth up to 24, bits_per_pixel 1 */ static GimpImage * load_xwd_f1_d24_b1 (GFile *file, FILE *ifp, L_XWDFILEHEADER *xwdhdr, L_XWDCOLOR *xwdcolmap, GError **error) { register guchar *dest, outmask, inmask, do_reverse; gint width, height, i, j, plane, fromright; gint tile_height, tile_start, tile_end; gint indexed, bytes_per_pixel; gint maxred, maxgreen, maxblue; gint red, green, blue, ncols, standard_rgb; goffset data_offset, plane_offset, tile_offset; guint32 redmask, greenmask, bluemask; guint redshift, greenshift, blueshift; guint32 g; guint32 maxval; guchar redmap[256], greenmap[256], bluemap[256]; guchar bit_reverse[256]; guchar *xwddata, *xwdin, *data; L_CARD32 pixelval; PIXEL_MAP pixel_map; gint err = 0; GimpImage *image; GimpLayer *layer; GeglBuffer *buffer; #ifdef XWD_DEBUG g_printf ("load_xwd_f1_d24_b1 (%s)\n", gimp_file_get_utf8_name (file)); #endif xwddata = g_malloc (xwdhdr->l_bytes_per_line); if (xwddata == NULL) return NULL; width = xwdhdr->l_pixmap_width; height = xwdhdr->l_pixmap_height; indexed = (xwdhdr->l_pixmap_depth <= 8); bytes_per_pixel = (indexed ? 1 : 3); for (j = 0; j < 256; j++) /* Create an array for reversing bits */ { inmask = 0; for (i = 0; i < 8; i++) { inmask <<= 1; if (j & (1 << i)) inmask |= 1; } bit_reverse[j] = inmask; } redmask = xwdhdr->l_red_mask; greenmask = xwdhdr->l_green_mask; bluemask = xwdhdr->l_blue_mask; if (redmask == 0) redmask = 0xff0000; if (greenmask == 0) greenmask = 0x00ff00; if (bluemask == 0) bluemask = 0x0000ff; standard_rgb = (redmask == 0xff0000) && (greenmask == 0x00ff00) && (bluemask == 0x0000ff); redshift = greenshift = blueshift = 0; if (!standard_rgb) /* Do we need to re-map the pixel-values ? */ { /* How to shift RGB to be right aligned ? */ /* (We rely on the the mask bits are grouped and not mixed) */ while (((1 << redshift) & redmask) == 0) redshift++; while (((1 << greenshift) & greenmask) == 0) greenshift++; while (((1 << blueshift) & bluemask) == 0) blueshift++; /* The bits_per_rgb may not be correct. Use redmask instead */ maxred = 0; while (redmask >> (redshift + maxred)) maxred++; maxred = (1 << maxred) - 1; maxgreen = 0; while (greenmask >> (greenshift + maxgreen)) maxgreen++; maxgreen = (1 << maxgreen) - 1; maxblue = 0; while (bluemask >> (blueshift + maxblue)) maxblue++; maxblue = (1 << maxblue) - 1; if (maxred == 0 || maxred >= sizeof (redmap) || maxgreen == 0 || maxgreen >= sizeof (greenmap) || maxblue == 0 || maxblue >= sizeof (bluemap)) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("XWD-file %s is corrupt."), gimp_file_get_utf8_name (file)); return NULL; } /* Set map-arrays for red, green, blue */ for (red = 0; red <= maxred; red++) redmap[red] = (red * 255) / maxred; for (green = 0; green <= maxgreen; green++) greenmap[green] = (green * 255) / maxgreen; for (blue = 0; blue <= maxblue; blue++) bluemap[blue] = (blue * 255) / maxblue; } image = create_new_image (file, width, height, indexed ? GIMP_INDEXED : GIMP_RGB, indexed ? GIMP_INDEXED_IMAGE : GIMP_RGB_IMAGE, &layer, &buffer); tile_height = gimp_tile_height (); data = g_malloc (tile_height * width * bytes_per_pixel); maxval = tile_height * width * bytes_per_pixel; ncols = xwdhdr->l_colormap_entries; if (xwdhdr->l_ncolors < ncols) ncols = xwdhdr->l_ncolors; if (indexed) { if (ncols < 2) set_bw_color_table (image); else set_color_table (image, xwdhdr, xwdcolmap); } else { set_pixelmap (ncols, xwdcolmap, &pixel_map); } do_reverse = !xwdhdr->l_bitmap_bit_order; /* This is where the image data starts within the file */ data_offset = ftell (ifp); for (tile_start = 0; tile_start < height; tile_start += tile_height) { guint current_dest = 0; memset (data, 0, width*tile_height*bytes_per_pixel); tile_end = tile_start + tile_height - 1; if (tile_end >= height) tile_end = height - 1; for (plane = 0; plane < xwdhdr->l_pixmap_depth; plane++) { dest = data; /* Position to start of tile within the plane */ plane_offset = data_offset + plane*height*xwdhdr->l_bytes_per_line; tile_offset = plane_offset + tile_start*xwdhdr->l_bytes_per_line; if (fseek (ifp, tile_offset, SEEK_SET) != 0) { err = 1; break; } /* Place the last plane at the least significant bit */ if (indexed) /* Only 1 byte per pixel */ { fromright = xwdhdr->l_pixmap_depth-1-plane; outmask = (1 << fromright); } else /* 3 bytes per pixel */ { fromright = xwdhdr->l_pixmap_depth-1-plane; current_dest += 2 - fromright / 8; if (current_dest < maxval) { dest += 2 - fromright / 8; } else { err = 1; break; } outmask = (1 << (fromright % 8)); } for (i = tile_start; i <= tile_end; i++) { if (fread (xwddata,xwdhdr->l_bytes_per_line,1,ifp) != 1) { err = 1; break; } xwdin = xwddata; /* Handle bitmap unit */ if (xwdhdr->l_bitmap_unit == 16) { if (xwdhdr->l_bitmap_bit_order != xwdhdr->l_byte_order) { j = xwdhdr->l_bytes_per_line/2; while (j--) { inmask = xwdin[0]; xwdin[0] = xwdin[1]; xwdin[1] = inmask; xwdin += 2; } xwdin = xwddata; } } else if (xwdhdr->l_bitmap_unit == 32) { if (xwdhdr->l_bitmap_bit_order != xwdhdr->l_byte_order) { j = xwdhdr->l_bytes_per_line/4; while (j--) { inmask = xwdin[0]; xwdin[0] = xwdin[3]; xwdin[3] = inmask; inmask = xwdin[1]; xwdin[1] = xwdin[2]; xwdin[2] = inmask; xwdin += 4; } xwdin = xwddata; } } g = inmask = 0; for (j = 0; j < width; j++) { if (!inmask) { g = *(xwdin++); if (do_reverse) g = bit_reverse[g]; inmask = 0x80; } if (g & inmask) *dest |= outmask; current_dest += bytes_per_pixel; if (current_dest < maxval) { dest += bytes_per_pixel; } else { err = 1; break; } inmask >>= 1; } } if (err) break; } if (err) break; /* For indexed images, the mapping to colors is done by the color table. */ /* Otherwise we must do the mapping by ourself. */ if (!indexed) { dest = data; for (i = tile_start; i <= tile_end; i++) { for (j = 0; j < width; j++) { pixelval = (*dest << 16) | (*(dest+1) << 8) | *(dest+2); if (get_pixelmap (pixelval, &pixel_map, dest, dest+1, dest+2) || standard_rgb) { dest += 3; } else /* We have to map RGB to 0,...,255 */ { *(dest++) = redmap[(pixelval & redmask) >> redshift]; *(dest++) = greenmap[(pixelval & greenmask) >> greenshift]; *(dest++) = bluemap[(pixelval & bluemask) >> blueshift]; } } } } gimp_progress_update ((gdouble) tile_end / (gdouble) height); gegl_buffer_set (buffer, GEGL_RECTANGLE (0, tile_start, width, tile_end-tile_start+1), 0, NULL, data, GEGL_AUTO_ROWSTRIDE); } g_free (data); g_free (xwddata); g_object_unref (buffer); if (err) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("EOF encountered on reading")); return NULL; } return image; } static gboolean save_index (GOutputStream *output, GimpImage *image, GimpDrawable *drawable, gboolean gray, GError **error) { gint height, width; gint linepad; gint tile_height; gint i, j; gint ncolors, vclass; gsize tmp = 0; guchar *data, *src, *cmap; L_XWDFILEHEADER xwdhdr; L_XWDCOLOR xwdcolmap[256]; const Babl *format; GeglBuffer *buffer; gboolean success = TRUE; #ifdef XWD_DEBUG g_printf ("save_index ()\n"); #endif buffer = gimp_drawable_get_buffer (drawable); width = gegl_buffer_get_width (buffer); height = gegl_buffer_get_height (buffer); tile_height = gimp_tile_height (); if (gray) format = babl_format ("Y' u8"); else format = gegl_buffer_get_format (buffer); /* allocate a buffer for retrieving information from the pixel region */ src = data = g_new (guchar, tile_height * width * babl_format_get_bytes_per_pixel (format)); linepad = width % 4; if (linepad) linepad = 4 - linepad; /* Fill XWD-color map */ if (gray) { vclass = 0; ncolors = 256; for (j = 0; j < ncolors; j++) { xwdcolmap[j].l_pixel = j; xwdcolmap[j].l_red = (j << 8) | j; xwdcolmap[j].l_green = (j << 8) | j; xwdcolmap[j].l_blue = (j << 8) | j; xwdcolmap[j].l_flags = 7; xwdcolmap[j].l_pad = 0; } } else { vclass = 3; cmap = gimp_palette_get_colormap (gimp_image_get_palette (image), babl_format ("R'G'B' for (j = 0; j < ncolors; j++) { xwdcolmap[j].l_pixel = j; xwdcolmap[j].l_red = ((*cmap) << 8) | *cmap; cmap++; xwdcolmap[j].l_green = ((*cmap) << 8) | *cmap; cmap++; xwdcolmap[j].l_blue = ((*cmap) << 8) | *cmap; cmap++; xwdcolmap[j].l_flags = 7; xwdcolmap[j].l_pad = 0; } } /* Fill in the XWD header (header_size is evaluated by write_xwd_hdr ()) */ xwdhdr.l_header_size = 0; xwdhdr.l_file_version = 7; xwdhdr.l_pixmap_format = 2; xwdhdr.l_pixmap_depth = 8; xwdhdr.l_pixmap_width = width; xwdhdr.l_pixmap_height = height; xwdhdr.l_xoffset = 0; xwdhdr.l_byte_order = 1; xwdhdr.l_bitmap_unit = 32; xwdhdr.l_bitmap_bit_order = 1; xwdhdr.l_bitmap_pad = 32; xwdhdr.l_bits_per_pixel = 8; xwdhdr.l_bytes_per_line = width + linepad; xwdhdr.l_visual_class = vclass; xwdhdr.l_red_mask = 0x000000; xwdhdr.l_green_mask = 0x000000; xwdhdr.l_blue_mask = 0x000000; xwdhdr.l_bits_per_rgb = 8; xwdhdr.l_colormap_entries = ncolors; xwdhdr.l_ncolors = ncolors; xwdhdr.l_window_width = width; xwdhdr.l_window_height = height; xwdhdr.l_window_x = 64; xwdhdr.l_window_y = 64; xwdhdr.l_window_bdrwidth = 0; success = (write_xwd_header (output, &xwdhdr, error) && write_xwd_cols (output, &xwdhdr, xwdcolmap, error)); if (! success) goto out; for (i = 0; i < height; i++) { if ((i % tile_height) == 0) /* Get more data */ { gint 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, data, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); src = data; } success = g_output_stream_write_all (output, src, width, NULL, NULL, error); if (! success) goto out; if (linepad) { success = g_output_stream_write_all (output, &tmp, linepad, NULL, NULL, error); if (! success) goto out; } src += width; if ((i % 20) == 0) gimp_progress_update ((gdouble) i / (gdouble) height); } out: g_free (data); g_object_unref (buffer); return success; } static gboolean save_rgb (GOutputStream *output, GimpImage *image, GimpDrawable *drawable, GError **error) { gint height, width; gint linepad; gint tile_height; gint i; gsize tmp = 0; guchar *data, *src; L_XWDFILEHEADER xwdhdr; const Babl *format; GeglBuffer *buffer; gboolean success = TRUE; #ifdef XWD_DEBUG g_printf ("save_rgb ()\n"); #endif buffer = gimp_drawable_get_buffer (drawable); 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_new (guchar, tile_height * width * babl_format_get_bytes_per_pixel (format)); linepad = (width * 3) % 4; if (linepad) linepad = 4 - linepad; /* Fill in the XWD header (header_size is evaluated by write_xwd_hdr ()) */ xwdhdr.l_header_size = 0; xwdhdr.l_file_version = 7; xwdhdr.l_pixmap_format = 2; xwdhdr.l_pixmap_depth = 24; xwdhdr.l_pixmap_width = width; xwdhdr.l_pixmap_height = height; xwdhdr.l_xoffset = 0; xwdhdr.l_byte_order = 1; xwdhdr.l_bitmap_unit = 32; xwdhdr.l_bitmap_bit_order = 1; xwdhdr.l_bitmap_pad = 32; xwdhdr.l_bits_per_pixel = 24; xwdhdr.l_bytes_per_line = width * 3 + linepad; xwdhdr.l_visual_class = 5; xwdhdr.l_red_mask = 0xff0000; xwdhdr.l_green_mask = 0x00ff00; xwdhdr.l_blue_mask = 0x0000ff; xwdhdr.l_bits_per_rgb = 8; xwdhdr.l_colormap_entries = 0; xwdhdr.l_ncolors = 0; xwdhdr.l_window_width = width; xwdhdr.l_window_height = height; xwdhdr.l_window_x = 64; xwdhdr.l_window_y = 64; xwdhdr.l_window_bdrwidth = 0; success = write_xwd_header (output, &xwdhdr, error); if (! success) goto out; for (i = 0; i < height; i++) { if ((i % tile_height) == 0) /* Get more data */ { gint 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, data, GEGL_AUTO_ROWSTRIDE, GEGL_ABYSS_NONE); src = data; } success = g_output_stream_write_all (output, src, width * 3, NULL, NULL, error); if (! success) goto out; if (linepad) { success = g_output_stream_write_all (output, &tmp, linepad, NULL, NULL, error); if (! success) goto out; } src += width * 3; if ((i % 20) == 0) gimp_progress_update ((gdouble) i / (gdouble) height); } out: g_free (data); g_object_unref (buffer); return success; }
¤ Dauer der Verarbeitung: 0.57 Sekunden ¤*© Formatika GbR, Deutschland |
|
||||||||||||||||||||||||
2026-11-01