Adding upstream version 2.10.36.upstream/2.10.36

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

1 files changed, 1611 insertions, 0 deletions

diff --git a/plug-ins/file-psd/psd-image-res-load.c b/plug-ins/file-psd/psd-image-res-load.c
new file mode 100644
index 0000000..a634bc6
--- /dev/null
+++ b/plug-ins/file-psd/psd-image-res-load.c
@@ -0,0 +1,1611 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * GIMP PSD Plug-in
+ * Copyright 2007 by John Marshall
+ *
+ * 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/>.
+ */
+
+/* ----- Known Image Resource Block Types -----
+  All image resources not otherwise handled, including unknown types
+  are added as image parasites.
+  The data is attached as-is from the file (i.e. in big endian order).
+
+  PSD_PS2_IMAGE_INFO    = 1000,    Dropped    * 0x03e8 - Obsolete - ps 2.0 image info *
+  PSD_MAC_PRINT_INFO    = 1001,    PS Only    * 0x03e9 - Optional - Mac print manager print info record *
+  PSD_PS2_COLOR_TAB     = 1003,    Dropped    * 0x03eb - Obsolete - ps 2.0 indexed color table *
+  PSD_RESN_INFO         = 1005,    Loaded     * 0x03ed - ResolutionInfo structure *
+  PSD_ALPHA_NAMES       = 1006,    Loaded     * 0x03ee - Alpha channel names *
+  PSD_DISPLAY_INFO      = 1007,    Loaded     * 0x03ef - DisplayInfo structure *
+  PSD_CAPTION           = 1008,    Loaded     * 0x03f0 - Optional - Caption string *
+  PSD_BORDER_INFO       = 1009,               * 0x03f1 - Border info *
+  PSD_BACKGROUND_COL    = 1010,               * 0x03f2 - Background color *
+  PSD_PRINT_FLAGS       = 1011,               * 0x03f3 - Print flags *
+  PSD_GREY_HALFTONE     = 1012,               * 0x03f4 - Greyscale and multichannel halftoning info *
+  PSD_COLOR_HALFTONE    = 1013,               * 0x03f5 - Color halftoning info *
+  PSD_DUOTONE_HALFTONE  = 1014,               * 0x03f6 - Duotone halftoning info *
+  PSD_GREY_XFER         = 1015,               * 0x03f7 - Greyscale and multichannel transfer functions *
+  PSD_COLOR_XFER        = 1016,               * 0x03f8 - Color transfer functions *
+  PSD_DUOTONE_XFER      = 1017,               * 0x03f9 - Duotone transfer functions *
+  PSD_DUOTONE_INFO      = 1018,               * 0x03fa - Duotone image information *
+  PSD_EFFECTIVE_BW      = 1019,               * 0x03fb - Effective black & white values for dot range *
+  PSD_OBSOLETE_01       = 1020,    Dropped    * 0x03fc - Obsolete *
+  PSD_EPS_OPT           = 1021,               * 0x03fd - EPS options *
+  PSD_QUICK_MASK        = 1022,    Loaded     * 0x03fe - Quick mask info *
+  PSD_OBSOLETE_02       = 1023,    Dropped    * 0x03ff - Obsolete *
+  PSD_LAYER_STATE       = 1024,    Loaded     * 0x0400 - Layer state info *
+  PSD_WORKING_PATH      = 1025,               * 0x0401 - Working path (not saved) *
+  PSD_LAYER_GROUP       = 1026,               * 0x0402 - Layers group info *
+  PSD_OBSOLETE_03       = 1027,    Dropped    * 0x0403 - Obsolete *
+  PSD_IPTC_NAA_DATA     = 1028,    Loaded     * 0x0404 - IPTC-NAA record (IMV4.pdf) *
+  PSD_IMAGE_MODE_RAW    = 1029,               * 0x0405 - Image mode for raw format files *
+  PSD_JPEG_QUAL         = 1030,    PS Only    * 0x0406 - JPEG quality *
+  PSD_GRID_GUIDE        = 1032,    Loaded     * 0x0408 - Grid & guide info *
+  PSD_THUMB_RES         = 1033,    Special    * 0x0409 - Thumbnail resource *
+  PSD_COPYRIGHT_FLG     = 1034,               * 0x040a - Copyright flag *
+  PSD_URL               = 1035,               * 0x040b - URL string *
+  PSD_THUMB_RES2        = 1036,    Special    * 0x040c - Thumbnail resource *
+  PSD_GLOBAL_ANGLE      = 1037,               * 0x040d - Global angle *
+  PSD_COLOR_SAMPLER     = 1038,               * 0x040e - Color samplers resource *
+  PSD_ICC_PROFILE       = 1039,    Loaded     * 0x040f - ICC Profile *
+  PSD_WATERMARK         = 1040,               * 0x0410 - Watermark *
+  PSD_ICC_UNTAGGED      = 1041,               * 0x0411 - Do not use ICC profile flag *
+  PSD_EFFECTS_VISIBLE   = 1042,               * 0x0412 - Show   hide all effects layers *
+  PSD_SPOT_HALFTONE     = 1043,               * 0x0413 - Spot halftone *
+  PSD_DOC_IDS           = 1044,               * 0x0414 - Document specific IDs *
+  PSD_ALPHA_NAMES_UNI   = 1045,    Loaded     * 0x0415 - Unicode alpha names *
+  PSD_IDX_COL_TAB_CNT   = 1046,    Loaded     * 0x0416 - Indexed color table count *
+  PSD_IDX_TRANSPARENT   = 1047,               * 0x0417 - Index of transparent color (if any) *
+  PSD_GLOBAL_ALT        = 1049,               * 0x0419 - Global altitude *
+  PSD_SLICES            = 1050,               * 0x041a - Slices *
+  PSD_WORKFLOW_URL_UNI  = 1051,               * 0x041b - Workflow URL - Unicode string *
+  PSD_JUMP_TO_XPEP      = 1052,               * 0x041c - Jump to XPEP (?) *
+  PSD_ALPHA_ID          = 1053,    Loaded     * 0x041d - Alpha IDs *
+  PSD_URL_LIST_UNI      = 1054,               * 0x041e - URL list - unicode *
+  PSD_VERSION_INFO      = 1057,               * 0x0421 - Version info *
+  PSD_EXIF_DATA         = 1058,    Loaded     * 0x0422 - Exif data block 1 *
+  PSD_EXIF_DATA_3       = 1059                * 0X0423 - Exif data block 3 (?) *
+  PSD_XMP_DATA          = 1060,    Loaded     * 0x0424 - XMP data block *
+  PSD_CAPTION_DIGEST    = 1061,               * 0x0425 - Caption digest *
+  PSD_PRINT_SCALE       = 1062,               * 0x0426 - Print scale *
+  PSD_PIXEL_AR          = 1064,               * 0x0428 - Pixel aspect ratio *
+  PSD_LAYER_COMPS       = 1065,               * 0x0429 - Layer comps *
+  PSD_ALT_DUOTONE_COLOR = 1066,               * 0x042A - Alternative Duotone colors *
+  PSD_ALT_SPOT_COLOR    = 1067,               * 0x042B - Alternative Spot colors *
+  PSD_LAYER_SELECT_ID   = 1069,               * 0x042D - Layer selection ID *
+  PSD_HDR_TONING_INFO   = 1070,               * 0x042E - HDR toning information *
+  PSD_PRINT_INFO_SCALE  = 1071,               * 0x042F - Print scale *
+  PSD_LAYER_GROUP_E_ID  = 1072,               * 0x0430 - Layer group(s) enabled ID *
+  PSD_COLOR_SAMPLER_NEW = 1073,               * 0x0431 - Color sampler resource for ps CS3 and higher PSD files *
+  PSD_MEASURE_SCALE     = 1074,               * 0x0432 - Measurement scale *
+  PSD_TIMELINE_INFO     = 1075,               * 0x0433 - Timeline information *
+  PSD_SHEET_DISCLOSE    = 1076,               * 0x0434 - Sheet discloser *
+  PSD_DISPLAY_INFO_NEW  = 1077,    Loaded     * 0x0435 - DisplayInfo structure for ps CS3 and higher PSD files *
+  PSD_ONION_SKINS       = 1078,               * 0x0436 - Onion skins *
+  PSD_COUNT_INFO        = 1080,               * 0x0438 - Count information*
+  PSD_PRINT_INFO        = 1082,               * 0x043A - Print information added in ps CS5*
+  PSD_PRINT_STYLE       = 1083,               * 0x043B - Print style *
+  PSD_MAC_NSPRINTINFO   = 1084,               * 0x043C - Mac NSPrintInfo*
+  PSD_WIN_DEVMODE       = 1085,               * 0x043D - Windows DEVMODE *
+  PSD_AUTO_SAVE_PATH    = 1086,               * 0x043E - Auto save file path *
+  PSD_AUTO_SAVE_FORMAT  = 1087,               * 0x043F - Auto save format *
+  PSD_PATH_INFO_FIRST   = 2000,    Loaded     * 0x07d0 - First path info block *
+  PSD_PATH_INFO_LAST    = 2998,    Loaded     * 0x0bb6 - Last path info block *
+  PSD_CLIPPING_PATH     = 2999,               * 0x0bb7 - Name of clipping path *
+  PSD_PLUGIN_R_FIRST    = 4000,               * 0x0FA0 - First plugin resource *
+  PSD_PLUGIN_R_LAST     = 4999,               * 0x1387 - Last plugin resource *
+  PSD_IMAGEREADY_VARS   = 7000,    PS Only    * 0x1B58 - Imageready variables *
+  PSD_IMAGEREADY_DATA   = 7001,    PS Only    * 0x1B59 - Imageready data sets *
+  PSD_LIGHTROOM_WORK    = 8000,    PS Only    * 0x1F40 - Lightroom workflow *
+  PSD_PRINT_FLAGS_2     = 10000               * 0x2710 - Print flags *
+*/
+
+#include "config.h"
+
+#include <string.h>
+#include <errno.h>
+
+#include <glib/gstdio.h>
+#include <libgimp/gimp.h>
+
+#include <jpeglib.h>
+#include <jerror.h>
+
+#ifdef HAVE_IPTCDATA
+#include <libiptcdata/iptc-data.h>
+#endif /* HAVE_IPTCDATA */
+
+#include "psd.h"
+#include "psd-util.h"
+#include "psd-image-res-load.h"
+
+#include "libgimp/stdplugins-intl.h"
+
+#define EXIF_HEADER_SIZE 8
+
+/*  Local function prototypes  */
+static gint     load_resource_unknown  (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_ps_only  (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1005     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1006     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        PSDimage              *img_a,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1007     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        PSDimage              *img_a,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1008     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1022     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        PSDimage              *img_a,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1024     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        PSDimage              *img_a,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1028     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1032     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1033     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1039     (const PSDimageres     *res_a,
+                                        PSDimage              *img_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1045     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        PSDimage              *img_a,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1046     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1053     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        PSDimage              *img_a,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1058     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_1077     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        PSDimage              *img_a,
+                                        FILE                  *f,
+                                        GError               **error);
+
+static gint     load_resource_2000     (const PSDimageres     *res_a,
+                                        gint32                 image_id,
+                                        FILE                  *f,
+                                        GError               **error);
+
+/* Public Functions */
+gint
+get_image_resource_header (PSDimageres  *res_a,
+                           FILE         *f,
+                           GError      **error)
+{
+  gint32        read_len;
+  gint32        write_len;
+  gchar        *name;
+
+  if (fread (&res_a->type, 4, 1, f) < 1
+      || fread (&res_a->id, 2, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+  res_a->id = GUINT16_FROM_BE (res_a->id);
+  name = fread_pascal_string (&read_len, &write_len, 2, f, error);
+  if (*error)
+    return -1;
+  if (name != NULL)
+    g_strlcpy (res_a->name, name, write_len + 1);
+  else
+    res_a->name[0] = 0x0;
+  g_free (name);
+  if (fread (&res_a->data_len, 4, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+  res_a->data_len = GUINT32_FROM_BE (res_a->data_len);
+  res_a->data_start = ftell (f);
+
+  IFDBG(2) g_debug ("Type: %.4s, id: %d, start: %d, len: %d",
+                    res_a->type, res_a->id, res_a->data_start, res_a->data_len);
+
+  return 0;
+}
+
+gint
+load_image_resource (PSDimageres  *res_a,
+                     gint32        image_id,
+                     PSDimage     *img_a,
+                     FILE         *f,
+                     gboolean     *resolution_loaded,
+                     gboolean     *profile_loaded,
+                     GError      **error)
+{
+  gint  pad;
+
+  /* Set file position to start of image resource data block */
+  if (fseek (f, res_a->data_start, SEEK_SET) < 0)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+
+  /* Process image resource blocks */
+  if (memcmp (res_a->type, "8BIM", 4) != 0 &&
+      memcmp (res_a->type, "MeSa", 4) !=0)
+    {
+      IFDBG(1) g_debug ("Unknown image resource type signature %.4s",
+                        res_a->type);
+    }
+  else
+    {
+      switch (res_a->id)
+        {
+          case PSD_PS2_IMAGE_INFO:
+          case PSD_PS2_COLOR_TAB:
+          case PSD_OBSOLETE_01:
+          case PSD_OBSOLETE_02:
+          case PSD_OBSOLETE_03:
+            /* Drop obsolete image resource blocks */
+            IFDBG(2) g_debug ("Obsolete image resource block: %d",
+                               res_a->id);
+            break;
+
+          case PSD_THUMB_RES:
+          case PSD_THUMB_RES2:
+            /* Drop thumbnails from standard file load */
+            IFDBG(2) g_debug ("Thumbnail resource block: %d",
+                               res_a->id);
+            break;
+
+          case PSD_MAC_PRINT_INFO:
+          case PSD_JPEG_QUAL:
+            /* Save photoshop resources with no meaning for GIMP
+              as image parasites */
+            load_resource_ps_only (res_a, image_id, f, error);
+            break;
+
+          case PSD_RESN_INFO:
+            if (! load_resource_1005 (res_a, image_id, f, error))
+              *resolution_loaded = TRUE;
+            break;
+
+          case PSD_ALPHA_NAMES:
+            if (! img_a->merged_image_only)
+              load_resource_1006 (res_a, image_id, img_a, f, error);
+            break;
+
+          case PSD_DISPLAY_INFO:
+            load_resource_1007 (res_a, image_id, img_a, f, error);
+            break;
+
+          case PSD_CAPTION:
+            load_resource_1008 (res_a, image_id, f, error);
+            break;
+
+          case PSD_QUICK_MASK:
+            if (! img_a->merged_image_only)
+              load_resource_1022 (res_a, image_id, img_a, f, error);
+            break;
+
+          case PSD_LAYER_STATE:
+            if (! img_a->merged_image_only)
+              load_resource_1024 (res_a, image_id, img_a, f, error);
+            break;
+
+          case PSD_WORKING_PATH:
+            if (! img_a->merged_image_only)
+              load_resource_2000 (res_a, image_id, f, error);
+            break;
+
+          case PSD_IPTC_NAA_DATA:
+            load_resource_1028 (res_a, image_id, f, error);
+            break;
+
+          case PSD_GRID_GUIDE:
+            if (! img_a->merged_image_only)
+              load_resource_1032 (res_a, image_id, f, error);
+            break;
+
+          case PSD_ICC_PROFILE:
+            if (! load_resource_1039 (res_a, img_a, image_id, f, error))
+              *profile_loaded = TRUE;
+            break;
+
+          case PSD_ALPHA_NAMES_UNI:
+            if (! img_a->merged_image_only)
+              load_resource_1045 (res_a, image_id, img_a, f, error);
+            break;
+
+          case PSD_IDX_COL_TAB_CNT:
+            load_resource_1046 (res_a, image_id, f, error);
+            break;
+
+          case PSD_ALPHA_ID:
+            if (! img_a->merged_image_only)
+              load_resource_1053 (res_a, image_id, img_a, f, error);
+            break;
+
+          case PSD_EXIF_DATA:
+            load_resource_1058 (res_a, image_id, f, error);
+            break;
+
+          case PSD_XMP_DATA:
+            break;
+
+          case PSD_DISPLAY_INFO_NEW:
+            load_resource_1077 (res_a, image_id, img_a, f, error);
+            break;
+
+          default:
+            if (res_a->id >= 2000 &&
+                res_a->id <  2999)
+              load_resource_2000 (res_a, image_id, f, error);
+            else
+              load_resource_unknown (res_a, image_id, f, error);
+        }
+    }
+
+  /* Image blocks are null padded to even length */
+  if (res_a->data_len % 2 == 0)
+    pad = 0;
+  else
+    pad = 1;
+
+  /* Set file position to end of image resource block */
+  if (fseek (f, res_a->data_start + res_a->data_len + pad, SEEK_SET) < 0)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+
+  return 0;
+}
+
+gint
+load_thumbnail_resource (PSDimageres  *res_a,
+                         gint32        image_id,
+                         FILE         *f,
+                         GError      **error)
+{
+  gint  rtn = 0;
+  gint  pad;
+
+  /* Set file position to start of image resource data block */
+  if (fseek (f, res_a->data_start, SEEK_SET) < 0)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+
+  /* Process image resource blocks */
+  if (res_a->id == PSD_THUMB_RES
+      || res_a->id == PSD_THUMB_RES2)
+    {
+      /* Load thumbnails from standard file load */
+      load_resource_1033 (res_a, image_id, f, error);
+      rtn = 1;
+    }
+
+  /* Image blocks are null padded to even length */
+  if (res_a->data_len % 2 == 0)
+    pad = 0;
+  else
+    pad = 1;
+
+  /* Set file position to end of image resource block */
+  if (fseek (f, res_a->data_start + res_a->data_len + pad, SEEK_SET) < 0)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+
+  return rtn;
+}
+
+/* Private Functions */
+
+static gint
+load_resource_unknown (const PSDimageres  *res_a,
+                       gint32              image_id,
+                       FILE               *f,
+                       GError            **error)
+{
+  /* Unknown image resources attached as parasites to re-save later */
+  GimpParasite  *parasite;
+  gchar         *data;
+  gchar         *name;
+
+  IFDBG(2) g_debug ("Process unknown image resource block: %d", res_a->id);
+
+  data = g_malloc (res_a->data_len);
+  if (res_a->data_len > 0 && fread (data, res_a->data_len, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      g_free (data);
+      return -1;
+    }
+
+  name = g_strdup_printf ("psd-image-resource-%.4s-%.4x",
+                           res_a->type, res_a->id);
+  IFDBG(2) g_debug ("Parasite name: %s", name);
+
+  parasite = gimp_parasite_new (name, 0, res_a->data_len, data);
+  gimp_image_attach_parasite (image_id, parasite);
+  gimp_parasite_free (parasite);
+  g_free (data);
+  g_free (name);
+
+  return 0;
+}
+
+static gint
+load_resource_ps_only (const PSDimageres  *res_a,
+                       gint32              image_id,
+                       FILE               *f,
+                       GError            **error)
+{
+  /* Save photoshop resources with no meaning for GIMP as image parasites
+     to re-save later */
+  GimpParasite  *parasite;
+  gchar         *data;
+  gchar         *name;
+
+  IFDBG(3) g_debug ("Process image resource block: %d", res_a->id);
+
+  data = g_malloc (res_a->data_len);
+  if (fread (data, res_a->data_len, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      g_free (data);
+      return -1;
+    }
+
+  name = g_strdup_printf ("psd-image-resource-%.4s-%.4x",
+                           res_a->type, res_a->id);
+  IFDBG(2) g_debug ("Parasite name: %s", name);
+
+  parasite = gimp_parasite_new (name, 0, res_a->data_len, data);
+  gimp_image_attach_parasite (image_id, parasite);
+  gimp_parasite_free (parasite);
+  g_free (data);
+  g_free (name);
+
+  return 0;
+}
+
+static gint
+load_resource_1005 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load image resolution and unit of measure */
+
+  /* FIXME  width unit and height unit unused at present */
+
+  ResolutionInfo        res_info;
+  GimpUnit              image_unit;
+
+  IFDBG(2) g_debug ("Process image resource block 1005: Resolution Info");
+
+  if (fread (&res_info.hRes, 4, 1, f) < 1
+      || fread (&res_info.hResUnit, 2, 1, f) < 1
+      || fread (&res_info.widthUnit, 2, 1, f) < 1
+      || fread (&res_info.vRes, 4, 1, f) < 1
+      || fread (&res_info.vResUnit, 2, 1, f) < 1
+      || fread (&res_info.heightUnit, 2, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+  res_info.hRes = GINT32_FROM_BE (res_info.hRes);
+  res_info.hResUnit = GINT16_FROM_BE (res_info.hResUnit);
+  res_info.widthUnit = GINT16_FROM_BE (res_info.widthUnit);
+  res_info.vRes = GINT32_FROM_BE (res_info.vRes);
+  res_info.vResUnit = GINT16_FROM_BE (res_info.vResUnit);
+  res_info.heightUnit = GINT16_FROM_BE (res_info.heightUnit);
+
+  IFDBG(3) g_debug ("Resolution: %d, %d, %d, %d, %d, %d",
+                     res_info.hRes,
+                     res_info.hResUnit,
+                     res_info.widthUnit,
+                     res_info.vRes,
+                     res_info.vResUnit,
+                     res_info.heightUnit);
+
+  /* Resolution always recorded as pixels / inch in a fixed point implied
+     decimal int32 with 16 bits before point and 16 after (i.e. cast as
+     double and divide resolution by 2^16 */
+  gimp_image_set_resolution (image_id,
+                             res_info.hRes / 65536.0, res_info.vRes / 65536.0);
+
+  /* GIMP only has one display unit so use ps horizontal resolution unit */
+  switch (res_info.hResUnit)
+    {
+    case PSD_RES_INCH:
+      image_unit = GIMP_UNIT_INCH;
+      break;
+    case PSD_RES_CM:
+      image_unit = GIMP_UNIT_MM;
+      break;
+    default:
+      image_unit = GIMP_UNIT_INCH;
+    }
+
+  gimp_image_set_unit (image_id, image_unit);
+
+  return 0;
+}
+
+static gint
+load_resource_1006 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    PSDimage           *img_a,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load alpha channel names stored as a series of pascal strings
+     unpadded between strings */
+
+  gchar        *str;
+  gint32        block_rem;
+  gint32        read_len;
+  gint32        write_len;
+
+  IFDBG(2) g_debug ("Process image resource block 1006: Alpha Channel Names");
+
+  if (img_a->alpha_names)
+    {
+      IFDBG(3) g_debug ("Alpha names loaded from unicode resource block");
+      return 0;
+    }
+
+  img_a->alpha_names = g_ptr_array_new ();
+
+  block_rem = res_a->data_len;
+  while (block_rem > 1)
+    {
+      str = fread_pascal_string (&read_len, &write_len, 1, f, error);
+      if (*error)
+        return -1;
+      IFDBG(3) g_debug ("String: %s, %d, %d", str, read_len, write_len);
+      if (write_len >= 0)
+        {
+          g_ptr_array_add (img_a->alpha_names, (gpointer) str);
+        }
+      block_rem -= read_len;
+    }
+
+  return 0;
+}
+
+static gint
+load_resource_1007 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    PSDimage           *img_a,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load alpha channel display info */
+
+  DisplayInfo       dsp_info;
+  CMColor           ps_color;
+  GimpRGB           gimp_rgb;
+  GimpHSV           gimp_hsv;
+  GimpCMYK          gimp_cmyk;
+  gint16            tot_rec;
+  gint              cidx;
+
+  IFDBG(2) g_debug ("Process image resource block 1007: Display Info");
+  tot_rec = res_a->data_len / 14;
+  if (tot_rec == 0)
+    return 0;
+
+  img_a->alpha_display_info = g_new (PSDchanneldata *, tot_rec);
+  img_a->alpha_display_count = tot_rec;
+  for (cidx = 0; cidx < tot_rec; ++cidx)
+    {
+      if (fread (&dsp_info.colorSpace, 2, 1, f) < 1
+          || fread (&dsp_info.color, 8, 1, f) < 1
+          || fread (&dsp_info.opacity, 2, 1, f) < 1
+          || fread (&dsp_info.kind, 1, 1, f) < 1
+          || fread (&dsp_info.padding, 1, 1, f) < 1)
+        {
+          psd_set_error (feof (f), errno, error);
+          return -1;
+        }
+      dsp_info.colorSpace = GINT16_FROM_BE (dsp_info.colorSpace);
+      ps_color.cmyk.cyan = GUINT16_FROM_BE (dsp_info.color[0]);
+      ps_color.cmyk.magenta = GUINT16_FROM_BE (dsp_info.color[1]);
+      ps_color.cmyk.yellow = GUINT16_FROM_BE (dsp_info.color[2]);
+      ps_color.cmyk.black = GUINT16_FROM_BE (dsp_info.color[3]);
+      dsp_info.opacity = GINT16_FROM_BE (dsp_info.opacity);
+
+      switch (dsp_info.colorSpace)
+        {
+          case PSD_CS_RGB:
+            gimp_rgb_set (&gimp_rgb, ps_color.rgb.red / 65535.0,
+                          ps_color.rgb.green / 65535.0,
+                          ps_color.rgb.blue / 65535.0);
+            break;
+
+          case PSD_CS_HSB:
+            gimp_hsv_set (&gimp_hsv, ps_color.hsv.hue / 65535.0,
+                          ps_color.hsv.saturation / 65535.0,
+                          ps_color.hsv.value / 65535.0);
+            gimp_hsv_to_rgb (&gimp_hsv, &gimp_rgb);
+            break;
+
+          case PSD_CS_CMYK:
+            gimp_cmyk_set (&gimp_cmyk, 1.0 - ps_color.cmyk.cyan / 65535.0,
+                           1.0 - ps_color.cmyk.magenta / 65535.0,
+                           1.0 - ps_color.cmyk.yellow / 65535.0,
+                           1.0 - ps_color.cmyk.black / 65535.0);
+            gimp_cmyk_to_rgb (&gimp_cmyk, &gimp_rgb);
+            break;
+
+          case PSD_CS_GRAYSCALE:
+            gimp_rgb_set (&gimp_rgb, ps_color.gray.gray / 10000.0,
+                          ps_color.gray.gray / 10000.0,
+                          ps_color.gray.gray / 10000.0);
+            break;
+
+          case PSD_CS_FOCOLTONE:
+          case PSD_CS_TRUMATCH:
+          case PSD_CS_HKS:
+          case PSD_CS_LAB:
+          case PSD_CS_PANTONE:
+          case PSD_CS_TOYO:
+          case PSD_CS_DIC:
+          case PSD_CS_ANPA:
+          default:
+            if (CONVERSION_WARNINGS)
+              g_message ("Unsupported color space: %d",
+                         dsp_info.colorSpace);
+            gimp_rgb_set (&gimp_rgb, 1.0, 0.0, 0.0);
+        }
+
+      gimp_rgb_set_alpha (&gimp_rgb, 1.0);
+
+      IFDBG(2) g_debug ("PS cSpace: %d, col: %d %d %d %d, opacity: %d, kind: %d",
+                        dsp_info.colorSpace, ps_color.cmyk.cyan, ps_color.cmyk.magenta,
+                        ps_color.cmyk.yellow, ps_color.cmyk.black, dsp_info.opacity,
+                        dsp_info.kind);
+
+      IFDBG(2) g_debug ("cSpace: %d, col: %g %g %g, opacity: %d, kind: %d",
+                        dsp_info.colorSpace, gimp_rgb.r * 255 , gimp_rgb.g * 255,
+                        gimp_rgb.b * 255, dsp_info.opacity, dsp_info.kind);
+
+      img_a->alpha_display_info[cidx] = g_malloc0 (sizeof (PSDchanneldata));
+      img_a->alpha_display_info[cidx]->gimp_color = gimp_rgb;
+      img_a->alpha_display_info[cidx]->opacity = dsp_info.opacity;
+      img_a->alpha_display_info[cidx]->ps_kind = dsp_info.kind;
+      img_a->alpha_display_info[cidx]->ps_cspace = dsp_info.colorSpace;
+      img_a->alpha_display_info[cidx]->ps_color = ps_color;
+    }
+
+  return 0;
+}
+
+static gint
+load_resource_1008 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load image caption */
+  GimpParasite  *parasite;
+  gchar         *caption;
+  gint32         read_len;
+  gint32         write_len;
+
+  IFDBG(2) g_debug ("Process image resource block: 1008: Caption");
+  caption = fread_pascal_string (&read_len, &write_len, 1, f, error);
+  if (*error)
+    return -1;
+
+  IFDBG(3) g_debug ("Caption: %s", caption);
+  parasite = gimp_parasite_new (GIMP_PARASITE_COMMENT, GIMP_PARASITE_PERSISTENT,
+                                write_len, caption);
+  gimp_image_attach_parasite (image_id, parasite);
+  gimp_parasite_free (parasite);
+  g_free (caption);
+
+  return 0;
+}
+
+static gint
+load_resource_1022 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    PSDimage           *img_a,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load quick mask info */
+  gboolean              quick_mask_empty;       /* Quick mask initially empty */
+
+  IFDBG(2) g_debug ("Process image resource block: 1022: Quick Mask");
+
+  if (fread (&img_a->quick_mask_id, 2, 1, f) < 1
+      || fread (&quick_mask_empty, 1, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+  img_a->quick_mask_id = GUINT16_FROM_BE (img_a->quick_mask_id);
+
+  IFDBG(3) g_debug ("Quick mask channel: %d, empty: %d",
+                    img_a->quick_mask_id,
+                    quick_mask_empty);
+
+  return 0;
+}
+
+static gint
+load_resource_1024 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    PSDimage           *img_a,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load image layer state - current active layer counting from bottom up */
+  IFDBG(2) g_debug ("Process image resource block: 1024: Layer State");
+
+  if (fread (&img_a->layer_state, 2, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+  img_a->layer_state = GUINT16_FROM_BE (img_a->layer_state);
+
+  return 0;
+}
+
+static gint
+load_resource_1028 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load IPTC data block */
+
+#ifdef HAVE_IPTCDATA
+  IptcData     *iptc_data;
+  guchar       *iptc_buf;
+  guint         iptc_buf_len;
+#else
+  gchar        *name;
+#endif /* HAVE_IPTCDATA */
+
+  GimpParasite *parasite;
+  gchar        *res_data;
+
+  IFDBG(2) g_debug ("Process image resource block: 1028: IPTC data");
+
+  res_data = g_malloc (res_a->data_len);
+  if (fread (res_data, res_a->data_len, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      g_free (res_data);
+      return -1;
+    }
+
+#ifdef HAVE_IPTCDATA
+  /* Load IPTC data structure */
+  iptc_data = iptc_data_new_from_data (res_data, res_a->data_len);
+  IFDBG (3) iptc_data_dump (iptc_data, 0);
+
+  /* Store resource data as a GIMP IPTC parasite */
+  IFDBG (2) g_debug ("Processing IPTC data as GIMP IPTC parasite");
+  /* Serialize IPTC data */
+  iptc_data_save (iptc_data, &iptc_buf, &iptc_buf_len);
+  if (iptc_buf_len > 0)
+    {
+      parasite = gimp_parasite_new (GIMP_PARASITE_IPTC,
+                                    GIMP_PARASITE_PERSISTENT,
+                                    iptc_buf_len, iptc_buf);
+      gimp_image_attach_parasite (image_id, parasite);
+      gimp_parasite_free (parasite);
+    }
+
+  iptc_data_unref (iptc_data);
+  g_free (iptc_buf);
+
+#else
+  /* Store resource data as a standard psd parasite */
+  IFDBG (2) g_debug ("Processing IPTC data as psd parasite");
+  name = g_strdup_printf ("psd-image-resource-%.4s-%.4x",
+                           res_a->type, res_a->id);
+  IFDBG(3) g_debug ("Parasite name: %s", name);
+
+  parasite = gimp_parasite_new (name, 0, res_a->data_len, res_data);
+  gimp_image_attach_parasite (image_id, parasite);
+  gimp_parasite_free (parasite);
+  g_free (name);
+
+#endif /* HAVE_IPTCDATA */
+
+  g_free (res_data);
+  return 0;
+}
+
+static gint
+load_resource_1032 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load grid and guides */
+
+  /* Grid info is not used (CS2 or earlier) */
+
+  GuideHeader           hdr;
+  GuideResource         guide;
+  gint                  i;
+
+  IFDBG(2) g_debug ("Process image resource block 1032: Grid and Guide Info");
+
+  if (fread (&hdr.fVersion, 4, 1, f) < 1
+      || fread (&hdr.fGridCycleV, 4, 1, f) < 1
+      || fread (&hdr.fGridCycleH, 4, 1, f) < 1
+      || fread (&hdr.fGuideCount, 4, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+  hdr.fVersion = GUINT32_FROM_BE (hdr.fVersion);
+  hdr.fGridCycleV = GUINT32_FROM_BE (hdr.fGridCycleV);
+  hdr.fGridCycleH = GUINT32_FROM_BE (hdr.fGridCycleH);
+  hdr.fGuideCount = GUINT32_FROM_BE (hdr.fGuideCount);
+
+  IFDBG(3) g_debug ("Grids & Guides: %d, %d, %d, %d",
+                     hdr.fVersion,
+                     hdr.fGridCycleV,
+                     hdr.fGridCycleH,
+                     hdr.fGuideCount);
+
+  for (i = 0; i < hdr.fGuideCount; ++i)
+    {
+      if (fread (&guide.fLocation, 4, 1, f) < 1
+          || fread (&guide.fDirection, 1, 1, f) < 1)
+        {
+          psd_set_error (feof (f), errno, error);
+          return -1;
+        }
+      guide.fLocation = GUINT32_FROM_BE (guide.fLocation);
+      guide.fLocation /= 32;
+
+      IFDBG(3) g_debug ("Guide: %d px, %d",
+                         guide.fLocation,
+                         guide.fDirection);
+
+      if (guide.fDirection == PSD_VERTICAL)
+        gimp_image_add_vguide (image_id, guide.fLocation);
+      else
+        gimp_image_add_hguide (image_id, guide.fLocation);
+    }
+
+  return 0;
+}
+
+static gint
+load_resource_1033 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load thumbnail image */
+
+  struct jpeg_decompress_struct cinfo;
+  struct jpeg_error_mgr         jerr;
+
+  ThumbnailInfo         thumb_info;
+  GeglBuffer           *buffer;
+  const Babl           *format;
+  gint32                layer_id;
+  guchar               *buf;
+  guchar               *rgb_buf;
+  guchar              **rowbuf;
+  gint                  i;
+
+  IFDBG(2) g_debug ("Process image resource block %d: Thumbnail Image", res_a->id);
+
+  /* Read thumbnail resource header info */
+  if (fread (&thumb_info.format, 4, 1, f) < 1
+      || fread (&thumb_info.width, 4, 1, f) < 1
+      || fread (&thumb_info.height, 4, 1, f) < 1
+      || fread (&thumb_info.widthbytes, 4, 1, f) < 1
+      || fread (&thumb_info.size, 4, 1, f) < 1
+      || fread (&thumb_info.compressedsize, 4, 1, f) < 1
+      || fread (&thumb_info.bitspixel, 2, 1, f) < 1
+      || fread (&thumb_info.planes, 2, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+  thumb_info.format = GINT32_FROM_BE (thumb_info.format);
+  thumb_info.width = GINT32_FROM_BE (thumb_info.width);
+  thumb_info.height = GINT32_FROM_BE (thumb_info.height);
+  thumb_info.widthbytes = GINT32_FROM_BE (thumb_info.widthbytes);
+  thumb_info.size = GINT32_FROM_BE (thumb_info.size);
+  thumb_info.compressedsize = GINT32_FROM_BE (thumb_info.compressedsize);
+  thumb_info.bitspixel = GINT16_FROM_BE (thumb_info.bitspixel);
+  thumb_info.planes = GINT16_FROM_BE (thumb_info.planes);
+
+  IFDBG(2) g_debug ("\nThumbnail:\n"
+                    "\tFormat: %d\n"
+                    "\tDimensions: %d x %d\n",
+                     thumb_info.format,
+                     thumb_info.width,
+                     thumb_info.height);
+
+  if (thumb_info.format != 1)
+    {
+      IFDBG(1) g_debug ("Unknown thumbnail format %d", thumb_info.format);
+      return -1;
+    }
+
+  /* Load Jpeg RGB thumbnail info */
+
+  /* Step 1: Allocate and initialize JPEG decompression object */
+  cinfo.err = jpeg_std_error (&jerr);
+  jpeg_create_decompress (&cinfo);
+
+  /* Step 2: specify data source (eg, a file) */
+  jpeg_stdio_src(&cinfo, f);
+
+  /* Step 3: read file parameters with jpeg_read_header() */
+  jpeg_read_header (&cinfo, TRUE);
+
+  /* Step 4: set parameters for decompression */
+
+
+  /* Step 5: Start decompressor */
+  jpeg_start_decompress (&cinfo);
+
+  /* temporary buffers */
+  buf = g_new (guchar, cinfo.output_height * cinfo.output_width
+               * cinfo.output_components);
+  if (res_a->id == PSD_THUMB_RES)
+    rgb_buf = g_new (guchar, cinfo.output_height * cinfo.output_width
+                     * cinfo.output_components);
+  else
+    rgb_buf = NULL;
+  rowbuf = g_new (guchar *, cinfo.output_height);
+
+  for (i = 0; i < cinfo.output_height; ++i)
+    rowbuf[i] = buf + cinfo.output_width * cinfo.output_components * i;
+
+  /* Create image layer */
+  gimp_image_resize (image_id, cinfo.output_width, cinfo.output_height, 0, 0);
+  layer_id = gimp_layer_new (image_id, _("Background"),
+                             cinfo.output_width,
+                             cinfo.output_height,
+                             GIMP_RGB_IMAGE,
+                             100,
+                             gimp_image_get_default_new_layer_mode (image_id));
+  buffer = gimp_drawable_get_buffer (layer_id);
+  format = babl_format ("R'G'B' u8");
+
+  /* Step 6: while (scan lines remain to be read) */
+  /*           jpeg_read_scanlines(...); */
+  while (cinfo.output_scanline < cinfo.output_height)
+    {
+      jpeg_read_scanlines (&cinfo,
+                           (JSAMPARRAY) &rowbuf[cinfo.output_scanline], 1);
+    }
+
+  if (res_a->id == PSD_THUMB_RES)   /* Order is BGR for resource 1033 */
+    {
+      guchar *dst = rgb_buf;
+      guchar *src = buf;
+
+      for (i = 0; i < gegl_buffer_get_width (buffer) * gegl_buffer_get_height (buffer); ++i)
+        {
+          guchar r, g, b;
+
+          r = *(src++);
+          g = *(src++);
+          b = *(src++);
+          *(dst++) = b;
+          *(dst++) = g;
+          *(dst++) = r;
+        }
+    }
+
+  gegl_buffer_set (buffer, GEGL_RECTANGLE (0, 0,
+                                           gegl_buffer_get_width (buffer),
+                                           gegl_buffer_get_height (buffer)),
+                   0, format, rgb_buf ? rgb_buf : buf, GEGL_AUTO_ROWSTRIDE);
+
+  /* Step 7: Finish decompression */
+  jpeg_finish_decompress (&cinfo);
+  /* We can ignore the return value since suspension is not possible
+   * with the stdio data source.
+   */
+
+  /* Step 8: Release JPEG decompression object */
+  jpeg_destroy_decompress (&cinfo);
+
+  /* free up the temporary buffers */
+  g_free (rowbuf);
+  g_free (buf);
+  g_free (rgb_buf);
+
+  /* At this point you may want to check to see whether any
+   * corrupt-data warnings occurred (test whether
+   * jerr.num_warnings is nonzero).
+   */
+  gimp_image_insert_layer (image_id, layer_id, -1, 0);
+  g_object_unref (buffer);
+
+  return 0;
+}
+
+static gint
+load_resource_1039 (const PSDimageres  *res_a,
+                    PSDimage           *img_a,
+                    gint32              image_id,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load ICC profile */
+  GimpColorProfile *profile;
+  gchar            *icc_profile;
+
+  IFDBG(2) g_debug ("Process image resource block: 1039: ICC Profile");
+
+  icc_profile = g_malloc (res_a->data_len);
+  if (fread (icc_profile, res_a->data_len, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      g_free (icc_profile);
+      return -1;
+    }
+
+  profile = gimp_color_profile_new_from_icc_profile ((guint8 *) icc_profile,
+                                                     res_a->data_len,
+                                                     NULL);
+  if (profile)
+    {
+      if (img_a->color_mode == PSD_CMYK &&
+          gimp_color_profile_is_cmyk (profile))
+        {
+          img_a->cmyk_profile = profile;
+        }
+      else
+        {
+          gimp_image_set_color_profile (image_id, profile);
+          g_object_unref (profile);
+        }
+    }
+
+  g_free (icc_profile);
+
+  return 0;
+}
+
+static gint
+load_resource_1045 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    PSDimage           *img_a,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load alpha channel names stored as a series of unicode strings
+     in a GPtrArray */
+
+  gchar        *str;
+  gint32        block_rem;
+  gint32        read_len;
+  gint32        write_len;
+
+  IFDBG(2) g_debug ("Process image resource block 1045: Unicode Alpha Channel Names");
+
+  if (img_a->alpha_names)
+    {
+      gint      i;
+      IFDBG(3) g_debug ("Deleting localised alpha channel names");
+      for (i = 0; i < img_a->alpha_names->len; ++i)
+        {
+          str = g_ptr_array_index (img_a->alpha_names, i);
+          g_free (str);
+        }
+      g_ptr_array_free (img_a->alpha_names, TRUE);
+    }
+
+  img_a->alpha_names = g_ptr_array_new ();
+
+  block_rem = res_a->data_len;
+  while (block_rem > 1)
+    {
+      str = fread_unicode_string (&read_len, &write_len, 1, f, error);
+      if (*error)
+        return -1;
+
+      IFDBG(3) g_debug ("String: %s, %d, %d", str, read_len, write_len);
+      if (write_len >= 0)
+        {
+          g_ptr_array_add (img_a->alpha_names, (gpointer) str);
+        }
+      block_rem -= read_len;
+    }
+
+  return 0;
+}
+
+static gint
+load_resource_1046 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load indexed color table count */
+  guchar       *cmap;
+  gint32        cmap_count = 0;
+  gint16        index_count = 0;
+
+  IFDBG(2) g_debug ("Process image resource block: 1046: Indexed Color Table Count");
+
+  if (fread (&index_count, 2, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+  index_count = GINT16_FROM_BE (index_count);
+
+  IFDBG(3) g_debug ("Indexed color table count: %d", index_count);
+  /* FIXME - check that we have indexed image */
+  if (index_count && index_count < 256)
+    {
+      cmap = gimp_image_get_colormap (image_id, &cmap_count);
+      if (cmap && index_count < cmap_count)
+        gimp_image_set_colormap (image_id, cmap, index_count);
+      g_free (cmap);
+    }
+  return 0;
+}
+
+static gint
+load_resource_1053 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    PSDimage           *img_a,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load image alpha channel ids (tattoos) */
+  gint16        tot_rec;
+  gint16        cidx;
+
+  IFDBG(2) g_debug ("Process image resource block: 1053: Channel ID");
+
+  tot_rec = res_a->data_len / 4;
+  if (tot_rec ==0)
+    return 0;
+
+  img_a->alpha_id = g_malloc (sizeof (img_a->alpha_id) * tot_rec);
+  img_a->alpha_id_count = tot_rec;
+  for (cidx = 0; cidx < tot_rec; ++cidx)
+    {
+      if (fread (&img_a->alpha_id[cidx], 4, 1, f) < 1)
+        {
+          psd_set_error (feof (f), errno, error);
+          return -1;
+        }
+      img_a->alpha_id[cidx] = GUINT32_FROM_BE (img_a->alpha_id[cidx]);
+
+      IFDBG(3) g_debug ("Channel id: %d", img_a->alpha_id[cidx]);
+    }
+
+  return 0;
+}
+
+static gint
+load_resource_1058 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    FILE               *f,
+                    GError            **error)
+{
+  gchar        *name;
+
+  GimpParasite *parasite;
+  gchar        *res_data;
+
+  IFDBG(2) g_debug ("Process image resource block: 1058: Exif data");
+
+  res_data = g_malloc (res_a->data_len);
+  if (fread (res_data, res_a->data_len, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      g_free (res_data);
+      return -1;
+    }
+
+  /* Store resource data as a standard psd parasite */
+  IFDBG (2) g_debug ("Processing exif data as psd parasite");
+  name = g_strdup_printf ("psd-image-resource-%.4s-%.4x",
+                           res_a->type, res_a->id);
+  IFDBG(3) g_debug ("Parasite name: %s", name);
+
+  parasite = gimp_parasite_new (name, 0, res_a->data_len, res_data);
+  gimp_image_attach_parasite (image_id, parasite);
+  gimp_parasite_free (parasite);
+  g_free (name);
+
+  g_free (res_data);
+  return 0;
+}
+
+static gint
+load_resource_1077 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    PSDimage           *img_a,
+                    FILE               *f,
+                    GError            **error)
+{
+  /* Load alpha channel display info */
+
+  DisplayInfoNew    dsp_info;
+  CMColor           ps_color;
+  GimpRGB           gimp_rgb;
+  GimpHSV           gimp_hsv;
+  GimpCMYK          gimp_cmyk;
+  gint16            tot_rec;
+  gint              cidx;
+
+  IFDBG(2) g_debug ("Process image resource block 1077: Display Info New");
+
+  /* For now, skip first 4 bytes since intention is unclear. Seems to be
+     a version number that is always one, but who knows. */
+  fseek (f, 4, SEEK_CUR);
+
+  tot_rec = res_a->data_len / 13;
+  if (tot_rec == 0)
+    return 0;
+
+  img_a->alpha_display_info = g_new (PSDchanneldata *, tot_rec);
+  img_a->alpha_display_count = tot_rec;
+  for (cidx = 0; cidx < tot_rec; ++cidx)
+    {
+      if (fread (&dsp_info.colorSpace, 2, 1, f) < 1
+          || fread (&dsp_info.color, 8, 1, f) < 1
+          || fread (&dsp_info.opacity, 2, 1, f) < 1
+          || fread (&dsp_info.mode, 1, 1, f) < 1)
+        {
+          psd_set_error (feof (f), errno, error);
+          return -1;
+        }
+      dsp_info.colorSpace = GINT16_FROM_BE (dsp_info.colorSpace);
+      ps_color.cmyk.cyan = GUINT16_FROM_BE (dsp_info.color[0]);
+      ps_color.cmyk.magenta = GUINT16_FROM_BE (dsp_info.color[1]);
+      ps_color.cmyk.yellow = GUINT16_FROM_BE (dsp_info.color[2]);
+      ps_color.cmyk.black = GUINT16_FROM_BE (dsp_info.color[3]);
+      dsp_info.opacity = GINT16_FROM_BE (dsp_info.opacity);
+
+      switch (dsp_info.colorSpace)
+        {
+          case PSD_CS_RGB:
+            gimp_rgb_set (&gimp_rgb, ps_color.rgb.red / 65535.0,
+                          ps_color.rgb.green / 65535.0,
+                          ps_color.rgb.blue / 65535.0);
+            break;
+
+          case PSD_CS_HSB:
+            gimp_hsv_set (&gimp_hsv, ps_color.hsv.hue / 65535.0,
+                          ps_color.hsv.saturation / 65535.0,
+                          ps_color.hsv.value / 65535.0);
+            gimp_hsv_to_rgb (&gimp_hsv, &gimp_rgb);
+            break;
+
+          case PSD_CS_CMYK:
+            gimp_cmyk_set (&gimp_cmyk, 1.0 - ps_color.cmyk.cyan / 65535.0,
+                           1.0 - ps_color.cmyk.magenta / 65535.0,
+                           1.0 - ps_color.cmyk.yellow / 65535.0,
+                           1.0 - ps_color.cmyk.black / 65535.0);
+            gimp_cmyk_to_rgb (&gimp_cmyk, &gimp_rgb);
+            break;
+
+          case PSD_CS_GRAYSCALE:
+            gimp_rgb_set (&gimp_rgb, ps_color.gray.gray / 10000.0,
+                          ps_color.gray.gray / 10000.0,
+                          ps_color.gray.gray / 10000.0);
+            break;
+
+          case PSD_CS_FOCOLTONE:
+          case PSD_CS_TRUMATCH:
+          case PSD_CS_HKS:
+          case PSD_CS_LAB:
+          case PSD_CS_PANTONE:
+          case PSD_CS_TOYO:
+          case PSD_CS_DIC:
+          case PSD_CS_ANPA:
+          default:
+            if (CONVERSION_WARNINGS)
+              g_message ("Unsupported color space: %d",
+                          dsp_info.colorSpace);
+            gimp_rgb_set (&gimp_rgb, 1.0, 0.0, 0.0);
+        }
+
+      gimp_rgb_set_alpha (&gimp_rgb, 1.0);
+
+      IFDBG(2) g_debug ("PS cSpace: %d, col: %d %d %d %d, opacity: %d, mode: %d",
+                        dsp_info.colorSpace, ps_color.cmyk.cyan, ps_color.cmyk.magenta,
+                        ps_color.cmyk.yellow, ps_color.cmyk.black, dsp_info.opacity,
+                        dsp_info.mode);
+
+      IFDBG(2) g_debug ("cSpace: %d, col: %g %g %g, opacity: %d, mode: %d",
+                        dsp_info.colorSpace, gimp_rgb.r * 255 , gimp_rgb.g * 255,
+                        gimp_rgb.b * 255, dsp_info.opacity, dsp_info.mode);
+
+      img_a->alpha_display_info[cidx] = g_malloc0 (sizeof (PSDchanneldata));
+      img_a->alpha_display_info[cidx]->gimp_color = gimp_rgb;
+      img_a->alpha_display_info[cidx]->opacity = dsp_info.opacity;
+      img_a->alpha_display_info[cidx]->ps_mode = dsp_info.mode;
+      img_a->alpha_display_info[cidx]->ps_cspace = dsp_info.colorSpace;
+      img_a->alpha_display_info[cidx]->ps_color = ps_color;
+    }
+
+  return 0;
+}
+
+static gint
+load_resource_2000 (const PSDimageres  *res_a,
+                    gint32              image_id,
+                    FILE               *f,
+                    GError            **error)
+{
+  gdouble      *controlpoints;
+  gint32        x[3];
+  gint32        y[3];
+  gint32        vector_id = -1;
+  gint16        type;
+  gint16        init_fill;
+  gint16        num_rec;
+  gint16        path_rec;
+  gint16        cntr;
+  gint          image_width;
+  gint          image_height;
+  gint          i;
+  gboolean      closed;
+
+  /* Load path data from image resources 2000-2998 */
+
+  IFDBG(2) g_debug ("Process image resource block: %d :Path data", res_a->id);
+  path_rec = res_a->data_len / 26;
+  if (path_rec ==0)
+    return 0;
+
+  if (fread (&type, 2, 1, f) < 1)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+  type = GINT16_FROM_BE (type);
+  if (type != PSD_PATH_FILL_RULE)
+    {
+      IFDBG(1) g_debug ("Unexpected path record type: %d", type);
+      return -1;
+    }
+
+  if (fseek (f, 24, SEEK_CUR) < 0)
+    {
+      psd_set_error (feof (f), errno, error);
+      return -1;
+    }
+
+  path_rec--;
+  if (path_rec ==0)
+    return 0;
+
+  image_width = gimp_image_width (image_id);
+  image_height = gimp_image_height (image_id);
+
+  /* Create path */
+  if (res_a->id == PSD_WORKING_PATH)
+    {
+      /* use "Working Path" for the path name to match the Photoshop display */
+      vector_id = gimp_vectors_new (image_id, "Working Path");
+    }
+  else
+    {
+      /* Use the name stored in the PSD to name the path */
+      vector_id = gimp_vectors_new (image_id, res_a->name);
+    }
+
+  gimp_image_insert_vectors (image_id, vector_id, -1, -1);
+
+  while (path_rec > 0)
+    {
+      if (fread (&type, 2, 1, f) < 1)
+        {
+          psd_set_error (feof (f), errno, error);
+          return -1;
+        }
+      type = GINT16_FROM_BE (type);
+      IFDBG(3) g_debug ("Path record type %d", type);
+
+      if (type == PSD_PATH_FILL_RULE)
+        {
+          if (fseek (f, 24, SEEK_CUR) < 0)
+            {
+              psd_set_error (feof (f), errno, error);
+              return -1;
+            }
+        }
+
+      else if (type == PSD_PATH_FILL_INIT)
+        {
+          if (fread (&init_fill, 2, 1, f) < 1)
+            {
+              psd_set_error (feof (f), errno, error);
+              return -1;
+            }
+
+          if (fseek (f, 22, SEEK_CUR) < 0)
+            {
+              psd_set_error (feof (f), errno, error);
+              return -1;
+            }
+        }
+
+      else if (type == PSD_PATH_CL_LEN
+               || type == PSD_PATH_OP_LEN)
+        {
+          if (fread (&num_rec, 2, 1, f) < 1)
+            {
+              psd_set_error (feof (f), errno, error);
+              return -1;
+            }
+          num_rec = GINT16_FROM_BE (num_rec);
+          if (num_rec > path_rec)
+            {
+              psd_set_error (feof (f), errno, error);
+              return - 1;
+            }
+          IFDBG(3) g_debug ("Num path records %d", num_rec);
+
+          if (type == PSD_PATH_CL_LEN)
+            closed = TRUE;
+          else
+            closed = FALSE;
+          cntr = 0;
+          controlpoints = g_malloc (sizeof (gdouble) * num_rec * 6);
+          if (fseek (f, 22, SEEK_CUR) < 0)
+            {
+              psd_set_error (feof (f), errno, error);
+              g_free (controlpoints);
+              return -1;
+            }
+
+          while (num_rec > 0)
+            {
+              if (fread (&type, 2, 1, f) < 1)
+                {
+                  psd_set_error (feof (f), errno, error);
+                  return -1;
+                }
+              type = GINT16_FROM_BE (type);
+              IFDBG(3) g_debug ("Path record type %d", type);
+
+              if (type == PSD_PATH_CL_LNK
+                  || type == PSD_PATH_CL_UNLNK
+                  || type == PSD_PATH_OP_LNK
+                  || type == PSD_PATH_OP_UNLNK)
+                {
+                  if (fread (&y[0], 4, 1, f) < 1
+                      || fread (&x[0], 4, 1, f) < 1
+                      || fread (&y[1], 4, 1, f) < 1
+                      || fread (&x[1], 4, 1, f) < 1
+                      || fread (&y[2], 4, 1, f) < 1
+                      || fread (&x[2], 4, 1, f) < 1)
+                    {
+                      psd_set_error (feof (f), errno, error);
+                      return -1;
+                    }
+                  for (i = 0; i < 3; ++i)
+                    {
+                      x[i] = GINT32_FROM_BE (x[i]);
+                      controlpoints[cntr] = x[i] / 16777216.0 * image_width;
+                      cntr++;
+                      y[i] = GINT32_FROM_BE (y[i]);
+                      controlpoints[cntr] = y[i] / 16777216.0 * image_height;
+                      cntr++;
+                    }
+                  IFDBG(3) g_debug ("Path points (%d,%d), (%d,%d), (%d,%d)",
+                                    x[0], y[0], x[1], y[1], x[2], y[2]);
+                }
+              else
+                {
+                  IFDBG(1) g_debug ("Unexpected path type record %d", type);
+                  if (fseek (f, 24, SEEK_CUR) < 0)
+                    {
+                      psd_set_error (feof (f), errno, error);
+                      return -1;
+                    }
+                }
+              path_rec--;
+              num_rec--;
+            }
+          /* Add sub-path */
+          gimp_vectors_stroke_new_from_points (vector_id,
+                                               GIMP_VECTORS_STROKE_TYPE_BEZIER,
+                                               cntr, controlpoints, closed);
+          g_free (controlpoints);
+        }
+
+      else
+        {
+          if (fseek (f, 24, SEEK_CUR) < 0)
+            {
+              psd_set_error (feof (f), errno, error);
+              return -1;
+            }
+        }
+
+      path_rec--;
+    }
+
+  return 0;
+}