179
static GimpParamDef save_args[] =
181
static const GimpParamDef save_args[] =
181
{ GIMP_PDB_INT32, "run_mode", "Interactive, non-interactive" },
182
{ GIMP_PDB_IMAGE, "image", "Input image" },
183
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" },
184
{ GIMP_PDB_STRING, "filename", "The name of the file to save the image in" },
185
{ GIMP_PDB_STRING, "raw_filename", "The name of the file to save the image in" },
186
{ GIMP_PDB_INT32, "compression", "Compression type: { NONE (0), LZW (1), PACKBITS (2)" },
187
{ GIMP_PDB_INT32, "fillorder", "Fill Order: { MSB to LSB (0), LSB to MSB (1)" }
183
{ GIMP_PDB_INT32, "run-mode", "Interactive, non-interactive" },
184
{ GIMP_PDB_IMAGE, "image", "Input image" },
185
{ GIMP_PDB_DRAWABLE, "drawable", "Drawable to save" },
186
{ GIMP_PDB_STRING, "filename", "The name of the file to save the image in" },
187
{ GIMP_PDB_STRING, "raw-filename", "The name of the file to save the image in" },
188
{ GIMP_PDB_INT32, "compression", "Compression type: { NONE (0), LZW (1), PACKBITS (2)" },
189
{ GIMP_PDB_INT32, "fill-order", "Fill Order: { MSB to LSB (0), LSB to MSB (1)" }
190
gimp_install_procedure ("file_psd_save",
192
gimp_install_procedure (SAVE_PROC,
191
193
"saves files in the Photoshop(tm) PSD file format",
192
194
"This filter saves files of Adobe Photoshop(tm) native PSD format. These files may be of any image type supported by GIMP, with or without layers, layer masks, aux channels and guides.",
220
221
*nreturn_vals = 1;
221
222
*return_vals = values;
222
224
values[0].type = GIMP_PDB_STATUS;
223
225
values[0].data.d_status = GIMP_PDB_CALLING_ERROR;
225
if (strcmp (name, "file_psd_save") == 0)
227
if (strcmp (name, SAVE_PROC) == 0)
228
230
gint32 drawable_id;
229
231
GimpExportReturn export = GIMP_EXPORT_IGNORE;
231
IFDBG printf ("\n---------------- %s ----------------\n", param[3].data.d_string);
233
IFDBG printf ("\n---------------- %s ----------------\n",
234
param[3].data.d_string);
233
236
image_id = param[1].data.d_int32;
234
237
drawable_id = param[2].data.d_int32;
236
239
switch (run_mode)
238
case GIMP_RUN_INTERACTIVE:
239
case GIMP_RUN_WITH_LAST_VALS:
240
gimp_ui_init ("psd_save", FALSE);
241
case GIMP_RUN_INTERACTIVE:
242
case GIMP_RUN_WITH_LAST_VALS:
243
gimp_ui_init (PLUG_IN_BINARY, FALSE);
241
244
export = gimp_export_image (&image_id, &drawable_id, "PSD",
242
245
GIMP_EXPORT_CAN_HANDLE_RGB |
243
246
GIMP_EXPORT_CAN_HANDLE_GRAY |
244
247
GIMP_EXPORT_CAN_HANDLE_INDEXED |
245
248
GIMP_EXPORT_CAN_HANDLE_ALPHA |
246
GIMP_EXPORT_CAN_HANDLE_LAYERS);
249
GIMP_EXPORT_CAN_HANDLE_LAYERS |
250
GIMP_EXPORT_CAN_HANDLE_LAYER_MASKS);
248
252
if (export == GIMP_EXPORT_CANCEL)
326
308
case GIMP_VALUE_MODE: /* ? */
327
309
strcpy (psdMode, "lum ");
329
case GIMP_OVERLAY_MODE: /* ? */
311
case GIMP_HARDLIGHT_MODE:
312
strcpy (psdMode, "hLit");
314
case GIMP_SOFTLIGHT_MODE:
315
strcpy (psdMode, "sLit");
317
case GIMP_OVERLAY_MODE:
330
318
strcpy (psdMode, "over");
332
/* case GIMP_BEHIND_MODE: These are from GIMP 1.1.14*/
333
/* case GIMP_DIVIDE_MODE: These are from GIMP 1.1.14*/
334
case GIMP_ADDITION_MODE:
335
case GIMP_SUBTRACT_MODE:
336
IFDBG printf ("PSD: Warning - unsupported layer-blend mode: %c, using 'norm' mode\n",
337
gimp_layer_get_mode (idLayer));
338
strcpy (psdMode, "norm");
341
IFDBG printf ("PSD: Warning - UNKNOWN layer-blend mode, reverting to 'norm'\n");
342
strcpy (psdMode, "norm");
322
const gchar *nick = "?";
324
gimp_enum_get_value (GIMP_TYPE_LAYER_MODE_EFFECTS,
325
gimp_layer_get_mode (idLayer),
326
NULL, &nick, NULL, NULL);
328
g_message (_("Unable to save layer with mode '%s'. Either the PSD "
329
"file format or the save plug-in does not support that, "
330
"using normal mode instead."), nick);
332
IFDBG printf ("PSD: Warning - unsupported layer-blend mode: %s, "
333
"using normal mode\n", nick);
335
strcpy (psdMode, "norm");
589
585
save_header (FILE *fd, gint32 image_id)
591
587
IFDBG printf (" Function: save_header\n");
592
IFDBG printf (" Rows: %d\n", PSDImageData.image_height);
593
IFDBG printf (" Columns: %d\n", PSDImageData.image_width);
594
IFDBG printf (" Base type: %d\n", PSDImageData.baseType);
595
IFDBG printf (" Number of channels: %d\n", PSDImageData.nChannels);
588
IFDBG printf ("\tRows: %d\n", PSDImageData.image_height);
589
IFDBG printf ("\tColumns: %d\n", PSDImageData.image_width);
590
IFDBG printf ("\tBase type: %d\n", PSDImageData.baseType);
591
IFDBG printf ("\tNumber of channels: %d\n", PSDImageData.nChannels);
597
593
xfwrite (fd, "8BPS", 4, "signature");
598
write_gshort (fd, 1, "version");
599
write_glong (fd, 0, "reserved 1"); /* 6 for the 'reserved' field + 4 bytes for a long */
600
write_gshort (fd, 0, "reserved 1"); /* and 2 bytes for a short */
601
write_gshort (fd, (PSDImageData.nChannels +
602
nChansLayer (PSDImageData.baseType, 0)),
594
write_gint16 (fd, 1, "version");
595
write_gint32 (fd, 0, "reserved 1"); /* 6 for the 'reserved' field + 4 bytes for a long */
596
write_gint16 (fd, 0, "reserved 1"); /* and 2 bytes for a short */
597
write_gint16 (fd, (PSDImageData.nChannels +
598
nChansLayer (PSDImageData.baseType, 0, 0)),
604
write_glong (fd, PSDImageData.image_height, "rows");
605
write_glong (fd, PSDImageData.image_width, "columns");
606
write_gshort (fd, 8, "depth"); /* Apparently GIMP only supports 8 bit deep
600
write_gint32 (fd, PSDImageData.image_height, "rows");
601
write_gint32 (fd, PSDImageData.image_width, "columns");
602
write_gint16 (fd, 8, "depth"); /* Apparently GIMP only supports 8 bit deep
608
write_gshort (fd, gimpBaseTypeToPsdMode (PSDImageData.baseType), "mode");
604
write_gint16 (fd, gimpBaseTypeToPsdMode (PSDImageData.baseType), "mode");
623
619
switch (PSDImageData.baseType)
625
621
case GIMP_INDEXED:
626
IFDBG printf (" Image type: INDEXED\n");
622
IFDBG printf ("\tImage type: INDEXED\n");
628
624
cmap = gimp_image_get_colormap (image_id, &nColors);
629
IFDBG printf (" Length of colormap returned by gimp_image_get_colormap: %d\n", nColors);
625
IFDBG printf ("\t\tLength of colormap returned by gimp_image_get_colormap: %d\n", nColors);
631
627
if (nColors == 0)
633
IFDBG printf (" The indexed image lacks a colormap\n");
634
write_glong (fd, 0, "color data length");
629
IFDBG printf ("\t\tThe indexed image lacks a colormap\n");
630
write_gint32 (fd, 0, "color data length");
636
632
else if (nColors != 256)
638
IFDBG printf (" The indexed image has %d!=256 colors\n", nColors);
639
IFDBG printf (" Padding with zeros up to 256\n");
640
write_glong (fd, 768, "color data length");
634
IFDBG printf ("\t\tThe indexed image has %d!=256 colors\n", nColors);
635
IFDBG printf ("\t\tPadding with zeros up to 256\n");
636
write_gint32 (fd, 768, "color data length");
641
637
/* For this type, length is always 768 */
643
cmap_modified = xmalloc (768);
639
cmap_modified = g_malloc (768);
644
640
for (i = 0; i < nColors * 3; i++)
645
641
cmap_modified[i] = cmap[i];
773
769
/* Count the guides */
774
770
while ((guide_id = gimp_image_find_next_guide(image_id, guide_id)))
777
773
xfwrite (fd, "8BIM", 4, "imageresources signature");
778
write_gshort (fd, 0x0408, "0x0408 Id (Guides)");
774
write_gint16 (fd, 0x0408, "0x0408 Id (Guides)"); /* 1032 */
779
775
/* write_pascalstring (fd, Name, "Id name"); */
780
write_gshort (fd, 0, "Id name"); /* Set to null string (two zeros) */
781
write_glong (fd, 16 + 5 * n_guides, "0x0408 resource size");
776
write_gint16 (fd, 0, "Id name"); /* Set to null string (two zeros) */
777
write_gint32 (fd, 16 + 5 * n_guides, "0x0408 resource size");
782
778
/* Save grid and guide header */
783
write_glong (fd, 1, "grid/guide header version");
784
write_glong (fd, 576, "grid custom spacing horizontal");/* dpi*32/4??*/
785
write_glong (fd, 576, "grid custom spacing vertical"); /* dpi*32/4??*/
786
write_glong (fd, n_guides, "number of guides");
779
write_gint32 (fd, 1, "grid/guide header version");
780
write_gint32 (fd, 576, "grid custom spacing horizontal");/* dpi*32/4??*/
781
write_gint32 (fd, 576, "grid custom spacing vertical"); /* dpi*32/4??*/
782
write_gint32 (fd, n_guides, "number of guides");
788
784
/* write the guides */
789
785
while ((guide_id = gimp_image_find_next_guide(image_id, guide_id)))
793
orientation = gimp_image_get_guide_orientation(image_id, guide_id);
794
position = 32 * gimp_image_get_guide_position(image_id, guide_id);
795
orientation ^= 1; /* in the psd vert =0 , horiz = 1 */
796
write_glong (fd, position, "Position of guide");
797
write_gchar (fd, orientation, "Orientation of guide");
789
orientation = gimp_image_get_guide_orientation(image_id, guide_id);
790
position = 32 * gimp_image_get_guide_position(image_id, guide_id);
791
orientation ^= 1; /* in the psd vert =0 , horiz = 1 */
792
write_gint32 (fd, position, "Position of guide");
793
write_gchar (fd, orientation, "Orientation of guide");
800
796
if ((ftell(fd) & 1))
801
write_gchar(fd, 0, "pad byte");
797
write_gchar(fd, 0, "pad byte");
802
798
if (n_guides != 0)
803
g_warning("Screwed up guide resource:: wrong number of guides\n");
804
IFDBG printf (" Total length of 0x0400 resource: %d\n", (int) sizeof (gshort));
799
g_warning("Screwed up guide resource:: wrong number of guides\n");
800
IFDBG printf ("\tTotal length of 0x0400 resource: %d\n", (int) sizeof (gint16));
807
803
/* --------------- Write resolution data ------------------- */
819
815
gdouble factor = gimp_unit_get_factor (g_unit) / 10.0;
824
psd_unit = PSD_UNIT_CM;
820
psd_unit = PSD_UNIT_CM;
828
psd_unit = PSD_UNIT_INCH;
824
psd_unit = PSD_UNIT_INCH;
831
827
xres_fix = xres * 65536.0 + .5; /* Convert to 16.16 fixed point */
832
828
yres_fix = yres * 65536.0 + .5; /* Convert to 16.16 fixed point */
834
830
xfwrite (fd, "8BIM", 4, "imageresources signature (for resolution)");
835
write_gshort(fd, 0x03ed, "0x03ed Id (resolution)");
836
write_gshort (fd, 0, "Id name"); /* Set to null string (two zeros) */
837
write_glong (fd, 16, "0x0400 resource size");
838
write_glong (fd, xres_fix, "hRes (16.16 fixed point)");
839
write_gshort (fd, psd_unit, "hRes unit");
840
write_gshort (fd, psd_unit, "width unit");
841
write_glong (fd, yres_fix, "vRes (16.16 fixed point)");
842
write_gshort (fd, psd_unit, "vRes unit");
843
write_gshort (fd, psd_unit, "height unit");
831
write_gint16(fd, 0x03ed, "0x03ed Id (resolution)"); /* 1005 */
832
write_gint16 (fd, 0, "Id name"); /* Set to null string (two zeros) */
833
write_gint32 (fd, 16, "0x0400 resource size");
834
write_gint32 (fd, xres_fix, "hRes (16.16 fixed point)");
835
write_gint16 (fd, psd_unit, "hRes unit");
836
write_gint16 (fd, psd_unit, "width unit");
837
write_gint32 (fd, yres_fix, "vRes (16.16 fixed point)");
838
write_gint16 (fd, psd_unit, "vRes unit");
839
write_gint16 (fd, psd_unit, "height unit");
845
841
/* --------------- Write Active Layer Number --------------- */
847
843
if (ActiveLayerPresent)
849
845
xfwrite (fd, "8BIM", 4, "imageresources signature");
850
write_gshort (fd, 0x0400, "0x0400 Id");
846
write_gint16 (fd, 0x0400, "0x0400 Id"); /* 1024 */
851
847
/* write_pascalstring (fd, Name, "Id name"); */
852
write_gshort (fd, 0, "Id name"); /* Set to null string (two zeros) */
853
write_glong (fd, sizeof (gshort), "0x0400 resource size");
855
/* Save title as gshort (length always even) */
857
write_gshort (fd, nActiveLayer, "active layer");
859
IFDBG printf (" Total length of 0x0400 resource: %d\n", (int) sizeof (gshort));
848
write_gint16 (fd, 0, "Id name"); /* Set to null string (two zeros) */
849
write_gint32 (fd, sizeof (gint16), "0x0400 resource size");
851
/* Save title as gint16 (length always even) */
853
write_gint16 (fd, nActiveLayer, "active layer");
855
IFDBG printf ("\tTotal length of 0x0400 resource: %d\n", (int) sizeof (gint16));
924
920
gint nChannelsLayer; /* Number of channels of a layer */
925
921
gint32 ChanSize; /* Data length for a channel */
926
922
gchar *layerName; /* Layer name */
928
gint32 eof_pos; /* Position: End of file */
929
gint32 ExtraDataPos; /* Position: Extra data length */
930
gint32 LayerMaskPos; /* Position: Layer & Mask section length */
931
gint32 LayerInfoPos; /* Position: Layer info section length*/
932
gint32 **ChannelLengthPos; /* Position: Channel length */
935
IFDBG printf (" Function: save_layer&mask\n");
923
gint mask; /* Layer mask */
925
glong eof_pos; /* Position: End of file */
926
glong ExtraDataPos; /* Position: Extra data length */
927
glong LayerMaskPos; /* Position: Layer & Mask section length */
928
glong LayerInfoPos; /* Position: Layer info section length*/
929
glong **ChannelLengthPos; /* Position: Channel length */
932
IFDBG printf (" Function: save_layer_and_mask\n");
937
934
/* Create first array dimension (layers, channels) */
939
ChannelLengthPos = g_new (gint32 *, PSDImageData.nLayers);
936
ChannelLengthPos = g_new (glong *, PSDImageData.nLayers);
941
938
/* Layer and mask information section */
943
940
LayerMaskPos = ftell (fd);
944
write_glong (fd, 0, "layers & mask information length");
941
write_gint32 (fd, 0, "layers & mask information length");
946
943
/* Layer info section */
948
945
LayerInfoPos = ftell (fd);
949
write_glong (fd, 0, "layers info section length");
946
write_gint32 (fd, 0, "layers info section length");
951
948
/* Layer structure section */
953
write_gshort (fd, PSDImageData.nLayers, "Layer structure count");
950
write_gint16 (fd, PSDImageData.nLayers, "Layer structure count");
955
952
/* Layer records section */
956
953
/* GIMP layers must be written in reverse order */
958
955
for (i = PSDImageData.nLayers - 1; i >= 0; i--)
960
959
gimp_drawable_offsets (PSDImageData.lLayers[i], &offset_x, &offset_y);
961
960
layerWidth = gimp_drawable_width (PSDImageData.lLayers[i]);
962
961
layerHeight = gimp_drawable_height (PSDImageData.lLayers[i]);
966
965
PSDImageData.layersDim[i].width = layerWidth;
967
966
PSDImageData.layersDim[i].height = layerHeight;
969
IFDBG printf (" Layer number: %d\n", i);
970
IFDBG printf (" Offset x: %d\n", PSDImageData.layersDim[i].left);
971
IFDBG printf (" Offset y: %d\n", PSDImageData.layersDim[i].top);
972
IFDBG printf (" Width: %d\n", PSDImageData.layersDim[i].width);
973
IFDBG printf (" Height: %d\n", PSDImageData.layersDim[i].height);
968
IFDBG printf ("\tLayer number: %d\n", i);
969
IFDBG printf ("\t\tX offset: %d\n", PSDImageData.layersDim[i].left);
970
IFDBG printf ("\t\tY offset: %d\n", PSDImageData.layersDim[i].top);
971
IFDBG printf ("\t\tWidth: %d\n", PSDImageData.layersDim[i].width);
972
IFDBG printf ("\t\tHeight: %d\n", PSDImageData.layersDim[i].height);
975
write_glong (fd, PSDImageData.layersDim[i].top, "Layer top");
976
write_glong (fd, PSDImageData.layersDim[i].left, "Layer left");
977
write_glong (fd, (PSDImageData.layersDim[i].height +
974
write_gint32 (fd, PSDImageData.layersDim[i].top, "Layer top");
975
write_gint32 (fd, PSDImageData.layersDim[i].left, "Layer left");
976
write_gint32 (fd, (PSDImageData.layersDim[i].height +
978
977
PSDImageData.layersDim[i].top), "Layer bottom");
979
write_glong (fd, (PSDImageData.layersDim[i].width +
978
write_gint32 (fd, (PSDImageData.layersDim[i].width +
980
979
PSDImageData.layersDim[i].left), "Layer right");
981
hasMask = (gimp_layer_get_mask(PSDImageData.lLayers[i]) == -1 ) ? 0 : 1;
982
982
nChannelsLayer = nChansLayer (PSDImageData.baseType,
983
gimp_drawable_has_alpha (PSDImageData.lLayers[i]));
986
write_gshort (fd, nChannelsLayer, "Number channels in the layer");
987
IFDBG printf (" Number of channels: %d\n", nChannelsLayer);
983
gimp_drawable_has_alpha (PSDImageData.lLayers[i]),
987
write_gint16 (fd, nChannelsLayer, "Number channels in the layer");
988
IFDBG printf ("\t\tNumber of channels: %d\n", nChannelsLayer);
989
990
/* Create second array dimension (layers, channels) */
991
ChannelLengthPos[i] = g_new (gint32, nChannelsLayer);
992
ChannelLengthPos[i] = g_new (glong, nChannelsLayer);
993
994
/* Try with gimp_drawable_bpp() */
998
999
idChannel = j - 1;
1002
if (hasMask && (j+1 == nChannelsLayer)) /* Last channel ... */
1003
idChannel = -2; /* ... will be layer mask */
1002
write_gshort (fd, idChannel, "Channel ID");
1003
IFDBG printf (" - Identifier: %d\n", idChannel);
1005
write_gint16 (fd, idChannel, "Channel ID");
1006
IFDBG printf ("\t\t\tChannel Identifier: %d\n", idChannel);
1005
1008
/* Write the length assuming no compression. In case there is,
1006
1009
will modify it later when writing data. */
1008
1011
ChannelLengthPos[i][j] = ftell (fd);
1009
ChanSize = sizeof (gshort) + (PSDImageData.layersDim[i].width *
1012
ChanSize = sizeof (gint16) + (PSDImageData.layersDim[i].width *
1010
1013
PSDImageData.layersDim[i].height);
1012
write_glong (fd, ChanSize, "Channel Size");
1013
IFDBG printf (" Length: %d\n", ChanSize);
1015
write_gint32 (fd, ChanSize, "Channel Size");
1016
IFDBG printf ("\t\t\tLength: %d\n", ChanSize);
1016
1019
xfwrite (fd, "8BIM", 4, "blend mode signature");
1018
1021
psd_lmode_layer (PSDImageData.lLayers[i], blendMode);
1019
IFDBG printf (" Blend mode: %s\n", blendMode);
1022
IFDBG printf ("\t\tBlend mode: %s\n", blendMode);
1020
1023
xfwrite (fd, blendMode, 4, "blend mode key");
1022
1025
layerOpacity = (gimp_layer_get_opacity (PSDImageData.lLayers[i]) * 255.0) / 100.0;
1023
IFDBG printf (" Opacity: %u\n", layerOpacity);
1026
IFDBG printf ("\t\tOpacity: %u\n", layerOpacity);
1024
1027
write_gchar (fd, layerOpacity, "Opacity");
1026
1029
/* Apparently this field is not used in GIMP */
1027
1030
write_gchar (fd, 0, "Clipping");
1030
if (gimp_layer_get_preserve_trans (PSDImageData.lLayers[i])) flags |= 1;
1033
if (gimp_layer_get_lock_alpha (PSDImageData.lLayers[i])) flags |= 1;
1031
1034
if (! gimp_drawable_get_visible (PSDImageData.lLayers[i])) flags |= 2;
1032
IFDBG printf (" Flags: %u\n", flags);
1035
IFDBG printf ("\t\tFlags: %u\n", flags);
1033
1036
write_gchar (fd, flags, "Flags");
1035
1038
/* Padding byte to make the length even */
1036
1039
write_gchar (fd, 0, "Filler");
1038
1041
ExtraDataPos = ftell (fd); /* Position of Extra Data size */
1039
write_glong (fd, 0, "Extra data size");
1042
write_gint32 (fd, 0, "Extra data size");
1041
#ifdef SAVELAYERMASK
1042
1044
mask = gimp_layer_get_mask (PSDImageData.lLayers[i]);
1045
write_glong (fd, 14, "Layer mask size");
1046
write_glong (fd, 0, "Layer mask top");
1047
write_glong (fd, 0, "Layer mask left");
1048
write_glong (fd, gimp_drawable_height(mask),"Layer mask bottom");
1049
write_glong (fd, gimp_drawable_width(mask), "Layer mask right");
1050
write_gchar (fd, 0, "lmask default color");
1051
flags = (1 | /* relative */
1052
(gimp_layer_mask_is_disabled(mask) << 1) | /* disabled?*/
1053
(0 << 2) /* invert */);
1054
write_gchar (fd, flags, "layer mask flags");
1055
write_gshort (fd, 0, "Layer mask Padding");
1047
IFDBG printf ("\t\tLayer mask size: %d\n", 20);
1048
write_gint32 (fd, 20, "Layer mask size");
1049
write_gint32 (fd, 0, "Layer mask top");
1050
write_gint32 (fd, 0, "Layer mask left");
1051
write_gint32 (fd, gimp_drawable_height(mask),"Layer mask bottom");
1052
write_gint32 (fd, gimp_drawable_width(mask), "Layer mask right");
1053
write_gchar (fd, 0, "lmask default color");
1054
flags = (1 | /* relative */
1055
(gimp_layer_get_apply_mask(PSDImageData.lLayers[i]) << 1) | /* disabled?*/
1056
(0 << 2) /* invert */);
1057
write_gchar (fd, flags, "layer mask flags");
1058
write_gint16 (fd, 0, "Layer mask Padding");
1059
/* NOTE Writing empty Layer mask / adjustment layer data */
1060
write_glong (fd, 0, "Layer mask size");
1061
IFDBG printf ("\n Layer mask size: %d\n", 0);
1062
/* NOTE Writing empty Layer mask / adjustment layer data */
1063
write_gint32 (fd, 0, "Layer mask size");
1064
IFDBG printf ("\t\tLayer mask size: %d\n", 0);
1064
1067
/* NOTE Writing empty Layer blending ranges data */
1065
write_glong (fd, 0, "Layer blending size");
1066
IFDBG printf ("\n Layer blending size: %d\n", 0);
1068
write_gint32 (fd, 0, "Layer blending size");
1069
IFDBG printf ("\t\tLayer blending size: %d\n", 0);
1068
1071
layerName = gimp_drawable_get_name (PSDImageData.lLayers[i]);
1069
1072
write_pascalstring (fd, layerName, 4, "layer name");
1070
IFDBG printf ("\n Layer name: %s\n", layerName);
1073
IFDBG printf ("\t\tLayer name: %s\n", layerName);
1072
1075
/* Write real length for: Extra data */
1074
1077
eof_pos = ftell (fd);
1076
1079
fseek (fd, ExtraDataPos, SEEK_SET);
1077
write_glong (fd, eof_pos - ExtraDataPos - sizeof (glong), "Extra data size");
1078
IFDBG printf (" ExtraData size: %d\n",
1079
(int) (eof_pos - ExtraDataPos - sizeof (glong)));
1080
write_gint32 (fd, eof_pos - ExtraDataPos - sizeof (gint32), "Extra data size");
1081
IFDBG printf ("\t\tExtraData size: %d\n",
1082
(int) (eof_pos - ExtraDataPos - sizeof (gint32)));
1081
1084
/* Return to EOF to continue writing */
1097
1101
/* Write actual size of Layer info section */
1099
1103
fseek (fd, LayerInfoPos, SEEK_SET);
1100
write_glong (fd, eof_pos - LayerInfoPos - sizeof (glong), "layers info section length");
1101
IFDBG printf ("\n Total layers info section length: %d\n",
1102
(int) (eof_pos - LayerInfoPos - sizeof (glong)));
1104
write_gint32 (fd, eof_pos - LayerInfoPos - sizeof (gint32), "layers info section length");
1105
IFDBG printf ("\t\tTotal layers info section length: %d\n",
1106
(int) (eof_pos - LayerInfoPos - sizeof (gint32)));
1104
1108
/* Write actual size of Layer and mask information secton */
1106
1110
fseek (fd, LayerMaskPos, SEEK_SET);
1107
write_glong (fd, eof_pos - LayerMaskPos - sizeof (glong), "layers & mask information length");
1108
IFDBG printf (" Total layers & mask information length: %d\n",
1109
(int) (eof_pos - LayerMaskPos - sizeof (glong)));
1111
write_gint32 (fd, eof_pos - LayerMaskPos - sizeof (gint32), "layers & mask information length");
1112
IFDBG printf ("\t\tTotal layers & mask information length: %d\n",
1113
(int) (eof_pos - LayerMaskPos - sizeof (gint32)));
1111
1115
/* Return to EOF to continue writing */
1132
1137
gint32 colors = bytes; /* fixed up down below */
1135
glong len; /* Length of compressed data */
1136
gshort *LengthsTable; /* Lengths of every compressed row */
1140
gint32 len; /* Length of compressed data */
1141
gint16 *LengthsTable; /* Lengths of every compressed row */
1137
1142
guchar *rledata; /* Compressed data from a region */
1138
gint32 length_table_pos; /* position in file of the length table */
1143
glong length_table_pos; /* position in file of the length table */
1146
IFDBG printf (" Function: write_pixel_data, drw %d, lto %d\n",
1147
drawableID, ltable_offset);
1141
1149
if ( gimp_drawable_has_alpha (drawableID) &&
1142
1150
!gimp_drawable_is_indexed (drawableID))
1144
1152
gimp_tile_cache_ntiles (2* (drawable->width / gimp_tile_width () + 1));
1146
LengthsTable = g_new (gshort, height);
1147
rledata = g_new (gchar, (MIN(height, tile_height) *
1148
(width + 10 + (width/100))));
1154
LengthsTable = g_new (gint16, height);
1155
rledata = g_new (guchar, (MIN (height, tile_height) *
1156
(width + 10 + (width / 100))));
1151
1158
data = g_new (guchar, MIN(height, tile_height) * width * bytes);
1153
1160
gimp_pixel_rgn_init (®ion, drawable, 0, 0,
1154
width, height, FALSE, FALSE);
1161
width, height, FALSE, FALSE);
1156
1163
for (i = 0; i < bytes; i++)
1160
1167
if (bytes != colors) /* Need to write alpha channel first */
1164
if (ltable_offset > 0)
1171
if (ltable_offset > 0)
1173
1180
if (ChanLenPosition)
1175
write_gshort (fd, 1, "Compression type (RLE)");
1182
write_gint16 (fd, 1, "Compression type (RLE)");
1179
1186
if (ltable_offset > 0)
1181
length_table_pos = ltable_offset + 2 * chan * height;
1188
length_table_pos = ltable_offset + 2 * chan * height;
1185
length_table_pos = ftell(fd);
1192
length_table_pos = ftell(fd);
1187
xfwrite (fd, LengthsTable, height * sizeof(gshort),
1188
"Dummy RLE length");
1194
xfwrite (fd, LengthsTable, height * sizeof(gint16),
1195
"Dummy RLE length");
1196
len += height * sizeof(gint16);
1197
IF_DEEP_DBG printf ("\t\t\t\t. ltable, pos %ld len %d\n", length_table_pos, len);
1192
1200
for (y = 0; y < height; y += tile_height)
1195
gimp_pixel_rgn_get_rect (®ion, data, 0, y,
1196
width, MIN(height - y, tile_height));
1197
tlen = get_compress_channel_data (&data[chan],
1199
MIN(height - y, tile_height),
1204
xfwrite (fd, rledata, tlen, "Compressed pixel data");
1203
gimp_pixel_rgn_get_rect (®ion, data, 0, y,
1204
width, MIN(height - y, tile_height));
1205
tlen = get_compress_channel_data (&data[chan],
1207
MIN(height - y, tile_height),
1212
xfwrite (fd, rledata, tlen, "Compressed pixel data");
1213
IF_DEEP_DBG printf ("\t\t\t\t. Writing compressed pixels, stream of %d\n", tlen);
1207
1216
/* Write compressed lengths table */
1208
1217
fseek (fd, length_table_pos, SEEK_SET);
1209
1218
for (j = 0; j < height; j++) /* write real length table */
1210
write_gshort (fd, LengthsTable[j], "RLE length");
1219
write_gint16 (fd, LengthsTable[j], "RLE length");
1212
1221
if (ChanLenPosition) /* Update total compressed length */
1214
fseek (fd, ChanLenPosition[i], SEEK_SET);
1215
write_glong (fd, len, "channel data length");
1223
fseek (fd, ChanLenPosition[i], SEEK_SET);
1224
write_gint32 (fd, len, "channel data length");
1225
IFDBG printf ("\t\tUpdating data len to %d\n", len);
1217
1227
fseek (fd, 0, SEEK_END);
1228
IF_DEEP_DBG printf ("\t\t\t\t. Cur pos %ld\n", ftell(fd));
1231
/* Write layer mask, as last channel, id -2 */
1233
GimpDrawable *mdrawable = gimp_drawable_get(maskID);
1236
gimp_pixel_rgn_init (®ion, mdrawable, 0, 0,
1237
width, height, FALSE, FALSE);
1239
if (ChanLenPosition)
1241
write_gint16 (fd, 1, "Compression type (RLE)");
1243
IF_DEEP_DBG printf ("\t\t\t\t. ChanLenPos, len %d\n", len);
1246
if (ltable_offset > 0)
1248
length_table_pos = ltable_offset + 2 * (bytes+1) * height;
1249
IF_DEEP_DBG printf ("\t\t\t\t. ltable, pos %ld\n", length_table_pos);
1253
length_table_pos = ftell(fd);
1255
xfwrite (fd, LengthsTable, height * sizeof(gint16),
1256
"Dummy RLE length");
1257
len += height * sizeof(gint16);
1258
IF_DEEP_DBG printf ("\t\t\t\t. ltable, pos %ld len %d\n", length_table_pos, len);
1261
for (y = 0; y < height; y += tile_height)
1264
gimp_pixel_rgn_get_rect (®ion, data, 0, y,
1265
width, MIN(height - y, tile_height));
1266
tlen = get_compress_channel_data (&data[0],
1268
MIN(height - y, tile_height),
1273
xfwrite (fd, rledata, tlen, "Compressed mask data");
1274
IF_DEEP_DBG printf ("\t\t\t\t. Writing compressed mask, stream of %d\n", tlen);
1277
/* Write compressed lengths table */
1278
fseek (fd, length_table_pos, SEEK_SET); /*POS WHERE???*/
1279
for (j = 0; j < height; j++) /* write real length table */
1281
write_gint16 (fd, LengthsTable[j], "RLE length");
1282
IF_DEEP_DBG printf ("\t\t\t\t. Updating RLE len %d\n", LengthsTable[j]);
1285
if (ChanLenPosition) /* Update total compressed length */
1287
fseek (fd, ChanLenPosition[bytes], SEEK_SET); /*+bytes OR SOMETHING*/
1288
write_gint32 (fd, len, "channel data length");
1289
IFDBG printf ("\t\tUpdating data len to %d, at %ld\n", len, ftell(fd));
1291
fseek (fd, 0, SEEK_END);
1292
IF_DEEP_DBG printf ("\t\t\t\t. Cur pos %ld\n", ftell(fd));
1294
gimp_drawable_detach (mdrawable);
1220
1297
gimp_drawable_detach (drawable);
1238
1315
gint32 bottom_layer;
1240
IFDBG printf ("\n Function: save_data\n");
1317
IFDBG printf (" Function: save_data\n");
1242
1319
ChanCount = (PSDImageData.nChannels +
1243
nChansLayer (PSDImageData.baseType, 0));
1320
nChansLayer (PSDImageData.baseType, 0, 0));
1245
i = PSDImageData.nLayers - 1; /* Channel to be written */
1246
IFDBG printf (" Processing layer %d\n", i);
1322
i = PSDImageData.nLayers - 1; /* Layers to be written */
1323
IFDBG printf ("\tProcessing %d layers\n", i);
1248
1325
imageHeight = gimp_image_height (image_id);
1253
write_gshort (fd, 1, "RLE compression");
1330
write_gint16 (fd, 1, "RLE compression");
1255
1332
/* All line lengths go before the rle pixel data */
1257
1334
offset = ftell(fd); /* Offset in file of line lengths */
1259
1336
for (i = 0; i < ChanCount; i++)
1260
1337
for (j = 0; j < imageHeight; j++)
1261
write_gshort (fd, 0, "junk line lengths");
1338
write_gint16 (fd, 0, "junk line lengths");
1263
1340
bottom_layer = PSDImageData.lLayers[PSDImageData.nLayers - 1];
1265
1342
if (PSDImageData.nLayers != 1 ||
1269
1346
gint32 flat_image;
1270
1347
gint32 flat_drawable;
1272
IFDBG printf ("\n Creating flattened image\n");
1349
IFDBG printf ("\t\tCreating flattened image\n");
1273
1350
flat_image = gimp_image_duplicate (image_id);
1274
1351
gimp_image_undo_disable (flat_image);
1275
1352
flat_drawable = gimp_image_flatten (flat_image);
1277
IFDBG printf ("\n Writing compressed flattened image data\n");
1278
write_pixel_data (fd, flat_drawable, NULL, offset);
1354
/* gimp_image_flatten() may fail if there are no visible layers */
1355
if (flat_drawable != -1)
1357
IFDBG printf ("\t\tWriting compressed flattened image data\n");
1358
write_pixel_data (fd, flat_drawable, NULL, offset);
1280
1361
gimp_image_delete (flat_image);
1284
IFDBG printf ("\n Writing compressed image data\n");
1365
IFDBG printf ("\t\tWriting compressed image data\n");
1285
1366
write_pixel_data (fd, PSDImageData.lLayers[PSDImageData.nLayers - 1],
1289
chan = nChansLayer (PSDImageData.baseType, 0);
1370
chan = nChansLayer (PSDImageData.baseType, 0, 0);
1291
1372
for (i = PSDImageData.nChannels - 1; i >= 0; i--)
1293
IFDBG printf ("\n Writing compressed channel data for channel %d\n",
1374
IFDBG printf ("\t\tWriting compressed channel data for channel %d\n",
1295
1376
write_pixel_data (fd, PSDImageData.lChannels[i], NULL,
1296
offset + 2*imageHeight*chan);
1377
offset + 2*imageHeight*chan);
1308
1389
PSDImageData.compression = FALSE;
1310
1391
PSDImageData.image_height = gimp_image_height (image_id);
1311
IFDBG printf (" Got number of rows: %d\n", PSDImageData.image_height);
1392
IFDBG printf ("\tGot number of rows: %d\n", PSDImageData.image_height);
1313
1394
PSDImageData.image_width = gimp_image_width (image_id);
1314
IFDBG printf (" Got number of cols: %d\n", PSDImageData.image_width);
1395
IFDBG printf ("\tGot number of cols: %d\n", PSDImageData.image_width);
1316
1397
PSDImageData.baseType = gimp_image_base_type (image_id);
1317
IFDBG printf (" Got base type: %d\n", PSDImageData.baseType);
1398
IFDBG printf ("\tGot base type: %d\n", PSDImageData.baseType);
1319
1400
/* PSD format does not support indexed layered images */
1321
1402
if (PSDImageData.baseType == GIMP_INDEXED)
1323
IFDBG printf (" Flattening indexed image\n");
1404
IFDBG printf ("\tFlattening indexed image\n");
1324
1405
gimp_image_flatten (image_id);
1327
1408
PSDImageData.lChannels = gimp_image_get_channels (image_id, &PSDImageData.nChannels);
1328
IFDBG printf (" Got number of channels: %d\n", PSDImageData.nChannels);
1409
IFDBG printf ("\tGot number of channels: %d\n", PSDImageData.nChannels);
1330
1411
PSDImageData.lLayers = gimp_image_get_layers (image_id, &PSDImageData.nLayers);
1331
IFDBG printf (" Got number of layers: %d\n", PSDImageData.nLayers);
1412
IFDBG printf ("\tGot number of layers: %d\n", PSDImageData.nLayers);
1333
1414
PSDImageData.layersDim = g_new (PSD_Layer_Dimension, PSDImageData.nLayers);
added
removed
plug-ins/common/psd_save.c
