| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Gimp/app/xcf/ (Gimp Bildeditor Version 3.2.0©) Datei vom 14.2.2026 mit Größe 179 kB |
|
Quelle xcf-load.c Sprache: C |
|||||||||||||||||||||||||
|
/* GIMP - The GNU Image Manipulation Program * Copyright (C) 1995 Spencer Kimball and Peter Mattis * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <https://www.gnu.org/licenses/>. */ #include "config.h" #include <string.h> #include <zlib.h> #include <cairo.h> #include <gegl.h> #include <gegl-plugin.h> #include <gdk-pixbuf/gdk-pixbuf.h> #include "libgimpbase/gimpbase.h" #include "libgimpcolor/gimpcolor.h" #include "libgimpconfig/gimpconfig.h" #include "core/core-types.h" #include "config/gimpcoreconfig.h" #include "gegl/gimp-babl.h" #include "gegl/gimp-gegl-tile-compat.h" #include "gegl/gimp-gegl-utils.h" #include "core/gimp.h" #include "core/gimpcontainer.h" #include "core/gimpdashpattern.h" #include "core/gimpdatafactory.h" #include "core/gimpdrawable-filters.h" #include "core/gimpdrawable-private.h" /* eek */ #include "core/gimpdrawablefilter.h" #include "core/gimpfilloptions.h" #include "core/gimpfilterstack.h" #include "core/gimpgrid.h" #include "core/gimpgrouplayer.h" #include "core/gimpimage.h" #include "core/gimpimage-color-profile.h" #include "core/gimpimage-colormap.h" #include "core/gimpimage-grid.h" #include "core/gimpimage-guides.h" #include "core/gimpimage-metadata.h" #include "core/gimpimage-private.h" #include "core/gimpimage-sample-points.h" #include "core/gimpimage-symmetry.h" #include "core/gimpimage-undo.h" #include "core/gimpitemlist.h" #include "core/gimpitemstack.h" #include "core/gimplayer-floating-selection.h" #include "core/gimplayer-new.h" #include "core/gimplayer-xcf.h" #include "core/gimplayermask.h" #include "core/gimplink.h" #include "core/gimplinklayer.h" #include "core/gimpparasitelist.h" #include "core/gimppattern.h" #include "core/gimpprogress.h" #include "core/gimprasterizable.h" #include "core/gimpselection.h" #include "core/gimpstrokeoptions.h" #include "core/gimpsymmetry.h" #include "core/gimptemplate.h" #include "core/gimpunit.h" #include "operations/layer-modes/gimp-layer-modes.h" #include "path/gimpanchor.h" #include "path/gimpstroke.h" #include "path/gimpbezierstroke.h" #include "path/gimppath.h" #include "path/gimppath-compat.h" #include "path/gimpvectorlayer.h" #include "path/gimpvectorlayeroptions.h" #include "plug-in/gimppluginmanager-file.h" #include "plug-in/gimppluginprocedure.h" #include "text/gimptextlayer.h" #include "text/gimptextlayer-xcf.h" #include "xcf-private.h" #include "xcf-load.h" #include "xcf-read.h" #include "xcf-seek.h" #include "xcf-utils.h" #include "gimp-log.h" #include "gimp-intl.h" #define MAX_XCF_PARASITE_DATA_LEN (256L * 1024 * 1024) /* #define GIMP_XCF_PATH_DEBUG */ /* Filters can not be created until a layer is attached * to an image, so we use this struct to store relevant * information until then */ typedef struct { GeglNode *operation; gchar *name; gchar *icon_name; gchar *operation_name; gchar *op_version; GimpChannel *mask; gboolean is_visible; gdouble opacity; GimpLayerMode paint_mode; GimpLayerColorSpace blend_space; GimpLayerColorSpace composite_space; GimpLayerCompositeMode composite_mode; gboolean clip; GimpFilterRegion region; gboolean unsupported_operation; } FilterData; typedef struct { GimpTattoo path_tattoo; gboolean modified; gboolean enable_fill; gboolean enable_stroke; GimpCustomStyle fill_style; gboolean fill_antialias; GeglColor *fill_color; GimpPattern *fill_pattern; GimpCustomStyle stroke_style; gboolean stroke_antialias; GeglColor *stroke_color; GimpPattern *stroke_pattern; gdouble stroke_width; GimpCapStyle stroke_cap_style; GimpJoinStyle stroke_join_style; gdouble stroke_miter_limit; gsize n_stroke_dashes; gdouble *stroke_dashes; } VectorLayerData; typedef struct { gint offset_x; gint offset_y; GimpInterpolationType interpolation; GimpMatrix3 matrix; } LayerTransformData; static void xcf_load_add_masks (GimpImage *image); static void xcf_load_add_effects (XcfInfo *info, GimpImage *image); static gboolean xcf_load_image_props (XcfInfo *info, GimpImage *image); static gboolean xcf_load_layer_props (XcfInfo *info, GimpImage *image, GimpLayer **layer, GList *loop_files, GList **item_path, gboolean *apply_mask, gboolean *edit_mask, gboolean *show_mask, guint32 *text_layer_flags, guint32 *group_layer_flags); static gboolean xcf_check_layer_props (XcfInfo *info, GList **item_path, gboolean *is_group_layer, gboolean *is_text_layer, gboolean *is_link_layer); static gboolean xcf_load_channel_props (XcfInfo *info, GimpImage *image, GimpChannel **channel, gboolean is_mask); static gboolean xcf_load_effect_props (XcfInfo *info, FilterData *filter); static gboolean xcf_load_path_props (XcfInfo *info, GimpImage *image, GimpPath **paths); static gboolean xcf_load_prop (XcfInfo *info, PropType *prop_type, guint32 *prop_size); static GimpLayer * xcf_load_layer (XcfInfo *info, GimpImage *image, GList *loop_files, GList **item_path, gint *n_broken_effects); static GimpChannel * xcf_load_channel (XcfInfo *info, GimpImage *image); static FilterData * xcf_load_effect (XcfInfo *info, GimpImage *image, GimpDrawable *drawable); static void xcf_load_free_effect (FilterData *data); static void xcf_load_free_effects (GList *effects); static GeglColor * xcf_load_color (XcfInfo *info, goffset next_prop, gboolean *valid_prop_value, GError **error); static GimpData * xcf_load_data (XcfInfo *info, GType data_type, GError **error); static GimpPath * xcf_load_path (XcfInfo *info, GimpImage *image); static GimpLayerMask * xcf_load_layer_mask (XcfInfo *info, GimpImage *image); static gboolean xcf_load_buffer (XcfInfo *info, GeglBuffer *buffer); static gboolean xcf_load_level (XcfInfo *info, GeglBuffer *buffer); static gboolean xcf_load_tile (XcfInfo *info, GeglBuffer *buffer, GeglRectangle *tile_rect, const Babl *format); static gboolean xcf_load_tile_rle (XcfInfo *info, GeglBuffer *buffer, GeglRectangle *tile_rect, const Babl *format, gint data_length); static gboolean xcf_load_tile_zlib (XcfInfo *info, GeglBuffer *buffer, GeglRectangle *tile_rect, const Babl *format, gint data_length); static GimpParasite * xcf_load_parasite (XcfInfo *info); static gboolean xcf_load_old_paths (XcfInfo *info, GimpImage *image); static gboolean xcf_load_old_path (XcfInfo *info, GimpImage *image); static gboolean xcf_load_old_vectors (XcfInfo *info, GimpImage *image); static gboolean xcf_load_old_vector (XcfInfo *info, GimpImage *image); static gboolean xcf_skip_unknown_prop (XcfInfo *info, gsize size); static gboolean xcf_item_path_is_parent (GList *path, GList *parent_path); static void xcf_fix_item_path (GimpLayer *layer, GList **path, GList *broken_paths); static void xcf_load_free_vector_data (VectorLayerData *data); #define xcf_progress_update(info) G_STMT_START \ { \ if (info->progress) \ gimp_progress_pulse (info->progress); \ } G_STMT_END gboolean xcf_load_magic_version (Gimp *gimp, GInputStream *input, GFile *input_file, GimpProgress *progress, XcfInfo *info) { gchar id[14]; g_return_val_if_fail (GIMP_IS_GIMP (gimp), FALSE); g_return_val_if_fail (G_IS_INPUT_STREAM (input), FALSE); g_return_val_if_fail (input_file == NULL || G_IS_FILE (input_file), FALSE); g_return_val_if_fail (progress == NULL || GIMP_IS_PROGRESS (progress), FALSE); info->gimp = gimp; info->input = input; info->seekable = G_SEEKABLE (input); info->bytes_per_offset = 4; info->progress = progress; info->file = input_file; info->compression = COMPRESS_NONE; xcf_read_int8 (info, (guint8 *) id, 14); if (! g_str_has_prefix (id, "gimp xcf ")) { return FALSE; } else if (strcmp (id + 9, "file") == 0) { info->file_version = 0; } else if (id[9] == 'v' && id[13] == '\0') { info->file_version = atoi (id + 10); } else { return FALSE; } if (info->file_version >= 11) info->bytes_per_offset = 8; return TRUE; } /* This function will load the image header then do a quick pass through * link layers, returning all files to ignore in link layers as * @loop_files. * * Argument @loop_found should be NULL on the initial call. It is only * being used in recursive calls to stop earlier. */ gboolean xcf_load_image_header (Gimp *gimp, XcfInfo *info, gint *width, gint *height, gint *image_type, GimpPrecision *precision, GList *prev_files, GList **loop_files, gboolean *loop_found, GError **error) { goffset reset_pos; /* read in the image width, height and type */ xcf_read_int32 (info, (guint32 *) width, 1); xcf_read_int32 (info, (guint32 *) height, 1); xcf_read_int32 (info, (guint32 *) image_type, 1); if (*image_type < GIMP_RGB || *image_type > GIMP_INDEXED) { if (error) g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, /* TODO: localize after freeze ends. */ "invalid image type."); return FALSE; } /* Be lenient with corrupt image dimensions. * Hopefully layer dimensions will be valid. */ if (*width <= 0 || *height <= 0 || *width > GIMP_MAX_IMAGE_SIZE || *height > GIMP_MAX_IMAGE_SIZE) { GIMP_LOG (XCF, "Invalid image size %d x %d, setting to 1x1.", *width, *height); *width = 1; *height = 1; } *precision = GIMP_PRECISION_U8_NON_LINEAR; if (info->file_version >= 4) { gint p; xcf_read_int32 (info, (guint32 *) &p, 1); if (info->file_version == 4) { switch (p) { case 0: *precision = GIMP_PRECISION_U8_NON_LINEAR; break; case 1: *precision = GIMP_PRECISION_U16_NON_LINEAR; break; case 2: *precision = GIMP_PRECISION_U32_LINEAR; break; case 3: *precision = GIMP_PRECISION_HALF_LINEAR; break; case 4: *precision = GIMP_PRECISION_FLOAT_LINEAR; break; default: if (error) g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, /* TODO: localize after freeze ends. */ "Invalid image precision value %d for XCF version %d.", p, info->file_version); return FALSE; } } else if (info->file_version == 5 || info->file_version == 6) { switch (p) { case 100: *precision = GIMP_PRECISION_U8_LINEAR; break; case 150: *precision = GIMP_PRECISION_U8_NON_LINEAR; break; case 200: *precision = GIMP_PRECISION_U16_LINEAR; break; case 250: *precision = GIMP_PRECISION_U16_NON_LINEAR; break; case 300: *precision = GIMP_PRECISION_U32_LINEAR; break; case 350: *precision = GIMP_PRECISION_U32_NON_LINEAR; break; case 400: *precision = GIMP_PRECISION_HALF_LINEAR; break; case 450: *precision = GIMP_PRECISION_HALF_NON_LINEAR; break; case 500: *precision = GIMP_PRECISION_FLOAT_LINEAR; break; case 550: *precision = GIMP_PRECISION_FLOAT_NON_LINEAR; break; default: if (error) g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, /* TODO: localize after freeze ends. */ "Invalid image precision value %d for XCF version %d.", p, info->file_version); return FALSE; } } else { *precision = p; } } GIMP_LOG (XCF, "version=%d, width=%d, height=%d, image_type=%d, precision=%d", info->file_version, *width, *height, *image_type, *precision); if (! gimp_babl_is_valid (*image_type, *precision)) { if (error) g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("Invalid image mode and precision combination.")); return FALSE; } reset_pos = info->cp; /******** END OF HEADER DATA LOAD ********\ * We will seek back to reset_pos as the position where the stream * will be if this function succeed. * * The rest of this function will quickly skip to layer structures and * try to identify any cycle in linked files. \******** START LINK SANITY CHECK ********/ /* Skip image properties */ while (TRUE) { PropType prop_type; guint32 prop_size; if (! xcf_load_prop (info, &prop_type, &prop_size)) { if (error) g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, /* TODO: localize after freeze ends. */ "Failed reading image properties."); return FALSE; } if (prop_type == PROP_END) break; if (! xcf_skip_unknown_prop (info, prop_size)) { if (error) g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, /* TODO: localize after freeze ends. */ "Failed skipping image properties."); return FALSE; } } /* Scan layers for link layers to search for loops (link layers in * succession ending up calling a parent XCF). * I do not error out on errors and will let xcf_load_image() do this, * or possibly salvage what can still be loaded. */ while (TRUE) { goffset offset; gint lwidth; gint lheight; gint ltype; gchar *lname; goffset saved_pos; /* read in the offset of the next layer */ if (xcf_read_offset (info, &offset, 1) < info->bytes_per_offset) break; if (offset == 0) break; saved_pos = info->cp; if (offset < saved_pos) break; /* seek to the layer offset */ if (! xcf_seek_pos (info, offset, NULL)) break; /* read in the layer */ xcf_read_int32 (info, (guint32 *) &lwidth, 1); xcf_read_int32 (info, (guint32 *) &lheight, 1); xcf_read_int32 (info, (guint32 *) <ype, 1); xcf_read_string (info, &lname, 1); g_free (lname); while (TRUE) { PropType prop_type; guint32 prop_size; if (! xcf_load_prop (info, &prop_type, &prop_size)) break; if (prop_type == PROP_END) { break; } else if (prop_type == PROP_LINK_LAYER) { gchar *path = NULL; guint32 flags; guint32 dimensions[2]; xcf_read_int32 (info, &flags, 1); xcf_read_string (info, &path, 1); xcf_read_int32 (info, dimensions, 2); if (path != NULL) { GFile *folder; GFile *link_file; GimpPlugInProcedure *file_proc; GList *iter; folder = g_file_get_parent (info->file); link_file = g_file_resolve_relative_path (folder, path); g_clear_object (&folder); g_free (path); for (iter = *loop_files; iter; iter = iter->next) if (xcf_load_file_equal (link_file, iter->data)) break; if (iter != NULL) { g_clear_object (&link_file); if (loop_found) *loop_found = TRUE; break; } for (iter = prev_files; iter; iter = iter->next) if (xcf_load_file_equal (link_file, iter->data)) break; if (iter != NULL) { *loop_files = g_list_prepend (*loop_files, link_file); if (loop_found) *loop_found = TRUE; break; } file_proc = gimp_plug_in_manager_file_procedure_find (gimp->plug_in_manager, GIMP_FILE_PROCEDURE_GROUP_OPEN, link_file, error); if (file_proc && gimp_plug_in_procedure_is_xcf_load (file_proc)) { GInputStream *input; GList *parent_files; XcfInfo info2 = { 0, }; gint width2; gint height2; gint type2; GimpPrecision precision2; gboolean subloop_found = FALSE; parent_files = g_list_copy (prev_files); parent_files = g_list_prepend (parent_files, link_file); input = G_INPUT_STREAM (g_file_read (link_file, NULL, NULL)); if (input && xcf_load_magic_version (gimp, input, link_file, NULL, &info2)) xcf_load_image_header (gimp, &info2, &width2, &height2, &type2, &precision2, parent_files, loop_files, &subloop_found, NULL); g_clear_object (&input); g_list_free (parent_files); if (subloop_found) { *loop_files = g_list_prepend (*loop_files, link_file); if (loop_found) *loop_found = TRUE; break; } } g_clear_object (&link_file); } } else if (! xcf_skip_unknown_prop (info, prop_size)) { break; } } if (loop_found && *loop_found) break; if (! xcf_seek_pos (info, saved_pos, NULL)) break; } if (! xcf_seek_pos (info, reset_pos, NULL)) { if (error) g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, /* TODO: localize after freeze ends. */ "Failed seeking back."); return FALSE; } return TRUE; } GimpImage * xcf_load_image (Gimp *gimp, XcfInfo *info, GError **error) { GimpImage *image = NULL; const GimpParasite *parasite; gboolean has_metadata = FALSE; goffset saved_pos; goffset offset; gint width; gint height; gint image_type; GimpPrecision precision = GIMP_PRECISION_U8_NON_LINEAR; gint num_successful_elements = 0; gint n_broken_layers = 0; gint n_broken_channels = 0; gint n_broken_paths = 0; gint n_broken_effects = 0; GList *layers; GList *broken_paths = NULL; GList *group_layers = NULL; GList *syms; GList *iter; GList *parent_files = NULL; GList *loop_files = NULL; parent_files = g_list_prepend (parent_files, info->file); if (! xcf_load_image_header (gimp, info, &width, &height, &image_type, &precision, parent_files, &loop_files, NULL, error)) goto hard_error; g_clear_pointer (&parent_files, g_list_free); image = gimp_create_image (gimp, width, height, image_type, precision, FALSE); gimp_image_undo_disable (image); xcf_progress_update (info); /* read the image properties */ if (! xcf_load_image_props (info, image)) goto hard_error; GIMP_LOG (XCF, "image props loaded"); /* Order matters for item sets. */ info->layer_sets = g_list_reverse (info->layer_sets); info->channel_sets = g_list_reverse (info->channel_sets); /* check for simulation intent parasite */ parasite = gimp_image_parasite_find (GIMP_IMAGE (image), "image-simulation-intent"); if (parasite) { guint32 parasite_size; GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image); const guint8 *data; GimpColorRenderingIntent intent; data = (const guint8 *) gimp_parasite_get_data (parasite, ¶site_size); intent = (GimpColorRenderingIntent) *data; gimp_parasite_list_remove (private->parasites, gimp_parasite_get_name (parasite)); if (parasite_size == 1) { if (intent != GIMP_COLOR_RENDERING_INTENT_PERCEPTUAL && intent != GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC && intent != GIMP_COLOR_RENDERING_INTENT_SATURATION && intent != GIMP_COLOR_RENDERING_INTENT_ABSOLUTE_COLORIMETRIC) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_ERROR, "Unknown simulation rendering intent: %d", intent); } else { gimp_image_set_simulation_intent (image, intent); } } else { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_ERROR, "Invalid simulation intent data"); } } /* check for simulation bpc parasite */ parasite = gimp_image_parasite_find (GIMP_IMAGE (image), "image-simulation-bpc"); if (parasite) { guint32 parasite_size; GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image); const guint8 *data; gboolean bpc; data = (const guint8 *) gimp_parasite_get_data (parasite, ¶site_size); bpc = *data ? TRUE : FALSE; gimp_parasite_list_remove (private->parasites, gimp_parasite_get_name (parasite)); if (parasite_size == 1) { gimp_image_set_simulation_bpc (image, bpc); } else { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_ERROR, "Invalid simulation bpc data"); } } /* check for a GimpGrid parasite */ parasite = gimp_image_parasite_find (GIMP_IMAGE (image), gimp_grid_parasite_name ()); if (parasite) { GimpGrid *grid = gimp_grid_from_parasite (parasite); if (grid) { GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image); gimp_parasite_list_remove (private->parasites, gimp_parasite_get_name (parasite)); gimp_image_set_grid (GIMP_IMAGE (image), grid, FALSE); g_object_unref (grid); } } /* check for a metadata parasite */ parasite = gimp_image_parasite_find (GIMP_IMAGE (image), "gimp-image-metadata"); if (parasite) { GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image); GimpMetadata *metadata = NULL; gchar *meta_string; guint32 parasite_data_size; meta_string = (gchar *) gimp_parasite_get_data (parasite, ¶site_data_size); if (meta_string) { meta_string = g_strndup (meta_string, parasite_data_size); metadata = gimp_metadata_deserialize (meta_string); g_free (meta_string); } gimp_parasite_list_remove (private->parasites, gimp_parasite_get_name (parasite)); if (metadata) { has_metadata = TRUE; gimp_image_set_metadata (image, metadata, FALSE); g_object_unref (metadata); } } /* check for symmetry parasites */ syms = gimp_image_symmetry_list (); for (iter = syms; iter; iter = g_list_next (iter)) { GType type = (GType) iter->data; gchar *parasite_name = gimp_symmetry_parasite_name (type); parasite = gimp_image_parasite_find (image, parasite_name); g_free (parasite_name); if (parasite) { GimpSymmetry *sym = gimp_symmetry_from_parasite (parasite, image, type); if (sym) { GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image); gimp_parasite_list_remove (private->parasites, gimp_parasite_get_name (parasite)); gimp_image_symmetry_add (image, sym); g_signal_emit_by_name (sym, "active-changed", NULL); if (sym->active) gimp_image_set_active_symmetry (image, type); } } } g_list_free (syms); /* migrate the old "exif-data" parasite */ parasite = gimp_image_parasite_find (GIMP_IMAGE (image), "exif-data"); if (parasite) { GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image); if (has_metadata) { g_printerr ("xcf-load: inconsistent metadata discovered: XCF file " "has both 'gimp-image-metadata' and 'exif-data' " "parasites, dropping old 'exif-data'\n"); } else { GimpMetadata *metadata = gimp_image_get_metadata (image); GError *my_error = NULL; const guchar *parasite_data; guint32 parasite_data_size; parasite_data = (const guchar *) gimp_parasite_get_data (parasite, ¶site_data_size); if (metadata) g_object_ref (metadata); else metadata = gimp_metadata_new (); if (! gimp_metadata_set_from_exif (metadata, parasite_data, parasite_data_size, &my_error)) { gimp_message (gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, _("Corrupt 'exif-data' parasite discovered.\n" "Exif data could not be migrated: %s"), my_error->message); g_clear_error (&my_error); } else { gimp_image_set_metadata (image, metadata, FALSE); } g_object_unref (metadata); } gimp_parasite_list_remove (private->parasites, gimp_parasite_get_name (parasite)); } /* migrate the old "gimp-metadata" parasite */ parasite = gimp_image_parasite_find (GIMP_IMAGE (image), "gimp-metadata"); if (parasite) { GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image); const gchar *xmp_data; guint32 xmp_length; xmp_data = (gchar *) gimp_parasite_get_data (parasite, &xmp_length); if (has_metadata) { g_printerr ("xcf-load: inconsistent metadata discovered: XCF file " "has both 'gimp-image-metadata' and 'gimp-metadata' " "parasites, dropping old 'gimp-metadata'\n"); } else if (xmp_length < 14 || strncmp (xmp_data, "GIMP_XMP_1", 10) != 0) { gimp_message (gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, _("Corrupt 'gimp-metadata' parasite discovered.\n" "XMP data could not be migrated.")); } else { GimpMetadata *metadata = gimp_image_get_metadata (image); GError *my_error = NULL; if (metadata) g_object_ref (metadata); else metadata = gimp_metadata_new (); if (! gimp_metadata_set_from_xmp (metadata, (const guint8 *) xmp_data + 10, xmp_length - 10, &my_error)) { /* XMP metadata from 2.8.x or earlier can be really messed up. * Let's make the message more user friendly so they will * understand that we can't do anything about it. * See issue #987. */ gimp_message (gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, _("Corrupt XMP metadata saved by an older version of " "GIMP could not be converted and will be ignored.\n" "If you don't know what XMP is, you most likely don't " "need it. Reported error: %s."), my_error->message); g_clear_error (&my_error); } else { gimp_image_set_metadata (image, metadata, FALSE); } g_object_unref (metadata); } gimp_parasite_list_remove (private->parasites, gimp_parasite_get_name (parasite)); } /* check for a gimp-xcf-compatibility-mode parasite */ parasite = gimp_image_parasite_find (GIMP_IMAGE (image), "gimp-xcf-compatibility-mode"); if (parasite) { GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image); /* just ditch it, it's unused but shouldn't be re-saved */ gimp_parasite_list_remove (private->parasites, gimp_parasite_get_name (parasite)); } xcf_progress_update (info); while (TRUE) { GimpLayer *layer; GList *item_path = NULL; /* read in the offset of the next layer */ if (xcf_read_offset (info, &offset, 1) < info->bytes_per_offset) { GIMP_LOG (XCF, "Failed to read layer offset" " at offset: %" G_GOFFSET_FORMAT, info->cp); break; } /* if the offset is 0 then we are at the end * of the layer list. */ if (offset == 0) break; /* save the current position as it is where the * next layer offset is stored. */ saved_pos = info->cp; if (offset < saved_pos) { GIMP_LOG (XCF, "Invalid layer offset: %" G_GOFFSET_FORMAT " at offset: %" G_GOFFSET_FORMAT, offset, saved_pos); goto error; } /* seek to the layer offset */ if (! xcf_seek_pos (info, offset, NULL)) goto error; /* read in the layer */ layer = xcf_load_layer (info, image, loop_files, &item_path, &n_broken_effects); if (! layer) { n_broken_layers++; if (! xcf_seek_pos (info, saved_pos, NULL)) { if (item_path) g_list_free (item_path); goto error; } /* Don't just stop at the first broken layer. Load as much as * possible. */ if (! item_path) { GimpContainer *layers = gimp_image_get_layers (image); item_path = g_list_prepend (NULL, GUINT_TO_POINTER (gimp_container_get_n_children (layers))); broken_paths = g_list_prepend (broken_paths, item_path); } continue; } if (broken_paths && item_path) { /* Item paths may be a problem when layers are missing. */ xcf_fix_item_path (layer, &item_path, broken_paths); } num_successful_elements++; xcf_progress_update (info); /* suspend layer-group size updates */ if (GIMP_IS_GROUP_LAYER (layer)) { GimpGroupLayer *group = GIMP_GROUP_LAYER (layer); group_layers = g_list_prepend (group_layers, group); gimp_group_layer_suspend_resize (group, FALSE); } /* add the layer to the image if its not the floating selection */ if (layer != info->floating_sel) { GimpContainer *layers = gimp_image_get_layers (image); GimpContainer *container; GimpLayer *parent; if (item_path) { if (info->floating_sel) { /* there is a floating selection, but it will get * added after all layers are loaded, so toplevel * layer indices are off-by-one. Adjust item paths * accordingly: */ gint toplevel_index; toplevel_index = GPOINTER_TO_UINT (item_path->data); toplevel_index--; item_path->data = GUINT_TO_POINTER (toplevel_index); } parent = GIMP_LAYER (gimp_item_stack_get_parent_by_path (GIMP_ITEM_STACK (layers), item_path, NULL)); container = gimp_viewable_get_children (GIMP_VIEWABLE (parent)); g_list_free (item_path); } else { parent = NULL; container = layers; } gimp_image_add_layer (image, layer, parent, gimp_container_get_n_children (container), FALSE); } /* restore the saved position so we'll be ready to * read the next offset. */ if (! xcf_seek_pos (info, saved_pos, NULL)) goto error; } g_list_free_full (loop_files, g_object_unref); loop_files = NULL; /* resume layer-group size updates, in reverse order */ for (iter = group_layers; iter; iter = g_list_next (iter)) { GimpGroupLayer *group = iter->data; gimp_group_layer_resume_resize (group, FALSE); } g_clear_pointer (&group_layers, g_list_free); if (broken_paths) { g_list_free_full (broken_paths, (GDestroyNotify) g_list_free); broken_paths = NULL; } while (TRUE) { GimpChannel *channel; /* read in the offset of the next channel */ if (xcf_read_offset (info, &offset, 1) < info->bytes_per_offset) { GIMP_LOG (XCF, "Failed to read channel offset" " at offset: %" G_GOFFSET_FORMAT, info->cp); break; } /* if the offset is 0 then we are at the end * of the channel list. */ if (offset == 0) break; /* save the current position as it is where the * next channel offset is stored. */ saved_pos = info->cp; if (offset < saved_pos) { GIMP_LOG (XCF, "Invalid channel offset: %" G_GOFFSET_FORMAT " at offset: % "G_GOFFSET_FORMAT, offset, saved_pos); goto error; } /* seek to the channel offset */ if (! xcf_seek_pos (info, offset, NULL)) goto error; /* read in the channel */ channel = xcf_load_channel (info, image); if (!channel) { n_broken_channels++; GIMP_LOG (XCF, "Failed to load channel."); if (! xcf_seek_pos (info, saved_pos, NULL)) goto error; continue; } num_successful_elements++; xcf_progress_update (info); /* add the channel to the image if its not the selection */ if (channel != gimp_image_get_mask (image)) gimp_image_add_channel (image, channel, NULL, /* FIXME tree */ gimp_container_get_n_children (gimp_image_get_channels (image)), FALSE); /* restore the saved position so we'll be ready to * read the next offset. */ if (! xcf_seek_pos (info, saved_pos, NULL)) goto error; } if (n_broken_layers == 0 && n_broken_channels == 0) { xcf_load_add_masks (image); xcf_load_add_effects (info, image); } if (info->floating_sel && info->floating_sel_drawable) { /* we didn't fix the loaded floating selection's format before * because we didn't know if it needed the layer space */ if (GIMP_IS_LAYER (info->floating_sel_drawable) && gimp_drawable_is_gray (GIMP_DRAWABLE (info->floating_sel))) gimp_layer_fix_format_space (info->floating_sel, TRUE, FALSE); floating_sel_attach (info->floating_sel, info->floating_sel_drawable); } if (info->file_version >= 18) { while (TRUE) { GimpPath *path; /* read in the offset of the next path */ if (xcf_read_offset (info, &offset, 1) < info->bytes_per_offset) { GIMP_LOG (XCF, "Failed to read path offset" " at offset: %" G_GOFFSET_FORMAT, info->cp); break; } /* if the offset is 0 then we are at the end * of the path list. */ if (offset == 0) break; /* save the current position as it is where the * next channel offset is stored. */ saved_pos = info->cp; if (offset < saved_pos) { GIMP_LOG (XCF, "Invalid path offset: %" G_GOFFSET_FORMAT " at offset: % "G_GOFFSET_FORMAT, offset, saved_pos); goto error; } /* seek to the path offset */ if (! xcf_seek_pos (info, offset, NULL)) goto error; /* read in the path */ path = xcf_load_path (info, image); if (! path) { n_broken_paths++; GIMP_LOG (XCF, "Failed to load path."); if (! xcf_seek_pos (info, saved_pos, NULL)) goto error; continue; } num_successful_elements++; xcf_progress_update (info); gimp_image_add_path (image, path, NULL, /* can't be a tree */ gimp_container_get_n_children (gimp_image_get_paths (image)), FALSE); /* restore the saved position so we'll be ready to * read the next offset. */ if (! xcf_seek_pos (info, saved_pos, NULL)) goto error; } } layers = gimp_image_get_layer_list (image); for (iter = layers; iter; iter = g_list_next (iter)) { GimpLayer *layer = iter->data; VectorLayerData *vdata; LayerTransformData *tdata; /* Once all items are loaded, we transform any vector layer in * waiting. We could not create vector layers directly because we * needed the paths to be loaded first. */ vdata = g_object_get_data (G_OBJECT (layer), "gimp-vector-layer-data"); if (vdata != NULL) { GimpLayer *vlayer; GimpVectorLayerOptions *options; GimpPath *path; GArray *dash_pattern; GList *selected; GList *linked; gboolean floating; selected = g_list_find (info->selected_layers, layer); linked = g_list_find (info->linked_layers, layer); floating = (info->floating_sel == layer); path = gimp_image_get_path_by_tattoo (image, vdata->path_tattoo); if (path == NULL) { GIMP_LOG (XCF, "Failed to load path associated with vector layer \"%s\". " "The vector layer is downgraded to a raster layer.", gimp_object_get_name (layer)); g_object_set_data (G_OBJECT (layer), "gimp-vector-layer-data", NULL); continue; } options = gimp_vector_layer_options_new (image, path, gimp_get_user_context (info->gimp)); options->enable_fill = vdata->enable_fill; options->enable_stroke = vdata->enable_stroke; gimp_fill_options_set_custom_style (options->fill_options, vdata->fill_style); gimp_fill_options_set_antialias (options->fill_options, vdata->fill_antialias); gimp_context_set_foreground (GIMP_CONTEXT (options->fill_options), vdata->fill_color) gimp_context_set_pattern (GIMP_CONTEXT (options->fill_options), vdata->fill_pattern); gimp_fill_options_set_custom_style (GIMP_FILL_OPTIONS (options->stroke_options), vda gimp_fill_options_set_antialias (GIMP_FILL_OPTIONS (options->stroke_options), vdata-> gimp_context_set_foreground (GIMP_CONTEXT (options->stroke_options), vdata->stroke_co gimp_context_set_pattern (GIMP_CONTEXT (options->stroke_options), vdata->stroke_patte dash_pattern = gimp_dash_pattern_from_double_array (vdata->n_stroke_dashes, vdata->str gimp_stroke_options_take_dash_pattern (options->stroke_options, GIMP_DASH_CUSTOM, da g_object_set (G_OBJECT (options->stroke_options), "width", vdata->stroke_width, "cap-style", vdata->stroke_cap_style, "join-style", vdata->stroke_join_style, "miter-limit", vdata->stroke_miter_limit, NULL); vlayer = gimp_layer_from_layer (layer, GIMP_TYPE_VECTOR_LAYER, "image", image, "vector-layer-options", options, NULL); g_object_unref (options); if (vdata->modified) gimp_rasterizable_rasterize (GIMP_RASTERIZABLE (vlayer), FALSE); if (selected) { info->selected_layers = g_list_delete_link (info->selected_layers, selected); info->selected_layers = g_list_prepend (info->selected_layers, vlayer); } if (linked) { info->linked_layers = g_list_delete_link (info->linked_layers, linked); info->linked_layers = g_list_prepend (info->linked_layers, vlayer); } if (floating) info->floating_sel = vlayer; layer = vlayer; } /* If any layer has a transformation matrix, we apply it after * everything is loaded so that we are sure that order of props * doesn't matter and also we need items to be already attached. * * XXX Right now, this can only be applied to link layers, but * eventually we should be able to port this to any type of layer * as a last-minute transformation in-one concept which would work * as a lesser-destruction edit when applying several * transformations. */ tdata = g_object_get_data (G_OBJECT (layer), "gimp-layer-transform-data"); if (tdata != NULL) { if (! GIMP_IS_LINK_LAYER (layer)) { GIMP_LOG (XCF, "PROP_TRANSFORM property can only be applied on link layers. " "The transformation on layer \"%s\" was dropped.", gimp_object_get_name (layer)); g_object_set_data (G_OBJECT (layer), "gimp-layer-transform-data", NULL); continue; } else if (! gimp_link_layer_is_monitored (GIMP_LINK_LAYER (layer)) || gimp_link_is_broken (gimp_link_layer_get_link (GIMP_LINK_LAYER (layer)))) { /* The loaded buffer from XCF will already be transformed. * It's not an error. */ g_object_set_data (G_OBJECT (layer), "gimp-layer-transform-data", NULL); continue; } gimp_item_set_offset (GIMP_ITEM (layer), tdata->offset_x, tdata->offset_y); gimp_link_layer_set_transform (GIMP_LINK_LAYER (layer), &tdata->matrix, tdata->interpolati g_object_set_data (G_OBJECT (layer), "gimp-layer-transform-data", NULL); } } g_list_free (layers); if (info->selected_layers) { gimp_image_set_selected_layers (image, info->selected_layers); g_clear_pointer (&info->selected_layers, g_list_free); } if (info->selected_channels) gimp_image_set_selected_channels (image, info->selected_channels); if (info->selected_paths) gimp_image_set_selected_paths (image, info->selected_paths); /* We don't have linked items concept anymore. We transform formerly * linked items into stored sets of named items instead. */ if (info->linked_layers) { GimpItemList *set; set = gimp_item_list_named_new (image, GIMP_TYPE_LAYER, _("Linked Layers"), info->linked_layers); gimp_image_store_item_set (image, set); g_clear_pointer (&info->linked_layers, g_list_free); } if (info->linked_channels) { GimpItemList *set; set = gimp_item_list_named_new (image, GIMP_TYPE_CHANNEL, _("Linked Channels"), info->linked_channels); gimp_image_store_item_set (image, set); g_clear_pointer (&info->linked_channels, g_list_free); } if (info->linked_paths) { /* It is kind of ugly but paths are really implemented as * exception in our XCF spec and building over it seems like a * mistake. Since I'm seriously not sure this would be much of an * issue, I'll let it as it for now. * Note that it's still possible to multi-select paths. It's only * not possible to store these selections. * * Only warn for more than 1 linked path. Less is kind of * pointless and doesn't deserve worrying people for no reason. */ if (g_list_length (info->linked_paths) > 1) g_printerr ("xcf: some paths were linked. " "GIMP does not support linked paths since version 3.0.\n"); #if 0 GimpItemList *set; set = gimp_item_list_named_new (image, GIMP_TYPE_PATH, _("Linked Paths"), info->linked_paths); gimp_image_store_item_set (image, set); #endif g_clear_pointer (&info->linked_paths, g_list_free); } for (iter = g_list_last (info->layer_sets); iter; iter = iter->prev) { if (iter->data) gimp_image_store_item_set (image, iter->data); } g_list_free (info->layer_sets); for (iter = g_list_last (info->channel_sets); iter; iter = iter->prev) { if (iter->data) gimp_image_store_item_set (image, iter->data); } g_list_free (info->channel_sets); if (info->file) gimp_image_set_file (image, info->file); if (info->tattoo_state > 0) gimp_image_set_tattoo_state (image, info->tattoo_state); if (n_broken_layers > 0 || n_broken_channels > 0 || n_broken_paths > 0 || n_broken_effects) goto error; gimp_image_undo_enable (image); return image; error: if (num_successful_elements == 0) goto hard_error; g_clear_pointer (&group_layers, g_list_free); g_list_free_full (loop_files, g_object_unref); if (broken_paths) { g_list_free_full (broken_paths, (GDestroyNotify) g_list_free); broken_paths = NULL; } gimp_message_literal (gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, _("This XCF file is corrupt! I have loaded as much " "of it as I can, but it is incomplete.")); xcf_load_add_masks (image); xcf_load_add_effects (info, image); gimp_image_undo_enable (image); return image; hard_error: g_clear_pointer (&group_layers, g_list_free); g_list_free (parent_files); g_list_free_full (loop_files, g_object_unref); if (broken_paths) { g_list_free_full (broken_paths, (GDestroyNotify) g_list_free); broken_paths = NULL; } if (*error) g_prefix_error (error, /* TODO: localize after string freeze ends. */ "This XCF file is corrupt: "); else g_set_error_literal (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, _("This XCF file is corrupt! I could not even " "salvage any partial image data from it.")); g_clear_object (&image); return NULL; } gboolean xcf_load_file_equal (GFile *file1, GFile *file2) { GFileInfo *info1; GFileInfo *info2; const gchar *id1; const gchar *id2; gboolean equal; if (g_file_equal (file1, file2)) return TRUE; info1 = g_file_query_info (file1, G_FILE_ATTRIBUTE_ID_FILE, /* This will follow symlinks by default. */ G_FILE_QUERY_INFO_NONE, NULL, NULL); info2 = g_file_query_info (file2, G_FILE_ATTRIBUTE_ID_FILE, G_FILE_QUERY_INFO_NONE, NULL, NULL); id1 = g_file_info_get_attribute_string (info1, G_FILE_ATTRIBUTE_ID_FILE); id2 = g_file_info_get_attribute_string (info2, G_FILE_ATTRIBUTE_ID_FILE); /* If hard-linking is supported, this will verify 2 files are the same * inode. If we don't have the ID attribute, we just assume these are * different files. */ equal = (id1 && id2 && g_strcmp0 (id1, id2) == 0); g_object_unref (info1); g_object_unref (info2); return equal; } static void xcf_load_add_masks (GimpImage *image) { GList *layers; GList *list; layers = gimp_image_get_layer_list (image); for (list = layers; list; list = g_list_next (list)) { GimpLayer *layer = list->data; GimpLayerMask *mask; mask = g_object_get_data (G_OBJECT (layer), "gimp-layer-mask"); if (mask) { gboolean apply_mask; gboolean edit_mask; gboolean show_mask; apply_mask = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (layer), "gimp-layer-mask-apply")); edit_mask = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (layer), "gimp-layer-mask-edit")); show_mask = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (layer), "gimp-layer-mask-show")); gimp_layer_add_mask (layer, mask, edit_mask, FALSE, NULL); gimp_layer_set_apply_mask (layer, apply_mask, FALSE); gimp_layer_set_show_mask (layer, show_mask, FALSE); g_object_set_data (G_OBJECT (layer), "gimp-layer-mask", NULL); g_object_set_data (G_OBJECT (layer), "gimp-layer-mask-apply", NULL); g_object_set_data (G_OBJECT (layer), "gimp-layer-mask-edit", NULL); g_object_set_data (G_OBJECT (layer), "gimp-layer-mask-show", NULL); } } g_list_free (layers); } static void xcf_load_add_effects (XcfInfo *info, GimpImage *image) { GList *layers; GList *list; layers = gimp_image_get_layer_list (image); for (list = layers; list; list = g_list_next (list)) { GimpLayer *layer = list->data; GList *effects_nodes; effects_nodes = g_object_get_data (G_OBJECT (layer), "gimp-layer-effects"); if (effects_nodes) { GList *iter; for (iter = effects_nodes; iter; iter = iter->next) { FilterData *data = iter->data; if (! data->unsupported_operation) { GimpDrawableFilter *filter = NULL; if (! data->icon_name) data->icon_name = g_strdup ("gimp-gegl"); filter = gimp_drawable_filter_new (GIMP_DRAWABLE (layer), data->name, data->operation, data->icon_name); gimp_drawable_filter_set_opacity (filter, data->opacity); gimp_drawable_filter_set_mode (filter, data->paint_mode, data->blend_space, data->composite_space, data->composite_mode); gimp_drawable_filter_set_clip (filter, data->clip); gimp_drawable_filter_set_region (filter, data->region); g_object_set (filter, "mask", data->mask, NULL); gimp_drawable_filter_apply_with_mask (filter, data->mask, NULL); gimp_drawable_filter_commit (filter, TRUE, NULL, FALSE); gimp_drawable_filter_layer_mask_freeze (filter); gimp_filter_set_active (GIMP_FILTER (filter), data->is_visible); g_object_unref (filter); } } g_object_set_data (G_OBJECT (layer), "gimp-layer-effects", NULL); } } g_list_free (layers); } static gboolean xcf_load_image_props (XcfInfo *info, GimpImage *image) { PropType prop_type; guint32 prop_size; while (TRUE) { if (! xcf_load_prop (info, &prop_type, &prop_size)) return FALSE; switch (prop_type) { case PROP_END: return TRUE; case PROP_COLORMAP: { guint32 n_colors; guchar cmap[GIMP_IMAGE_COLORMAP_SIZE]; xcf_read_int32 (info, &n_colors, 1); if (n_colors > (GIMP_IMAGE_COLORMAP_SIZE / 3)) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_ERROR, "Maximum colormap size (%d) exceeded", GIMP_IMAGE_COLORMAP_SIZE); return FALSE; } if (info->file_version == 0) { gint i; gimp_message_literal (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, _("XCF warning: version 0 of XCF file format\n" "did not save indexed colormaps correctly.\n" "Substituting grayscale map.")); if (! xcf_seek_pos (info, info->cp + n_colors, NULL)) return FALSE; for (i = 0; i < n_colors; i++) { cmap[i * 3 + 0] = i; cmap[i * 3 + 1] = i; cmap[i * 3 + 2] = i; } } else { xcf_read_int8 (info, cmap, n_colors * 3); } /* only set color map if image is indexed, this is just * sanity checking to make sure gimp doesn't end up with * an image state that is impossible. */ if (gimp_image_get_base_type (image) == GIMP_INDEXED) _gimp_image_set_colormap (image, cmap, n_colors, FALSE); GIMP_LOG (XCF, "prop colormap n_colors=%d", n_colors); } break; case PROP_COMPRESSION: { guint8 compression; xcf_read_int8 (info, (guint8 *) &compression, 1); if ((compression != COMPRESS_NONE) && (compression != COMPRESS_RLE) && (compression != COMPRESS_ZLIB) && (compression != COMPRESS_FRACTAL)) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_ERROR, "Unknown compression type: %d", (gint) compression); return FALSE; } info->compression = compression; gimp_image_set_xcf_compression (image, compression >= COMPRESS_ZLIB); GIMP_LOG (XCF, "prop compression=%d", compression); } break; case PROP_GUIDES: { GimpImagePrivate *private = GIMP_IMAGE_GET_PRIVATE (image); gint32 position; gint8 orientation; gint i, nguides; nguides = prop_size / (4 + 1); for (i = 0; i < nguides; i++) { xcf_read_int32 (info, (guint32 *) &position, 1); xcf_read_int8 (info, (guint8 *) &orientation, 1); /* Some very old XCF had -1 guides which have been * skipped since 2003 (commit 909a28ced2). * Then XCF up to version 14 only had positive guide * positions. * Since XCF 15 (GIMP 3.0), off-canvas guides became a * thing. */ if (info->file_version < 15 && position < 0) continue; GIMP_LOG (XCF, "prop guide orientation=%d position=%d", orientation, position); switch (orientation) { case XCF_ORIENTATION_HORIZONTAL: if (info->file_version < 15 && position > gimp_image_get_height (image)) gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Ignoring off-canvas horizontal guide (position %d) in XCF %d file", position, info->file_version); else gimp_image_add_hguide (image, position, FALSE); break; case XCF_ORIENTATION_VERTICAL: if (info->file_version < 15 && position > gimp_image_get_width (image)) gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Ignoring off-canvas vertical guide (position %d) in XCF %d file", position, info->file_version); else gimp_image_add_vguide (image, position, FALSE); break; default: gimp_message_literal (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Guide orientation out of range in XCF file"); continue; } } /* this is silly as the order of guides doesn't really matter, * but it restores the list to its original order, which * cannot be wrong --Mitch */ private->guides = g_list_reverse (private->guides); } break; case PROP_SAMPLE_POINTS: { gint n_sample_points, i; n_sample_points = prop_size / (5 * 4); for (i = 0; i < n_sample_points; i++) { GimpSamplePoint *sample_point; gint32 x, y; GimpColorPickMode pick_mode; guint32 padding[2] = { 0, }; xcf_read_int32 (info, (guint32 *) &x, 1); xcf_read_int32 (info, (guint32 *) &y, 1); xcf_read_int32 (info, (guint32 *) &pick_mode, 1); xcf_read_int32 (info, (guint32 *) padding, 2); GIMP_LOG (XCF, "prop sample point x=%d y=%d mode=%d", x, y, pick_mode); if (pick_mode > GIMP_COLOR_PICK_MODE_LAST) pick_mode = GIMP_COLOR_PICK_MODE_PIXEL; sample_point = gimp_image_add_sample_point_at_pos (image, x, y, FALSE); gimp_image_set_sample_point_pick_mode (image, sample_point, pick_mode, FALSE); } } break; case PROP_OLD_SAMPLE_POINTS: { gint32 x, y; gint i, n_sample_points; /* if there are already sample points, we loaded the new * prop before */ if (gimp_image_get_sample_points (image)) { if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; break; } n_sample_points = prop_size / (4 + 4); for (i = 0; i < n_sample_points; i++) { xcf_read_int32 (info, (guint32 *) &x, 1); xcf_read_int32 (info, (guint32 *) &y, 1); GIMP_LOG (XCF, "prop old sample point x=%d y=%d", x, y); gimp_image_add_sample_point_at_pos (image, x, y, FALSE); } } break; case PROP_RESOLUTION: { gfloat xres, yres; xcf_read_float (info, &xres, 1); xcf_read_float (info, &yres, 1); GIMP_LOG (XCF, "prop resolution x=%f y=%f", xres, yres); if (xres < GIMP_MIN_RESOLUTION || xres > GIMP_MAX_RESOLUTION || yres < GIMP_MIN_RESOLUTION || yres > GIMP_MAX_RESOLUTION) { GimpTemplate *template = image->gimp->config->default_image; gimp_message_literal (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Warning, resolution out of range in XCF file"); xres = gimp_template_get_resolution_x (template); yres = gimp_template_get_resolution_y (template); } gimp_image_set_resolution (image, xres, yres); } break; case PROP_TATTOO: { xcf_read_int32 (info, &info->tattoo_state, 1); GIMP_LOG (XCF, "prop tattoo state=%d", info->tattoo_state); } break; case PROP_PARASITES: { goffset base = info->cp; while (info->cp - base < prop_size) { GimpParasite *p = xcf_load_parasite (info); GError *error = NULL; if (! p) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Invalid image parasite found. " "Possibly corrupt XCF file."); xcf_seek_pos (info, base + prop_size, NULL); continue; } if (! gimp_image_parasite_validate (image, p, &error)) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Warning, invalid image parasite in XCF file: %s", error->message); g_clear_error (&error); } else { gimp_image_parasite_attach (image, p, FALSE); } gimp_parasite_free (p); } if (info->cp - base != prop_size) gimp_message_literal (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Error while loading an image's parasites"); } break; case PROP_UNIT: { guint32 unit_index; xcf_read_int32 (info, &unit_index, 1); GIMP_LOG (XCF, "prop unit=%d", unit_index); if (unit_index <= GIMP_UNIT_PIXEL || unit_index >= GIMP_UNIT_END) { gimp_message_literal (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Warning, unit out of range in XCF file, " "falling back to inches"); unit_index = GIMP_UNIT_INCH; } gimp_image_set_unit (image, gimp_unit_get_by_id (unit_index)); } break; case PROP_PATHS: { goffset base = info->cp; if (info->file_version >= 18) gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "XCF %d file should not contain PROP_PATHS image properties", info->file_version); if (! xcf_load_old_paths (info, image)) xcf_seek_pos (info, base + prop_size, NULL); } break; case PROP_USER_UNIT: { gchar *unit_strings[5] = { 0 }; float factor; guint32 digits; GimpUnit *unit; GList *iter; gint n_fields = 3; gint i; xcf_read_float (info, &factor, 1); xcf_read_int32 (info, &digits, 1); /* Depending on XCF version, read more or less strings. */ if (info->file_version < 21) n_fields = 5; xcf_read_string (info, unit_strings, n_fields); for (i = 0; i < n_fields; i++) if (unit_strings[i] == NULL) unit_strings[i] = g_strdup (""); for (iter = info->gimp->user_units; iter; iter = iter->next) { unit = iter->data; /* if the factor and the name match some unit in unitrc, * use the unitrc unit */ if (ABS (gimp_unit_get_factor (unit) - factor) < 1e-5 && (strcmp (unit_strings[0], gimp_unit_get_name (unit)) == 0 || (info->file_version < 21 && strcmp (unit_strings[4], gimp_unit_get_name (unit)) == 0))) { break; } } if (iter == NULL) /* No match. Create a temporary unit set with deletion * flag. */ unit = _gimp_unit_new (info->gimp, unit_strings[4] && strlen (unit_strings[4]) > 0 ? unit_strings[4] : unit_strings[0], (gdouble) factor, digits, unit_strings[1], unit_strings[2]); gimp_image_set_unit (image, unit); for (i = 0; i < n_fields; i++) g_free (unit_strings[i]); } break; case PROP_VECTORS: { goffset base = info->cp; if (info->file_version >= 18) gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "XCF %d file should not contain PROP_VECTORS image properties", info->file_version); if (xcf_load_old_vectors (info, image)) { if (base + prop_size != info->cp) { g_printerr ("Mismatch in PROP_VECTORS size: " "skipping %" G_GOFFSET_FORMAT " bytes.\n", base + prop_size - info->cp); xcf_seek_pos (info, base + prop_size, NULL); } } else { /* skip silently since we don't understand the format and * xcf_load_old_vectors already explained what was wrong */ xcf_seek_pos (info, base + prop_size, NULL); } } break; case PROP_ITEM_SET: { GimpItemList *set = NULL; gchar *label; GType item_type = 0; guint32 itype; guint32 method; xcf_read_int32 (info, &itype, 1); xcf_read_int32 (info, &method, 1); xcf_read_string (info, &label, 1); if (itype == 0) item_type = GIMP_TYPE_LAYER; else item_type = GIMP_TYPE_CHANNEL; if (itype > 1) { g_printerr ("xcf: unsupported item set '%s' type: %d (skipping)\n", label ? label : "unnamed", itype); /* Only case where we break because we wouldn't even * know where to categorize the item set anyway. */ break; } else if (label == NULL) { g_printerr ("xcf: item set without a name or pattern (skipping)\n"); } else if (method != G_MAXUINT32 && method > GIMP_SELECT_GLOB_PATTERN) { g_printerr ("xcf: unsupported item set '%s' selection method attribute: 0x%x (skipping)\n" label, method); } else { if (method == G_MAXUINT32) { /* Don't use gimp_item_list_named_new() because it * doesn't allow NULL items (it would try to get the * selected items instead). */ set = g_object_new (GIMP_TYPE_ITEM_LIST, "image", image, "name", label, "is-pattern", FALSE, "item-type", item_type, "items", NULL, NULL); } else { set = gimp_item_list_pattern_new (image, item_type, method, label); } } /* Note: we are still adding invalid item sets as NULL on * purpose, in order not to break order-base association * between PROP_ITEM_SET and PROP_ITEM_SET_ITEM. */ if (item_type == GIMP_TYPE_LAYER) info->layer_sets = g_list_prepend (info->layer_sets, set); else info->channel_sets = g_list_prepend (info->channel_sets, set); } break; default: #ifdef GIMP_UNSTABLE g_printerr ("unexpected/unknown image property: %d (skipping)\n", prop_type); #endif if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; break; } } return FALSE; } static gboolean xcf_load_layer_props (XcfInfo *info, GimpImage *image, GimpLayer **layer, GList *loop_files, GList **item_path, gboolean *apply_mask, gboolean *edit_mask, gboolean *show_mask, guint32 *text_layer_flags, guint32 *group_layer_flags) { PropType prop_type; guint32 prop_size; while (TRUE) { if (! xcf_load_prop (info, &prop_type, &prop_size)) return FALSE; switch (prop_type) { case PROP_END: return TRUE; case PROP_ACTIVE_LAYER: { if (g_list_index (info->selected_layers, *layer) < 0) info->selected_layers = g_list_prepend (info->selected_layers, *layer); else gimp_message_literal (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Invalid duplicate selected layer detected"); } break; case PROP_FLOATING_SELECTION: info->floating_sel = *layer; xcf_read_offset (info, &info->floating_sel_offset, 1); break; case PROP_OPACITY: { guint32 opacity; xcf_read_int32 (info, &opacity, 1); gimp_layer_set_opacity (*layer, (gdouble) opacity / 255.0, FALSE); } break; case PROP_FLOAT_OPACITY: { gfloat opacity; xcf_read_float (info, &opacity, 1); gimp_layer_set_opacity (*layer, opacity, FALSE); } break; case PROP_VISIBLE: { gboolean visible; xcf_read_int32 (info, (guint32 *) &visible, 1); gimp_item_set_visible (GIMP_ITEM (*layer), visible, FALSE); } break; case PROP_LINKED: { gboolean linked; xcf_read_int32 (info, (guint32 *) &linked, 1); if (linked) info->linked_layers = g_list_prepend (info->linked_layers, *layer); } break; case PROP_COLOR_TAG: { GimpColorTag color_tag; xcf_read_int32 (info, (guint32 *) &color_tag, 1); gimp_item_set_color_tag (GIMP_ITEM (*layer), color_tag, FALSE); } break; case PROP_LOCK_CONTENT: { gboolean lock_content; xcf_read_int32 (info, (guint32 *) &lock_content, 1); if (gimp_item_can_lock_content (GIMP_ITEM (*layer))) gimp_item_set_lock_content (GIMP_ITEM (*layer), lock_content, FALSE); } break; case PROP_LOCK_ALPHA: { gboolean lock_alpha; xcf_read_int32 (info, (guint32 *) &lock_alpha, 1); if (gimp_layer_can_lock_alpha (*layer)) gimp_layer_set_lock_alpha (*layer, lock_alpha, FALSE); } break; case PROP_LOCK_POSITION: { gboolean lock_position; xcf_read_int32 (info, (guint32 *) &lock_position, 1); if (gimp_item_can_lock_position (GIMP_ITEM (*layer))) gimp_item_set_lock_position (GIMP_ITEM (*layer), lock_position, FALSE); } break; case PROP_LOCK_VISIBILITY: { gboolean lock_visibility; xcf_read_int32 (info, (guint32 *) &lock_visibility, 1); if (gimp_item_can_lock_visibility (GIMP_ITEM (*layer))) gimp_item_set_lock_visibility (GIMP_ITEM (*layer), lock_visibility, FALSE); } break; case PROP_APPLY_MASK: xcf_read_int32 (info, (guint32 *) apply_mask, 1); break; case PROP_EDIT_MASK: xcf_read_int32 (info, (guint32 *) edit_mask, 1); break; case PROP_SHOW_MASK: xcf_read_int32 (info, (guint32 *) show_mask, 1); break; case PROP_OFFSETS: { gint32 offset_x; gint32 offset_y; xcf_read_int32 (info, (guint32 *) &offset_x, 1); xcf_read_int32 (info, (guint32 *) &offset_y, 1); if (offset_x < -GIMP_MAX_IMAGE_SIZE || offset_x > GIMP_MAX_IMAGE_SIZE) { g_printerr ("unexpected item offset_x (%d) in XCF, " "setting to 0\n", offset_x); offset_x = 0; } if (offset_y < -GIMP_MAX_IMAGE_SIZE || offset_y > GIMP_MAX_IMAGE_SIZE) { g_printerr ("unexpected item offset_y (%d) in XCF, " "setting to 0\n", offset_y); offset_y = 0; } gimp_item_set_offset (GIMP_ITEM (*layer), offset_x, offset_y); } break; case PROP_MODE: { GimpLayerMode mode; xcf_read_int32 (info, (guint32 *) &mode, 1); if (mode == GIMP_LAYER_MODE_OVERLAY_LEGACY) mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY; gimp_layer_set_mode (*layer, mode, FALSE); } break; case PROP_BLEND_SPACE: { gint32 blend_space; xcf_read_int32 (info, (guint32 *) &blend_space, 1); /* if blend_space < 0 it was originally AUTO, and its negative is * the actual value AUTO used to map to at the time the file was * saved. if AUTO still maps to the same value, keep using AUTO * for the property; otherwise, use the concrete value. */ if (blend_space < 0) { GimpLayerMode mode = gimp_layer_get_mode (*layer); blend_space = -blend_space; if (blend_space == gimp_layer_mode_get_blend_space (mode)) blend_space = GIMP_LAYER_COLOR_SPACE_AUTO; else GIMP_LOG (XCF, "BLEND_SPACE: AUTO => %d", blend_space); } gimp_layer_set_blend_space (*layer, blend_space, FALSE); } break; case PROP_COMPOSITE_SPACE: { gint32 composite_space; xcf_read_int32 (info, (guint32 *) &composite_space, 1); /* if composite_space < 0 it was originally AUTO, and its negative * is the actual value AUTO used to map to at the time the file was * saved. if AUTO still maps to the same value, keep using AUTO * for the property; otherwise, use the concrete value. */ if (composite_space < 0) { GimpLayerMode mode = gimp_layer_get_mode (*layer); composite_space = -composite_space; if (composite_space == gimp_layer_mode_get_composite_space (mode)) composite_space = GIMP_LAYER_COLOR_SPACE_AUTO; else GIMP_LOG (XCF, "COMPOSITE_SPACE: AUTO => %d", composite_space); } gimp_layer_set_composite_space (*layer, composite_space, FALSE); } break; case PROP_COMPOSITE_MODE: { gint32 composite_mode; xcf_read_int32 (info, (guint32 *) &composite_mode, 1); /* if composite_mode < 0 it was originally AUTO, and its negative * is the actual value AUTO used to map to at the time the file was * saved. if AUTO still maps to the same value, keep using AUTO * for the property; otherwise, use the concrete value. */ if (composite_mode < 0) { GimpLayerMode mode = gimp_layer_get_mode (*layer); composite_mode = -composite_mode; if (composite_mode == gimp_layer_mode_get_composite_mode (mode)) composite_mode = GIMP_LAYER_COMPOSITE_AUTO; else GIMP_LOG (XCF, "COMPOSITE_MODE: AUTO => %d", composite_mode); } gimp_layer_set_composite_mode (*layer, composite_mode, FALSE); } break; case PROP_TATTOO: { GimpTattoo tattoo; xcf_read_int32 (info, (guint32 *) &tattoo, 1); gimp_item_set_tattoo (GIMP_ITEM (*layer), tattoo); } break; case PROP_PARASITES: { goffset base = info->cp; while (info->cp - base < prop_size) { GimpParasite *p = xcf_load_parasite (info); GError *error = NULL; if (! p) return FALSE; if (! gimp_item_parasite_validate (GIMP_ITEM (*layer), p, &error)) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Warning, invalid layer parasite in XCF file: %s", error->message); g_clear_error (&error); } else { gimp_item_parasite_attach (GIMP_ITEM (*layer), p, FALSE); } gimp_parasite_free (p); } if (info->cp - base != prop_size) gimp_message_literal (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Error while loading a layer's parasites"); } break; case PROP_TEXT_LAYER_FLAGS: xcf_read_int32 (info, text_layer_flags, 1); break; case PROP_VECTOR_LAYER: { VectorLayerData *data; guint32 uint_val; gfloat float_val; goffset next_prop; gboolean valid_color = TRUE; GError *error = NULL; next_prop = info->cp + prop_size; data = g_new0 (VectorLayerData, 1); xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->modified = (gboolean) uint_val; xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->path_tattoo = (GimpTattoo) uint_val; xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->enable_fill = (gboolean) uint_val; xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->enable_stroke = (gboolean) uint_val; xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->fill_style = (GimpCustomStyle) uint_val; xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->fill_antialias = (gboolean) uint_val; data->fill_color = xcf_load_color (info, next_prop, &valid_color, &error); if (error) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Warning, invalid color in XCF file: %s", error->message); g_clear_error (&error); valid_color = TRUE; } data->fill_pattern = GIMP_PATTERN (xcf_load_data (info, GIMP_TYPE_PATTERN, &error)); /* Just ignore errors here? */ g_clear_error (&error); xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->stroke_style = (GimpCustomStyle) uint_val; xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->stroke_antialias = (gboolean) uint_val; data->stroke_color = xcf_load_color (info, next_prop, &valid_color, &error); if (error) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Warning, invalid color in XCF file: %s", error->message); g_clear_error (&error); valid_color = TRUE; } /* Just ignore errors here? */ data->stroke_pattern = GIMP_PATTERN (xcf_load_data (info, GIMP_TYPE_PATTERN, &error)); g_clear_error (&error); xcf_read_float (info, (gfloat *) &float_val, 1); data->stroke_width = (gfloat) float_val; xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->stroke_cap_style = (GimpCapStyle) uint_val; xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->stroke_join_style = (GimpJoinStyle) uint_val; xcf_read_float (info, (gfloat *) &float_val, 1); data->stroke_miter_limit = (gfloat) float_val; xcf_read_int32 (info, (guint32 *) &uint_val, 1); data->n_stroke_dashes = (gboolean) uint_val; data->stroke_dashes = g_new0 (gdouble, data->n_stroke_dashes); for (gint i = 0; i < data->n_stroke_dashes; i++) { xcf_read_float (info, (gfloat *) &float_val, 1); data->stroke_dashes[i] = (gdouble) float_val; } g_object_set_data_full (G_OBJECT (*layer), "gimp-vector-layer-data", data, (GDestroyNotify) xcf_load_free_vector_data); } break; case PROP_LINK_LAYER: { gchar *path; guint32 flags; guint32 dimensions[2]; xcf_read_int32 (info, &flags, 1); xcf_read_string (info, &path, 1); xcf_read_int32 (info, dimensions, 2); if (path == NULL) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "XCF Warning: invalid link in XCF file. " "The link layer \"%s\" is downgraded to a raster layer.", gimp_object_get_name (*layer)); } else { GFile *folder; GFile *link_file; gboolean ignore = FALSE; folder = g_file_get_parent (info->file); link_file = g_file_resolve_relative_path (folder, path); g_object_unref (folder); for (GList *iter = loop_files; iter; iter = iter->next) { if (xcf_load_file_equal (iter->data, link_file)) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "XCF Warning: cycling link detected in XCF file. " "The link layer \"%s\" is downgraded to a raster layer.", gimp_object_get_name (*layer)); ignore = TRUE; break; } } if (! ignore) { GimpLink *link; GList *selected; GList *linked; gboolean floating; gint raster_width; gint raster_height; raster_width = gimp_item_get_width (GIMP_ITEM (*layer)); raster_height = gimp_item_get_height (GIMP_ITEM (*layer)); floating = (info->floating_sel == *layer); selected = g_list_find (info->selected_layers, *layer); linked = g_list_find (info->linked_layers, *layer); link = gimp_link_new (info->gimp, link_file, (gint) dimensions[0], (gint) dimensions[1], FALSE, NULL, NULL); *layer = gimp_layer_from_layer (*layer, GIMP_TYPE_LINK_LAYER, "image", image, NULL); gimp_link_layer_set_link (GIMP_LINK_LAYER (*layer), link, FALSE); gimp_link_layer_set_xcf_flags (GIMP_LINK_LAYER (*layer), flags); if (! gimp_link_layer_is_monitored (GIMP_LINK_LAYER (*layer)) || gimp_link_is_broken (gimp_link_layer_get_link (GIMP_LINK_LAYER (*layer)))) { GeglColor *color = gegl_color_new ("transparent"); /* Let's completely ignore the link size. The * stored buffer will be used instead, so we * should resize the item back to how it was. * We don't care about proper scaling here, * the buffer will be the real content. */ gimp_item_resize (GIMP_ITEM (*layer), gimp_get_user_context (info->gimp), GIMP_FILL_WHITE, raster_width, raster_height, 0, 0); gegl_buffer_set_color (gimp_drawable_get_buffer (GIMP_DRAWABLE (*layer)), NULL, color); g_object_unref (color); } if (selected) { info->selected_layers = g_list_delete_link (info->selected_layers, selected); info->selected_layers = g_list_prepend (info->selected_layers, *layer); } if (linked) { info->linked_layers = g_list_delete_link (info->linked_layers, linked); info->linked_layers = g_list_prepend (info->linked_layers, *layer); } if (floating) info->floating_sel = *layer; g_object_unref (link); } g_object_unref (link_file); } g_free (path); } break; case PROP_TRANSFORM: { LayerTransformData *data; gint32 int_val[2]; guint32 uint_val; gfloat mfloat[9]; data = g_new0 (LayerTransformData, 1); xcf_read_int32 (info, (guint32 *) int_val, 2); data->offset_x = (gint) int_val[0]; data->offset_y = (gint) int_val[1]; xcf_read_int32 (info, &uint_val, 1); data->interpolation = (GimpInterpolationType) uint_val; xcf_read_float (info, mfloat, 9); data->matrix.coeff[0][0] = (gdouble) mfloat[0]; data->matrix.coeff[0][1] = (gdouble) mfloat[1]; data->matrix.coeff[0][2] = (gdouble) mfloat[2]; data->matrix.coeff[1][0] = (gdouble) mfloat[3]; data->matrix.coeff[1][1] = (gdouble) mfloat[4]; data->matrix.coeff[1][2] = (gdouble) mfloat[5]; data->matrix.coeff[2][0] = (gdouble) mfloat[6]; data->matrix.coeff[2][1] = (gdouble) mfloat[7]; data->matrix.coeff[2][2] = (gdouble) mfloat[8]; g_object_set_data_full (G_OBJECT (*layer), "gimp-layer-transform-data", data, (GDestroyNotify) g_free); } break; case PROP_GROUP_ITEM: { GimpLayer *group; gboolean is_selected_layer; /* We're going to delete *layer, Don't leave its pointers * in @info. After that, we'll restore them back with the * new pointer. See bug #767873. */ is_selected_layer = (g_list_find (info->selected_layers, *layer ) != NULL); if (is_selected_layer) info->selected_layers = g_list_remove (info->selected_layers, *layer); if (*layer == info->floating_sel) info->floating_sel = NULL; group = gimp_group_layer_new (image); gimp_object_set_name (GIMP_OBJECT (group), gimp_object_get_name (*layer)); g_object_ref_sink (*layer); g_object_unref (*layer); *layer = group; if (is_selected_layer) info->selected_layers = g_list_prepend (info->selected_layers, *layer); /* Don't restore info->floating_sel because group layers * can't be floating selections */ } break; case PROP_ITEM_PATH: { goffset base = info->cp; GList *path = NULL; while (info->cp - base < prop_size) { guint32 index; if (xcf_read_int32 (info, &index, 1) != 4) { g_list_free (path); return FALSE; } path = g_list_append (path, GUINT_TO_POINTER (index)); } *item_path = path; } break; case PROP_GROUP_ITEM_FLAGS: xcf_read_int32 (info, group_layer_flags, 1); break; case PROP_ITEM_SET_ITEM: { GimpItemList *set; guint32 n; xcf_read_int32 (info, &n, 1); set = g_list_nth_data (info->layer_sets, n); if (set == NULL) g_printerr ("xcf: layer '%s' cannot be added to unknown layer set at index %d (skipping)\n", gimp_object_get_name (*layer), n); else if (! g_type_is_a (G_TYPE_FROM_INSTANCE (*layer), gimp_item_list_get_item_type (set))) g_printerr ("xcf: layer '%s' cannot be added to item set '%s' with item type %s (skipping)\n", gimp_object_get_name (*layer), gimp_object_get_name (set), g_type_name (gimp_item_list_get_item_type (set))); else if (gimp_item_list_is_pattern (set, NULL)) g_printerr ("xcf: layer '%s' cannot be added to pattern item set '%s' (skipping)\n", gimp_object_get_name (*layer), gimp_object_get_name (set)); else gimp_item_list_add (set, GIMP_ITEM (*layer)); } break; default: #ifdef GIMP_UNSTABLE g_printerr ("unexpected/unknown layer property: %d (skipping)\n", prop_type); #endif if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; break; } } return FALSE; } static gboolean xcf_check_layer_props (XcfInfo *info, GList **item_path, gboolean *is_group_layer, gboolean *is_text_layer, gboolean *is_link_layer) { PropType prop_type; guint32 prop_size; g_return_val_if_fail (*is_group_layer == FALSE, FALSE); g_return_val_if_fail (*is_text_layer == FALSE, FALSE); g_return_val_if_fail (*is_link_layer == TRUE, FALSE); while (TRUE) { if (! xcf_load_prop (info, &prop_type, &prop_size)) return FALSE; switch (prop_type) { case PROP_END: return TRUE; case PROP_TEXT_LAYER_FLAGS: *is_text_layer = TRUE; if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; break; case PROP_LINK_LAYER: *is_link_layer = TRUE; if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; break; case PROP_GROUP_ITEM: case PROP_GROUP_ITEM_FLAGS: *is_group_layer = TRUE; if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; break; case PROP_ITEM_PATH: { goffset base = info->cp; GList *path = NULL; while (info->cp - base < prop_size) { guint32 index; if (xcf_read_int32 (info, &index, 1) != 4) { g_list_free (path); return FALSE; } path = g_list_append (path, GUINT_TO_POINTER (index)); } *item_path = path; } break; case PROP_ACTIVE_LAYER: case PROP_FLOATING_SELECTION: case PROP_OPACITY: case PROP_FLOAT_OPACITY: case PROP_VISIBLE: case PROP_LINKED: case PROP_COLOR_TAG: case PROP_LOCK_CONTENT: case PROP_LOCK_ALPHA: case PROP_LOCK_POSITION: case PROP_LOCK_VISIBILITY: case PROP_APPLY_MASK: case PROP_EDIT_MASK: case PROP_SHOW_MASK: case PROP_OFFSETS: case PROP_MODE: case PROP_BLEND_SPACE: case PROP_COMPOSITE_SPACE: case PROP_COMPOSITE_MODE: case PROP_TATTOO: case PROP_PARASITES: case PROP_ITEM_SET_ITEM: if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; /* Just ignore for now. */ break; default: #ifdef GIMP_UNSTABLE g_printerr ("unexpected/unknown layer property: %d (skipping)\n", prop_type); #endif if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; break; } } return FALSE; } static gboolean xcf_load_channel_props (XcfInfo *info, GimpImage *image, GimpChannel **channel, gboolean is_mask) { PropType prop_type; guint32 prop_size; while (TRUE) { if (! xcf_load_prop (info, &prop_type, &prop_size)) return FALSE; switch (prop_type) { case PROP_END: return TRUE; case PROP_ACTIVE_CHANNEL: info->selected_channels = g_list_prepend (info->selected_channels, *channel); break; case PROP_SELECTION: { GimpChannel *mask; GList *iter; if (is_mask) { /* PROP_SELECTION is not valid for masks, and we have to avoid * overwriting the channel. */ continue; } if (*channel == gimp_image_get_mask (image)) { /* PROP_SELECTION was already seen once for this * channel. Let's silently ignore the second identical * property to avoid a double free. */ continue; } else if (gimp_image_get_mask (image) != NULL && ! gimp_channel_is_empty (gimp_image_get_mask (image))) { /* This would happen when PROP_SELECTION was already set * on a previous channel. This is a minor case of data * loss (we don't know which selection was the right one * and we drop the non-first ones), and also means it's * a broken XCF, though it's not a major bug either. So * let's go with a stderr print. */ g_printerr ("PROP_SELECTION property was set on 2 channels (skipping)\n"); continue; } /* We're going to delete *channel, Don't leave its pointer * in @info. See bug #767873. */ for (iter = info->selected_channels; iter; iter = iter->next) if (*channel == iter->data) { info->selected_channels = g_list_delete_link (info->selected_channels, iter); break; } mask = gimp_selection_new (image, gimp_item_get_width (GIMP_ITEM (*channel)), gimp_item_get_height (GIMP_ITEM (*channel))); gimp_image_take_mask (image, mask); gimp_drawable_steal_buffer (GIMP_DRAWABLE (mask), GIMP_DRAWABLE (*channel)); g_object_unref (*channel); *channel = mask; /* Don't restore info->selected_channels because the * selection can't be the active channel */ } break; case PROP_OPACITY: { guint32 opacity; xcf_read_int32 (info, &opacity, 1); gimp_channel_set_opacity (*channel, opacity / 255.0, FALSE); } break; case PROP_FLOAT_OPACITY: { gfloat opacity; xcf_read_float (info, &opacity, 1); gimp_channel_set_opacity (*channel, opacity, FALSE); } break; case PROP_VISIBLE: { gboolean visible; xcf_read_int32 (info, (guint32 *) &visible, 1); gimp_item_set_visible (GIMP_ITEM (*channel), visible, FALSE); } break; case PROP_COLOR_TAG: { GimpColorTag color_tag; xcf_read_int32 (info, (guint32 *) &color_tag, 1); gimp_item_set_color_tag (GIMP_ITEM (*channel), color_tag, FALSE); } break; case PROP_LINKED: { gboolean linked; xcf_read_int32 (info, (guint32 *) &linked, 1); if (linked) info->linked_channels = g_list_prepend (info->linked_channels, *channel); } break; case PROP_LOCK_CONTENT: { gboolean lock_content; xcf_read_int32 (info, (guint32 *) &lock_content, 1); if (gimp_item_can_lock_content (GIMP_ITEM (*channel))) gimp_item_set_lock_content (GIMP_ITEM (*channel), lock_content, FALSE); } break; case PROP_LOCK_POSITION: { gboolean lock_position; xcf_read_int32 (info, (guint32 *) &lock_position, 1); if (gimp_item_can_lock_position (GIMP_ITEM (*channel))) gimp_item_set_lock_position (GIMP_ITEM (*channel), lock_position, FALSE); } break; case PROP_LOCK_VISIBILITY: { gboolean lock_visibility; xcf_read_int32 (info, (guint32 *) &lock_visibility, 1); if (gimp_item_can_lock_visibility (GIMP_ITEM (*channel))) gimp_item_set_lock_visibility (GIMP_ITEM (*channel), lock_visibility, FALSE); } break; case PROP_SHOW_MASKED: { gboolean show_masked; xcf_read_int32 (info, (guint32 *) &show_masked, 1); gimp_channel_set_show_masked (*channel, show_masked); } break; case PROP_COLOR: { guchar col[3]; gdouble opacity; /* Load existing opacity */ opacity = gimp_channel_get_opacity (*channel); xcf_read_int8 (info, (guint8 *) col, 3); gegl_color_set_pixel ((*channel)->color, babl_format ("R'G'B' u8"), col); gimp_channel_set_opacity (*channel, opacity, FALSE); } break; case PROP_FLOAT_COLOR: { gfloat col[3]; gdouble opacity; /* Load existing opacity */ opacity = gimp_channel_get_opacity (*channel); xcf_read_float (info, col, 3); /* TODO: is the channel color in sRGB or in the image's color space? */ gegl_color_set_pixel ((*channel)->color, babl_format ("R'G'B' float"), col); gimp_channel_set_opacity (*channel, opacity, FALSE); } break; case PROP_TATTOO: { GimpTattoo tattoo; xcf_read_int32 (info, (guint32 *) &tattoo, 1); gimp_item_set_tattoo (GIMP_ITEM (*channel), tattoo); } break; case PROP_PARASITES: { goffset base = info->cp; while ((info->cp - base) < prop_size) { GimpParasite *p = xcf_load_parasite (info); GError *error = NULL; if (! p) return FALSE; if (! gimp_item_parasite_validate (GIMP_ITEM (*channel), p, &error)) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Warning, invalid channel parasite in XCF file: %s", error->message); g_clear_error (&error); } else { gimp_item_parasite_attach (GIMP_ITEM (*channel), p, FALSE); } gimp_parasite_free (p); } if (info->cp - base != prop_size) gimp_message_literal (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Error while loading a channel's parasites"); } break; case PROP_ITEM_SET_ITEM: { GimpItemList *set; guint32 n; xcf_read_int32 (info, &n, 1); set = g_list_nth_data (info->channel_sets, n); if (set == NULL) g_printerr ("xcf: unknown channel set: %d (skipping)\n", n); else if (! g_type_is_a (G_TYPE_FROM_INSTANCE (*channel), gimp_item_list_get_item_type (set))) g_printerr ("xcf: channel '%s' cannot be added to item set '%s' with item type %s (skipping)\n" gimp_object_get_name (*channel), gimp_object_get_name (set), g_type_name (gimp_item_list_get_item_type (set))); else gimp_item_list_add (set, GIMP_ITEM (*channel)); } break; default: #ifdef GIMP_UNSTABLE g_printerr ("unexpected/unknown channel property: %d (skipping)\n", prop_type); #endif if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; break; } } return FALSE; } static gboolean xcf_load_effect_props (XcfInfo *info, FilterData *filter) { PropType prop_type; guint32 prop_size; while (TRUE) { goffset next_prop; if (! xcf_load_prop (info, &prop_type, &prop_size)) return FALSE; next_prop = info->cp + prop_size; switch (prop_type) { case PROP_END: return TRUE; case PROP_VISIBLE: { gboolean visible; xcf_read_int32 (info, (guint32 *) &visible, 1); filter->is_visible = visible; } break; case PROP_FLOAT_OPACITY: { gfloat opacity; xcf_read_float (info, &opacity, 1); filter->opacity = (gdouble) opacity; } break; case PROP_MODE: { GimpLayerMode mode; xcf_read_int32 (info, (guint32 *) &mode, 1); if (mode == GIMP_LAYER_MODE_OVERLAY_LEGACY) mode = GIMP_LAYER_MODE_SOFTLIGHT_LEGACY; filter->paint_mode = mode; } break; case PROP_BLEND_SPACE: { gint32 blend_space; xcf_read_int32 (info, (guint32 *) &blend_space, 1); /* TODO: Revisit when blend space can be set * on filter effects */ blend_space = GIMP_LAYER_COLOR_SPACE_AUTO; filter->blend_space = blend_space; } break; case PROP_COMPOSITE_SPACE: { gint32 composite_space; xcf_read_int32 (info, (guint32 *) &composite_space, 1); /* TODO: Revisit when composite space can be set * on filter effects */ composite_space = GIMP_LAYER_COLOR_SPACE_AUTO; filter->composite_space = composite_space; } break; case PROP_COMPOSITE_MODE: { gint32 composite_mode; xcf_read_int32 (info, (guint32 *) &composite_mode, 1); /* TODO: Revisit when composite mode can be set * on filter effects */ composite_mode = GIMP_LAYER_COMPOSITE_AUTO; filter->composite_mode = composite_mode; } break; case PROP_FILTER_REGION: { GimpFilterRegion region; xcf_read_int32 (info, (guint32 *) ®ion, 1); filter->region = region; } break; case PROP_FILTER_ARGUMENT: { GParamSpec *pspec; gchar *filter_prop_name; guint32 filter_type = FILTER_PROP_UNKNOWN; GValue filter_prop_value = G_VALUE_INIT; gboolean valid_prop_value = TRUE; xcf_read_string (info, &filter_prop_name, 1); xcf_read_int32 (info, (guint32 *) &filter_type, 1); /* Check if valid property first */ if (! (pspec = gegl_operation_find_property (filter->operation_name, filter_prop_name))) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, _("XCF Warning: version %s of filter \"%s\" does not " "have the %s property. The property was ignored and " "the filter may not render properly.\n" "This should not happen. " "You should report the issue to the filter's developers."), filter->op_version ? filter->op_version : "0:0", filter->operation_name, filter_prop_name); valid_prop_value = FALSE; goto set_or_seek_node_property; } switch (filter_type) { case FILTER_PROP_INT: case FILTER_PROP_UINT: case FILTER_PROP_ENUM: { guint32 value; xcf_read_int32 (info, (guint32 *) &value, 1); g_value_init (&filter_prop_value, pspec->value_type); if (filter_type == FILTER_PROP_INT) g_value_set_int (&filter_prop_value, value); else if (filter_type == FILTER_PROP_UINT) g_value_set_uint (&filter_prop_value, value); else g_value_set_enum (&filter_prop_value, value); } break; case FILTER_PROP_BOOL: { gboolean value; xcf_read_int32 (info, (guint32 *) &value, 1); g_value_init (&filter_prop_value, G_TYPE_BOOLEAN); g_value_set_boolean (&filter_prop_value, value); } break; case FILTER_PROP_FLOAT: { gfloat value; xcf_read_float (info, &value, 1); g_value_init (&filter_prop_value, G_TYPE_FLOAT); g_value_set_float (&filter_prop_value, value); } break; case FILTER_PROP_STRING: { gchar *value; xcf_read_string (info, &value, 1); g_value_init (&filter_prop_value, G_TYPE_STRING); g_value_set_string (&filter_prop_value, value); g_free (value); } break; case FILTER_PROP_CONFIG: { GObject *config; gchar *serialized; GError *error = NULL; if (! g_type_is_a (pspec->value_type, GIMP_TYPE_CONFIG)) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "XCF Warning: property '%s' of filter '%s' is a %s, which does not implement GimpConfig interfa filter_prop_name, filter->operation_name, g_type_name (pspec->value_type)); valid_prop_value = FALSE; break; } xcf_read_string (info, &serialized, 1); if (! (serialized && strlen (serialized))) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "XCF Warning: failure to deserialize config object for property '%s' of filter '%s'.\n" "Serialized config could not be read.", filter_prop_name, filter->operation_name); valid_prop_value = FALSE; break; } g_value_init (&filter_prop_value, pspec->value_type); config = g_object_new (pspec->value_type, NULL); if (gimp_config_deserialize_string (GIMP_CONFIG (config), serialized, -1, NULL, &error)) { g_value_set_object (&filter_prop_value, config); } else { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "XCF Warning: failure to deserialize config object for property '%s' of filter '%s': %s\n" "Serialized config was: %s", filter_prop_name, filter->operation_name, error->message, serialized); valid_prop_value = FALSE; } g_object_unref (config); g_free (serialized); } break; case FILTER_PROP_COLOR: { GeglColor *color; GError *error = NULL; g_value_init (&filter_prop_value, GEGL_TYPE_COLOR); color = xcf_load_color (info, next_prop, &valid_prop_value, &error); if (valid_prop_value) { g_value_set_object (&filter_prop_value, color); if (color == NULL) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "XCF Warning: NULL value for color " "property '%s' of filter '%s' is " "invalid.", filter->operation_name, filter_prop_name); valid_prop_value = FALSE; } } else if (error != NULL) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "XCF Warning: invalid value for color " "property '%s' of filter '%s': %s", filter->operation_name, filter_prop_name, error->message); } g_clear_object (&color); g_clear_error (&error); } break; default: gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "XCF Warning: property '%s' of filter '%s' holds unsupported type %s.\n", filter_prop_name, filter->operation_name, g_type_name (pspec->value_type)); valid_prop_value = FALSE; break; } set_or_seek_node_property: if (valid_prop_value) gegl_node_set_property (filter->operation, filter_prop_name, &filter_prop_value); else xcf_seek_pos (info, next_prop, NULL); g_value_unset (&filter_prop_value); g_free (filter_prop_name); } break; case PROP_FILTER_CLIP: { gboolean clip; xcf_read_int32 (info, (guint32 *) &clip, 1); filter->clip = clip; } break; default: #ifdef GIMP_UNSTABLE g_printerr ("unexpected/unknown effect property: %d (skipping)\n", prop_type); #endif if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; } } return FALSE; } static gboolean xcf_load_path_props (XcfInfo *info, GimpImage *image, GimpPath **path) { PropType prop_type; guint32 prop_size; while (TRUE) { if (! xcf_load_prop (info, &prop_type, &prop_size)) return FALSE; switch (prop_type) { case PROP_END: return TRUE; case PROP_SELECTED_PATH: info->selected_paths = g_list_prepend (info->selected_paths, *path); break; case PROP_VISIBLE: { gboolean visible; xcf_read_int32 (info, (guint32 *) &visible, 1); gimp_item_set_visible (GIMP_ITEM (*path), visible, FALSE); } break; case PROP_COLOR_TAG: { GimpColorTag color_tag; xcf_read_int32 (info, (guint32 *) &color_tag, 1); gimp_item_set_color_tag (GIMP_ITEM (*path), color_tag, FALSE); } break; case PROP_LOCK_CONTENT: { gboolean lock_content; xcf_read_int32 (info, (guint32 *) &lock_content, 1); if (gimp_item_can_lock_content (GIMP_ITEM (*path))) gimp_item_set_lock_content (GIMP_ITEM (*path), lock_content, FALSE); } break; case PROP_LOCK_POSITION: { gboolean lock_position; xcf_read_int32 (info, (guint32 *) &lock_position, 1); if (gimp_item_can_lock_position (GIMP_ITEM (*path))) gimp_item_set_lock_position (GIMP_ITEM (*path), lock_position, FALSE); } break; case PROP_LOCK_VISIBILITY: { gboolean lock_visibility; xcf_read_int32 (info, (guint32 *) &lock_visibility, 1); if (gimp_item_can_lock_visibility (GIMP_ITEM (*path))) gimp_item_set_lock_visibility (GIMP_ITEM (*path), lock_visibility, FALSE); } break; case PROP_TATTOO: { GimpTattoo tattoo; xcf_read_int32 (info, (guint32 *) &tattoo, 1); gimp_item_set_tattoo (GIMP_ITEM (*path), tattoo); } break; case PROP_PARASITES: { goffset base = info->cp; while ((info->cp - base) < prop_size) { GimpParasite *p = xcf_load_parasite (info); GError *error = NULL; if (! p) return FALSE; if (! gimp_item_parasite_validate (GIMP_ITEM (*path), p, &error)) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Warning, invalid path parasite in XCF file: %s", error->message); g_clear_error (&error); } else { gimp_item_parasite_attach (GIMP_ITEM (*path), p, FALSE); } gimp_parasite_free (p); } if (info->cp - base != prop_size) gimp_message_literal (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Error while loading a path's parasites"); } break; #if 0 case PROP_ITEM_SET_ITEM: { GimpItemList *set; guint32 n; xcf_read_int32 (info, &n, 1); set = g_list_nth_data (info->path_sets, n); if (set == NULL) g_printerr ("xcf: unknown path set: %d (skipping)\n", n); else if (! g_type_is_a (G_TYPE_FROM_INSTANCE (*path), gimp_item_list_get_item_type (set))) g_printerr ("xcf: path '%s' cannot be added to item set '%s' with item type %s (skipping)\n", gimp_object_get_name (*path), gimp_object_get_name (set), g_type_name (gimp_item_list_get_item_type (set))); else gimp_item_list_add (set, GIMP_ITEM (*path)); } break; #endif default: #ifdef GIMP_UNSTABLE g_printerr ("unexpected/unknown path property: %d (skipping)\n", prop_type); #endif if (! xcf_skip_unknown_prop (info, prop_size)) return FALSE; break; } } return FALSE; } static gboolean xcf_load_prop (XcfInfo *info, PropType *prop_type, guint32 *prop_size) { if (G_UNLIKELY (xcf_read_int32 (info, (guint32 *) prop_type, 1) != 4)) return FALSE; if (G_UNLIKELY (xcf_read_int32 (info, (guint32 *) prop_size, 1) != 4)) return FALSE; GIMP_LOG (XCF, "prop type=%d size=%u", *prop_type, *prop_size); return TRUE; } static GimpLayer * xcf_load_layer (XcfInfo *info, GimpImage *image, GList *loop_files, GList **item_path, gint *n_broken_effects) { GimpLayer *layer; GimpLayerMask *layer_mask; goffset hierarchy_offset; goffset effects_offset = 0; goffset layer_mask_offset; gboolean apply_mask = TRUE; gboolean edit_mask = FALSE; gboolean show_mask = FALSE; GList *selected; GList *linked; GList *filter_data_list = NULL; gboolean floating; guint32 group_layer_flags = 0; guint32 text_layer_flags = 0; gint filter_count = 0; gint width; gint height; gint type; GimpImageBaseType base_type; gboolean has_alpha; const Babl *format; gboolean is_fs_drawable; gchar *name; goffset cur_offset; /* check and see if this is the drawable the floating selection * is attached to. if it is then we'll do the attachment in our caller. */ is_fs_drawable = (info->cp == info->floating_sel_offset); /* read in the layer width, height, type and name */ xcf_read_int32 (info, (guint32 *) &width, 1); xcf_read_int32 (info, (guint32 *) &height, 1); xcf_read_int32 (info, (guint32 *) &type, 1); xcf_read_string (info, &name, 1); GIMP_LOG (XCF, "width=%d, height=%d, type=%d, name='%s'", width, height, type, name); switch (type) { case GIMP_RGB_IMAGE: base_type = GIMP_RGB; has_alpha = FALSE; break; case GIMP_RGBA_IMAGE: base_type = GIMP_RGB; has_alpha = TRUE; break; case GIMP_GRAY_IMAGE: base_type = GIMP_GRAY; has_alpha = FALSE; break; case GIMP_GRAYA_IMAGE: base_type = GIMP_GRAY; has_alpha = TRUE; break; case GIMP_INDEXED_IMAGE: base_type = GIMP_INDEXED; has_alpha = FALSE; break; case GIMP_INDEXEDA_IMAGE: base_type = GIMP_INDEXED; has_alpha = TRUE; break; default: g_free (name); return NULL; } if (width <= 0 || height <= 0 || width > GIMP_MAX_IMAGE_SIZE || height > GIMP_MAX_IMAGE_SIZE) { gboolean is_group_layer = FALSE; gboolean is_text_layer = FALSE; gboolean is_link_layer = FALSE; goffset saved_pos; saved_pos = info->cp; /* Load item path and check if this is a group or text layer. */ xcf_check_layer_props (info, item_path, &is_group_layer, &is_text_layer, &is_link_layer); if ((is_text_layer || is_group_layer || is_link_layer) && xcf_seek_pos (info, saved_pos, NULL)) { /* Something is wrong, but leave a chance to the layer because * anyway group, text and link layer depends on their contents. */ width = height = 1; g_clear_pointer (item_path, g_list_free); } else { g_free (name); return NULL; } } if (base_type == GIMP_GRAY) { /* do not use gimp_image_get_layer_format() because it might * be the floating selection of a channel or mask */ format = gimp_image_get_format (image, base_type, gimp_image_get_precision (image), has_alpha, NULL /* we will fix the space later */); } else { format = gimp_image_get_layer_format (image, has_alpha); } /* create a new layer */ layer = gimp_layer_new (image, width, height, format, name, GIMP_OPACITY_OPAQUE, GIMP_LAYER_MODE_NORMAL); g_free (name); if (! layer) return NULL; /* read in the layer properties */ if (! xcf_load_layer_props (info, image, &layer, loop_files, item_path, &apply_mask, &edit_mask, &show_mask, &text_layer_flags, &group_layer_flags)) goto error; GIMP_LOG (XCF, "layer props loaded"); xcf_progress_update (info); /* call the evil text layer hack that might change our layer pointer */ selected = g_list_find (info->selected_layers, layer); linked = g_list_find (info->linked_layers, layer); floating = (info->floating_sel == layer); if (gimp_text_layer_xcf_load_hack (&layer)) { gimp_text_layer_set_xcf_flags (GIMP_TEXT_LAYER (layer), text_layer_flags); if (selected) { info->selected_layers = g_list_delete_link (info->selected_layers, selected); info->selected_layers = g_list_prepend (info->selected_layers, layer); } if (linked) { info->linked_layers = g_list_delete_link (info->linked_layers, linked); info->linked_layers = g_list_prepend (info->linked_layers, layer); } if (floating) info->floating_sel = layer; } /* if this is not the floating selection, we can fix the layer's * space already now, the function will do nothing if we already * created the layer with the right format */ if (! floating && base_type == GIMP_GRAY) gimp_layer_fix_format_space (layer, FALSE, FALSE); /* read the hierarchy and layer mask offsets */ cur_offset = info->cp; xcf_read_offset (info, &hierarchy_offset, 1); xcf_read_offset (info, &layer_mask_offset, 1); if (info->file_version >= 20) xcf_read_offset (info, &effects_offset, 1); /* read in the hierarchy (ignore it for group layers, both as an * optimization and because the hierarchy's extents don't match * the group layer's tiles) */ if (! gimp_viewable_get_children (GIMP_VIEWABLE (layer)) && /* Link layers are loaded from XCF only if they are not monitored * or if the link is broken. */ (! GIMP_IS_LINK_LAYER (layer) || ! gimp_link_layer_is_monitored (GIMP_LINK_LAYER (layer)) || gimp_link_is_broken (gimp_link_layer_get_link (GIMP_LINK_LAYER (layer))))) { if (hierarchy_offset < cur_offset) { GIMP_LOG (XCF, "Invalid layer hierarchy offset!"); goto error; } if (! xcf_seek_pos (info, hierarchy_offset, NULL)) goto error; GIMP_LOG (XCF, "loading buffer"); if (! xcf_load_buffer (info, gimp_drawable_get_buffer (GIMP_DRAWABLE (layer)))) goto error; GIMP_LOG (XCF, "buffer loaded"); xcf_progress_update (info); } else { gboolean expanded = group_layer_flags & XCF_GROUP_ITEM_EXPANDED; gimp_viewable_set_expanded (GIMP_VIEWABLE (layer), expanded); } cur_offset += info->bytes_per_offset; /* read in the layer mask */ if (layer_mask_offset != 0) { if (layer_mask_offset < cur_offset) { GIMP_LOG (XCF, "Invalid layer mask offset!"); goto error; } if (! xcf_seek_pos (info, layer_mask_offset, NULL)) goto error; layer_mask = xcf_load_layer_mask (info, image); if (! layer_mask) goto error; cur_offset += info->bytes_per_offset; xcf_progress_update (info); /* don't add the layer mask yet, that won't work for group * layers which update their size automatically; instead * attach it so it can be added when all layers are loaded */ g_object_set_data_full (G_OBJECT (layer), "gimp-layer-mask", g_object_ref_sink (layer_mask), (GDestroyNotify) g_object_unref); g_object_set_data (G_OBJECT (layer), "gimp-layer-mask-apply", GINT_TO_POINTER (apply_mask)); g_object_set_data (G_OBJECT (layer), "gimp-layer-mask-edit", GINT_TO_POINTER (edit_mask)); g_object_set_data (G_OBJECT (layer), "gimp-layer-mask-show", GINT_TO_POINTER (show_mask)); } else { /* If no layer mask, move ahead to layer effects */ cur_offset += info->bytes_per_offset; } /* read in any layer effects and effect masks */ while (effects_offset != 0) { FilterData *filter_data; if (effects_offset < cur_offset) { GIMP_LOG (XCF, "Invalid effect offset: %" G_GOFFSET_FORMAT " at offset: %" G_GOFFSET_FORMAT, effects_offset, cur_offset); goto error; } /* seek to the effect offset */ if (! xcf_seek_pos (info, effects_offset, NULL)) goto error; filter_data = xcf_load_effect (info, image, GIMP_DRAWABLE (layer)); if (! filter_data) { (*n_broken_effects)++; } else { filter_data_list = g_list_prepend (filter_data_list, filter_data); filter_count++; } xcf_progress_update (info); /* restore the saved position so we'll be ready to * read the next offset. */ cur_offset += info->bytes_per_offset; if (! xcf_seek_pos (info, cur_offset, NULL)) goto error; /* read in the offset of the next effect */ if (xcf_read_offset (info, &effects_offset, 1) < info->bytes_per_offset) { GIMP_LOG (XCF, "Failed to read effects offset" " at offset: %" G_GOFFSET_FORMAT, info->cp); break; } } if (filter_count > 0) g_object_set_data_full (G_OBJECT (layer), "gimp-layer-effects", filter_data_list, (GDestroyNotify) xcf_load_free_effects); /* attach the floating selection... */ if (is_fs_drawable) info->floating_sel_drawable = GIMP_DRAWABLE (layer); return layer; error: info->selected_layers = g_list_remove (info->selected_layers, layer); if (info->floating_sel == layer) info->floating_sel = NULL; if (info->floating_sel_drawable == GIMP_DRAWABLE (layer)) info->floating_sel_drawable = NULL; g_object_unref (layer); return NULL; } static GimpChannel * xcf_load_channel (XcfInfo *info, GimpImage *image) { GimpChannel *channel; goffset hierarchy_offset; gint width; gint height; gboolean is_fs_drawable; gchar *name; goffset cur_offset; /* check and see if this is the drawable the floating selection * is attached to. if it is then we'll do the attachment in our caller. */ is_fs_drawable = (info->cp == info->floating_sel_offset); /* read in the layer width, height and name */ xcf_read_int32 (info, (guint32 *) &width, 1); xcf_read_int32 (info, (guint32 *) &height, 1); if (width <= 0 || height <= 0 || width > GIMP_MAX_IMAGE_SIZE || height > GIMP_MAX_IMAGE_SIZE) { GIMP_LOG (XCF, "Invalid channel size %d x %d.", width, height); return NULL; } xcf_read_string (info, &name, 1); GIMP_LOG (XCF, "Channel width=%d, height=%d, name='%s'", width, height, name); /* create a new channel */ channel = gimp_channel_new (image, width, height, name, NULL); g_free (name); if (!channel) return NULL; /* read in the channel properties */ if (! xcf_load_channel_props (info, image, &channel, FALSE)) goto error; xcf_progress_update (info); /* read the hierarchy offset */ cur_offset = info->cp; xcf_read_offset (info, &hierarchy_offset, 1); if (hierarchy_offset < cur_offset) { GIMP_LOG (XCF, "Invalid hierarchy offset!"); goto error; } /* read in the hierarchy */ if (! xcf_seek_pos (info, hierarchy_offset, NULL)) goto error; if (! xcf_load_buffer (info, gimp_drawable_get_buffer (GIMP_DRAWABLE (channel)))) goto error; xcf_progress_update (info); if (is_fs_drawable) info->floating_sel_drawable = GIMP_DRAWABLE (channel); return channel; error: /* don't unref the selection of a partially loaded XCF */ if (channel != gimp_image_get_mask (image)) { GList *iter; for (iter = info->selected_channels; iter; iter = iter->next) if (channel == iter->data) { info->selected_channels = g_list_delete_link (info->selected_channels, iter); break; } if (info->floating_sel_drawable == GIMP_DRAWABLE (channel)) info->floating_sel_drawable = NULL; g_object_unref (channel); } return NULL; } static FilterData * xcf_load_effect (XcfInfo *info, GimpImage *image, GimpDrawable *drawable) { FilterData *filter; GimpChannel *effect_mask = NULL; goffset mask_offset = 0; gchar *string; GError *error = NULL; filter = g_new0 (FilterData, 1); /* Effect name */ xcf_read_string (info, &string, 1); filter->name = string; /* Effect icon */ xcf_read_string (info, &string, 1); filter->icon_name = string; /* Effect operation */ xcf_read_string (info, &string, 1); filter->operation_name = string; if (! gimp_gegl_op_nde_allowed (filter->operation_name, &error)) { filter->unsupported_operation = TRUE; if (filter->name) gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, /* TODO: localize after string freeze. */ "XCF Warning: the filter \"%s\" (%s) was discarded. %s", filter->name, filter->operation_name, error->message); else gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, /* TODO: localize after string freeze. */ "XCF Warning: an unnamed filter (%s) was discarded. %s", filter->operation_name, error->message); g_clear_error (&error); return filter; } if (info->file_version >= 22) { xcf_read_string (info, &string, 1); filter->op_version = string; } if (filter->op_version && g_strcmp0 (gegl_operation_get_op_version (filter->operation_name), filter->op_version) != 0) { filter->unsupported_operation = TRUE; gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, _("XCF Warning: version '%s' of filter '%s' is unsupported. " "The filter was discarded.\n" "It either means that you are using an old version of the filter or " "that it was updated without proper version management. " "In the latter case, you should report the issue to the filter's developers."), filter->op_version, filter->operation_name); return filter; } /* We'll set valid properties individually */ filter->operation = gegl_node_new (); gegl_node_set (filter->operation, "operation", filter->operation_name, NULL); /* read in the effect properties */ if (! xcf_load_effect_props (info, &(*filter))) goto error; /* seek to the effect mask offset */ xcf_read_offset (info, &mask_offset, 1); if (mask_offset != 0) { if (! xcf_seek_pos (info, mask_offset, NULL)) goto error; effect_mask = xcf_load_channel (info, image); if (! effect_mask) goto error; } filter->mask = effect_mask; xcf_progress_update (info); return filter; error: xcf_load_free_effect (filter); return NULL; } static void xcf_load_free_effect (FilterData *data) { g_free (data->name); g_free (data->icon_name); g_free (data->operation_name); g_free (data->op_version); g_clear_object (&data->operation); g_clear_object (&data->mask); g_free (data); } static void xcf_load_free_effects (GList *effects) { g_list_free_full (effects, (GDestroyNotify) xcf_load_free_effect); } static GeglColor * xcf_load_color (XcfInfo *info, goffset next_prop, gboolean *valid_prop_value, GError **error) { GeglColor *color; const Babl *format; gchar *encoding; guint8 *data = NULL; gint data_length; gint profile_data_length; *valid_prop_value = TRUE; if (info->cp == next_prop) /* Up to GIMP 3.2, a NULL color would just be empty data. Though * it's ugly, we keep this code to load 3.0 files which may have got * into this edge case. */ return NULL; xcf_read_string (info, &encoding, 1); if (encoding == NULL) return NULL; if (! babl_format_exists (encoding)) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "Invalid Babl format \"%s\".", encoding); g_free (encoding); *valid_prop_value = FALSE; return NULL; } format = babl_format (encoding); g_free (encoding); xcf_read_int32 (info, (guint32 *) &data_length, 1); if (data_length != babl_format_get_bytes_per_pixel (format)) { g_set_error (error, G_FILE_ERROR, G_FILE_ERROR_FAILED, "Format \"%s\" expected %d bpp, but color " "was serialized as %d bpp.", babl_get_name (format), babl_format_get_bytes_per_pixel (format), data_length); *valid_prop_value = FALSE; return NULL; } data = g_new (guint8, data_length); xcf_read_int8 (info, data, data_length); xcf_read_int32 (info, (guint32 *) &profile_data_length, 1); if (profile_data_length > 0) { const Babl *space = NULL; GimpColorProfile *profile; guint8 *profile_data; profile_data = g_new (guint8, profile_data_length); xcf_read_int8 (info, profile_data, profile_data_length); profile = gimp_color_profile_new_from_icc_profile (profile_data, profile_data_length, error); g_free (profile_data); if (profile) { space = gimp_color_profile_get_space (profile, GIMP_COLOR_RENDERING_INTENT_RELATIVE_COLORIMETRIC, error); g_object_unref (profile); } if (! space) { g_free (data); *valid_prop_value = FALSE; return NULL; } format = babl_format_with_space (babl_format_get_encoding (format), space); } color = gegl_color_new (NULL); gegl_color_set_pixel (color, format, data); g_free (data); return color; } static GimpData * xcf_load_data (XcfInfo *info, GType data_type, GError **error) { GimpData *data = NULL; GimpDataFactory *factory; gchar *name; gchar *collection; gboolean is_internal; guint32 uint_val; xcf_read_string (info, &name, 1); if (name != NULL) { xcf_read_string (info, &collection, 1); xcf_read_int32 (info, (guint32 *) &uint_val, 1); is_internal = (gboolean) uint_val; factory = gimp_get_data_factory (info->gimp, data_type); data = gimp_data_factory_get_data (factory, name, collection, is_internal); g_free (name); g_free (collection); } return data; } /* The new path structure since XCF 18. */ static GimpPath * xcf_load_path (XcfInfo *info, GimpImage *image) { GimpPath *path = NULL; gchar *name; guint32 version; guint32 plength; guint32 num_strokes; goffset base; gint i; /* read in the path name. */ xcf_read_string (info, &name, 1); GIMP_LOG (XCF, "Path name='%s'", name); /* create a new path */ path = gimp_path_new (image, name); g_free (name); if (! path) return NULL; /* Read the path's payload size. */ xcf_read_int32 (info, (guint32 *) &plength, 1); base = info->cp; /* read in the path properties */ if (! xcf_load_path_props (info, image, &path)) goto error; GIMP_LOG (XCF, "path props loaded"); xcf_progress_update (info); xcf_read_int32 (info, (guint32 *) &version, 1); if (version != 1) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Unknown path version: %d (skipping)", version); goto error; } /* Read the number of strokes. */ xcf_read_int32 (info, &num_strokes, 1); for (i = 0; i < num_strokes; i++) { guint32 stroke_type_id; guint32 closed; guint32 num_axes; guint32 num_control_points; guint32 type; gfloat coords[13] = GIMP_COORDS_DEFAULT_VALUES; GimpStroke *stroke; gint j; GimpValueArray *control_points; GValue value = G_VALUE_INIT; GimpAnchor anchor = { { 0, } }; GType stroke_type; g_value_init (&value, GIMP_TYPE_ANCHOR); xcf_read_int32 (info, &stroke_type_id, 1); xcf_read_int32 (info, &closed, 1); xcf_read_int32 (info, &num_axes, 1); xcf_read_int32 (info, &num_control_points, 1); #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("stroke_type: %d, closed: %d, num_axes %d, len %d\n", stroke_type_id, closed, num_axes, num_control_points); #endif switch (stroke_type_id) { case XCF_STROKETYPE_BEZIER_STROKE: stroke_type = GIMP_TYPE_BEZIER_STROKE; break; default: g_printerr ("skipping unknown stroke type\n"); xcf_seek_pos (info, info->cp + 4 * num_axes * num_control_points, NULL); continue; } if (num_axes < 2 || num_axes > 6) { g_printerr ("bad number of axes in stroke description\n"); goto error; } control_points = gimp_value_array_new (num_control_points); anchor.selected = FALSE; for (j = 0; j < num_control_points; j++) { xcf_read_int32 (info, &type, 1); xcf_read_float (info, coords, num_axes); anchor.type = type; anchor.position.x = coords[0]; anchor.position.y = coords[1]; anchor.position.pressure = coords[2]; anchor.position.xtilt = coords[3]; anchor.position.ytilt = coords[4]; anchor.position.wheel = coords[5]; g_value_set_boxed (&value, &anchor); gimp_value_array_append (control_points, &value); #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("Anchor: %d, (%f, %f, %f, %f, %f, %f)\n", type, coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]); #endif } g_value_unset (&value); stroke = g_object_new (stroke_type, "closed", closed, "control-points", control_points, NULL); gimp_path_stroke_add (path, stroke); g_object_unref (stroke); gimp_value_array_unref (control_points); } if (plength != info->cp - base) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Path payload size does not match stored size (skipping)"); goto error; } return path; error: xcf_seek_pos (info, base + plength, NULL); g_clear_object (&path); return NULL; } static GimpLayerMask * xcf_load_layer_mask (XcfInfo *info, GimpImage *image) { GimpLayerMask *layer_mask; GimpChannel *channel; GList *iter; goffset hierarchy_offset; gint width; gint height; gboolean is_fs_drawable; gchar *name; GeglColor *color = gegl_color_new ("black"); goffset cur_offset; /* check and see if this is the drawable the floating selection * is attached to. if it is then we'll do the attachment in our caller. */ is_fs_drawable = (info->cp == info->floating_sel_offset); /* read in the layer width, height and name */ xcf_read_int32 (info, (guint32 *) &width, 1); xcf_read_int32 (info, (guint32 *) &height, 1); if (width <= 0 || height <= 0 || width > GIMP_MAX_IMAGE_SIZE || height > GIMP_MAX_IMAGE_SIZE) { GIMP_LOG (XCF, "Invalid layer mask size %d x %d.", width, height); return NULL; } xcf_read_string (info, &name, 1); GIMP_LOG (XCF, "Layer mask width=%d, height=%d, name='%s'", width, height, name); /* create a new layer mask */ layer_mask = gimp_layer_mask_new (image, width, height, name, color); g_object_unref (color); g_free (name); if (! layer_mask) return NULL; /* read in the layer_mask properties */ channel = GIMP_CHANNEL (layer_mask); if (! xcf_load_channel_props (info, image, &channel, TRUE)) goto error; xcf_progress_update (info); /* read the hierarchy offset */ cur_offset = info->cp; xcf_read_offset (info, &hierarchy_offset, 1); if (hierarchy_offset < cur_offset) { GIMP_LOG (XCF, "Invalid hierarchy offset!"); goto error; } /* read in the hierarchy */ if (! xcf_seek_pos (info, hierarchy_offset, NULL)) goto error; if (! xcf_load_buffer (info, gimp_drawable_get_buffer (GIMP_DRAWABLE (layer_mask)))) goto error; xcf_progress_update (info); /* attach the floating selection... */ if (is_fs_drawable) info->floating_sel_drawable = GIMP_DRAWABLE (layer_mask); return layer_mask; error: for (iter = info->selected_channels; iter; iter = iter->next) if (layer_mask == iter->data) { info->selected_channels = g_list_delete_link (info->selected_channels, iter); break; } if (info->floating_sel_drawable == GIMP_DRAWABLE (layer_mask)) info->floating_sel_drawable = NULL; g_object_unref (layer_mask); return NULL; } static gboolean xcf_load_buffer (XcfInfo *info, GeglBuffer *buffer) { const Babl *format; goffset offset; gint width; gint height; gint bpp; goffset cur_offset; format = gegl_buffer_get_format (buffer); xcf_read_int32 (info, (guint32 *) &width, 1); xcf_read_int32 (info, (guint32 *) &height, 1); xcf_read_int32 (info, (guint32 *) &bpp, 1); /* make sure the values in the file correspond to the values * calculated when the GeglBuffer was created. */ if (width != gegl_buffer_get_width (buffer) || height != gegl_buffer_get_height (buffer) || bpp != babl_format_get_bytes_per_pixel (format)) return FALSE; cur_offset = info->cp; xcf_read_offset (info, &offset, 1); /* top level */ if (offset < cur_offset) { GIMP_LOG (XCF, "Invalid buffer offset!"); return FALSE; } /* seek to the level offset */ if (! xcf_seek_pos (info, offset, NULL)) return FALSE; /* read in the level */ if (! xcf_load_level (info, buffer)) return FALSE; /* discard levels below first. */ return TRUE; } static gboolean xcf_load_level (XcfInfo *info, GeglBuffer *buffer) { const Babl *format; gint bpp; goffset saved_pos; goffset offset; goffset offset2; goffset max_data_length; gint n_tile_rows; gint n_tile_cols; guint ntiles; gint width; gint height; gint i; gint fail; format = gegl_buffer_get_format (buffer); bpp = babl_format_get_bytes_per_pixel (format); xcf_read_int32 (info, (guint32 *) &width, 1); xcf_read_int32 (info, (guint32 *) &height, 1); if (width != gegl_buffer_get_width (buffer) || height != gegl_buffer_get_height (buffer)) return FALSE; /* maximal allowable size of on-disk tile data. make it somewhat bigger than * the uncompressed tile size, to allow for the possibility of negative * compression. */ max_data_length = XCF_TILE_WIDTH * XCF_TILE_HEIGHT * bpp * XCF_TILE_MAX_DATA_LENGTH_FACTOR /* = 1.5, currently */; /* read in the first tile offset. * if it is '0', then this tile level is empty * and we can simply return. */ if (xcf_read_offset (info, &offset, 1) < info->bytes_per_offset) { GIMP_LOG (XCF, "Failed to read tile offset" " at offset: %" G_GOFFSET_FORMAT, info->cp); return FALSE; } if (offset == 0) return TRUE; n_tile_rows = gimp_gegl_buffer_get_n_tile_rows (buffer, XCF_TILE_HEIGHT); n_tile_cols = gimp_gegl_buffer_get_n_tile_cols (buffer, XCF_TILE_WIDTH); ntiles = n_tile_rows * n_tile_cols; for (i = 0; i < ntiles; i++) { GeglRectangle rect; fail = FALSE; if (offset == 0) { gimp_message_literal (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_ERROR, "not enough tiles found in level"); return FALSE; } /* save the current position as it is where the * next tile offset is stored. */ saved_pos = info->cp; /* read in the offset of the next tile so we can calculate the amount * of data needed for this tile */ if (xcf_read_offset (info, &offset2, 1) < info->bytes_per_offset) { GIMP_LOG (XCF, "Failed to read tile offset" " at offset: %" G_GOFFSET_FORMAT, info->cp); return FALSE; } /* if the offset is 0 then we need to read in the maximum possible * allowing for negative compression */ if (offset2 == 0) offset2 = offset + max_data_length; /* seek to the tile offset */ if (! xcf_seek_pos (info, offset, NULL)) return FALSE; if (offset2 < offset || offset2 - offset > max_data_length) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_ERROR, "invalid tile data length: %" G_GOFFSET_FORMAT, offset2 - offset); return FALSE; } /* get buffer rectangle to write to */ gimp_gegl_buffer_get_tile_rect (buffer, XCF_TILE_WIDTH, XCF_TILE_HEIGHT, i, &rect); GIMP_LOG (XCF, "loading tile %d/%d", i + 1, ntiles); /* read in the tile */ switch (info->compression) { case COMPRESS_NONE: if (! xcf_load_tile (info, buffer, &rect, format)) fail = TRUE; break; case COMPRESS_RLE: if (! xcf_load_tile_rle (info, buffer, &rect, format, offset2 - offset)) fail = TRUE; break; case COMPRESS_ZLIB: if (! xcf_load_tile_zlib (info, buffer, &rect, format, offset2 - offset)) fail = TRUE; break; case COMPRESS_FRACTAL: g_printerr ("xcf: fractal compression unimplemented. " "Possibly corrupt XCF file."); fail = TRUE; break; default: g_printerr ("xcf: unknown compression. " "Possibly corrupt XCF file."); fail = TRUE; break; } if (fail) return FALSE; GIMP_LOG (XCF, "loaded tile %d/%d", i + 1, ntiles); /* restore the saved position so we'll be ready to * read the next offset. */ if (!xcf_seek_pos (info, saved_pos, NULL)) return FALSE; /* read in the offset of the next tile */ if (xcf_read_offset (info, &offset, 1) < info->bytes_per_offset) { GIMP_LOG (XCF, "Failed to read tile offset" " at offset: %" G_GOFFSET_FORMAT, info->cp); return FALSE; } } if (offset != 0) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_ERROR, "encountered garbage after reading level: %" G_GOFFSET_FORMAT, offset); return FALSE; } return TRUE; } static gboolean xcf_load_tile (XcfInfo *info, GeglBuffer *buffer, GeglRectangle *tile_rect, const Babl *format) { gint bpp = babl_format_get_bytes_per_pixel (format); gint tile_size = bpp * tile_rect->width * tile_rect->height; guchar *tile_data = g_alloca (tile_size); if (info->file_version <= 11) { xcf_read_int8 (info, tile_data, tile_size); } else { gint n_components = babl_format_get_n_components (format); xcf_read_component (info, bpp / n_components, tile_data, tile_size / bpp * n_components); } if (! xcf_data_is_zero (tile_data, tile_size)) { gegl_buffer_set (buffer, tile_rect, 0, format, tile_data, GEGL_AUTO_ROWSTRIDE); } return TRUE; } static gboolean xcf_load_tile_rle (XcfInfo *info, GeglBuffer *buffer, GeglRectangle *tile_rect, const Babl *format, gint data_length) { gint bpp = babl_format_get_bytes_per_pixel (format); gint tile_size = bpp * tile_rect->width * tile_rect->height; guchar *tile_data = g_alloca (tile_size); guchar nonzero = FALSE; gsize bytes_read; gint i; guchar *xcfdata; guchar *xcfodata; guchar *xcfdatalimit; /* Workaround for bug #357809: avoid crashing on g_malloc() and skip * this tile (return TRUE without storing data) as if it did not * contain any data. It is better than returning FALSE, which would * skip the whole hierarchy while there may still be some valid * tiles in the file. */ if (data_length <= 0) return TRUE; xcfdata = xcfodata = g_alloca (data_length); /* we have to read directly instead of xcf_read_* because we may be * reading past the end of the file here */ g_input_stream_read_all (info->input, xcfdata, data_length, &bytes_read, NULL, NULL); info->cp += bytes_read; if (bytes_read == 0) return TRUE; xcfdatalimit = &xcfodata[bytes_read - 1]; for (i = 0; i < bpp; i++) { guchar *data = tile_data + i; gint size = tile_rect->width * tile_rect->height; gint count = 0; guchar val; gint length; gint j; while (size > 0) { if (xcfdata > xcfdatalimit) { goto bogus_rle; } val = *xcfdata++; length = val; if (length >= 128) { length = 255 - (length - 1); if (length == 128) { if (xcfdata >= xcfdatalimit) { goto bogus_rle; } length = (*xcfdata << 8) + xcfdata[1]; xcfdata += 2; } count += length; size -= length; if (size < 0) { goto bogus_rle; } if (&xcfdata[length-1] > xcfdatalimit) { goto bogus_rle; } while (length-- > 0) { *data = *xcfdata++; nonzero |= *data; data += bpp; } } else { length += 1; if (length == 128) { if (xcfdata >= xcfdatalimit) { goto bogus_rle; } length = (*xcfdata << 8) + xcfdata[1]; xcfdata += 2; } count += length; size -= length; if (size < 0) { goto bogus_rle; } if (xcfdata > xcfdatalimit) { goto bogus_rle; } val = *xcfdata++; nonzero |= val; for (j = 0; j < length; j++) { *data = val; data += bpp; } } } } if (nonzero) { if (info->file_version >= 12) { gint n_components = babl_format_get_n_components (format); xcf_read_from_be (bpp / n_components, tile_data, tile_size / bpp * n_components); } gegl_buffer_set (buffer, tile_rect, 0, format, tile_data, GEGL_AUTO_ROWSTRIDE); } return TRUE; bogus_rle: return FALSE; } static gboolean xcf_load_tile_zlib (XcfInfo *info, GeglBuffer *buffer, GeglRectangle *tile_rect, const Babl *format, gint data_length) { z_stream strm; int action; int status; gint bpp = babl_format_get_bytes_per_pixel (format); gint tile_size = bpp * tile_rect->width * tile_rect->height; guchar *tile_data = g_alloca (tile_size); gsize bytes_read; guchar *xcfdata; /* Workaround for bug #357809: avoid crashing on g_malloc() and skip * this tile (return TRUE without storing data) as if it did not * contain any data. It is better than returning FALSE, which would * skip the whole hierarchy while there may still be some valid * tiles in the file. */ if (data_length <= 0) return TRUE; xcfdata = g_alloca (data_length); /* we have to read directly instead of xcf_read_* because we may be * reading past the end of the file here */ g_input_stream_read_all (info->input, xcfdata, data_length, &bytes_read, NULL, NULL); info->cp += bytes_read; if (bytes_read == 0) return TRUE; strm.next_out = tile_data; strm.avail_out = tile_size; strm.zalloc = Z_NULL; strm.zfree = Z_NULL; strm.opaque = Z_NULL; strm.next_in = xcfdata; strm.avail_in = bytes_read; /* Initialize the stream decompression. */ status = inflateInit (&strm); if (status != Z_OK) return FALSE; action = Z_NO_FLUSH; while (status == Z_OK) { if (strm.avail_in == 0) { action = Z_FINISH; } status = inflate (&strm, action); if (status == Z_STREAM_END) { /* All the data was successfully decoded. */ break; } else if (status == Z_BUF_ERROR) { g_printerr ("xcf: decompressed tile bigger than the expected size."); inflateEnd (&strm); return FALSE; } else if (status != Z_OK) { g_printerr ("xcf: tile decompression failed: %s", zError (status)); inflateEnd (&strm); return FALSE; } } if (! xcf_data_is_zero (tile_data, tile_size)) { if (info->file_version >= 12) { gint n_components = babl_format_get_n_components (format); xcf_read_from_be (bpp / n_components, tile_data, tile_size / bpp * n_components); } gegl_buffer_set (buffer, tile_rect, 0, format, tile_data, GEGL_AUTO_ROWSTRIDE); } inflateEnd (&strm); return TRUE; } static GimpParasite * xcf_load_parasite (XcfInfo *info) { GimpParasite *parasite = NULL; gchar *name; guint32 flags; guint32 size, size_read; gpointer data; xcf_read_string (info, &name, 1); xcf_read_int32 (info, &flags, 1); xcf_read_int32 (info, &size, 1); GIMP_LOG (XCF, "Parasite name: %s, flags: %d, size: %d", name, flags, size); if (size > MAX_XCF_PARASITE_DATA_LEN) { g_printerr ("Maximum parasite data length (%ld bytes) exceeded. " "Possibly corrupt XCF file.", MAX_XCF_PARASITE_DATA_LEN); g_free (name); return NULL; } if (! name || strlen (name) == 0) { g_printerr ("Parasite has no name! Possibly corrupt XCF file.\n"); return NULL; } data = g_new (gchar, size); size_read = xcf_read_int8 (info, data, size); if (size_read != size) { g_printerr ("Incorrect parasite data size: read %u bytes instead of %u. " "Possibly corrupt XCF file.\n", size_read, size); } else { parasite = gimp_parasite_new (name, flags, size, data); } g_free (name); g_free (data); return parasite; } /* Old paths are the PROP_PATHS property, even older than PROP_VECTORS. */ static gboolean xcf_load_old_paths (XcfInfo *info, GimpImage *image) { guint32 num_paths; guint32 last_selected_row; GimpPath *active_path; xcf_read_int32 (info, &last_selected_row, 1); xcf_read_int32 (info, &num_paths, 1); GIMP_LOG (XCF, "Number of old paths: %u", num_paths); while (num_paths-- > 0) if (! xcf_load_old_path (info, image)) return FALSE; active_path = GIMP_PATH (gimp_container_get_child_by_index (gimp_image_get_paths (image), last_selected_row)); if (active_path) { GList *list = g_list_prepend (NULL, active_path); gimp_image_set_selected_paths (image, list); g_list_free (list); } return TRUE; } static gboolean xcf_load_old_path (XcfInfo *info, GimpImage *image) { gchar *name; guint32 locked; guint8 state; guint32 closed; guint32 num_points; guint32 version; /* changed from num_paths */ GimpTattoo tattoo = 0; GimpPath *path; GimpPathCompatPoint *points; gint i; xcf_read_string (info, &name, 1); xcf_read_int32 (info, &locked, 1); xcf_read_int8 (info, &state, 1); xcf_read_int32 (info, &closed, 1); xcf_read_int32 (info, &num_points, 1); xcf_read_int32 (info, &version, 1); if (version == 2) { guint32 dummy; /* Had extra type field and points are stored as doubles */ xcf_read_int32 (info, (guint32 *) &dummy, 1); } else if (version == 3) { guint32 dummy; /* Has extra tattoo field */ xcf_read_int32 (info, (guint32 *) &dummy, 1); xcf_read_int32 (info, (guint32 *) &tattoo, 1); } else if (version != 1) { g_printerr ("Unknown path type (version: %u). Possibly corrupt XCF file.\n", version); g_free (name); return FALSE; } /* skip empty compatibility paths */ if (num_points == 0) { g_free (name); return FALSE; } points = g_new0 (GimpPathCompatPoint, num_points); for (i = 0; i < num_points; i++) { if (version == 1) { gint32 x; gint32 y; xcf_read_int32 (info, &points[i].type, 1); xcf_read_int32 (info, (guint32 *) &x, 1); xcf_read_int32 (info, (guint32 *) &y, 1); points[i].x = x; points[i].y = y; } else { gfloat x; gfloat y; xcf_read_int32 (info, &points[i].type, 1); xcf_read_float (info, &x, 1); xcf_read_float (info, &y, 1); points[i].x = x; points[i].y = y; } } path = gimp_path_compat_new (image, name, points, num_points, closed); g_free (name); g_free (points); if (locked) info->linked_paths = g_list_prepend (info->linked_paths, path); if (tattoo) gimp_item_set_tattoo (GIMP_ITEM (path), tattoo); gimp_image_add_path (image, path, NULL, /* can't be a tree */ gimp_container_get_n_children (gimp_image_get_paths (image)), FALSE); return TRUE; } /* Old vectors are the PROP_VECTORS property up to all GIMP 2.10 versions. */ static gboolean xcf_load_old_vectors (XcfInfo *info, GimpImage *image) { guint32 version; guint32 active_index; guint32 num_paths; GimpPath *active_path; #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("xcf_load_old_vectors\n"); #endif xcf_read_int32 (info, &version, 1); if (version != 1) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Unknown path version: %d (skipping)", version); return FALSE; } xcf_read_int32 (info, &active_index, 1); xcf_read_int32 (info, &num_paths, 1); #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("%d paths (active: %d)\n", num_paths, active_index); #endif while (num_paths-- > 0) if (! xcf_load_old_vector (info, image)) return FALSE; /* FIXME tree */ active_path = GIMP_PATH (gimp_container_get_child_by_index (gimp_image_get_paths (image), active_index)); if (active_path) { GList *list = g_list_prepend (NULL, active_path); gimp_image_set_selected_paths (image, list); g_list_free (list); } #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("xcf_load_old_vectors: loaded %d bytes\n", info->cp - base); #endif return TRUE; } static gboolean xcf_load_old_vector (XcfInfo *info, GimpImage *image) { gchar *name; GimpTattoo tattoo = 0; guint32 visible; guint32 linked; guint32 num_parasites; guint32 num_strokes; GimpPath *path; gint i; #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("xcf_load_old_vector\n"); #endif xcf_read_string (info, &name, 1); xcf_read_int32 (info, &tattoo, 1); xcf_read_int32 (info, &visible, 1); xcf_read_int32 (info, &linked, 1); xcf_read_int32 (info, &num_parasites, 1); xcf_read_int32 (info, &num_strokes, 1); #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("name: %s, tattoo: %d, visible: %d, linked: %d, " "num_parasites %d, num_strokes %d\n", name, tattoo, visible, linked, num_parasites, num_strokes); #endif path = gimp_path_new (image, name); g_free (name); gimp_item_set_visible (GIMP_ITEM (path), visible, FALSE); if (linked) info->linked_paths = g_list_prepend (info->linked_paths, path); if (tattoo) gimp_item_set_tattoo (GIMP_ITEM (path), tattoo); for (i = 0; i < num_parasites; i++) { GimpParasite *parasite = xcf_load_parasite (info); GError *error = NULL; if (! parasite) return FALSE; if (! gimp_item_parasite_validate (GIMP_ITEM (path), parasite, &error)) { gimp_message (info->gimp, G_OBJECT (info->progress), GIMP_MESSAGE_WARNING, "Warning, invalid vectors parasite in XCF file: %s", error->message); g_clear_error (&error); } else { gimp_item_parasite_attach (GIMP_ITEM (path), parasite, FALSE); } gimp_parasite_free (parasite); } for (i = 0; i < num_strokes; i++) { guint32 stroke_type_id; guint32 closed; guint32 num_axes; guint32 num_control_points; guint32 type; gfloat coords[13] = GIMP_COORDS_DEFAULT_VALUES; GimpStroke *stroke; gint j; GimpValueArray *control_points; GValue value = G_VALUE_INIT; GimpAnchor anchor = { { 0, } }; GType stroke_type; g_value_init (&value, GIMP_TYPE_ANCHOR); xcf_read_int32 (info, &stroke_type_id, 1); xcf_read_int32 (info, &closed, 1); xcf_read_int32 (info, &num_axes, 1); xcf_read_int32 (info, &num_control_points, 1); #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("stroke_type: %d, closed: %d, num_axes %d, len %d\n", stroke_type_id, closed, num_axes, num_control_points); #endif switch (stroke_type_id) { case XCF_STROKETYPE_BEZIER_STROKE: stroke_type = GIMP_TYPE_BEZIER_STROKE; break; default: g_printerr ("skipping unknown stroke type\n"); xcf_seek_pos (info, info->cp + 4 * num_axes * num_control_points, NULL); continue; } if (num_axes < 2 || num_axes > 6) { g_printerr ("bad number of axes in stroke description\n"); return FALSE; } control_points = gimp_value_array_new (num_control_points); anchor.selected = FALSE; for (j = 0; j < num_control_points; j++) { xcf_read_int32 (info, &type, 1); xcf_read_float (info, coords, num_axes); anchor.type = type; anchor.position.x = coords[0]; anchor.position.y = coords[1]; anchor.position.pressure = coords[2]; anchor.position.xtilt = coords[3]; anchor.position.ytilt = coords[4]; anchor.position.wheel = coords[5]; g_value_set_boxed (&value, &anchor); gimp_value_array_append (control_points, &value); #ifdef GIMP_XCF_PATH_DEBUG g_printerr ("Anchor: %d, (%f, %f, %f, %f, %f, %f)\n", type, coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]); #endif } g_value_unset (&value); stroke = g_object_new (stroke_type, "closed", closed, "control-points", control_points, NULL); gimp_path_stroke_add (path, stroke); g_object_unref (stroke); gimp_value_array_unref (control_points); } gimp_image_add_path (image, path, NULL, /* FIXME tree */ gimp_container_get_n_children (gimp_image_get_paths (image)), FALSE); return TRUE; } static gboolean xcf_skip_unknown_prop (XcfInfo *info, gsize size) { guint8 buf[16]; guint amount; while (size > 0) { if (g_input_stream_is_closed (info->input)) return FALSE; amount = MIN (16, size); amount = xcf_read_int8 (info, buf, amount); if (amount == 0) return FALSE; size -= amount; } return TRUE; } static gboolean xcf_item_path_is_parent (GList *path, GList *parent_path) { GList *iter = path; GList *parent_iter = parent_path; if (g_list_length (parent_path) >= g_list_length (path)) return FALSE; while (iter && parent_iter) { if (iter->data != parent_iter->data) return FALSE; iter = iter->next; parent_iter = parent_iter->next; } return TRUE; } static void xcf_fix_item_path (GimpLayer *layer, GList **path, GList *broken_paths) { GList *iter; for (iter = broken_paths; iter; iter = iter->next) { if (xcf_item_path_is_parent (*path, iter->data)) { /* Not much to do when the absent path is a parent. */ g_printerr ("%s: layer '%s' moved to layer tree root because of missing parent.", G_STRFUNC, gimp_object_get_name (layer)); g_clear_pointer (path, g_list_free); return; } } /* Check if a parent of path, or path itself is on the same * tree level as any broken path; and if so, and if the broken path is * in a lower position in the item group, decrement it. */ for (iter = broken_paths; iter; iter = iter->next) { GList *broken_path = iter->data; GList *iter1 = *path; GList *iter2 = broken_path; if (g_list_length (broken_path) > g_list_length (*path)) continue; while (iter1 && iter2) { if (iter2->next && iter1->data != iter2->data) /* Paths diverged before reaching iter2 leaf. */ break; if (iter2->next) { iter1 = iter1->next; iter2 = iter2->next; continue; } if (GPOINTER_TO_UINT (iter2->data) < GPOINTER_TO_UINT (iter1->data)) iter1->data = GUINT_TO_POINTER (GPOINTER_TO_UINT (iter1->data) - 1); break; } } } static void xcf_load_free_vector_data (VectorLayerData *data) { g_clear_object (&data->fill_color); g_clear_object (&data->stroke_color); g_clear_pointer (&data->stroke_dashes, g_free); g_free (data); }
¤ Dauer der Verarbeitung: 0.203 Sekunden ¤*© Formatika GbR, Deutschland |
|
||||||||||||||||||||||||
2026-11-01