Lines Matching refs:image
13 % Read/Write Adobe Photoshop Image Format %
61 #include "MagickCore/image.h"
62 #include "MagickCore/image-private.h"
128 Image
129 *image;
147 Image
148 *image;
177 WritePSDImage(const ImageInfo *,Image *,ExceptionInfo *);
191 % IsPSD()() returns MagickTrue if the image format type, identified by the
200 % o magick: compare image format pattern against these bytes.
226 % ReadPSDImage() reads an Adobe Photoshop image file and returns it. It
227 % allocates the memory necessary for the new Image structure and returns a
228 % pointer to the new image.
232 % Image *ReadPSDImage(image_info,ExceptionInfo *exception)
236 % o image_info: the image info.
283 Image *image,ExceptionInfo* exception)
294 if (image->alpha_trait != BlendPixelTrait || image->colorspace != sRGBColorspace)
302 magick_threads(image,image,image->rows,1)
304 for (y=0; y < (ssize_t) image->rows; y++)
314 q=GetAuthenticPixels(image,0,y,image->columns,1,exception);
320 for (x=0; x < (ssize_t) image->columns; x++)
328 gamma=QuantumScale*GetPixelAlpha(image, q);
331 for (i=0; i < (ssize_t) GetPixelChannels(image); i++)
333 PixelChannel channel=GetPixelChannelChannel(image,i);
338 q+=GetPixelChannels(image);
340 if (SyncAuthenticPixels(image,exception) == MagickFalse)
374 layer_info->image->alpha_trait=BlendPixelTrait;
378 magick_threads(layer_info->image,layer_info->image,layer_info->image->rows,1)
380 for (y=0; y < (ssize_t) layer_info->image->rows; y++)
390 q=GetAuthenticPixels(layer_info->image,0,y,layer_info->image->columns,1,
397 for (x=0; x < (ssize_t) layer_info->image->columns; x++)
399 SetPixelAlpha(layer_info->image,(Quantum) (QuantumScale*(GetPixelAlpha(
400 layer_info->image,q))*layer_info->opacity),q);
401 q+=GetPixelChannels(layer_info->image);
403 if (SyncAuthenticPixels(layer_info->image,exception) == MagickFalse)
548 if (layer_info[i].image != (Image *) NULL)
549 layer_info[i].image=DestroyImage(layer_info[i].image);
550 if (layer_info[i].mask.image != (Image *) NULL)
551 layer_info[i].mask.image=DestroyImage(layer_info[i].mask.image);
557 static inline size_t GetPSDPacketSize(Image *image)
559 if (image->storage_class == PseudoClass)
561 if (image->colors > 256)
563 else if (image->depth > 8)
567 if (image->depth > 8)
573 static inline MagickSizeType GetPSDSize(const PSDInfo *psd_info,Image *image)
576 return((MagickSizeType) ReadBlobLong(image));
577 return((MagickSizeType) ReadBlobLongLong(image));
580 static inline size_t GetPSDRowSize(Image *image)
582 if (image->depth == 1)
583 return(((image->columns+7)/8)*GetPSDPacketSize(image));
585 return(image->columns*GetPSDPacketSize(image));
604 static MagickBooleanType NegateCMYK(Image *image,ExceptionInfo *exception)
612 channel_mask=SetImageChannelMask(image,(ChannelType)(AllChannels &~
614 status=NegateImage(image,MagickFalse,exception);
615 (void) SetImageChannelMask(image,channel_mask);
619 static void ParseImageResourceBlocks(Image *image,
641 (void) SetImageProfile(image,"8bim",profile,exception);
667 image->resolution.x=(double) resolution;
668 (void) FormatLocaleString(value,MagickPathExtent,"%g",image->resolution.x);
669 (void) SetImageProperty(image,"tiff:XResolution",value,exception);
674 image->resolution.y=(double) resolution;
675 (void) FormatLocaleString(value,MagickPathExtent,"%g",image->resolution.y);
676 (void) SetImageProperty(image,"tiff:YResolution",value,exception);
680 image->units=PixelsPerInchResolution;
755 static inline void ReversePSDString(Image *image,char *p,size_t length)
760 if (image->endian == MSBEndian)
772 static inline void SetPSDPixel(Image *image,const size_t channels,
776 if (image->storage_class == PseudoClass)
779 SetPixelIndex(image,ScaleQuantumToChar(pixel),q);
781 SetPixelIndex(image,ScaleQuantumToShort(pixel),q);
782 SetPixelViaPixelInfo(image,image->colormap+(ssize_t)
783 ConstrainColormapIndex(image,GetPixelIndex(image,q),exception),q);
790 SetPixelAlpha(image, pixel,q);
796 SetPixelRed(image,pixel,q);
798 SetPixelGray(image,pixel,q);
803 if (image->storage_class == PseudoClass)
804 SetPixelAlpha(image,pixel,q);
806 SetPixelGreen(image,pixel,q);
811 if (image->storage_class == PseudoClass)
812 SetPixelAlpha(image,pixel,q);
814 SetPixelBlue(image,pixel,q);
819 if (image->colorspace == CMYKColorspace)
820 SetPixelBlack(image,pixel,q);
822 if (image->alpha_trait != UndefinedPixelTrait)
823 SetPixelAlpha(image,pixel,q);
828 if ((IssRGBCompatibleColorspace(image->colorspace) != MagickFalse) &&
831 if (image->alpha_trait != UndefinedPixelTrait)
832 SetPixelAlpha(image,pixel,q);
838 static MagickBooleanType ReadPSDChannelPixels(Image *image,
861 q=GetAuthenticPixels(image,0,row,image->columns,1,exception);
864 packet_size=GetPSDPacketSize(image);
865 for (x=0; x < (ssize_t) image->columns; x++)
874 if (image->depth > 1)
876 SetPSDPixel(image,channels,type,packet_size,pixel,q,exception);
877 q+=GetPixelChannels(image);
885 number_bits=image->columns-x;
890 SetPSDPixel(image,channels,type,packet_size,(((unsigned char) pixel)
892 q+=GetPixelChannels(image);
895 if (x != (ssize_t) image->columns)
900 return(SyncAuthenticPixels(image,exception));
903 static MagickBooleanType ReadPSDChannelRaw(Image *image,const size_t channels,
919 if (image->debug != MagickFalse)
923 row_size=GetPSDRowSize(image);
927 image->filename);
930 for (y=0; y < (ssize_t) image->rows; y++)
934 count=ReadBlob(image,row_size,pixels);
938 status=ReadPSDChannelPixels(image,channels,y,type,pixels,exception);
947 static inline MagickOffsetType *ReadPSDRLEOffsets(Image *image,
962 offsets[y]=(MagickOffsetType) ReadBlobShort(image);
964 offsets[y]=(MagickOffsetType) ReadBlobLong(image);
970 static MagickBooleanType ReadPSDChannelRLE(Image *image,const PSDInfo *psd_info,
988 if (image->debug != MagickFalse)
992 row_size=GetPSDRowSize(image);
996 image->filename);
999 for (y=0; y < (ssize_t) image->rows; y++)
1007 image->filename);
1015 image->filename);
1021 for (y=0; y < (ssize_t) image->rows; y++)
1025 count=ReadBlob(image,(size_t) offsets[y],compact_pixels);
1030 (ssize_t) (image->depth == 1 ? 123456 : image->depth),row_size,pixels);
1034 status=ReadPSDChannelPixels(image,psd_info->channels,y,type,pixels,
1046 static MagickBooleanType ReadPSDChannelZip(Image *image,const size_t channels,
1072 if (image->debug != MagickFalse)
1080 image->filename);
1082 packet_size=GetPSDPacketSize(image);
1083 row_size=image->columns*packet_size;
1084 count=image->rows*row_size;
1091 image->filename);
1096 (void) ReadBlob(image,compact_size,compact_pixels);
1126 length=image->columns;
1145 for (y=0; y < (ssize_t) image->rows; y++)
1147 status=ReadPSDChannelPixels(image,channels,y,type,p,exception);
1160 static MagickBooleanType ReadPSDChannel(Image *image,const PSDInfo *psd_info,
1164 Image
1174 channel_image=image;
1175 mask=(Image *) NULL;
1185 SeekBlob(image,layer_info->channel_info[channel].size-2,SEEK_CUR);
1188 mask=CloneImage(image,layer_info->mask.page.width,
1194 offset=TellBlob(image);
1210 image->filename);
1225 "'%s' (ZLIB)",image->filename);
1234 SeekBlob(image,offset+layer_info->channel_info[channel].size-2,SEEK_SET);
1237 if (mask != (Image *) NULL)
1240 image->filename);
1242 if (mask != (Image *) NULL)
1249 layer_info->mask.image=CloneImage(image,image->columns,image->rows,
1251 layer_info->mask.image->alpha_trait=UndefinedPixelTrait;
1252 GetPixelInfo(layer_info->mask.image,&color);
1254 SetImageColor(layer_info->mask.image,&color,exception);
1255 (void) CompositeImage(layer_info->mask.image,mask,OverCompositeOp,
1265 static MagickBooleanType ReadPSDLayer(Image *image,const PSDInfo *psd_info,
1280 if (image->debug != MagickFalse)
1282 " setting up new layer image");
1283 (void) SetImageBackgroundColor(layer_info->image,exception);
1284 layer_info->image->compose=PSDBlendModeToCompositeOperator(
1287 layer_info->image->compose=NoCompositeOp;
1289 SetImageColorspace(layer_info->image,CMYKColorspace,exception);
1292 SetImageColorspace(layer_info->image,GRAYColorspace,exception);
1298 (void) SetImageArtifact(layer_info->image,"psd:layer.x",message);
1301 (void) SetImageArtifact(layer_info->image,"psd:layer.y",message);
1304 (void) SetImageArtifact(layer_info->image,"psd:layer.opacity",message);
1305 (void) SetImageProperty(layer_info->image,"label",(char *) layer_info->name,
1311 if (image->debug != MagickFalse)
1315 compression=(PSDCompressionType) ReadBlobShort(layer_info->image);
1316 layer_info->image->compression=ConvertPSDCompression(compression);
1318 layer_info->image->alpha_trait=BlendPixelTrait;
1320 status=ReadPSDChannel(layer_info->image,psd_info,layer_info,j,
1331 (layer_info->image->colorspace == CMYKColorspace))
1332 status=NegateCMYK(layer_info->image,exception);
1334 if ((status != MagickFalse) && (layer_info->mask.image != (Image *) NULL))
1336 status=CompositeImage(layer_info->image,layer_info->mask.image,
1338 layer_info->mask.image=DestroyImage(layer_info->mask.image);
1344 ModuleExport MagickBooleanType ReadPSDLayers(Image *image,
1368 size=GetPSDSize(psd_info,image);
1374 (void) ReadBlobLong(image);
1375 count=ReadBlob(image,4,(unsigned char *) type);
1376 ReversePSDString(image,type,4);
1382 count=ReadBlob(image,4,(unsigned char *) type);
1383 ReversePSDString(image,type,4);
1385 size=GetPSDSize(psd_info,image);
1394 number_layers=(short) ReadBlobShort(image);
1403 if (image->debug != MagickFalse)
1406 image->alpha_trait=BlendPixelTrait;
1410 We only need to know if the image has an alpha channel
1415 if (image->debug != MagickFalse)
1417 " image contains %.20g layers",(double) number_layers);
1421 image->filename);
1427 if (image->debug != MagickFalse)
1431 image->filename);
1442 if (image->debug != MagickFalse)
1445 layer_info[i].page.y=ReadBlobSignedLong(image);
1446 layer_info[i].page.x=ReadBlobSignedLong(image);
1447 y=ReadBlobSignedLong(image);
1448 x=ReadBlobSignedLong(image);
1451 layer_info[i].channels=ReadBlobShort(image);
1456 image->filename);
1458 if (image->debug != MagickFalse)
1466 layer_info[i].channel_info[j].type=(short) ReadBlobShort(image);
1468 image);
1469 if (image->debug != MagickFalse)
1475 count=ReadBlob(image,4,(unsigned char *) type);
1476 ReversePSDString(image,type,4);
1479 if (image->debug != MagickFalse)
1484 image->filename);
1486 count=ReadBlob(image,4,(unsigned char *) layer_info[i].blendkey);
1487 ReversePSDString(image,layer_info[i].blendkey,4);
1489 ReadBlobByte(image));
1490 layer_info[i].clipping=(unsigned char) ReadBlobByte(image);
1491 layer_info[i].flags=(unsigned char) ReadBlobByte(image);
1493 if (image->debug != MagickFalse)
1499 (void) ReadBlobByte(image); /* filler */
1501 size=ReadBlobLong(image);
1508 if (image->debug != MagickFalse)
1511 length=ReadBlobLong(image);
1518 layer_info[i].mask.page.y=ReadBlobSignedLong(image);
1519 layer_info[i].mask.page.x=ReadBlobSignedLong(image);
1520 layer_info[i].mask.page.height=(size_t) (ReadBlobLong(image)-
1522 layer_info[i].mask.page.width=(size_t) (ReadBlobLong(image)-
1525 image);
1526 layer_info[i].mask.flags=(unsigned char) ReadBlobByte(image);
1534 if (image->debug != MagickFalse)
1544 if (DiscardBlobBytes(image,(MagickSizeType) (length-18)) == MagickFalse)
1548 image->filename);
1551 length=ReadBlobLong(image);
1558 if (image->debug != MagickFalse)
1567 size_t blend_source=ReadBlobLong(image);
1568 size_t blend_dest=ReadBlobLong(image);
1569 if (image->debug != MagickFalse)
1578 length=(size_t) ReadBlobByte(image);
1581 (void) ReadBlob(image,(size_t) length++,layer_info[i].name);
1583 if (image->debug != MagickFalse)
1589 if (image->debug != MagickFalse)
1593 if (DiscardBlobBytes(image,(MagickSizeType) (size-combined_length)) == MagickFalse)
1597 "UnexpectedEndOfFile",image->filename);
1607 if (image->debug != MagickFalse)
1614 Allocate layered image.
1616 layer_info[i].image=CloneImage(image,layer_info[i].page.width,
1618 if (layer_info[i].image == (Image *) NULL)
1621 if (image->debug != MagickFalse)
1623 " allocation of image for layer %.20g failed",(double) i);
1625 image->filename);
1633 if (layer_info[i].image == (Image *) NULL)
1637 if (DiscardBlobBytes(image,(MagickSizeType)
1642 "UnexpectedEndOfFile",image->filename);
1648 if (image->debug != MagickFalse)
1652 status=ReadPSDLayer(image,psd_info,&layer_info[i],exception);
1656 status=SetImageProgress(image,LoadImagesTag,i,(MagickSizeType)
1667 if (layer_info[i].image == (Image *) NULL)
1681 layer_info[i].image->previous=layer_info[i-1].image;
1683 layer_info[i].image->next=layer_info[i+1].image;
1684 layer_info[i].image->page=layer_info[i].page;
1686 image->next=layer_info[0].image;
1687 layer_info[0].image->previous=image;
1699 Image *image,const PSDInfo *psd_info,ExceptionInfo *exception)
1713 compression=(PSDCompressionType) ReadBlobMSBShort(image);
1714 image->compression=ConvertPSDCompression(compression);
1726 offsets=ReadPSDRLEOffsets(image,psd_info,image->rows*psd_info->channels);
1729 image->filename);
1736 status=ReadPSDChannelRLE(image,psd_info,i,offsets+(i*image->rows),
1739 status=ReadPSDChannelRaw(image,psd_info->channels,i,exception);
1742 status=SetImageProgress(image,LoadImagesTag,i,psd_info->channels);
1748 if ((status != MagickFalse) && (image->colorspace == CMYKColorspace))
1749 status=NegateCMYK(image,exception);
1752 status=CorrectPSDAlphaBlend(image_info,image,exception);
1760 static Image *ReadPSDImage(const ImageInfo *image_info,ExceptionInfo *exception)
1762 Image
1763 *image;
1791 Open image file.
1801 image=AcquireImage(image_info,exception);
1802 status=OpenBlob(image_info,image,ReadBinaryBlobMode,exception);
1805 image=DestroyImageList(image);
1806 return((Image *) NULL);
1809 Read image header.
1811 image->endian=MSBEndian;
1812 count=ReadBlob(image,4,(unsigned char *) psd_info.signature);
1813 psd_info.version=ReadBlobMSBShort(image);
1817 (void) ReadBlob(image,6,psd_info.reserved);
1818 psd_info.channels=ReadBlobMSBShort(image);
1821 psd_info.rows=ReadBlobMSBLong(image);
1822 psd_info.columns=ReadBlobMSBLong(image);
1826 psd_info.depth=ReadBlobMSBShort(image);
1829 psd_info.mode=ReadBlobMSBShort(image);
1830 if (image->debug != MagickFalse)
1832 " Image is %.20g x %.20g with channels=%.20g, depth=%.20g, mode=%s",
1837 Initialize image.
1839 image->depth=psd_info.depth;
1840 image->columns=psd_info.columns;
1841 image->rows=psd_info.rows;
1842 status=SetImageExtent(image,image->columns,image->rows,exception);
1844 return(DestroyImageList(image));
1845 if (SetImageBackgroundColor(image,exception) == MagickFalse)
1847 image=DestroyImageList(image);
1848 return((Image *) NULL);
1851 SetImageColorspace(image,LabColorspace,exception);
1854 SetImageColorspace(image,CMYKColorspace,exception);
1855 image->alpha_trait=psd_info.channels > 4 ? BlendPixelTrait :
1861 status=AcquireImageColormap(image,psd_info.depth != 16 ? 256 : 65536,
1865 if (image->debug != MagickFalse)
1867 " Image colormap allocated");
1868 SetImageColorspace(image,GRAYColorspace,exception);
1869 image->alpha_trait=psd_info.channels > 1 ? BlendPixelTrait :
1873 image->alpha_trait=psd_info.channels > 3 ? BlendPixelTrait :
1878 length=ReadBlobMSBLong(image);
1881 if (image->debug != MagickFalse)
1887 Duotone image data; the format of this data is undocumented.
1893 (void) ReadBlob(image,(size_t) length,data);
1907 if (AcquireImageColormap(image,number_colors,exception) == MagickFalse)
1909 for (i=0; i < (ssize_t) image->colors; i++)
1910 image->colormap[i].red=ScaleCharToQuantum((unsigned char)
1911 ReadBlobByte(image));
1912 for (i=0; i < (ssize_t) image->colors; i++)
1913 image->colormap[i].green=ScaleCharToQuantum((unsigned char)
1914 ReadBlobByte(image));
1915 for (i=0; i < (ssize_t) image->colors; i++)
1916 image->colormap[i].blue=ScaleCharToQuantum((unsigned char)
1917 ReadBlobByte(image));
1918 image->alpha_trait=UndefinedPixelTrait;
1921 if ((image->depth == 1) && (image->storage_class != PseudoClass))
1924 length=ReadBlobMSBLong(image);
1931 Image resources block.
1933 if (image->debug != MagickFalse)
1935 " reading image resource blocks - %.20g bytes",(double)
1941 count=ReadBlob(image,(size_t) length,blocks);
1948 ParseImageResourceBlocks(image,blocks,(size_t) length,&has_merged_image,
1955 length=GetPSDSize(&psd_info,image);
1958 length=ReadBlobMSBLong(image);
1959 length=ReadBlobMSBLong(image);
1961 offset=TellBlob(image);
1966 if (image->debug != MagickFalse)
1973 if (image->debug != MagickFalse)
1975 " image has no layers");
1979 if (ReadPSDLayers(image,image_info,&psd_info,skip_layers,exception) !=
1982 (void) CloseBlob(image);
1983 image=DestroyImageList(image);
1984 return((Image *) NULL);
1990 SeekBlob(image,offset+length,SEEK_SET);
1993 If we are only "pinging" the image, then we're done - so return.
1997 (void) CloseBlob(image);
1998 return(GetFirstImageInList(image));
2003 if (image->debug != MagickFalse)
2006 if ((has_merged_image != MagickFalse) || (GetImageListLength(image) == 1))
2007 has_merged_image=(MagickBooleanType) ReadPSDMergedImage(image_info,image,
2009 if ((has_merged_image == MagickFalse) && (GetImageListLength(image) == 1) &&
2012 SeekBlob(image,offset,SEEK_SET);
2013 status=ReadPSDLayers(image,image_info,&psd_info,MagickFalse,exception);
2016 (void) CloseBlob(image);
2017 image=DestroyImageList(image);
2018 return((Image *) NULL);
2021 if ((has_merged_image == MagickFalse) && (GetImageListLength(image) > 1))
2023 Image
2026 SetImageAlphaChannel(image,TransparentAlphaChannel,exception);
2027 image->background_color.alpha=TransparentAlpha;
2028 image->background_color.alpha_trait=BlendPixelTrait;
2029 merged=MergeImageLayers(image,FlattenLayer,exception);
2030 ReplaceImageInList(&image,merged);
2032 (void) CloseBlob(image);
2033 return(GetFirstImageInList(image));
2048 % RegisterPSDImage() adds properties for the PSD image format to
2049 % the list of supported formats. The properties include the image format
2118 % WritePSDImage() writes an image in the Adobe Photoshop encoded image format.
2122 % MagickBooleanType WritePSDImage(const ImageInfo *image_info,Image *image,
2127 % o image_info: the image info.
2129 % o image: The image.
2135 static inline ssize_t SetPSDOffset(const PSDInfo *psd_info,Image *image,
2139 return(WriteBlobMSBShort(image,(unsigned short) offset));
2140 return(WriteBlobMSBLong(image,(unsigned short) offset));
2143 static inline ssize_t SetPSDSize(const PSDInfo *psd_info,Image *image,
2147 return(WriteBlobMSBLong(image,(unsigned int) size));
2148 return(WriteBlobMSBLongLong(image,size));
2151 static size_t PSDPackbitsEncodeImage(Image *image,const size_t length,
2171 assert(image != (Image *) NULL);
2172 assert(image->signature == MagickCoreSignature);
2173 if (image->debug != MagickFalse)
2174 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2179 image->filename);
2262 const ImageInfo *image_info,Image *image,Image *next_image,
2286 quantum_info=AcquireQuantumInfo(image_info,image);
2295 length=PSDPackbitsEncodeImage(image,length,pixels,compact_pixels,
2297 (void) SetPSDOffset(psd_info,image,length);
2303 Image *image,Image *next_image,unsigned char *compact_pixels,
2332 (void) WriteBlobMSBShort(image,0);
2335 monochrome=IsImageMonochrome(image) && (image->depth == 1) ?
2339 quantum_info=AcquireQuantumInfo(image_info,image);
2352 (void) WriteBlob(image,length,pixels);
2355 length=PSDPackbitsEncodeImage(image,length,pixels,compact_pixels,
2357 (void) WriteBlob(image,length,compact_pixels);
2364 const ImageInfo *image_info,Image *image,Image *next_image,
2394 (void) WriteBlobMSBShort(image,1);
2395 WritePackbitsLength(psd_info,image_info,image,next_image,
2398 WritePackbitsLength(psd_info,image_info,image,next_image,
2401 WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
2404 WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
2406 (void) SetImageProgress(image,SaveImagesTag,0,1);
2416 (void) WriteBlobMSBShort(image,1);
2417 WritePackbitsLength(psd_info,image_info,image,next_image,
2420 WritePackbitsLength(psd_info,image_info,image,next_image,
2423 WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
2426 WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
2428 (void) SetImageProgress(image,SaveImagesTag,0,1);
2439 (void) WriteBlobMSBShort(image,1);
2440 WritePackbitsLength(psd_info,image_info,image,next_image,
2442 WritePackbitsLength(psd_info,image_info,image,next_image,
2444 WritePackbitsLength(psd_info,image_info,image,next_image,
2447 WritePackbitsLength(psd_info,image_info,image,next_image,
2450 WritePackbitsLength(psd_info,image_info,image,next_image,
2453 (void) SetImageProgress(image,SaveImagesTag,0,6);
2454 WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
2456 (void) SetImageProgress(image,SaveImagesTag,1,6);
2457 WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
2459 (void) SetImageProgress(image,SaveImagesTag,2,6);
2460 WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
2462 (void) SetImageProgress(image,SaveImagesTag,3,6);
2464 WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
2466 (void) SetImageProgress(image,SaveImagesTag,4,6);
2468 WriteOneChannel(psd_info,image_info,image,next_image,compact_pixels,
2470 (void) SetImageProgress(image,SaveImagesTag,5,6);
2479 static void WritePascalString(Image* inImage,const char *inString,int inPad)
2505 static void WriteResolutionResourceBlock(Image *image)
2514 if (image->units == PixelsPerCentimeterResolution)
2516 x_resolution=2.54*65536.0*image->resolution.x+0.5;
2517 y_resolution=2.54*65536.0*image->resolution.y+0.5;
2522 x_resolution=65536.0*image->resolution.x+0.5;
2523 y_resolution=65536.0*image->resolution.y+0.5;
2526 (void) WriteBlob(image,4,(const unsigned char *) "8BIM");
2527 (void) WriteBlobMSBShort(image,0x03ED);
2528 (void) WriteBlobMSBShort(image,0);
2529 (void) WriteBlobMSBLong(image,16); /* resource size */
2530 (void) WriteBlobMSBLong(image,(unsigned int) (x_resolution+0.5));
2531 (void) WriteBlobMSBShort(image,units); /* horizontal resolution unit */
2532 (void) WriteBlobMSBShort(image,units); /* width unit */
2533 (void) WriteBlobMSBLong(image,(unsigned int) (y_resolution+0.5));
2534 (void) WriteBlobMSBShort(image,units); /* vertical resolution unit */
2535 (void) WriteBlobMSBShort(image,units); /* height unit */
2646 Image *image,ExceptionInfo *exception)
2654 Image
2681 Open image file.
2685 assert(image != (Image *) NULL);
2686 assert(image->signature == MagickCoreSignature);
2687 if (image->debug != MagickFalse)
2688 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",image->filename);
2691 status=OpenBlob(image_info,image,WriteBinaryBlobMode,exception);
2694 packet_size=(size_t) (image->depth > 8 ? 6 : 3);
2695 if (image->alpha_trait != UndefinedPixelTrait)
2696 packet_size+=image->depth > 8 ? 2 : 1;
2699 (image->columns > 30000) || (image->rows > 30000))
2701 (void) WriteBlob(image,4,(const unsigned char *) "8BPS");
2702 (void) WriteBlobMSBShort(image,psd_info.version); /* version */
2704 (void) WriteBlobByte(image, 0); /* 6 bytes of reserved */
2705 if (SetImageGray(image,exception) != MagickFalse)
2706 num_channels=(image->alpha_trait != UndefinedPixelTrait ? 2UL : 1UL);
2709 TrueColorAlphaType) && (image->storage_class == PseudoClass))
2710 num_channels=(image->alpha_trait != UndefinedPixelTrait ? 2UL : 1UL);
2713 if (image->storage_class == PseudoClass)
2714 (void) SetImageStorageClass(image,DirectClass,exception);
2715 if (image->colorspace != CMYKColorspace)
2716 num_channels=(image->alpha_trait != UndefinedPixelTrait ? 4UL : 3UL);
2718 num_channels=(image->alpha_trait != UndefinedPixelTrait ? 5UL : 4UL);
2720 (void) WriteBlobMSBShort(image,(unsigned short) num_channels);
2721 (void) WriteBlobMSBLong(image,(unsigned int) image->rows);
2722 (void) WriteBlobMSBLong(image,(unsigned int) image->columns);
2723 if (IsImageGray(image) != MagickFalse)
2731 monochrome=IsImageMonochrome(image) && (image->depth == 1) ?
2733 (void) WriteBlobMSBShort(image,(unsigned short)
2734 (monochrome != MagickFalse ? 1 : image->depth > 8 ? 16 : 8));
2735 (void) WriteBlobMSBShort(image,(unsigned short)
2740 (void) WriteBlobMSBShort(image,(unsigned short) (image->storage_class ==
2741 PseudoClass ? 8 : image->depth > 8 ? 16 : 8));
2744 (image->colorspace != CMYKColorspace)) &&
2747 (void) TransformImageColorspace(image,sRGBColorspace,exception);
2748 (void) WriteBlobMSBShort(image,(unsigned short)
2749 (image->storage_class == PseudoClass ? IndexedMode : RGBMode));
2753 if (image->colorspace != CMYKColorspace)
2754 (void) TransformImageColorspace(image,CMYKColorspace,exception);
2755 (void) WriteBlobMSBShort(image,CMYKMode);
2758 if ((IsImageGray(image) != MagickFalse) ||
2759 (image->storage_class == DirectClass) || (image->colors > 256))
2760 (void) WriteBlobMSBLong(image,0);
2766 (void) WriteBlobMSBLong(image,768);
2767 for (i=0; i < (ssize_t) image->colors; i++)
2768 (void) WriteBlobByte(image,ScaleQuantumToChar(image->colormap[i].red));
2770 (void) WriteBlobByte(image,0);
2771 for (i=0; i < (ssize_t) image->colors; i++)
2772 (void) WriteBlobByte(image,ScaleQuantumToChar(
2773 image->colormap[i].green));
2775 (void) WriteBlobByte(image,0);
2776 for (i=0; i < (ssize_t) image->colors; i++)
2777 (void) WriteBlobByte(image,ScaleQuantumToChar(image->colormap[i].blue));
2779 (void) WriteBlobByte(image,0);
2782 Image resource block.
2785 bim_profile=(StringInfo *) GetImageProfile(image,"8bim");
2786 icc_profile=GetImageProfile(image,"icc");
2797 (void) WriteBlobMSBLong(image,(unsigned int) length);
2798 WriteResolutionResourceBlock(image);
2801 (void) WriteBlob(image,GetStringInfoLength(bim_profile),
2807 (void) WriteBlob(image,4,(const unsigned char *) "8BIM");
2808 (void) WriteBlobMSBShort(image,0x0000040F);
2809 (void) WriteBlobMSBShort(image,0);
2810 (void) WriteBlobMSBLong(image,(unsigned int) GetStringInfoLength(
2812 (void) WriteBlob(image,GetStringInfoLength(icc_profile),
2816 (void) WriteBlobByte(image,0);
2820 base_image=GetNextImageInList(image);
2821 if (base_image == (Image *) NULL)
2822 base_image=image;
2824 while (next_image != (Image *) NULL)
2855 (void) SetPSDSize(&psd_info,image,0);
2861 (void) SetPSDSize(&psd_info,image,layer_info_size+
2867 (void) SetPSDSize(&psd_info,image,rounded_layer_info_size);
2868 if (image->alpha_trait != UndefinedPixelTrait)
2869 (void) WriteBlobMSBShort(image,-(unsigned short) layer_count);
2871 (void) WriteBlobMSBShort(image,(unsigned short) layer_count);
2877 (void) WriteBlobMSBLong(image,(unsigned int) next_image->page.y);
2878 (void) WriteBlobMSBLong(image,(unsigned int) next_image->page.x);
2879 (void) WriteBlobMSBLong(image,(unsigned int) (next_image->page.y+
2881 (void) WriteBlobMSBLong(image,(unsigned int) (next_image->page.x+
2889 (void) WriteBlobMSBShort(image,(unsigned short)
2891 (void) WriteBlobMSBShort(image,0);
2892 (void) SetPSDSize(&psd_info,image,channel_size);
2895 (void) WriteBlobMSBShort(image,(unsigned short) -1);
2896 (void) SetPSDSize(&psd_info,image,channel_size);
2902 (void) WriteBlobMSBShort(image,(unsigned short)
2904 (void) WriteBlobMSBShort(image,0);
2905 (void) SetPSDSize(&psd_info,image,channel_size);
2906 (void) WriteBlobMSBShort(image,1);
2907 (void) SetPSDSize(&psd_info,image,channel_size);
2908 (void) WriteBlobMSBShort(image,2);
2909 (void) SetPSDSize(&psd_info,image,channel_size);
2912 (void) WriteBlobMSBShort(image,(unsigned short) -1);
2913 (void) SetPSDSize(&psd_info,image,channel_size);
2918 (void) WriteBlobMSBShort(image,(unsigned short)
2920 (void) WriteBlobMSBShort(image,0);
2921 (void) SetPSDSize(&psd_info,image,channel_size);
2922 (void) WriteBlobMSBShort(image,1);
2923 (void) SetPSDSize(&psd_info,image,channel_size);
2924 (void) WriteBlobMSBShort(image,2);
2925 (void) SetPSDSize(&psd_info,image,channel_size);
2926 (void) WriteBlobMSBShort(image,3);
2927 (void) SetPSDSize(&psd_info,image,channel_size);
2930 (void) WriteBlobMSBShort(image,(unsigned short) -1);
2931 (void) SetPSDSize(&psd_info,image,channel_size);
2934 (void) WriteBlob(image,4,(const unsigned char *) "8BIM");
2935 (void) WriteBlob(image,4,(const unsigned char *)
2937 (void) WriteBlobByte(image,255); /* layer opacity */
2938 (void) WriteBlobByte(image,0);
2939 (void) WriteBlobByte(image,next_image->compose==NoCompositeOp ?
2941 (void) WriteBlobByte(image,0);
2948 (void) WriteBlobMSBLong(image,16);
2949 (void) WriteBlobMSBLong(image,0);
2950 (void) WriteBlobMSBLong(image,0);
2953 WritePascalString(image,layer_name,4);
2961 (void) WriteBlobMSBLong(image,(unsigned int) (label_length+(4-
2963 (void) WriteBlobMSBLong(image,0);
2964 (void) WriteBlobMSBLong(image,0);
2965 WritePascalString(image,property,4);
2970 Now the image data!
2975 status=WriteImageChannels(&psd_info,image_info,image,next_image,
2979 (void) WriteBlobMSBLong(image,0); /* user mask data */
2983 Write composite image.
2986 status=WriteImageChannels(&psd_info,image_info,image,image,MagickFalse,
2988 (void) CloseBlob(image);
